pokerdf 1.0.0__py3-none-any.whl

pokerdf/core/read_and_convert.py

@@ -0,0 +1,254 @@
+import os
+import pandas as pd
+from typing import List
+from joblib import Parallel, delayed
+from pokerdf.validation.pydantic_modules import ValidateInput
+from pokerdf.utils.strings import PLATFORM
+from pokerdf.regex.regex_execution import (
+    capture_common_data,
+    capture_general_data_of_the_hand,
+    capture_specific_data_of_the_player,
+    r,
+)
+import warnings
+
+warnings.simplefilter(action="ignore", category=FutureWarning)
+
+
+def get_files_paths(path: str) -> List[str]:
+    """
+    Retrieve the paths of relevant files in the specified directory.
+
+    Args:
+        path (str): The directory path to search for files.
+
+    Returns:
+        List[str]: A list of file paths that match the criteria.
+    """
+    # Get files names
+    list_of_all_files_names = os.listdir(path)
+
+    # Order by ID
+    list_of_all_files_names.sort()
+
+    # Keep relevant files only
+    list_of_selected_files = [
+        file_name
+        for file_name in list_of_all_files_names
+        if file_name.startswith("HH") and file_name.endswith(".txt")
+    ]
+
+    # Compose the final path for each file
+    paths = [os.path.join(path, file_name) for file_name in list_of_selected_files]
+
+    return paths
+
+
+def compose_dataframe() -> pd.DataFrame:
+    """
+    Create an empty DataFrame with predefined columns to hold poker data.
+
+    Returns:
+        pd.DataFrame: An empty DataFrame with predefined columns.
+    """
+    # Compose default dataframe
+    df = pd.DataFrame(
+        columns=[
+            "Modality",
+            "TableSize",
+            "BuyIn",
+            "TournID",
+            "TableID",
+            "HandID",
+            "LocalTime",
+            "Level",
+            "Ante",
+            "Blinds",
+            "Owner",
+            "OwnersHand",
+            "Playing",
+            "Player",
+            "Seat",
+            "PostedAnte",
+            "Position",
+            "PostedBlind",
+            "Stack",
+            "PreflopAction",
+            "FlopAction",
+            "TurnAction",
+            "RiverAction",
+            "AnteAllIn",
+            "PreflopAllIn",
+            "FlopAllIn",
+            "TurnAllIn",
+            "RiverAllIn",
+            "BoardFlop",
+            "BoardTurn",
+            "BoardRiver",
+            "ShowDown",
+            "CardCombination",
+            "Result",
+            "Balance",
+            "FinalRank",
+            "Prize",
+        ],
+        data=None,
+    )
+    return df
+
+
+def apply_regex(txt: str) -> pd.DataFrame:
+    """
+    Apply regex functions to parse the hand history text and collect relevant data.
+
+    Args:
+        txt (str): The text content of the poker hand history file.
+
+    Returns:
+        pd.DataFrame: A DataFrame containing the parsed data from the hand history.
+    """
+    # Generate dataframe
+    df = compose_dataframe()
+
+    # Spliting tournament's hands in a list
+    list_of_hands_as_text = txt.split(f"{PLATFORM} ")
+
+    # Cleaning list_of_hands_as_text
+    string_to_remove = "\ufeff"
+    if string_to_remove in list_of_hands_as_text:
+        list_of_hands_as_text.remove(string_to_remove)
+    list_of_hands_as_text = [hand for hand in list_of_hands_as_text if hand is not None]
+    list_of_hands_as_text = [hand for hand in list_of_hands_as_text if len(hand) > 0]
+
+    # Capture common info about the tournament
+    common = capture_common_data(list_of_hands_as_text[0].split("\n*** "))
+
+    for hand in list_of_hands_as_text:
+
+        # Split hand in stages (pre-flop/flop/turn/river)
+        splited_hand = hand.split("\n*** ")
+
+        # Capture general info of the hand
+        general = capture_general_data_of_the_hand(splited_hand)
+
+        # Get players
+        players = r.get_players(splited_hand)
+
+        # Iterate over players
+        for player in players:
+
+            # Capture specific info of players' actions
+            specific = capture_specific_data_of_the_player(splited_hand, player)
+
+            # Combine collected info
+            collected_data = {**common, **general, **specific}
+
+            # Validate
+            ValidateInput(**collected_data)
+
+            # Convert to dataframe
+            result = pd.DataFrame(collected_data)
+
+            # Concat to the final results
+            df = pd.concat([df, result])
+
+    return df
+
+
+def convert_txt_to_tabular_data(path: str) -> pd.DataFrame:
+    """
+    Convert a poker hand history text file into a structured DataFrame.
+
+    Args:
+        path (str): The path to the .txt file containing the hand history.
+
+    Returns:
+        pd.DataFrame: A DataFrame with parsed data from the hand history.
+    """
+    with open(path, "r", encoding="utf-8", errors="replace") as file:
+        txt = file.read()
+        result = apply_regex(txt)
+
+    return result
+
+
+def _save_log(msg: str, destination: str, file_name: str) -> None:
+    """
+    Save a log message to a file.
+
+    Args:
+        msg (str): The message to be logged.
+        destination (str): The folder where the log file will be saved.
+        file_name (str): The name of the log file.
+    """
+    # Compose path of the log
+    path = os.path.join(destination, file_name)
+
+    # Open the file
+    file = open(path, "a")
+
+    # Write content
+    file.write(msg + "\n")
+
+    # Close the writing process
+    file.close()
+
+
+class DataProcessing:
+    """
+    Process and save a poker hand history file, logging the result.
+
+    Args:
+        path (str): The path to the hand history file.
+        destination (str): The directory where the processed data will be saved.
+    """
+
+    def __init__(self, path: str, destination: str) -> None:
+        self.path = path
+        self.destination = destination
+
+    def run(self) -> None:
+        """
+        Trigger the data processing.
+        """
+        try:
+
+            # Convert text to pd.DataFrame
+            df = convert_txt_to_tabular_data(self.path).reset_index(drop=True)
+
+            # Compose name of the .parquet file (the Tournament ID + the Local Time)
+            clean_datetime = str(df.LocalTime[0]).replace("-", "")[:8]
+            file_name = clean_datetime + "-T" + str(df.TournID[0]) + ".parquet"
+
+            # Path to save the file
+            destination_path = os.path.join(self.destination, file_name)
+
+            # Save the table
+            df.to_parquet(destination_path, index=False)
+
+            # Log / print DONE status
+            msg = "   DONE: " + self.path.split("/")[-1]
+            _save_log(msg, self.destination, "success.txt")
+            print(msg)
+
+        except Exception as e:
+
+            # Log / print FAIL status
+            msg = "   FAIL: " + self.path.split("/")[-1]
+            msg += " (" + str(e) + ")"
+            _save_log(msg, self.destination, "fail.txt")
+            print(msg)
+
+
+def execute_in_parallel(source: str, destination: str) -> None:
+    """
+    Function to run the DataProcessing with multiple cores
+    """
+
+    # Get all paths
+    all_paths = get_files_paths(source)
+
+    # Run a DataProcessing in parallel.
+    Parallel(n_jobs=-1)(
+        delayed(DataProcessing(path, destination).run)() for path in all_paths
+    )

pokerdf/main.py

@@ -0,0 +1,79 @@
+import os
+import sys
+import datetime
+
+from pokerdf.core.read_and_convert import execute_in_parallel
+
+
+def main() -> None:
+    """
+    Main function to process command line arguments and execute the 'convert' command.
+
+    - Checks if the command is 'convert'.
+    - If 'convert', generates a session ID and creates a destination path.
+    - Executes the pipeline function `execute_in_parallel` to process files from source to destination.
+
+    Raises:
+        SystemExit: If there are not enough arguments or if an invalid command is provided.
+    """
+
+    if len(sys.argv) < 3:
+        print("Usage: pokerdf convert <path>")
+        sys.exit(1)
+
+    command = sys.argv[1]
+    source_path = sys.argv[2]
+
+    if command == "convert":
+
+        # Check if the source path exists
+        if not os.path.exists(source_path):
+            print(f"The source path '{source_path}' does not exist.")
+            sys.exit(1)
+        # Check if the source path is a directory
+        if not os.path.isdir(source_path):
+            print(f"The source path '{source_path}' is not a directory.")
+            sys.exit(1)
+        # Check if the source path is empty
+        if not os.listdir(source_path):
+            print(f"The source path '{source_path}' is empty.")
+            sys.exit(1)
+        # Check if the source path is a valid poker hand history file
+        if not any(file.endswith(".txt") for file in os.listdir(source_path)):
+            print(
+                f"The source path '{source_path}' does not contain any poker hand history files."
+            )
+            sys.exit(1)
+
+        # Get start time
+        start_time = datetime.datetime.now()
+
+        # Generate session ID
+        session_id = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
+
+        # Generate destionation path
+        destination_path = f"./output/{session_id}"
+
+        # Create folder
+        os.makedirs(destination_path)
+
+        # Execute pipeline
+        execute_in_parallel(source=source_path, destination=destination_path)
+
+        # Get end time
+        end_time = datetime.datetime.now()
+        elapsed_time = end_time - start_time
+        # Get the completed time in hours, minutes, and seconds
+        hours, remainder = divmod(elapsed_time.total_seconds(), 3600)
+        minutes, seconds = divmod(remainder, 60)
+        # Print the completed time in a readable format
+        print(
+            f"Processing completed in {int(hours)} hours, {int(minutes)} minutes, and {int(seconds)} seconds."
+        )
+
+    else:
+        print(f"The command '{command}' does not exist.")
+
+
+if __name__ == "__main__":
+    main()

pokerdf/regex/regex_execution.py

@@ -0,0 +1,89 @@
+from typing import Any
+from pokerdf.regex.regex_patterns import RegexPatterns
+
+r = RegexPatterns()
+
+
+def capture_common_data(hand: list[str]) -> dict[str, Any]:
+    """
+    Captures the common data of the tournament
+
+    Args:
+        hand (list): List of texts from a specific hand.
+
+    Returns:
+        dict: Dictionary of captured values.
+    """
+    row: dict[str, Any] = {}
+    row["Modality"] = r.get_modality(hand)
+    row["TableSize"] = r.get_table_size(hand)
+    row["BuyIn"] = r.get_buyin(hand)
+    row["TournID"] = r.get_tourn_id(hand)
+    row["Owner"] = r.get_owner(hand)
+
+    return row
+
+
+def capture_general_data_of_the_hand(splitted_hand: list[str]) -> dict[str, Any]:
+    """
+    Captures the general data of the hand
+
+    Args:
+        hand (list): List of texts from a specific hand.
+
+    Returns:
+        dict: Dictionary of captured values.
+    """
+    row: dict[str, Any] = {}
+    row["HandID"] = r.get_hand_id(splitted_hand)
+    row["TableID"] = r.get_table_id(splitted_hand)
+    row["LocalTime"] = r.get_time(splitted_hand)
+    row["Level"] = r.get_level(splitted_hand)
+    row["Ante"] = r.get_ante(splitted_hand)
+    row["Blinds"] = r.get_blinds(splitted_hand)
+    row["OwnersHand"] = r.get_owner_cards(splitted_hand)
+    row["Playing"] = r.get_number_of_active_players(splitted_hand)
+    row["BoardFlop"] = r.get_board(splitted_hand, stage="FLOP ***")
+    row["BoardTurn"] = r.get_board(splitted_hand, stage="TURN ***")
+    row["BoardRiver"] = r.get_board(splitted_hand, stage="RIVER ***")
+
+    return row
+
+
+def capture_specific_data_of_the_player(
+    splitted_hand: list[str], player: str
+) -> dict[str, Any]:
+    """
+    Captures the specific data of a player
+
+    Args:
+        hand (list): List of texts from a specific hand.
+        player (str): Name of the player.
+
+    Returns:
+        dict: Dictionary of captured values.
+    """
+    row: dict[str, Any] = {}
+    row["Player"] = [player]
+    row["Seat"] = r.get_seat(player, splitted_hand)
+    row["PostedAnte"] = r.get_posted_ante(player, splitted_hand)
+    row["Position"] = r.get_position(player, splitted_hand)
+    row["PostedBlind"] = r.get_posted_blind(player, splitted_hand)
+    row["Stack"] = r.get_stack(player, splitted_hand)
+    row["PreflopAction"] = r.get_actions(player, splitted_hand, stage="HOLE CARDS ***")
+    row["FlopAction"] = r.get_actions(player, splitted_hand, stage="FLOP ***")
+    row["TurnAction"] = r.get_actions(player, splitted_hand, stage="TURN ***")
+    row["RiverAction"] = r.get_actions(player, splitted_hand, stage="RIVER ***")
+    row["AnteAllIn"] = r.get_allin(player, splitted_hand, stage=" posts the ante ")
+    row["PreflopAllIn"] = r.get_allin(player, splitted_hand, stage="HOLE CARDS ***")
+    row["FlopAllIn"] = r.get_allin(player, splitted_hand, stage="FLOP ***")
+    row["TurnAllIn"] = r.get_allin(player, splitted_hand, stage="TURN ***")
+    row["RiverAllIn"] = r.get_allin(player, splitted_hand, stage="RIVER ***")
+    row["ShowDown"] = r.get_showed_card(player, splitted_hand)
+    row["CardCombination"] = r.get_card_combination(player, splitted_hand)
+    row["Result"] = r.get_result(player, splitted_hand)
+    row["Balance"] = r.get_balance(player, splitted_hand)
+    row["FinalRank"] = r.get_final_rank(player, splitted_hand)
+    row["Prize"] = r.get_prize(player, splitted_hand)
+
+    return row