pokerdf 1.0.0__tar.gz

pokerdf-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Murilo Amaral
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pokerdf-1.0.0/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.3
+Name: pokerdf
+Version: 1.0.0
+Summary: Converts poker hand history files to pandas DataFrames.
+Author: Murilo Amaral
+Author-email: murilogmamaral@gmail.com
+Requires-Python: >=3.11.5
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: joblib (==1.3.2)
+Requires-Dist: mypy (>=0.0.0)
+Requires-Dist: pandas (>=2.0.0)
+Requires-Dist: pyarrow (>=16.1.0)
+Requires-Dist: pydantic (>=2.8.0)
+Requires-Dist: ruff (>=0.0.0)
+Project-URL: homepage, https://gitlab.com/murilogmamaral/pokerdf
+Project-URL: repository, https://gitlab.com/murilogmamaral/pokerdf
+Description-Content-Type: text/markdown
+
+# PokerDF
+
+Converts poker hand history files into structured Pandas DataFrames, making it easier to analyze your games.
+
+Fast and reliable, PokerDF is able to process 3,000 hand history files into _.parquet_ per minute, in a MacBook Air M2 with 8-core CPU.
+
+Currently supports PokerStars. Make sure hand histories are saved in English.
+
+## Introduction
+
+Converting raw hand histories into structured data is the first step toward building a solid poker strategy and maximizing ROI. What are the optimal VPIP, PFR, and C-BET frequencies for No Limit Hold'em 6-Max? In which specific situations is a 3-Bet most profitable? When is bluffing a clear mistake? Once your data is organized in a Pandas DataFrame, the analytical explorations become unlimited, opening new possibilities to fine-tune your decision-making.
+
+## Installation
+```
+pip install pokerdf
+```
+
+## Usage
+Navigate to the folder where you want to save the output:
+```
+cd output_directory
+```
+Then, run the package like this:
+```
+pokerdf convert /path/to/handhistory/folder
+```
+
+Once the process is concluded, you will find something like this:
+```
+output_directory/
+└── output/
+   └── 20250510-105423/
+      ├── 20200607-T2928873630.parquet
+      ├── 20200607-T2928880893.parquet
+      ├── 20200607-T2928925240.parquet
+      ├── 20200607-T2928950825.parquet
+      ├── 20200607-T2928996127.parquet
+      ├── 20200607-T2929005994.parquet
+      ├── ...
+      ├── fail.txt
+      └── success.txt
+```
+#### Details
+1. Inside `output` you’ll find a subfolder named with the session ID, in this case, `20250510-105423`, containing all _.parquet_ files.
+2. Each hand history file is converted into a _.parquet_ file with the exact same structure, allowing you to concatenate them seamlessly.
+3. Each _.parquet_ file follows the naming convention _{DATE_OF_TOURNAMENT}-T{TOURNAMENT_ID}.parquet_.
+4. The file `fail.txt` provides detailed information about any files that failed to process. This file is only generated if there are failures.
+5. The file `success.txt` lists all successfully converted files. 
+
+## DataFrame structure
+| Column            | Description                                                  | Example                           | Data Type       |
+|-------------------|--------------------------------------------------------------|-----------------------------------|-----------------|
+| Modality          | The type of game being played                                | Hold'em No Limit                  | string          |
+| TableSize         | Maximum number of players                                    | 6                                 | int             |
+| BuyIn             | The buy-in amount for the tournament                         | $4.60+$0.40                       | string          |
+| TournID           | Unique identifier for the tournament                         | 2928882649                        | string          |
+| TableID           | Unique identifier for the table inside a tournament          | 10                                | int             |
+| HandID            | Unique identifier for the hand inside a tournament           | 215024616736                      | string          |
+| LocalTime         | Local time when the hand was played                          | 2020-06-07 07:44:35               | datetime        |
+| Level             | Level of the tournament                                      | IV                                | string          |
+| Ante              | Ante amount posted in the hand                               | 10.00                             | float           |
+| Blinds            | Big blind and small blind amounts                            | [10.0, 20.0]                      | list[float]     |
+| Owner             | Owner of the hand history files                              | ownername                         | string          |
+| OwnersHand        | Cards held by the owner in a specific hand                   | [9d, Js]                          | list[string]    |
+| Playing           | Number of players active during the hand                     | 5                                 | int             |
+| Player            | Player involved in the hand                                  | playername                        | string          |
+| Seat              | Seat number of the player                                    | 3                                 | int             |
+| PostedAnte        | Amount the player paid for the ante                          | 5.00                              | float           |
+| PostedBlind       | Amount the player paid for the blinds                        | 50.00                             | float           |
+| Position          | Player's position at the table                               | big blind                         | string          |
+| Stack             | Current stack size of the player                             | 2500.00                           | float           |
+| PreflopAction     | Actions taken during the preflop stage                       | [[checks, ]]                      | list[list[str]] |
+| FlopAction        | Actions taken during the flop stage                          | [[bets, 840], [calls, 220]]       | list[list[str]] |
+| TurnAction        | Actions taken during the turn stage                          | [[raises, 400], [calls, 500]]     | list[list[str]] |
+| RiverAction       | Actions taken during the river stage                         | [[folds, ]]                       | list[list[str]] |
+| AnteAllIn         | Whether the player went all-in during the ante               | True                              | bool            |
+| PreflopAllIn      | Whether the player went all-in during preflop                | False                             | bool            |
+| FlopAllIn         | Whether the player went all-in during the flop               | False                             | bool            |
+| TurnAllIn         | Whether the player went all-in during the turn               | False                             | bool            |
+| RiverAllIn        | Whether the player went all-in during the river              | False                             | bool            |
+| BoardFlop         | Cards dealt on the flop                                      | [4d, Qs, Ad]                      | list[string]    |
+| BoardTurn         | Card dealt on the turn                                       | [4d, Qs, Ad, 7d]                  | list[string]    |
+| BoardRiver        | Card dealt on the river                                      | [4d, Qs, Ad, 7d, 2d]              | list[string]    |
+| ShowDown          | Player's cards if went to showdown                           | [Ah, Ac]                          | list[string]    |
+| CardCombination   | Card combination held by the player                          | three of a kind, Aces             | string          |
+| Result            | Result of the hand (folded, lost, mucked, non-sd win, won)   | won                               | string          |
+| Balance           | Total value won in a hand                                    | 9150.25                           | float           |
+| FinalRank         | Player's final ranking in the tournament                     | 1                                 | int             |
+| Prize             | Prize won by the player, if any                              | 30000.00                          | float           |
+
+## License
+MIT Licence
+

pokerdf-1.0.0/README.md

@@ -0,0 +1,92 @@
+# PokerDF
+
+Converts poker hand history files into structured Pandas DataFrames, making it easier to analyze your games.
+
+Fast and reliable, PokerDF is able to process 3,000 hand history files into _.parquet_ per minute, in a MacBook Air M2 with 8-core CPU.
+
+Currently supports PokerStars. Make sure hand histories are saved in English.
+
+## Introduction
+
+Converting raw hand histories into structured data is the first step toward building a solid poker strategy and maximizing ROI. What are the optimal VPIP, PFR, and C-BET frequencies for No Limit Hold'em 6-Max? In which specific situations is a 3-Bet most profitable? When is bluffing a clear mistake? Once your data is organized in a Pandas DataFrame, the analytical explorations become unlimited, opening new possibilities to fine-tune your decision-making.
+
+## Installation
+```
+pip install pokerdf
+```
+
+## Usage
+Navigate to the folder where you want to save the output:
+```
+cd output_directory
+```
+Then, run the package like this:
+```
+pokerdf convert /path/to/handhistory/folder
+```
+
+Once the process is concluded, you will find something like this:
+```
+output_directory/
+└── output/
+   └── 20250510-105423/
+      ├── 20200607-T2928873630.parquet
+      ├── 20200607-T2928880893.parquet
+      ├── 20200607-T2928925240.parquet
+      ├── 20200607-T2928950825.parquet
+      ├── 20200607-T2928996127.parquet
+      ├── 20200607-T2929005994.parquet
+      ├── ...
+      ├── fail.txt
+      └── success.txt
+```
+#### Details
+1. Inside `output` you’ll find a subfolder named with the session ID, in this case, `20250510-105423`, containing all _.parquet_ files.
+2. Each hand history file is converted into a _.parquet_ file with the exact same structure, allowing you to concatenate them seamlessly.
+3. Each _.parquet_ file follows the naming convention _{DATE_OF_TOURNAMENT}-T{TOURNAMENT_ID}.parquet_.
+4. The file `fail.txt` provides detailed information about any files that failed to process. This file is only generated if there are failures.
+5. The file `success.txt` lists all successfully converted files. 
+
+## DataFrame structure
+| Column            | Description                                                  | Example                           | Data Type       |
+|-------------------|--------------------------------------------------------------|-----------------------------------|-----------------|
+| Modality          | The type of game being played                                | Hold'em No Limit                  | string          |
+| TableSize         | Maximum number of players                                    | 6                                 | int             |
+| BuyIn             | The buy-in amount for the tournament                         | $4.60+$0.40                       | string          |
+| TournID           | Unique identifier for the tournament                         | 2928882649                        | string          |
+| TableID           | Unique identifier for the table inside a tournament          | 10                                | int             |
+| HandID            | Unique identifier for the hand inside a tournament           | 215024616736                      | string          |
+| LocalTime         | Local time when the hand was played                          | 2020-06-07 07:44:35               | datetime        |
+| Level             | Level of the tournament                                      | IV                                | string          |
+| Ante              | Ante amount posted in the hand                               | 10.00                             | float           |
+| Blinds            | Big blind and small blind amounts                            | [10.0, 20.0]                      | list[float]     |
+| Owner             | Owner of the hand history files                              | ownername                         | string          |
+| OwnersHand        | Cards held by the owner in a specific hand                   | [9d, Js]                          | list[string]    |
+| Playing           | Number of players active during the hand                     | 5                                 | int             |
+| Player            | Player involved in the hand                                  | playername                        | string          |
+| Seat              | Seat number of the player                                    | 3                                 | int             |
+| PostedAnte        | Amount the player paid for the ante                          | 5.00                              | float           |
+| PostedBlind       | Amount the player paid for the blinds                        | 50.00                             | float           |
+| Position          | Player's position at the table                               | big blind                         | string          |
+| Stack             | Current stack size of the player                             | 2500.00                           | float           |
+| PreflopAction     | Actions taken during the preflop stage                       | [[checks, ]]                      | list[list[str]] |
+| FlopAction        | Actions taken during the flop stage                          | [[bets, 840], [calls, 220]]       | list[list[str]] |
+| TurnAction        | Actions taken during the turn stage                          | [[raises, 400], [calls, 500]]     | list[list[str]] |
+| RiverAction       | Actions taken during the river stage                         | [[folds, ]]                       | list[list[str]] |
+| AnteAllIn         | Whether the player went all-in during the ante               | True                              | bool            |
+| PreflopAllIn      | Whether the player went all-in during preflop                | False                             | bool            |
+| FlopAllIn         | Whether the player went all-in during the flop               | False                             | bool            |
+| TurnAllIn         | Whether the player went all-in during the turn               | False                             | bool            |
+| RiverAllIn        | Whether the player went all-in during the river              | False                             | bool            |
+| BoardFlop         | Cards dealt on the flop                                      | [4d, Qs, Ad]                      | list[string]    |
+| BoardTurn         | Card dealt on the turn                                       | [4d, Qs, Ad, 7d]                  | list[string]    |
+| BoardRiver        | Card dealt on the river                                      | [4d, Qs, Ad, 7d, 2d]              | list[string]    |
+| ShowDown          | Player's cards if went to showdown                           | [Ah, Ac]                          | list[string]    |
+| CardCombination   | Card combination held by the player                          | three of a kind, Aces             | string          |
+| Result            | Result of the hand (folded, lost, mucked, non-sd win, won)   | won                               | string          |
+| Balance           | Total value won in a hand                                    | 9150.25                           | float           |
+| FinalRank         | Player's final ranking in the tournament                     | 1                                 | int             |
+| Prize             | Prize won by the player, if any                              | 30000.00                          | float           |
+
+## License
+MIT Licence

pokerdf-1.0.0/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-1.0.0/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-1.0.0/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