UFCData 0.1.3__tar.gz → 0.3.0__tar.gz

{ufcdata-0.1.3 → ufcdata-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: UFCData
-Version: 0.1.3
+Version: 0.3.0
 Summary: Obtain UFC data and functions to manipulate it
 Requires-Python: >=3.10
 License-File: LICENSE.md
@@ -8,4 +8,5 @@ Requires-Dist: huggingface-hub
 Requires-Dist: pandas
 Requires-Dist: numpy
 Requires-Dist: glicko2
+Requires-Dist: rapidfuzz
 Dynamic: license-file

ufcdata-0.3.0/README.md

@@ -0,0 +1,216 @@
+# UFCData
+
+An open-source Python package for accessing, manipulating, and analyzing UFC data.
+
+https://pypi.org/project/UFCData/
+
+add helper functions like convert odds
+
+## Table of Contents
+
+- [Installation](#installation)
+
+Accessing Data
+  - [Loading Data](#loading-data)
+  - [Search](#search)
+
+Rating Function
+  - [Elo](#elo)
+
+Fighter Functions
+- [Fighter History](#elo)
+- [Fighter Statistic](#elo)
+
+Helper Functions
+  - [Odds Convert](#elo)
+  - [Weight Convert](#elo)
+  - [Gender Convert](#elo)
+  - [Mirror](#elo)
+
+Model Evaluation
+- [Odds Baseline Example](#elo)
+
+Data Sources
+  - [Online Sources](#online-sources)
+  - [Discrepancies in Data](#discrepancies-in-data)
+  - [Update Frequency](#update-frequency)
+
+## Installation
+
+```bash
+pip install ufcdata
+```
+
+##  Loading Data
+
+```python
+import ufcdata as ufc
+data = ufc.get_data()
+
+## Obtain fighter_bio dataframe
+fighter_bio = data["fighter_bio"].copy()
+
+```
+
+Note that data in here and other functions below reference data that is available prior to the data.
+
+## Search
+
+Due to various event naming conventions and fighters sharing the same name, the primary keys for the dataframes are links, which can be difficult for humans to interpret. The `search()` function uses fuzzy string matching to make it easier to find fighters, events, and other records.
+
+```python
+search(data, column, query, matches=1)
+```
+
+### Parameters
+
+* `data` — The dataframe you are searching.
+* `column` — The name of the column to search.
+* `query` — The name or text you are searching for.
+* `matches` — The number of closest matches to return. Defaults to `1`.
+
+### Example
+
+```python
+john_jones = ufc.search(fighter_bio, "Name", "Jon Jones", 3)
+```
+
+This searches the `"Name"` column of the `fighter_bio` dataframe for the three closest matches to `"Jon Jones"`.
+
+The results are returned as a dataframe, with the closest match appearing first.
+
+### Returns
+
+
+```text
+Name             Nickname   Height   Weight   Reach   Stance      Total W   Total L   Fighter Link
+Jon Jones        Bones      76.0     248.0    84.0    Orthodox    28        1         ufcstats.com/...
+Roshaun Jones    NaN        68.0     135.0    NaN     NaN         2         6         ufcstats.com/...
+Mason Jones      The Dragon 70.0     155.0    74.0    Orthodox    18        2         ufcstats.com/...
+```
+
+This is useful when the exact value stored in the dataset is unknown or when there are multiple similar names. The same function can be used with any dataframe and column containing searchable text.
+
+
+## Elo
+
+UFCData provides an Elo rating system for calculating fighter ratings based on their previous fight results. Ratings are calculated chronologically, with each fighter's rating recorded **immediately before each fight**.
+
+This allows Elo ratings to be used as features for predictive modeling without incorporating information from the fight being predicted.
+
+
+```python
+ufc.get_elo(fight_df, fighter_df, r=1500, k=30, s=400)
+```
+
+### Parameters
+
+* `fight_df` — The UFC fight dataframe, sorted from most recent to least recent.
+* `fighter_df` — The fighter information dataframe containing a `"Fighter Link"` column.
+* `r` — Initial Elo rating for each fighter. Defaults to `1500`.
+* `k` — K-factor controlling how much ratings change after each fight. Defaults to `30`.
+* `s` — Scaling factor used when calculating expected scores. Defaults to `400`.
+
+### Returns
+
+The function returns a tuple containing:
+
+1. `fighter_elo` — A dictionary mapping each fighter's UFCStats link to their final Elo rating.
+2. `elo` — The original `fights_df` dataframe with `"Fighter 1 Elo"` and `"Fighter 2 Elo"` columns added. These columns contain each fighter's Elo rating immediately prior to the corresponding fight.
+
+
+### Example
+
+```python
+import ufcdata as ufc
+
+data = ufc.get_data()
+
+past_fights = data["past_fights"].copy()
+fighter_bio = data["fighter_bio"].copy()
+
+current_elo, past_elo = ufc.get_elo(
+    past_fights,
+    fighter_bio
+)
+```
+
+The resulting `fight_elo` dataframe can then be used to examine or incorporate pre-fight Elo ratings into analysis and predictive models.
+
+
+### Important
+
+`fight_df` should be sorted from **most recent to least recent** before being passed to `get_elo()`. The function reverses the dataframe internally to process fights chronologically and returns the resulting data in the original order.
+
+## Fighter History
+
+The `get_fighter_history()` function retrieves all UFC fights for a specific fighter and formats the results from the fighter's perspective. The requested fighter is always represented as `"Fighter 1"`, regardless of which side of the original fight dataframe they appeared on.
+
+The function also calculates the age of both fighters at the time of each fight and assigns a `"UFC Fight"` number to each fight.
+
+
+```python
+ufc.get_fighter_history(fighter_link, fighter_bio, fights_df)
+```
+
+### Parameters
+
+* `fighter_link` — The UFCStats link identifying the fighter.
+* `fighter_bio` — The fighter information dataframe returned by `get_data()`.
+* `fights_df` — The fight dataframe containing UFC fight history.
+
+### Returns
+
+A dataframe containing the fighter's fight history from most recent to least recent. The requested fighter is always `"Fighter 1"`, with fighter ages and `"UFC Fight"` numbers included.
+
+
+
+### Example
+
+```python
+import ufcdata as ufc
+
+data = ufc.get_data()
+
+fighter_bio = data["fighter_bio"].copy()
+fights_df = data["past_fights"].copy()
+
+# Obtain Jon Jones' UFCStats link
+jon_jones = ufc.search(
+    fighter_bio,
+    "Name",
+    "Jon Jones"
+).iloc[0]["Fighter Link"]
+
+# Get Jon Jones' fight history
+jon_jones_history = ufc.get_fighter_history(
+    jon_jones,
+    fighter_bio,
+    fights_df
+)
+```
+
+This function is useful for analyzing an individual fighter's career, constructing fighter-level features, or preparing historical data for predictive modeling.
+
+
+## Online Sources
+
+Odds and birthplace data was obtained from https://www.tapology.com
+ 
+Venue and attendance data was obtained from https://en.wikipedia.org/wiki/List_of_UFC_events
+
+All other data was obtained from http://ufcstats.com
+
+## Discrepancies in Data
+
+UFCStats is treated as the authoritative source for UFCData. When discrepancies exist between UFCStats and other sources, such as Wikipedia or Tapology, the UFCStats data is used.
+
+The UFCStats completed events page serves as the authoritative source for event, fight, and round data. Individual fighter profiles may contain fights from organizations or events that are not included in the completed events database, including WEC, Strikeforce, and PRIDE. These events are therefore excluded from UFCData.
+
+## Update Frequency
+
+The dataset is updated at the start of the scheduled broadcast time for each event. This update captures changes to betting odds, as well as any cancelled, postponed, or otherwise modified fights.
+
+A second update occurs 24 hours after the start of the broadcast. This update captures the finalized event, fight, and round data, as well as information on upcoming events and fights.
+
+Changes occurring between these scheduled updates are not automatically captured. Users are responsible for manually updating the dataset if they require the most current data for analysis or prediction.

{ufcdata-0.1.3 → ufcdata-0.3.0}/UFCData.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: UFCData
-Version: 0.1.3
+Version: 0.3.0
 Summary: Obtain UFC data and functions to manipulate it
 Requires-Python: >=3.10
 License-File: LICENSE.md
@@ -8,4 +8,5 @@ Requires-Dist: huggingface-hub
 Requires-Dist: pandas
 Requires-Dist: numpy
 Requires-Dist: glicko2
+Requires-Dist: rapidfuzz
 Dynamic: license-file

{ufcdata-0.1.3 → ufcdata-0.3.0}/UFCData.egg-info/SOURCES.txt

@@ -8,6 +8,9 @@ UFCData.egg-info/requires.txt
 UFCData.egg-info/top_level.txt
 ufcdata/__init__.py
 ufcdata/data.py
+ufcdata/fighter.py
+ufcdata/ratings.py
+ufcdata/search.py
 ufcdata.egg-info/PKG-INFO
 ufcdata.egg-info/SOURCES.txt
 ufcdata.egg-info/dependency_links.txt

{ufcdata-0.1.3 → ufcdata-0.3.0}/UFCData.egg-info/requires.txt

@@ -2,3 +2,4 @@ huggingface-hub
 pandas
 numpy
 glicko2
+rapidfuzz

{ufcdata-0.1.3 → ufcdata-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "UFCData"
-version = "0.1.3"
+version = "0.3.0"
 description = "Obtain UFC data and functions to manipulate it"
 requires-python = ">=3.10"
 
@@ -9,4 +9,5 @@ dependencies = [
     "pandas",
     "numpy",
     "glicko2",
+    "rapidfuzz",
 ]

ufcdata-0.3.0/ufcdata/__init__.py

@@ -0,0 +1,4 @@
+from .data import get_data
+from .search import search
+from .ratings import get_elo
+from .fighter import get_fighter_history

{ufcdata-0.1.3 → ufcdata-0.3.0}/ufcdata/data.py

@@ -3,6 +3,20 @@ import pickle
 import logging
 
 def get_data():
+    """
+    Obtains all UFC related data
+
+    Returns
+    dict
+        Dictionary containing UFC data as pandas DataFrames.
+        Individual DataFrames can be accessed using their
+        corresponding dictionary keys.
+
+    Examples
+    --------
+    >>> data = get_data()
+    >>> past_events = data["past_events"].copy()
+    """
 
     logging.getLogger("huggingface_hub").setLevel(logging.ERROR)
     

ufcdata-0.3.0/ufcdata/fighter.py

@@ -0,0 +1,701 @@
+import pandas as pd
+import numpy as np
+from datetime import date
+from .ratings import get_elo, expected_score, update_rating
+
+def _mirror_helper(df, cols_1, cols_2, in_order=True):
+    df = df.copy()
+    df_original = df.copy()
+
+    # Swap each pair of columns
+    for c1, c2 in zip(cols_1, cols_2):
+        temp = df[c1].copy()
+        df[c1] = df[c2]
+        df[c2] = temp
+
+    if not in_order:
+        return pd.concat([df_original, df], ignore_index=True)
+
+    rows = []
+    for r1, r2 in zip(df_original.itertuples(index=False), df.itertuples(index=False)):
+        rows.append(r1)
+        rows.append(r2)
+
+    return pd.DataFrame(rows, columns=df.columns)
+
+
+def get_fighter_history(fighter_link, fighter_bio, fights_df):
+  """
+    Retrieves the fight history of a UFC fighter.
+
+    The returned DataFrame contains all fights involving the specified
+    fighter, with the fighter consistently represented as "Fighter 1".
+    The function also calculates the age of both fighters at the time
+    of each fight and assigns a chronological UFC fight number.
+
+    Parameters
+    ----------
+    fighter_link : str
+        UFCStats link identifying the fighter whose history is being
+        retrieved.
+    fighter_bio : pandas.DataFrame
+        DataFrame containing fighter information. Must contain
+        "Fighter Link" and "DOB" columns.
+    fights_df : pandas.DataFrame
+        DataFrame containing UFC fight data. Must contain fighter links,
+        fight dates, outcomes, and the other fight information required
+        by the function.
+
+    Returns
+    -------
+    pandas.DataFrame
+        DataFrame containing the fighter's complete fight history.
+        The requested fighter is represented as "Fighter 1" in every
+        row. The DataFrame includes the ages of both fighters at the
+        time of each fight and a "UFC Fight" column numbering the
+        fighter's fights chronologically.
+
+    Notes
+    -----
+    Fighter ages are calculated using 365.25 days per year. The
+    "UFC Fight" column counts fights from the most recent fight
+    backwards, with the most recent fight numbered 1.
+
+    Examples
+    --------
+    >>> fighter_history = get_fighter_history(
+    ...     fighter_link,
+    ...     fighter_bio,
+    ...     fights_df
+    ... )
+    >>> fighter_history[["Date", "UFC Fight", "Fighter 1",
+    ...                   "Fighter 1 Age"]].head()
+
+  """
+
+  fighter_history = fights_df[
+    (fights_df["Fighter 1 Link"] == fighter_link) |
+    (fights_df["Fighter 2 Link"] == fighter_link)]
+
+  fighter_history = _mirror_helper(fighter_history, ['Fighter 1', 'Fighter 1 Odds', 'Fighter 1 Link',
+       'Fighter 1 Outcome', 'Fighter 1 Bonus'],['Fighter 2', 'Fighter 2 Odds',
+       'Fighter 2 Link', 'Fighter 2 Outcome', 'Fighter 2 Bonus'])
+
+  fighter_history = fighter_history[
+    (fighter_history["Fighter 1 Link"] == fighter_link)]
+
+  fighter_history = fighter_history.merge(
+    fighter_bio[["Fighter Link", "DOB"]],
+    left_on="Fighter 1 Link",
+    right_on="Fighter Link",
+    how="left")
+  fighter_history = fighter_history.rename(columns={"DOB": "Fighter 1 Age"})
+  fighter_history = fighter_history.drop(columns=["Fighter Link"])
+  fighter_history["Fighter 1 Age"] = (pd.to_datetime(fighter_history["Date"]) - pd.to_datetime(fighter_history["Fighter 1 Age"])).dt.days / 365.25
+
+  fighter_history = fighter_history.merge(
+    fighter_bio[["Fighter Link", "DOB"]],
+    left_on="Fighter 2 Link",
+    right_on="Fighter Link",
+    how="left")
+  fighter_history = fighter_history.rename(columns={"DOB": "Fighter 2 Age"})
+  fighter_history = fighter_history.drop(columns=["Fighter Link"])
+  fighter_history["Fighter 2 Age"] = (pd.to_datetime(fighter_history["Date"]) - pd.to_datetime(fighter_history["Fighter 2 Age"])).dt.days / 365.25
+  fighter_history["UFC Fight"] = range(len(fighter_history), 0, -1)
+  fighter_history = fighter_history[['Date', "UFC Fight", 'Event Link', 'Fight Link', 'Weight Class',
+       'Gender', 'Title', 'Fighter 1', 'Fighter 1 Odds', 'Fighter 1 Age', 'Fighter 1 Link',
+       'Fighter 1 Outcome', 'Fighter 1 Bonus', 'Fighter 2', 'Fighter 2 Odds','Fighter 2 Age',
+       'Fighter 2 Link', 'Fighter 2 Outcome', 'Fighter 2 Bonus', 'Method',
+       'Round', 'Time', 'Time Format', 'Referee', 'Details']]
+
+  return fighter_history
+
+
+
+def get_fighter_statistic(fighter_link, fighter_bio, fights_df, rounds_df, future_df,
+                          r=1500, k=30, s=400):
+    
+    """
+    Generate historical and current statistics for a UFC fighter.
+
+    The function retrieves the fighter's UFC fight history and constructs
+    fight-level statistics from the fighter's perspective. It calculates
+    the fighter's UFC record, win rate, Elo rating, cumulative fight time,
+    striking statistics, takedown statistics, and submission averages using
+    only information available before each fight.
+
+    For fighters with no previous UFC fights, a baseline row is returned
+    with an initial Elo rating and zero UFC wins, losses, draws, and
+    no-contests. Historical performance statistics are left as NaN because
+    no prior fight data is available.
+
+    Parameters
+    ----------
+    fighter_link : str
+        URL or unique identifier for the fighter.
+    fighter_bio : pandas.DataFrame
+        DataFrame containing fighter biographical information, including
+        fighter names and links.
+    fights_df : pandas.DataFrame
+        DataFrame containing UFC fight-level results.
+    rounds_df : pandas.DataFrame
+        DataFrame containing round-level UFC statistics.
+    future_df : pandas.DataFrame
+        DataFrame containing the fighter's upcoming fight. The first row
+        is used to determine the date for which current statistics are
+        calculated.
+    r : float, default=1500
+        Initial Elo rating assigned to fighters with no previous Elo history.
+    k : float, default=30
+        Elo update factor.
+    s : float, default=400
+        Elo scaling factor used when calculating expected scores.
+
+    Returns
+    -------
+    current_statistic : pandas.DataFrame
+        One-row DataFrame containing the fighter's statistics immediately
+        before the upcoming fight. Historical statistics are calculated
+        using only fights occurring before the upcoming fight date.
+
+    past_statistic : pandas.DataFrame
+        DataFrame containing the fighter's historical statistics for each
+        previous UFC fight, with statistics calculated using only fights
+        occurring before each respective fight.
+
+    Notes
+    -----
+    The function calculates cumulative statistics rather than statistics
+    from a single fight. This prevents information from a future fight from
+    being used when generating features for an earlier fight.
+
+    Historical statistics include:
+        - UFC record and win rate
+        - Elo rating
+        - Total fight time
+        - Significant strikes landed per minute (SLpM)
+        - Significant strike accuracy and defense
+        - Significant strikes absorbed per minute (SApM)
+        - Takedown average, accuracy, and defense
+        - Submission attempts per 15 minutes
+
+    Fighters with no previous UFC fights receive an initial Elo rating of
+    `r`, while statistics requiring historical fight data are set to NaN.
+    """
+
+    record = get_fighter_history(fighter_link, fighter_bio, fights_df)
+
+    date = future_df.iloc[0]["Date"]
+    date = pd.to_datetime(date).date()
+
+    if len(record) == 0:
+        columns = [
+            'Date', 'UFC Fight', 'Weight Class', 'Gender', 'Title', 'Fighter',
+            'Fighter Link', 'Fighter Outcome', 'UFC W', 'UFC L', 'UFC D', 'UFC NC',
+            'UFC Win Rate', 'Fighter Elo',
+            'Fight Time', 'SLpM', 'Str Acc', 'SApM',
+            'Str Def', 'TD Avg', 'TD Acc', 'TD Def', 'Sub Avg'
+        ]
+
+        fighter_name = fighter_bio.loc[
+            fighter_bio["Fighter Link"] == fighter_link,
+            "Name"
+        ].iloc[0]
+
+        df = pd.DataFrame([{
+            "Date": date,
+            "UFC Fight": 1,
+            "Weight Class": None,
+            "Gender": None,
+            "Title": None,
+            "Fighter": fighter_name,
+            "Fighter Link": fighter_link,
+            "Fighter Outcome": None,
+            "UFC W": 0,
+            "UFC L": 0,
+            "UFC D": 0,
+            "UFC NC": 0,
+            "UFC Win Rate": None,
+            "Fighter Elo": r,
+            "Fight Time": None,
+            "SLpM": None,
+            "Str Acc": None,
+            "SApM": None,
+            "Str Def": None,
+            "TD Avg": None,
+            "TD Acc": None,
+            "TD Def": None,
+            "Sub Avg": None
+        }], columns=columns)
+
+        df = df.astype(object).where(pd.notna(df), np.nan)
+
+        df["UFC Fight"] = df["UFC Fight"].astype("Int64")
+        df[["UFC W", "UFC L", "UFC D", "UFC NC"]] = (
+            df[["UFC W", "UFC L", "UFC D", "UFC NC"]].astype("Int64")
+        )
+
+        return (df, df)
+
+    statistic = record[
+        ['Date', 'UFC Fight', 'Weight Class',
+         'Gender', 'Title', 'Fighter 1',
+         'Fighter 1 Link', 'Fighter 1 Outcome']
+    ].copy()
+
+    cols = [
+        "Date", "UFC Fight", "Weight Class", "Gender",
+        "Title", "Fighter 1", "Fighter 1 Link",
+        "Fighter 1 Outcome"
+    ]
+
+    statistic[cols] = statistic[cols].iloc[::-1].to_numpy()
+
+    last = statistic.iloc[-1]
+    new_row = last.copy()
+    new_row[:] = pd.NA
+
+    new_row["Date"] = date
+    new_row["UFC Fight"] = last["UFC Fight"] + 1
+    new_row["Gender"] = last["Gender"]
+    new_row["Fighter 1"] = last["Fighter 1"]
+    new_row["Fighter 1 Link"] = last["Fighter 1 Link"]
+
+    statistic = pd.concat(
+        [statistic, new_row.to_frame().T],
+        ignore_index=True
+    )
+
+    statistic["Date"] = pd.to_datetime(statistic["Date"]).dt.date
+
+    statistic["UFC W"] = 0
+    statistic["UFC L"] = 0
+    statistic["UFC D"] = 0
+    statistic["UFC NC"] = 0
+
+    for i in range(1, len(statistic)):
+
+        # Carry forward previous totals
+        statistic.loc[i, "UFC W"] = statistic.loc[i-1, "UFC W"]
+        statistic.loc[i, "UFC L"] = statistic.loc[i-1, "UFC L"]
+        statistic.loc[i, "UFC D"] = statistic.loc[i-1, "UFC D"]
+        statistic.loc[i, "UFC NC"] = statistic.loc[i-1, "UFC NC"]
+
+        # Update based on previous fight result
+        result = statistic.loc[i-1, "Fighter 1 Outcome"]
+
+        if result == "W":
+            statistic.loc[i, "UFC W"] += 1
+        elif result == "L":
+            statistic.loc[i, "UFC L"] += 1
+        elif result == "D":
+            statistic.loc[i, "UFC D"] += 1
+        elif result == "NC":
+            statistic.loc[i, "UFC NC"] += 1
+
+    statistic = statistic[::-1]
+
+    statistic[
+        ["UFC W", "UFC L", "UFC D", "UFC NC"]
+    ] = (
+        statistic[
+            ["UFC W", "UFC L", "UFC D", "UFC NC"]
+        ].iloc[::-1].reset_index(drop=True)
+    )
+
+    statistic["UFC Win Rate"] = (
+        statistic["UFC W"] /
+        (
+            statistic["UFC L"]
+            + statistic["UFC D"]
+            + statistic["UFC NC"]
+            + statistic["UFC W"]
+        )
+    )
+
+    # Elo
+    current_elo,elo = get_elo(fights_df, fighter_bio, r, k, s)
+
+    elo = elo[
+        (elo["Fighter 1 Link"] == fighter_link) |
+        (elo["Fighter 2 Link"] == fighter_link)
+    ]
+
+    elo = elo[
+        [
+            "Fighter 1", "Fighter 1 Elo", "Fighter 1 Outcome",
+            "Fighter 1 Link",
+            "Fighter 2", "Fighter 2 Elo", "Fighter 2 Outcome",
+            "Fighter 2 Link"
+        ]
+    ]
+
+    elo = _mirror_helper(
+        elo,
+        [
+            "Fighter 1", "Fighter 1 Elo",
+            "Fighter 1 Outcome", "Fighter 1 Link"
+        ],
+        [
+            "Fighter 2", "Fighter 2 Elo",
+            "Fighter 2 Outcome", "Fighter 2 Link"
+        ]
+    )
+
+    elo = elo[
+        elo["Fighter 1 Link"] == fighter_link
+    ]
+
+    elo = elo.reset_index(drop=True)
+
+    new_row = pd.DataFrame(
+        [[np.nan] * len(elo.columns)],
+        columns=elo.columns
+    )
+
+    elo = pd.concat(
+        [new_row, elo],
+        ignore_index=True
+    )
+
+    fighter_elo = elo.at[1, "Fighter 1 Elo"]
+    opponent_elo = elo.at[1, "Fighter 2 Elo"]
+    fighter_outcome = elo.at[1, "Fighter 1 Outcome"]
+
+    if fighter_outcome == "W":
+        expected_1 = expected_score(
+            fighter_elo,
+            opponent_elo,
+            s
+        )
+
+        elo_1_new = update_rating(
+            fighter_elo,
+            k,
+            1,
+            expected_1
+        )
+
+        elo.at[0, "Fighter 1 Elo"] = elo_1_new
+
+    elif fighter_outcome == "L":
+        expected_1 = expected_score(
+            fighter_elo,
+            opponent_elo,
+            s
+        )
+
+        elo_1_new = update_rating(
+            fighter_elo,
+            k,
+            0,
+            expected_1
+        )
+
+        elo.at[0, "Fighter 1 Elo"] = elo_1_new
+
+    elif fighter_outcome == "D":
+        expected_1 = expected_score(
+            fighter_elo,
+            opponent_elo,
+            s
+        )
+
+        elo_1_new = update_rating(
+            fighter_elo,
+            k,
+            0.5,
+            expected_1
+        )
+
+        elo.at[0, "Fighter 1 Elo"] = elo_1_new
+
+    elif fighter_outcome == "NC":
+        elo.at[0, "Fighter 1 Elo"] = fighter_elo
+
+    elo = elo["Fighter 1 Elo"]
+    elo = elo.iloc[::-1].reset_index(drop=True)
+
+    statistic = pd.concat(
+        [statistic, elo],
+        axis=1
+    )
+
+    # Get fight statistics
+    fight_time = get_fighter_history(
+        fighter_link,
+        fighter_bio,
+        fights_df
+    )
+
+    fight_time["new_time"] = fight_time["Time"].apply(
+        lambda x: int(x.split(":")[0]) * 60
+        + int(x.split(":")[1])
+    )
+
+    fight_time["new_round"] = (
+        (fight_time["Round"] - 1) * 60 * 5
+    )
+
+    fight_time["Fight Time"] = (
+        fight_time["new_time"]
+        + fight_time["new_round"]
+    ) / 60
+
+    statistic["Fight Time"] = statistic["Date"].apply(
+        lambda d: fight_time.loc[
+            fight_time["Date"].dt.date < d,
+            "Fight Time"
+        ].sum()
+    )
+
+    rounds = rounds_df
+
+    rounds = rounds[
+        (rounds["Fighter 1 Link"] == fighter_link) |
+        (rounds["Fighter 2 Link"] == fighter_link)
+    ]
+
+    rounds = _mirror_helper(
+        rounds,
+        [
+            "Fighter 1", "Fighter 1 Link",
+            "Fighter 1 TD", "Fighter 1 Sub Att",
+            "Fighter 1 Rev", "Fighter 1 Ctrl",
+            "Fighter 1 KD", "Fighter 1 Total SS"
+        ],
+        [
+            "Fighter 2", "Fighter 2 Link",
+            "Fighter 2 TD", "Fighter 2 Sub Att",
+            "Fighter 2 Rev", "Fighter 2 Ctrl",
+            "Fighter 2 KD", "Fighter 2 Total SS"
+        ]
+    )
+
+    rounds = rounds[
+        rounds["Fighter 1 Link"] == fighter_link
+    ]
+
+    rounds["Sig landed"] = (
+        rounds["Fighter 1 Total SS"]
+        .str.split()
+        .str[0]
+        .astype(int)
+    )
+
+    rounds["Sig att"] = (
+        rounds["Fighter 1 Total SS"]
+        .str.split()
+        .str[2]
+        .astype(int)
+    )
+
+    rounds["Strike acc"] = (
+        rounds["Sig landed"] / rounds["Sig att"]
+    )
+
+    rounds["Strikes absorbed"] = (
+        rounds["Fighter 2 Total SS"]
+        .str.split()
+        .str[0]
+        .astype(int)
+    )
+
+    rounds["Opp sig att"] = (
+        rounds["Fighter 2 Total SS"]
+        .str.split()
+        .str[2]
+        .astype(int)
+    )
+
+    statistic["SLpM"] = statistic["Date"].apply(
+        lambda d: rounds.loc[
+            rounds["Date"].dt.date < d,
+            "Sig landed"
+        ].sum()
+    )
+
+    statistic["SLpM"] = (
+        statistic["SLpM"] / statistic["Fight Time"]
+    )
+
+    statistic["Sig landed"] = statistic["Date"].apply(
+        lambda d: rounds.loc[
+            rounds["Date"].dt.date < d,
+            "Sig landed"
+        ].sum()
+    )
+
+    statistic["Sig att"] = statistic["Date"].apply(
+        lambda d: rounds.loc[
+            rounds["Date"].dt.date < d,
+            "Sig att"
+        ].sum()
+    )
+
+    statistic["Str Acc"] = (
+        statistic["Sig landed"] /
+        statistic["Sig att"]
+    )
+
+    statistic["SApM"] = statistic["Date"].apply(
+        lambda d: rounds.loc[
+            rounds["Date"].dt.date < d,
+            "Strikes absorbed"
+        ].sum()
+    )
+
+    statistic["SApM"] = (
+        statistic["SApM"] / statistic["Fight Time"]
+    )
+
+    statistic["Strikes absorbed"] = statistic["Date"].apply(
+        lambda d: rounds.loc[
+            rounds["Date"].dt.date < d,
+            "Strikes absorbed"
+        ].sum()
+    )
+
+    statistic["Opp sig att"] = statistic["Date"].apply(
+        lambda d: rounds.loc[
+            rounds["Date"].dt.date < d,
+            "Opp sig att"
+        ].sum()
+    )
+
+    statistic["Str Def"] = 1 - (
+        statistic["Strikes absorbed"] /
+        statistic["Opp sig att"]
+    )
+
+    rounds["Td"] = (
+        rounds["Fighter 1 TD"]
+        .str.split()
+        .str[0]
+        .astype(int)
+    )
+
+    rounds["TD landed"] = (
+        rounds["Fighter 1 TD"]
+        .str.split()
+        .str[0]
+        .astype(int)
+    )
+
+    rounds["TD att"] = (
+        rounds["Fighter 1 TD"]
+        .str.split()
+        .str[2]
+        .astype(int)
+    )
+
+    rounds["TD absorbed"] = (
+        rounds["Fighter 2 TD"]
+        .str.split()
+        .str[0]
+        .astype(int)
+    )
+
+    rounds["Opp TD att"] = (
+        rounds["Fighter 2 TD"]
+        .str.split()
+        .str[2]
+        .astype(int)
+    )
+
+    rounds["Sub att"] = rounds["Fighter 1 Sub Att"]
+
+    statistic["TD Avg"] = statistic["Date"].apply(
+        lambda d: rounds.loc[
+            rounds["Date"].dt.date < d,
+            "Td"
+        ].sum()
+    )
+
+    statistic["TD Avg"] = (
+        statistic["TD Avg"] /
+        statistic["Fight Time"] * 15
+    )
+
+    statistic["TD landed"] = statistic["Date"].apply(
+        lambda d: rounds.loc[
+            rounds["Date"].dt.date < d,
+            "TD landed"
+        ].sum()
+    )
+
+    statistic["TD att"] = statistic["Date"].apply(
+        lambda d: rounds.loc[
+            rounds["Date"].dt.date < d,
+            "TD att"
+        ].sum()
+    )
+
+    statistic["TD absorbed"] = statistic["Date"].apply(
+        lambda d: rounds.loc[
+            rounds["Date"].dt.date < d,
+            "TD absorbed"
+        ].sum()
+    )
+
+    statistic["Opp TD att"] = statistic["Date"].apply(
+        lambda d: rounds.loc[
+            rounds["Date"].dt.date < d,
+            "Opp TD att"
+        ].sum()
+    )
+
+    statistic["TD Acc"] = np.where(
+        statistic["TD att"] > 0,
+        statistic["TD landed"] /
+        statistic["TD att"],
+        np.nan
+    )
+
+    statistic["TD Def"] = np.where(
+        statistic["Opp TD att"] > 0,
+        1 - (
+            statistic["TD absorbed"] /
+            statistic["Opp TD att"]
+        ),
+        np.nan
+    )
+
+    statistic["Sub Avg"] = statistic["Date"].apply(
+        lambda d: rounds.loc[
+            rounds["Date"].dt.date < d,
+            "Sub att"
+        ].sum()
+    )
+
+    statistic["Sub Avg"] = (
+        statistic["Sub Avg"] /
+        statistic["Fight Time"] * 15
+    )
+
+    statistic = statistic.drop(
+        columns=[
+            "Sig landed",
+            "Sig att",
+            "Strikes absorbed",
+            "Opp sig att",
+            "TD landed",
+            "TD att",
+            "TD absorbed",
+            "Opp TD att"
+        ]
+    )
+
+    statistic.columns = statistic.columns.str.replace(
+        "Fighter 1",
+        "Fighter",
+        regex=False
+    )
+
+    statistic = statistic.reset_index(drop=True)
+
+    current_statistic = statistic.iloc[[0]].copy()
+    current_statistic["Date"] = np.nan
+    past_statistic = statistic.iloc[1:].reset_index(drop=True)
+
+    return (current_statistic, past_statistic)

ufcdata-0.3.0/ufcdata/ratings.py

@@ -0,0 +1,130 @@
+import pandas as pd
+from glicko2 import Player
+
+#@title Elo function
+def expected_score(rating, opponent_rating, s):
+  return (1)/(1 + 10**((opponent_rating - rating)/(s)))
+
+#Rating update
+def update_rating(rating, k, outcome, expected):
+  return rating + k*(outcome - expected)
+
+# Elo function
+#  Make sure fights are sorted from most recent to least recent. Gets Elo prior to fight.
+def get_elo(fight_df, fighter_df, r=1500, k=30, s=400):
+  """
+    Calculates pre-fight Elo ratings for UFC fighters.
+
+    Fights are processed chronologically from oldest to newest, with
+    each fighter's Elo rating recorded immediately before each fight.
+    Fighter ratings are initialized to `r` and updated after each fight
+    using the specified K-factor and Elo scale.
+
+    Parameters
+    ----------
+    fight_df : pandas.DataFrame
+        UFC fight data sorted from most recent to least recent.
+        Must contain fighter links, fight outcomes, and the fight
+        information required to construct the output.
+    fighter_df : pandas.DataFrame
+        DataFrame containing fighter information. Must contain a
+        "Fighter Link" column used to identify each fighter.
+    r : float, default=1500
+        Initial Elo rating assigned to each fighter.
+    k : float, default=30
+        K-factor controlling the magnitude of Elo rating changes
+        after each fight.
+    s : float, default=400
+        Elo scaling factor used when calculating expected scores.
+
+    Returns
+    -------
+    current_elo : dict
+        Dictionary mapping each fighter's link to their current Elo rating
+        after processing all fights.
+
+    past_elo : pandas.DataFrame
+        Fight-level DataFrame containing the original fight information
+        and the Elo rating of each fighter immediately before the fight.
+
+    Notes
+    -----
+    The input fight data should be sorted from most recent to least
+    recent. The function reverses this order internally to process
+    fights chronologically, then returns the resulting data in the
+    original order.
+
+    Examples
+    --------
+    >>> fighter_elo, fight_elo = get_elo(fight_df, fighter_df)
+    >>> fight_elo[["Fighter 1", "Fighter 1 Elo",
+    ...            "Fighter 2", "Fighter 2 Elo"]].head()
+  """
+
+  fight_df = fight_df[::-1]
+
+  original_fight_df = fight_df.copy()
+
+  fighter_1_elo = []
+  fighter_2_elo = []
+
+  ## Create a dictionary of fighters and their Elo
+  fighter_df = fighter_df.copy()
+  fighter_df["Elo"] = r
+  fighter_df = dict(zip(fighter_df["Fighter Link"], fighter_df["Elo"]))
+
+  ## Create a list of fights
+  fight_df = fight_df[["Fighter 1 Link", "Fighter 1 Outcome", "Fighter 2 Link", "Fighter 2 Outcome"]]
+  fight_df = fight_df.values.tolist()
+
+
+  ## Loop through each fight in order
+  for fight in fight_df:
+    ## Get fighters Elo from fighter_df
+    elo_1 = fighter_df[fight[0]]
+    elo_2 = fighter_df[fight[2]]
+    ## Add to final list
+    fighter_1_elo.append(elo_1)
+    fighter_2_elo.append(elo_2)
+    ## Update Elo
+    if (fight[1] == "W") and ((fight[3] == "L")):
+      expected_1 = expected_score(elo_1, elo_2, s)
+      elo_1_new = update_rating(elo_1, k, 1, expected_1)
+      expected_2 = expected_score(elo_2, elo_1, s)
+      elo_2_new = update_rating(elo_2, k, 0, expected_2)
+      fighter_df[fight[0]] = elo_1_new
+      fighter_df[fight[2]] = elo_2_new
+    elif (fight[1] == "L") and (fight[3] == "W"):
+      expected_1 = expected_score(elo_1, elo_2, s)
+      elo_1_new = update_rating(elo_1, k, 0, expected_1)
+      expected_2 = expected_score(elo_2, elo_1, s)
+      elo_2_new = update_rating(elo_2, k, 1, expected_2)
+      fighter_df[fight[0]] = elo_1_new
+      fighter_df[fight[2]] = elo_2_new
+    elif (fight[1] == "D") and (fight[3] == "D"):
+      expected_1 = expected_score(elo_1, elo_2, s)
+      elo_1_new = update_rating(elo_1, k, 0.5, expected_1)
+      expected_2 = expected_score(elo_2, elo_1, s)
+      elo_2_new = update_rating(elo_2, k, 0.5, expected_2)
+      fighter_df[fight[0]] = elo_1_new
+      fighter_df[fight[2]] = elo_2_new
+
+
+  elo_1 = pd.DataFrame(fighter_1_elo, columns=["Fighter 1 Elo"])
+  elo_2 = pd.DataFrame(fighter_2_elo, columns=["Fighter 2 Elo"])
+  elo = pd.concat(
+    [
+        original_fight_df.reset_index(drop=True),
+        elo_1.reset_index(drop=True),
+        elo_2.reset_index(drop=True)
+    ],
+    axis=1
+  )
+  elo = elo[['Date', 'Event Link', 'Fight Number', 'Fight Link', 'Weight Class',
+       'Gender', 'Title', 'Fighter 1', 'Fighter 1 Elo', 'Fighter 1 Odds', 'Fighter 1 Link',
+       'Fighter 1 Outcome', 'Fighter 1 Bonus', 'Fighter 2','Fighter 2 Elo', 'Fighter 2 Odds',
+       'Fighter 2 Link', 'Fighter 2 Outcome', 'Fighter 2 Bonus', 'Method',
+       'Round', 'Time', 'Time Format', 'Referee', 'Details']]
+  past_elo = elo[::-1].copy()
+  current_elo = fighter_df
+  return (current_elo, past_elo)

ufcdata-0.3.0/ufcdata/search.py

@@ -0,0 +1,39 @@
+from rapidfuzz.fuzz import ratio
+
+def search(data, column , query, matches=1):
+    """
+    Searches a UFC DataFrame for rows matching a query.
+
+    Uses fuzzy string matching to identify the rows in the specified
+    column that most closely match the query.
+
+    Parameters
+    ----------
+    data : pandas.DataFrame
+        UFC DataFrame to search.
+    column : str
+        Name of the column to search.
+    query : str
+        Search query to match against the specified column.
+    matches : int, default=1
+        Number of closest matches to return.
+
+    Returns
+    -------
+    pandas.DataFrame
+        DataFrame containing the closest matching rows, sorted from
+        highest to lowest similarity.
+
+    Examples
+    --------
+    >>> data = get_data()
+    >>> results = search(data["fighters"], "Name", "Jon Jones")
+    """
+    scores = data[column].fillna("").apply(
+    lambda x: ratio(str(x), query))
+
+    result = data.loc[scores.nlargest(matches).index].copy()
+    result["score"] = scores.loc[result.index]
+    result = result.sort_values("score", ascending=False).drop(columns="score")
+
+    return result

ufcdata-0.1.3/ufcdata/__init__.py

@@ -1 +0,0 @@
-from .data import get_data