rustat-python-api 0.4.11__py3-none-any.whl

rustat_python_api/__init__.py

@@ -0,0 +1,4 @@
+from .parser import RuStatParser
+from .models_api import DynamoLab
+
+__all__ = ['RuStatParser', 'DynamoLab']

rustat_python_api/config.py

@@ -0,0 +1,37 @@
+columns = [
+    'player_name', 'team_name', 'half', 'second', 'action_id', 'action_name',
+    'position_name', 'possession_number', 'pos_x', 'pos_y', 'pos_dest_x', 'pos_dest_y',
+    'player_id', 'number', 'team_id', 'standart_name', 'possession_time',
+    'opponent_id', 'opponent_name', 'opponent_team_id', 'opponent_team_name',
+    'opponent_position_name', 'zone_name', 'zone_dest_name', 'len',
+    'possession_team_id', 'possession_team_name', 'possession_name',
+    'attack_status_name', 'attack_type_name', 'attack_flang_name',
+    'attack_team_id', 'attack_team_name', 'attack_number',
+    'body_name', 'gate_x', 'gate_y', 'assistant_id',
+    'assistant_name', 'shot_type', 'touches', 'xg',
+    'shot_handling', 'match_id', 'receiver_id', 'receiver_name'
+]
+
+numeric_columns = [
+    'id', 'number', 'player_id', 'team_id', 'half', 'second',
+    'pos_x', 'pos_y', 'pos_dest_x', 'pos_dest_y', 'len', 'possession_id', 'possession_team_id',
+    'opponent_id', 'opponent_team_id', 'zone_id', 'zone_dest_id',
+    'possession_number', 'attack_status_id', 'attack_team_id', 'assistant_id', 'touches', 'xg'
+]
+
+id2type = {
+    1: 'pass', 2: 'duel', 3: 'foul',
+    4: 'shot', 5: 'free kick', 6: 'interception',
+    7: 'rebound', 8: 'goal', 9: 'clearance',
+    10: 'bad ball control', 11: 'control', 12: 'attack',
+    13: 'keeper', 14: 'substitution', 15: 'formation',
+    16: 'player position', 17: 'ball off', 18: 'match status',
+    19: 'mistake', 20: 'translation problem', 21: 'carry',
+    22: 'receive', 23: 'goal attack involvement', 24: 'rating',
+    25: 'average position', 26: 'cross', 27: 'ball out',
+    28: 'other', 29: 'video', 30: 'bad mistake',
+    31: 'bad keeper mistake', 32: 'goal moment', 33: 'team pressing',
+    34: 'line up', 35: 'sync', 36: 'referee',
+    37: 'insurance', 38: 'injury',
+    128: 'staff', 161: 'sub player'
+}

rustat_python_api/models_api.py

@@ -0,0 +1,58 @@
+import requests
+import numpy as np
+import pandas as pd
+
+
+class DynamoLab:
+    def __init__(self, host: str = "http://localhost:8000/"):
+        self.host = host
+
+    def get_active_models(self):
+        url = self.host + "models"
+        response = requests.get(url)
+        return response.json()
+
+    def run_model(
+        self,
+        model: str,
+        data: pd.DataFrame,
+        return_type: str = "json",
+        inplace: bool = False,
+        return_df: bool = False,
+        inplace_column: str = None
+    ):
+        """
+        model: str
+            The name of the model to run
+        return_type: str
+            One of: "json", "list", "numpy"
+        """
+
+        url = self.host + "predict"
+        csv_string = data.to_csv(index=False)
+
+        body = {
+            "model": model,
+            "data": csv_string,
+        }
+
+        response = requests.post(url, json=body)
+
+        if return_df or inplace:
+            if inplace_column is None:
+                raise ValueError("inplace_column must be specified if inplace is True")
+            if inplace:
+                data[inplace_column] = np.array(response.json()["prediction"])
+            else:
+                df = data.copy()
+                df[inplace_column] = np.array(response.json()["prediction"])
+                return df
+        else:
+            if return_type == "json":
+                return response.json()
+            elif return_type == "list":
+                return response.json()["prediction"]
+            elif return_type == "numpy":
+                return np.array(response.json()["prediction"])
+            else:
+                raise ValueError("return_type must be one of: json, list, numpy")

rustat_python_api/parser.py

@@ -0,0 +1,226 @@
+import requests
+import pandas as pd
+from collections import defaultdict
+from tqdm import tqdm
+import time
+
+from .urls import URLs
+from .config import numeric_columns
+from .processing import processing
+
+
+class RuStatParser:
+    def __init__(
+        self,
+        user: str,
+        password: str,
+        urls: dict = URLs,
+        sleep: int = -1
+    ):
+        self.user = user
+        self.password = password
+        self.urls = urls
+        self.sleep = sleep
+
+        self.cached_info = {}
+
+    def resp2data(self, query: str) -> dict:
+
+        if self.sleep > 0:
+            time.sleep(self.sleep)
+
+        response = requests.get(query)
+        return response.json()
+
+    def get_rpl_info(self):
+        for season_id in tqdm(range(1, 36)):
+            data = self.resp2data(
+                self.urls["tournament_teams"].format(
+                    user=self.user,
+                    password=self.password,
+                    season_id=season_id
+                )
+            )
+
+            if data:
+                first_team_id = data["data"]["row"][0]["id"]
+                first_team_schedule = self.resp2data(
+                    self.urls["schedule"].format(
+                        user=self.user,
+                        password=self.password,
+                        team_id=first_team_id,
+                        season_id=season_id
+                    )
+                )
+
+                if first_team_schedule:
+                    last_match = first_team_schedule["data"]["row"][0]
+                    season_name = f'{last_match["tournament_name"]} {last_match["season_name"]}'
+                else:
+                    season_name = ""
+
+                self.cached_info[season_id] = {
+                    "season_name": season_name,
+                    "season_teams": data["data"]["row"]
+                }
+
+        return self.cached_info
+
+    def get_schedule(self, team_id: str, season_id: str) -> dict:
+        data = self.resp2data(
+            self.urls["schedule"].format(
+                user=self.user,
+                password=self.password,
+                team_id=team_id,
+                season_id=season_id
+            )
+        )
+
+        if not data:
+            return {}
+
+        return {
+            int(row["id"]): {
+                "match_date": row["match_date"],
+                "team1_id": int(row["team1_id"]),
+                "team2_id": int(row["team2_id"]),
+                "team1_name": row["team1_name"],
+                "team2_name": row["team2_name"],
+                "round_name": (row["round_name"] if "round_name" in row else None),
+                "tournament_name": (row["tournament_name"] if "tournament_name" in row else None),
+                "season_name": (row["season_name"] if "season_name" in row else None)
+            }
+            for row in data["data"]["row"]
+        }
+
+    def get_events(
+        self,
+        match_id: int,
+        process: bool = True,
+        return_subs: bool = True
+    ) -> pd.DataFrame | None | tuple[pd.DataFrame, pd.DataFrame]:
+        data = self.resp2data(
+            self.urls["events"].format(
+                user=self.user,
+                password=self.password,
+                match_id=match_id
+            )
+        )
+
+        if not data:
+            return None
+
+        df = pd.json_normalize(data["data"]["row"])
+
+        current_numeric_columns = [column for column in numeric_columns if column in df.columns]
+        df[current_numeric_columns] = df[current_numeric_columns].apply(pd.to_numeric, errors='coerce')
+
+        if process:
+            df['match_id'] = match_id
+
+            if return_subs:
+                subs = df[df['action_id'] == '14000'][[
+                    'match_id', 'half', 'second',
+                    'team_id', 'team_name',
+                    'opponent_id', 'opponent_name',
+                    'player_id', 'player_name'
+                ]].rename(columns={
+                    'player_id': 'player_id_out',
+                    'opponent_id': 'player_id_in',
+                    'player_name': 'player_name_out',
+                    'opponent_name': 'player_name_in'
+                })
+
+            df = processing(df)
+
+        return (df, subs) if return_subs else df
+
+    def get_tracking(self, match_id: int) -> pd.DataFrame | None:
+        data = self.resp2data(
+            self.urls["tracking"].format(
+                user=self.user,
+                password=self.password,
+                match_id=match_id
+            )
+        )
+
+        if not data:
+            return None
+
+        data = data["data"]["team"]
+        df = pd.DataFrame(columns=["half", "second", "pos_x", "pos_y", "team_id", "player_id", "player_name", "side_1h"])
+
+        for team_data in tqdm(data):
+            team_id = team_data["id"]
+            side_1h = team_data["gate_position_half_1"]
+
+            for player_data in team_data["player"]:
+                player_id = player_data["id"]
+                player_name = player_data["name"]
+
+                cur_df = pd.json_normalize(player_data["row"])
+                cur_df = cur_df.apply(pd.to_numeric, errors='coerce')
+                cur_df["team_id"] = team_id
+                cur_df["player_id"] = player_id
+                cur_df["player_name"] = player_name
+                cur_df["side_1h"] = side_1h
+
+                df = pd.concat([df, cur_df], ignore_index=True)
+
+        return df.sort_values(by=["second", "team_id", "player_id"])
+
+    def get_match_stats(self, match_id: int) -> dict:
+        data = self.resp2data(
+            self.urls["match_stats"].format(
+                user=self.user,
+                password=self.password,
+                match_id=match_id
+            )
+        )
+
+        if not data:
+            return {}
+
+        stats = defaultdict(dict)
+
+        for row in data['data']['row']:
+            team_id = int(row['team_id'])
+            param_name = row['param_name']
+
+            param_value = float(row['value'])
+
+            stats[param_name][team_id] = param_value
+
+        return stats
+
+    def get_players_match_stats(self, match_id: int) -> dict:
+        data = self.resp2data(
+            self.urls["player_match_stats"].format(
+                user=self.user,
+                password=self.password,
+                match_id=match_id
+            )
+        )
+
+        if not data:
+            return {}
+
+        return data['data']['team']
+
+    def get_players_minutes_in_match(self, match_id: int) -> dict:
+        data = self.get_players_match_stats(match_id)
+
+        if not data:
+            return {}
+
+        players_minutes = {}
+
+        for team_data in data:
+            for player_data in team_data['player']:
+                player_id = int(player_data['id'])
+
+                minutes = [float(metric['value']) for metric in player_data['param'] if metric['id'] == '288'][0]
+
+                players_minutes[player_id] = minutes
+
+        return players_minutes

rustat_python_api/processing.py

@@ -0,0 +1,89 @@
+import pandas as pd
+import numpy as np
+
+from .config import columns, id2type
+
+
+def process_list(x: pd.Series):
+    lst = x.dropna().unique().tolist()
+    if len(lst) == 1:
+        return lst[0]
+    elif len(lst) == 0:
+        return np.nan
+    else:
+        return lst
+
+
+def gluing(df: pd.DataFrame) -> pd.DataFrame:
+    cols = ['player_id', 'half', 'second', 'pos_x', 'pos_y']
+
+    df_gb = df.groupby(cols).agg(process_list).reset_index()
+    df_gb['possession_number'] = df_gb['possession_number'].apply(
+        lambda x: max(x) if isinstance(x, list) else x
+    )
+    df_gb['pos_dest_x'] = df_gb['pos_dest_x'].apply(
+        lambda x: x[0] if isinstance(x, list) else x
+    )
+    df_gb['pos_dest_y'] = df_gb['pos_dest_y'].apply(
+        lambda x: x[0] if isinstance(x, list) else x
+    )
+    df_gb['pos_dest_nan'] = (df_gb['pos_dest_x'].isna() & df_gb['pos_dest_y'].isna()).astype(int)
+    df_gb = df_gb.sort_values(by=['half', 'second', 'possession_number', 'pos_dest_nan']).reset_index(drop=True)
+    return df_gb
+
+
+def add_reciever(glued_df: pd.DataFrame) -> pd.DataFrame:
+    df = glued_df.copy()
+    df['receiver_id'] = df['player_id'].shift(-1)
+    df['receiver_name'] = df['player_name'].shift(-1)
+
+    mask = (
+            (df['action_name'] == 'Ball receiving')
+            & (df['pos_x'] == df['pos_dest_x'].shift(1))
+            & (df['pos_y'] == df['pos_dest_y'].shift(1))
+            & (df['team_id'] == df['team_id'].shift(1))
+            & (df['player_id'] != df['player_id'].shift(1))
+            & (df['possession_number'] == df['possession_number'].shift(1))
+    )
+
+    idx = df[mask].index
+    remaining_idx = df.drop(idx-1).index
+
+    df.loc[remaining_idx, 'receiver_id'] = np.nan
+    df.loc[remaining_idx, 'receiver_name'] = np.nan
+
+    df = df[df['action_name'] != 'Ball receiving'].reset_index(drop=True)
+
+    return df
+
+
+def filter_data(df: pd.DataFrame) -> pd.DataFrame:
+    for column in columns:
+        if column not in df.columns:
+            df[column] = np.nan
+
+    return df[(~df['possession_number'].isna()) | (df['second'] != 0)][columns].reset_index(drop=True)
+
+
+def tagging(df: pd.DataFrame) -> pd.DataFrame:
+    df = df.rename(columns={'action_name': 'sub_tags', 'action_id': 'sub_tags_ids'})
+    df['sub_tags'] = df['sub_tags'].apply(lambda x: x if isinstance(x, list) else [x])
+    df['sub_tags_ids'] = df['sub_tags_ids'].apply(
+        lambda x:
+        list(set([int(t) // 1000 for t in x]))
+        if isinstance(x, list)
+        else [int(x) // 1000]
+    )
+    df['sub_tags_ids'] = df['sub_tags_ids'].apply(lambda x: [id2type[t] for t in x])
+    df = df.rename(columns={'sub_tags_ids': 'tags'})
+
+    return df
+
+
+def processing(df: pd.DataFrame) -> pd.DataFrame:
+    df = gluing(df)
+    df = add_reciever(df)
+    df = filter_data(df)
+    df = tagging(df)
+
+    return df

rustat_python_api/urls.py

@@ -0,0 +1,8 @@
+URLs = {
+    "schedule": "http://feeds.rustatsport.ru/?tpl=35&user={user}&key={password}&team_id={team_id}&season_id={season_id}&date_start=&date_end=&format=json",
+    "events": "http://feeds.rustatsport.ru/?tpl=36&user={user}&key={password}&match_id={match_id}&start_ms=0&dl=0&lang_id=1&format=json",
+    "match_stats": "http://feeds.rustatsport.ru/?tpl=207&user={user}&key={password}&match_id={match_id}&lang_id=1&format=json",
+    "tournament_teams": "http://feeds.rustatsport.ru/?tpl=32&user={user}&key={password}&tournament_id=2&season_id={season_id}&date_start=&date_end=&lang_id=1&format=json",
+    "tracking": "https://feeds.rustatsport.ru/?tpl=274&user={user}&key={password}&match_id={match_id}&lang_id=0&format=json",
+    "player_match_stats": "http://feeds.rustatsport.ru/?tpl=227&user={user}&key={password}&match_id={match_id}&lang_id=1&format=json"
+}

rustat_python_api-0.4.11.dist-info/LICENSE

@@ -0,0 +1 @@
+Делайте че хотите с этим кодом.

rustat_python_api-0.4.11.dist-info/METADATA

@@ -0,0 +1,49 @@
+Metadata-Version: 2.1
+Name: rustat-python-api
+Version: 0.4.11
+Summary: A Python wrapper for RuStat API
+Home-page: https://github.com/dailydaniel/rustat-python-api
+Author: Daniel Zholkovsky
+Author-email: daniel@zholkovsky.com
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests==2.32.3
+Requires-Dist: pandas==2.2.3
+Requires-Dist: tqdm==4.66.5
+
+# rustat-python-api
+
+### Python wrapper for the Rustat API
+### Example of usage:
+0. Install the package:
+```bash
+pip install rustat-python-api
+```
+1. Usage:
+```python
+from rustat_python_api import RuStatParser
+
+user = "your_login"
+password = "your_password"
+
+parser = RuStatParser(user, password)
+
+info = parser.get_rpl_info()
+keys = list(info.keys())
+season_id, team_id = keys[-1], info[keys[-1]]["season_teams"][0]["id"]
+
+schedule = parser.get_schedule(team_id, season_id)
+keys = list(schedule.keys())
+match_id = keys[-1]
+
+events, subs = parser.get_events(match_id, process=True, return_subs=True)
+
+stats = parser.get_match_stats(match_id)
+
+tracking = parser.get_tracking(match_id)
+```

rustat_python_api-0.4.11.dist-info/RECORD

@@ -0,0 +1,11 @@
+rustat_python_api/__init__.py,sha256=kjE2XCKbWzIIJ__xY2aoIj5aB6um197lgMlaaZ15iJ4,108
+rustat_python_api/config.py,sha256=eMvi1p8Cfvnbp6Cd4bBOwgehVN7thKnaQV5uzWyGZXM,1844
+rustat_python_api/models_api.py,sha256=oHXEqeCupvZwjVEdoxf7W9LP7ELFKA8-9DuRXpQHLno,1701
+rustat_python_api/parser.py,sha256=kCKvpHYB8eNvrq64mEpGhWdUnJN8neMBFdwMbGAKWso,6913
+rustat_python_api/processing.py,sha256=46O7wUGv5boWf4A38zYinbtqEC7ke-BwTdEg589XQaw,2816
+rustat_python_api/urls.py,sha256=MIUDXq5QFacyVWbrIIuMbwf-WRARsxb32kFY97zw4OQ,865
+rustat_python_api-0.4.11.dist-info/LICENSE,sha256=4Cohqg5p6Mq1xyrzdEX8AvFSA62GSVvapEOr2xK_tgY,57
+rustat_python_api-0.4.11.dist-info/METADATA,sha256=4a4tT5JQ7YaMkocnPZnx3GQoGEo2Swya2FS3O0qdiR0,1248
+rustat_python_api-0.4.11.dist-info/WHEEL,sha256=eOLhNAGa2EW3wWl_TU484h7q1UNgy0JXjjoqKoxAAQc,92
+rustat_python_api-0.4.11.dist-info/top_level.txt,sha256=VK0hmkKZE9YThxolUcoE6JtGI67NFeKJMBLuet8kI4w,18
+rustat_python_api-0.4.11.dist-info/RECORD,,

rustat_python_api-0.4.11.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.44.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

rustat_python_api-0.4.11.dist-info/top_level.txt

@@ -0,0 +1 @@
+rustat_python_api