reconcile_holds works to create a basic excel output with all needed

information, and its pretty quick. OnHoldRec.bas is an Excel macro that almost works to filter GP...
3 years ago · 075a84133b
commit 075a84133b
6 changed files with 675 additions and 0 deletions
--- a/.gitignore
+++ b/.gitignore
@ -0,0 +1,4 @@
 __pycache__/
 venv/
 work/
 *.log
--- a/OnHoldRec.bas
+++ b/OnHoldRec.bas
@ -0,0 +1,199 @@
 Sub OnHoldReconcile()
 Dim gpFull As Range
 Dim GpFilteredPaste As Range
 Dim gpFiltered As Range
 ' Get the values in the GP (Great PLains) sheet
 Set gpFull = SelectRange("GP", "A", 2, "L")
 Set GpFilteredPaste = WorkSheets("GPFiltered").Range("A2")
 Set gpFilered = FilterGreatPlains(gpFull, GpFilteredPaste)
 Dim gpContracts As Range
 gpContracts = gpFileted.Range("H:H")
 NormalizeContractNumbers gpContracts
 End Sub
 Sub PasteRows(sourceRange As Range, sourceRows() As Long, destRange As Range)
    ' Copies specific rows from a source range to a destination range.
    ' Parameters:
    '   sourceRange: The range of data to copy rows from.
    '   sourceRows: An array of row numbers to copy from the source range.
    '   destRange: The destination range to paste the copied rows.
    Dim srcRow As Range
    Dim destRow As Range
    ' Loop through each row in the sourceRows array
    For I = 0 To UBound(sourceRows)
        ' Define the row to copy from the source range
        Set srcRow = sourceRange.Rows(sourceRows(I) - sourceRange.Row + 1)
        ' Define the row to paste into the destination range
        Set destRow = destRange.Offset(I)
        ' Copy the row from the source range to the destination range
        srcRow.Copy destRow
    Next I
 End Sub
 '-------------------------------------------------------------------
 'NormalizeContractNumbers Sub | Normalizes contract numbers in a given range by removing whitespace or words
 '
 '@param columnRange  | The range of cells containing the contract numbers to be normalized
 '
 '@return             | None
 '-------------------------------------------------------------------
 Sub NormalizeContractNumbers(columnRange As Range)
    Dim cnRegex As String
    ' Regex to remove whitespace or words
    ' Matches contracts with & without the schedule id
    cnRegex = "\d{7}(-\d{3})?"
    ' Find the last filled Row
    Dim lastRow As Long
    ' Subtract one to exclude the header row
    lastRow = columnRange.End(xlUp).Row - 1
    Dim cell As Range
    ' I = 2 to avoid header row
    For I = 2 To lastRow
        ' Returns a normalized contract number, or the orginal value passed in
        cell.Value = ExtractMatch(cnRegex, cell.Value, room:=True) ' room: ReturnOriginalOnMiss
    Next I
 End Sub
 '------------------------------------------------------
 ' SelectRange | Selects a range of filled test using
 ' from tl to tr, down to the last filled row of tl
 '
 ' Params |
 ' tl (Top Left): A column letter as a string 'C'
 ' startRow: the top row to start at.
 ' tr (Top Right): A column letter as a string 'F'
 '
 'Returns -> Selected range from tl to tr down to
 ' last filled row of tl
 '-----------------------------------------------------
 Function SelectRange(sheet As String, tl As String, startRow As Integer, tr As String) As Range
    Dim lastRow As Long
    lastRow = WorkSheets(sheet).Cells(Rows.Count, tl).End(xlUp).Row
    Debug.Print "Select range " & tl & ":" & tr & " | Last Row " & lastRow
    Set SelectRange = WorkSheets(sheet).Range(tl & startRow & ":" & tr & lastRow)
 End Function
 Function FilterGreatPlains(gpRange As Range, destRange As Range) As Range
    ' Filters a source range of data based on a condition, and copies the
    ' filtered data to a destination range.
    ' Parameters:
    '   gpRange: The range of data to filter.
    '   destRange: The destination range to paste the filtered data.
    Dim I As Long
    Dim goodRowList() As Long
    Dim filteredGp As Range
    Dim gdn As String
    gdn = "(^(\d+-?)+$)|(ho?ld)"
    Dim cmaRegex As String
    cmaRegex = "cma"
    ' Loop through each row in the source range
    For Each gpRow In gpRange.Rows
        Debug.Print ("")
        Debug.Print ("Doc Type: " + Trim(gpRow.Cells(1, 5).Value))
        ' Only take cells in E (Document Type) that are 'Invoice'
        If Not gpRow.Cells(1, 5).Value = "Invoice" Then
            Debug.Print ("Kicked! Not an invoice!")
            GoTo NextRow ' This is not a row we need
        End If
        Debug.Print ("Doc Num: " + Trim(gpRow.Cells(1, 7).Value))
        ' If regex matches on the docuemnt number (G) kick don't include
        If Not MatchFound(gdn, Trim(gpRow.Cells(1, 7).Value)) Then
            Debug.Print ("Kicked! Did not match doc # regex!")
            GoTo NextRow
        End If
        Debug.Print ("Purch Num: " + Trim(gpRow.Cells(1, 11).Value))
        ' Check Purchase Order Number (K) for CMA
        If MatchFound(cmaRegex, gpRow.Cells(1, 11).Value) Then
            Debug.Print ("Kicked! CMA in purch order #!")
            GoTo NextRow
        End If
        ' If none of the kickout conditions were met then
        ' record this a good row
        Debug.Print ("Good!")
        ReDim Preserve goodRowList(I)
        goodRowList(I) = gpRow.Row
        I = I + 1
 NextRow:
    Next gpRow
    ' Copy the filtered rows to the destination range
    PasteRows gpRange, goodRowList, destRange
    ' Define a new range object representing the filtered data
    Set filteredGp = destRange.Resize(I, gpRange.Columns.Count)
    ' Return the filtered range object
    Set FilterGreatPlains = filteredGp
 End Function
 Function MatchFound(regexPattern As String, cellValue As String, Optional ignoreCase As Boolean = True) As Boolean
    Dim regex As New RegExp
    regex.Pattern = regexPattern ' Set the regular expression pattern
    regex.ignoreCase = ignoreCase
    If regex.Test(cellValue) Then ' Test the cell value against the regular expression pattern
        MatchFound = True ' If a match is found, return True
    Else
        MatchFound = False ' If no match is found, return False
    End If
 End Function
 '-------------------------------------------------------------------
 'ExtractMatch Function | Extracts the first match of a regex pattern
 '
 '@param regexPattern   | The regex pattern to match
 '@param cellValue      | The input string to search for matches
 '@param ignoreCase     | Optional boolean indicating if case should be ignored (default True)
 '@param room           | ReturnOriginalOnMissing -> Optional boolean indicating if the original cell value should be returned if no matches are found (default False)
 '
 '@return               | String value of the first regex match, or #N/A if no matches found and room parameter is False
 '-------------------------------------------------------------------
 Function ExtractMatch(regexPattern As String, cellValue As String, Optional ignoreCase As Boolean = True, Optional room As Boolean = False) As String
    ' Create a new RegExp object and set its properties
    Dim regex As New RegExp
    regex.Pattern = regexPattern
    regex.ignoreCase = ignoreCase
    ' Find all matches in the input string
    Dim regexMatches As Object
    Set regexMatches = regex.Execute(inputString)
    ' If there are no matches, return either the input string or Null depending on the value of "room"
    If regexMatchs.Count = 0 Then
        Debug.Print ("No match found! " + regexPattern + " not in " + cellValue)
        If room Then
            Debug.Print ("Returning original value.")
            Set ExtractMatch = cellValue
        Else
            Set ExtractMatch = CVErr(xlErrNA) ' Return #N/A error
        End If
    Else
        ' If there is at least one match, iterate through all the matches and return the value of the first match found
        Dim match As Object
        For Each match In regexMatches:
            Debug.Print ("Match : " + match.Value)
            Set ExtractMatch = match.Value
            Exit Function ' exit the loop after the first match is found
        Next match
    End If
 End Function
--- a/config.toml
+++ b/config.toml
@ -0,0 +1,39 @@
 write_dir = "../Work"
 [ExcelColumns]
    [ExcelColumns.OB]
    contract_number = "Contract" # 3070508-007
    onhold_amount = "CurrentOnHold"
    install_date = "InstallDate"
    [ExcelColumns.GP]
    contract_number = "Transaction Description" # 1234-56789
    onhold_amount = "Current Trx Amount"
    doc_num = "Document Number" # 1-316141 HOLD
    pur_order = "Purchase Order Number" # ABC123
    doc_type = "Document Type" # Invoice or Credit Memo
 [logger]
    version = 1
    disable_existing_loggers = false
    [logger.formatters.custom]
    format = "'%(asctime)s - %(module)s - %(levelname)s - %(message)s'"
    [logger.handlers.console]
    class = "logging.StreamHandler"
    level = "INFO"
    formatter = "custom"
    stream = "ext://sys.stdout"
    [logger.handlers.file]
    class = "logging.FileHandler"
    level = "DEBUG"
    formatter = "custom"
    filename = "on_hold.log"
    [logger.root]
    level = "DEBUG"
    handlers = ["console", "file"]
--- a/rec_lib.py
+++ b/rec_lib.py
@ -0,0 +1,237 @@
 import pandas as pd
 from pandas import DataFrame
 from datetime import datetime as dt
 import datetime
 import re
 from typing import Literal
 def get_overdue(onbase_df: DataFrame, onbase_excel_config) -> DataFrame:
    """
    Given a DataFrame containing OnBase installation data and a dictionary containing the OnBase Excel configuration,
    this function returns a DataFrame containing the rows from `onbase_df` that have an installation date that is before
    the current date.
    Args:
        onbase_df (pd.DataFrame): A pandas DataFrame containing OnBase installation data.
        onbase_excel_config (dict): A dictionary containing the OnBase Excel configuration.
    Returns:
        pd.DataFrame: A pandas DataFrame containing the rows from `onbase_df` that have an installation date that is before
        the current date.
    """
    id_col = onbase_excel_config["install_date"]
    onbase_df[id_col] = pd.to_datetime(onbase_df[id_col])
    onbase_df[id_col].fillna(pd.NaT, inplace=True)
    return  onbase_df[onbase_df[id_col].dt.date < datetime.date.today()]
 def filter_gp(gp_dataframe: pd.DataFrame, gp_config: dict) -> pd.DataFrame:
    """
    Given a pandas DataFrame containing GP data and a dictionary containing the GP configuration, this function
    filters out rows from the DataFrame that are not needed for further analysis based on certain criteria.
    Args:
        gp_dataframe (pd.DataFrame): A pandas DataFrame containing GP data.
        gp_config (dict): A dictionary containing the GP configuration.
    Returns:
        pd.DataFrame: A pandas DataFrame containing the filtered GP data.
    """
    # Regex used to filter unneeded transactions
    # filters anything that does not contain a ONLY contract number OR
    # The work hold or just hld
    GOOD_DOC_NUM = re.compile(r"(^(\d+-?)+$)|(ho?ld)", re.IGNORECASE)
    # Excludes anything that contains cma with a space or digit following it
    # CMA23532 would be excluded but 'John Locman' would be allowed
    GOOD_PO_NUM = re.compile(r"^(?!.*cma(\s|\d)).*$", re.IGNORECASE)
    # Create a filter/mask to use on the data
    mask = (
        (gp_dataframe[gp_config['doc_type']] == "Invoice") &
        (gp_dataframe[gp_config['doc_num']].str.contains(GOOD_DOC_NUM)) &
        (gp_dataframe[gp_config['pur_order']].str.contains(GOOD_PO_NUM))
    )
    # Get the rows to drop based on the filter/mask
    rows_to_drop = gp_dataframe[~mask].index
    # Drop the rows and return the filtered DataFrame
    return gp_dataframe.drop(rows_to_drop, inplace=False)
 def create_transaction_df(dataframe: pd.DataFrame, source: Literal["GP", "OB"], excelConfig: dict):
    """
    Given a pandas DataFrame containing transaction data, the source of the data ("GP" or "OB"), and a dictionary
    containing the Excel configuration, this function creates a new DataFrame with columns for the contract number,
    the amount on hold, a unique transaction ID, and the source of the data.
    Args:
        dataframe (pd.DataFrame): A pandas DataFrame containing transaction data.
        source (Literal["GP", "OB"]): The source of the data ("GP" or "OB").
        excelConfig (dict): A dictionary containing the Excel configuration.
    Returns:
        pd.DataFrame: A pandas DataFrame containing the contract number, amount on hold, transaction ID, and data source
        for each transaction in the original DataFrame.
    """
    column_config: dict = excelConfig[source]
    # Create a new DataFrame with the contract number and on-hold amount columns
    transactions = dataframe[[column_config["contract_number"], column_config["onhold_amount"]]].copy()
    # Rename the columns to standardize the column names
    transactions.rename(columns={
        column_config["contract_number"]: "contract_number",
        column_config["onhold_amount"]: "onhold_amount",
    }, inplace=True)
    # Convert the on-hold amount column to float format and round to two decimal places
    transactions["onhold_amount"] = transactions["onhold_amount"].astype(float).round(2)
    # Use regex to extract the contract number from the column values and create a new column with the standardized format
    CN_REGEX = re.compile(r"\d{7}(-\d{3})?")
    transactions["contract_number"] = transactions["contract_number"].apply(
        lambda cn: str(cn) if not re.search(CN_REGEX, str(cn))
        else re.search(CN_REGEX, str(cn)).group(0)
    )
    # Create a new column with a unique transaction ID
    transactions["ID"] = transactions["contract_number"] +'_'+\
        transactions["onhold_amount"].astype(str)
    # Create a new column with the data source
    transactions["Source"] = source
    # Return the new DataFrame with the contract number, on-hold amount, transaction ID, and data source columns
    return transactions
 def get_no_match(obt_df: pd.DataFrame, gpt_df: pd.DataFrame):
    """
    Given two pandas DataFrames containing transaction data from OBT and GPT, respectively, this function returns a new
    DataFrame containing only the transactions that do not have a match in both the OBT and GPT DataFrames.
    Args:
        obt_df (pd.DataFrame): A pandas DataFrame containing transaction data from OBT.
        gpt_df (pd.DataFrame): A pandas DataFrame containing transaction data from GPT.
    Returns:
        pd.DataFrame: A pandas DataFrame containing the transactions that do not have a match in both the OBT and GPT
        DataFrames.
    """
    # Merge the two DataFrames using the contract number as the join key
    merged_df = pd.merge(
        obt_df, gpt_df,
        how="outer",
        on=["contract_number"],
        suffixes=("_ob", "_gp")
    )
    # Filter the merged DataFrame to include only the transactions that do not have a match in both OBT and GPT
    no_match = merged_df.loc[
        (merged_df["Source_ob"].isna()) |
        (merged_df["Source_gp"].isna())
    ]
    # Fill in missing values and drop unnecessary columns
    no_match["Source"] = no_match["Source_ob"].fillna("GP")
    no_match["onhold_amount"] = no_match["onhold_amount_ob"].fillna(no_match["onhold_amount_gp"])
    no_match.drop(columns=[
        "ID_ob", "ID_gp",
        "onhold_amount_ob", "onhold_amount_gp",
        "Source_ob", "Source_gp"
        ],
    inplace=True)
    # Reorder and return the new DataFrame with the source, contract number, and on-hold amount columns
    no_match = no_match[
        [ "Source", "contract_number", "onhold_amount"]
    ]
    return no_match
 def get_not_full_match(obt_df: pd.DataFrame, gpt_df: pd.DataFrame):
    """
    Given two pandas DataFrames containing transaction data from OBT and GPT, respectively, this function returns two new
    DataFrames. The first DataFrame contains the transactions that have a full match on both the OBT and GPT DataFrames,
    and the second DataFrame contains the transactions that do not have a full match.
    Args:
        obt_df (pd.DataFrame): A pandas DataFrame containing transaction data from OBT.
        gpt_df (pd.DataFrame): A pandas DataFrame containing transaction data from GPT.
    Returns:
        tuple(pd.DataFrame, pd.DataFrame): A tuple of two DataFrames. The first DataFrame contains the transactions that
        have a full match on both the OBT and GPT DataFrames, and the second DataFrame contains the transactions that do
        not have a full match.
    """
    # Combine the two DataFrames using an outer join on the contract number and on-hold amount
    merged_df = pd.merge(
        obt_df, gpt_df,
        how="outer",
        on=["ID", "contract_number", "onhold_amount"],
        suffixes=("_ob", "_gp")
    )
    # Filter the merged DataFrame to include only the transactions that have a full match in both OBT and GPT
    full_matched = merged_df.dropna(subset=["Source_ob", "Source_gp"])
    full_matched.drop(columns=["Source_ob", "Source_gp"], inplace=True)
    # Create a boolean mask for the rows to drop in full_matched
    mask = merged_df["ID"].isin(full_matched["ID"])
    # Use the mask to remove the selected rows and create a new DataFrame for not full match
    not_full_match = merged_df[~mask]
    # This includes items that DO match contracts, but not amounts
    # It can have multiple items from one source with the same contract number
    # Create a new column with the data source, using OBT as the default and GPT as backup if missing
    not_full_match["Source"] = not_full_match["Source_ob"].fillna(not_full_match["Source_gp"])
    # Drop the redundant Source columns
    not_full_match.drop(columns=["Source_ob", "Source_gp"], inplace=True)
    # Reorder and return the new DataFrame with the source, contract number, and on-hold amount columns
    not_full_match = not_full_match[
        [ "Source", "contract_number", "onhold_amount"]
    ]
    # Return the two DataFrames
    return full_matched, not_full_match
 def get_contract_match(not_full_match: pd.DataFrame) -> pd.DataFrame:
    """
    Given a pandas DataFrame containing transactions that do not have a full match between OBT and GPT, this function
    returns a new DataFrame containing only the transactions that have a matching contract number in both OBT and GPT.
    Args:
        not_full_match (pd.DataFrame): A pandas DataFrame containing transactions that do not have a full match between
        OBT and GPT.
    Returns:
        pd.DataFrame: A pandas DataFrame containing only the transactions that have a matching contract number in both
        OBT and GPT.
    """
    # Filter the not_full_match DataFrame by source
    ob_df = not_full_match[not_full_match["Source"] == "OB"]
    gp_df = not_full_match[not_full_match["Source"] == "GP"]
    # Merge the two filtered DataFrames on the contract number
    contract_match = pd.merge(
        ob_df, gp_df,
        how="inner",
        on=["contract_number"],
        suffixes=("_ob", "_gp")
    )
    # Fill in missing values in the Source column and drop the redundant columns
    contract_match["Source"] = contract_match["Source_ob"].fillna("GP")
    contract_match.drop(columns=["Source_ob", "Source_gp"], inplace=True)
    # Reorder and return the new DataFrame with the source, contract number, and on-hold amount columns
    contract_match = contract_match[
        [ "Source", "contract_number", "onhold_amount_ob", "onhold_amount_gp"]
    ]
    return contract_match
--- a/reconcile_holds.py
+++ b/reconcile_holds.py
@ -0,0 +1,196 @@
 import pandas as pd
 from pandas import DataFrame, Series
 import re
 from re import Pattern
 import os
 from os.path import basename
 import glob
 import logging
 from pathlib import Path
 from tomllib import load
 import logging.config
 from datetime import datetime as dt
 """
 [ ] Pull in past reconciliations to check against
 [ ] Record reconciled transaction (connect with VBA)
 [ ] Check GP against the database
 [ ] Check OB against the database
 """
 # Custom module for reconciliation
 from rec_lib import get_contract_match, get_no_match, \
    get_not_full_match, get_overdue, filter_gp, create_transaction_df
 def setup_logging():
    """
    Sets up logging configuration from the TOML file. If the logging configuration fails to be loaded from the file,
    a default logging configuration is used instead.
    Returns:
        logging.Logger: The logger instance.
    """
    with open("config.toml", "rb") as f:
        config_dict: dict = load(f)
        try:
            # Try to load logging configuration from the TOML file
            logging.config.dictConfig(config_dict["logger"])
        except Exception as e:
            # If the logging configuration fails, use a default configuration and log the error
            logger = logging.getLogger()
            logger.setLevel(logging.DEBUG)
            logger.warning("Failed setting up logger!")
            logger.exception(e)
            logger.warning(f"Config:\n{config_dict}")
            return logger
 setup_logging()
 logger = logging.getLogger(__name__)
 logger.info(f"Logger started with level: {logger.level}")
 def find_most_recent_file(folder_path: Path, file_pattern: Pattern) -> str:
    """
    Given a folder path and a regular expression pattern, this function returns the path of the most recently modified
    file in the folder that matches the pattern.
    Args:
        folder_path (Path): A pathlib.Path object representing the folder to search.
        file_pattern (Pattern): A regular expression pattern used to filter the files in the folder.
    Returns:
        str: The path of the most recently modified file in the folder that matches the pattern.
    """
    # Find all files in the folder that match the pattern
    files = glob.glob(f"{folder_path}/*")
    logger.debug(f"files: {files}")
    # Get the modification time of each file and filter to only those that match the pattern
    file_times = [(os.path.getmtime(path), path) for path in files if re.match(file_pattern, basename(path))]
    # Sort the files by modification time (most recent first)
    file_times.sort(reverse=True)
    logger.debug(f"file times: {file_times}")
    # Return the path of the most recent file
    return file_times[0][1]
 def check_sheet(df_cols: list[str], excel_col_config: dict) -> bool:
    """
    Given a list of column names and a dictionary of column name configurations, this function checks if the required
    columns are present in the list of column names.
    Args:
        df_cols (list[str]): A list of column names.
        excel_col_config (dict): A dictionary of column name configurations.
    Returns:
        bool: True if all of the required columns are present in the list of column names, False otherwise.
    """
    # Get the list of required columns from the column configuration dictionary
    required_cols: list[str] = list(excel_col_config.values())
    # Check if all of the required columns are present in the list of column names
    return all([col in df_cols for col in required_cols])
 def get_dataframes(excelConfig: dict) -> tuple[pd.DataFrame|None, pd.DataFrame|None]:
    """
    Given a dictionary of Excel configuration options, this function searches for the most recently modified GP and OB
    Excel files in a "Work" folder and returns their corresponding dataframes.
    Args:
        excelConfig (dict): A dictionary containing configuration options for the GP and OB Excel files.
    Returns:
        tuple[pd.DataFrame|None, pd.DataFrame|None]: A tuple containing the OB and GP dataframes, respectively.
    """
    # Get the current working directory and the path to the "Work" folder
    current_dir: Path = Path(os.getcwd())
    work_folder: Path = current_dir / 'Work'
    logger.debug(f"Workpath: {work_folder}")
    # Check that the "Work" folder exists
    assert work_folder.exists, "No work folder found!"
    # Define regular expression patterns to match the GP and OB Excel files
    gp_regex: Pattern = re.compile(".*gp.*\.xlsx$", re.IGNORECASE)
    ob_regex: Pattern = re.compile(".*ob.*\.xlsx$", re.IGNORECASE)
    # Find the paths of the most recently modified GP and OB Excel files
    gp_file_path = find_most_recent_file(work_folder, gp_regex)
    logger.debug(f"gp_file_path: {gp_file_path}")
    ob_file_path = find_most_recent_file(work_folder, ob_regex)
    logger.debug(f"gp_file_path: {ob_file_path}")
    # Read the GP and OB Excel files into dataframes and check that each dataframe has the required columns
    gp_xl = pd.ExcelFile(gp_file_path)
    gp_config = excelConfig["GP"]
    gp_sheets = gp_xl.sheet_names
    gp_dfs = pd.read_excel(gp_xl, sheet_name=gp_sheets)
    for sheet in gp_dfs:
        if check_sheet(gp_dfs[sheet].columns, gp_config):
            gp_df = gp_dfs[sheet]
            break
    ob_xl = pd.ExcelFile(ob_file_path)
    ob_config = excelConfig["OB"]
    ob_sheets = ob_xl.sheet_names
    ob_dfs = pd.read_excel(ob_xl, sheet_name=ob_sheets)
    for sheet in ob_dfs:
        if check_sheet(ob_dfs[sheet].columns, ob_config):
            ob_df = ob_dfs[sheet]
            break
    return ob_df, gp_df
 def main() -> int:
    """
    This is the main function for the script. It reads configuration options from a TOML file, reads in the GP and OB
    Excel files, performs data reconciliation and analysis, and writes the results to a new Excel file.
    Returns:
        int: 0 if the script executes successfully.
    """
    # Read the configuration options from a TOML file
    with open("config.toml", "rb") as f:
        config_dict: dict = load(f)
    excelConfig: dict = config_dict["ExcelColumns"]
    # Get the GP and OB dataframes from the Excel files
    ob_df, gp_df = get_dataframes(excelConfig)
    assert not ob_df.empty, "OB Data empty!"
    assert not gp_df.empty, "GP Data empty!"
    # Filter the GP dataframe to include only relevant transactions
    fgp_df: DataFrame = filter_gp(gp_df, excelConfig["GP"])
    # Get the overdue transactions from the OB dataframe
    overdue: DataFrame = get_overdue(ob_df, excelConfig["OB"])
    # Create transaction dataframes for the GP and OB dataframes
    ob_transactions: DataFrame = create_transaction_df(ob_df, 'OB', excelConfig)
    gp_transactions: DataFrame = create_transaction_df(fgp_df, 'GP', excelConfig)
    # Get the transactions that do not have matches in both the GP and OB dataframes
    no_match: DataFrame = get_no_match(ob_transactions, gp_transactions)
    # Get the transactions that have matches in both the GP and OB dataframes but have amount mismatches
    full_match, not_full_match = get_not_full_match(ob_transactions, gp_transactions)
    only_contracts_match: DataFrame = get_contract_match(not_full_match)
    # Write the results to a new Excel file
    with pd.ExcelWriter(f"{config_dict['work_dir']}/Reconciled Holds [{dt.now().strftime('%m-%d-%Y')}].xlsx", mode='w') as writer:
        full_match.to_excel(writer,sheet_name="FULL", index=False)
        no_match.to_excel(writer, sheet_name="No Match", index=False)
        only_contracts_match.to_excel(writer, sheet_name="Amount Mismatch", index=False)
        overdue.to_excel(writer, sheet_name="Overdue", index=False)
    return 0
 if __name__ == "__main__":
    print("Starting")
    main()
    print("Completed")
--- a/requirements.txt
+++ b/requirements.txt