aiosofascore 0.0.1__tar.gz

aiosofascore-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025
+
+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.

aiosofascore-0.0.1/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md
+include LICENSE
+recursive-include src *.py

aiosofascore-0.0.1/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.1
+Name: aiosofascore
+Version: 0.0.1
+Summary: API client for SofaScore soccer data
+Home-page: https://github.com/Rooney27/aio_sofascore
+Author: Philip
+Author-email: vasilewskij.fil@gmail.com
+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: aiohttp
+Requires-Dist: pydantic
+
+# Aiosofascore
+
+**Aiosofascore** is an API client for SofaScore's soccer data, designed to provide easy access to soccer categories, tournaments, events, and much more. It is built with `aiohttp` for asynchronous HTTP requests and can be integrated into any Python project that needs soccer-related data.
+
+## Features
+
+- Fetch soccer categories and tournaments
+- Get detailed tournament standings and seasons
+- Retrieve pregame forms, head-to-head stats, and event managers
+- Built using Python's asynchronous capabilities with `aiohttp`
+
+## Installation
+
+To install **aiosofascore** from PyPI, run the following command:
+
+```bash
+pip install my_project

aiosofascore-0.0.1/README.md

@@ -0,0 +1,17 @@
+# Aiosofascore
+
+**Aiosofascore** is an API client for SofaScore's soccer data, designed to provide easy access to soccer categories, tournaments, events, and much more. It is built with `aiohttp` for asynchronous HTTP requests and can be integrated into any Python project that needs soccer-related data.
+
+## Features
+
+- Fetch soccer categories and tournaments
+- Get detailed tournament standings and seasons
+- Retrieve pregame forms, head-to-head stats, and event managers
+- Built using Python's asynchronous capabilities with `aiohttp`
+
+## Installation
+
+To install **aiosofascore** from PyPI, run the following command:
+
+```bash
+pip install my_project

aiosofascore-0.0.1/aiosofascore.egg-info/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.1
+Name: aiosofascore
+Version: 0.0.1
+Summary: API client for SofaScore soccer data
+Home-page: https://github.com/Rooney27/aio_sofascore
+Author: Philip
+Author-email: vasilewskij.fil@gmail.com
+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: aiohttp
+Requires-Dist: pydantic
+
+# Aiosofascore
+
+**Aiosofascore** is an API client for SofaScore's soccer data, designed to provide easy access to soccer categories, tournaments, events, and much more. It is built with `aiohttp` for asynchronous HTTP requests and can be integrated into any Python project that needs soccer-related data.
+
+## Features
+
+- Fetch soccer categories and tournaments
+- Get detailed tournament standings and seasons
+- Retrieve pregame forms, head-to-head stats, and event managers
+- Built using Python's asynchronous capabilities with `aiohttp`
+
+## Installation
+
+To install **aiosofascore** from PyPI, run the following command:
+
+```bash
+pip install my_project

aiosofascore-0.0.1/aiosofascore.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+LICENSE
+MANIFEST.in
+README.md
+setup.py
+aiosofascore.egg-info/PKG-INFO
+aiosofascore.egg-info/SOURCES.txt
+aiosofascore.egg-info/dependency_links.txt
+aiosofascore.egg-info/requires.txt
+aiosofascore.egg-info/top_level.txt
+src/__init__.py
+src/execptions.py
+src/api/__init__.py
+src/api/mixins.py
+src/api/soccer/__init__.py
+src/api/soccer/base.py
+src/api/soccer/categories.py
+src/api/soccer/event.py
+src/api/soccer/tournaments.py
+src/api/soccer/schemas/__init__.py
+src/api/soccer/schemas/base.py

aiosofascore-0.0.1/aiosofascore.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

aiosofascore-0.0.1/aiosofascore.egg-info/requires.txt

@@ -0,0 +1,2 @@
+aiohttp
+pydantic

aiosofascore-0.0.1/aiosofascore.egg-info/top_level.txt

@@ -0,0 +1 @@
+src

aiosofascore-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

aiosofascore-0.0.1/setup.py

@@ -0,0 +1,23 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="aiosofascore",
+    version="0.0.1",
+    description="API client for SofaScore soccer data",
+    long_description=open('README.md').read(),
+    long_description_content_type="text/markdown",
+    author="Philip",  # Ваше имя
+    author_email="vasilewskij.fil@gmail.com",
+    url="https://github.com/Rooney27/aio_sofascore",
+    packages=find_packages(),
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    install_requires=[
+        "aiohttp",
+        "pydantic"
+    ],
+    python_requires='>=3.10',  # Укажите минимальную версию Python
+)

aiosofascore-0.0.1/src/api/mixins.py

@@ -0,0 +1,30 @@
+from aiohttp import ClientSession, ClientResponse
+
+from sofascore.execptions import ResponseParseContentError
+
+
+class ClientSessionManagerMixin:
+    async def __aenter__(self):
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 YaBrowser/24.12.0.0 Safari/537.36'
+        }
+        self.session = ClientSession(headers=headers)
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.session.close()
+
+    async def _get(self, path: str, params: dict = None) -> ClientResponse:
+        """
+        Executes an HTTP GET request to the given API path.
+
+        Args:
+            path (str): The API path to request.
+            params (dict, optional): Query parameters for the request.
+
+        Returns:
+            ClientResponse: The response from the API.
+        """
+        result = await self.session.get(self.BASE_URL + path, params=params)
+        if result.ok:
+            return await result.json()
+        raise ResponseParseContentError(result,path)

aiosofascore-0.0.1/src/api/soccer/base.py

@@ -0,0 +1,14 @@
+from src.api.mixins import ClientSessionManagerMixin
+from src.api.soccer.categories import SoccerCategoriesApi
+from src.api.soccer.event import SoccerEventApi
+from src.api.soccer.tournaments import SoccerTournamentApi
+
+__all__ =['BaseSoccerApi']
+
+class BaseSoccerApi(ClientSessionManagerMixin, SoccerCategoriesApi,
+                    SoccerTournamentApi, SoccerEventApi):
+    """
+    Base API client for interacting with SofaScore's soccer API.
+    Provides methods for fetching soccer categories and tournaments.
+    """
+    BASE_URL = 'https://api.sofascore.com/'

aiosofascore-0.0.1/src/api/soccer/categories.py

@@ -0,0 +1,21 @@
+from typing import Union
+
+from src.api.soccer.schemas.base import CategoryList, Category
+
+__all__ = ['SoccerCategoriesApi']
+
+class SoccerCategoriesApi:
+    async def get_categories(self) -> Union[CategoryList,list]:
+        """
+        Fetches a list of soccer categories.
+
+        Returns:
+            CategoryList: A list of soccer categories encapsulated in a CategoryList object.
+            Returns an empty list if an error occurs during the request or JSON parsing.
+        """
+        async with self:
+            content = await self._get('api/v1/sport/football/categories/')
+            return CategoryList(
+                    categories=[Category(**category) for category in
+                                content['categories']]
+                )

aiosofascore-0.0.1/src/api/soccer/event.py

@@ -0,0 +1,20 @@
+from src.api.soccer.schemas.base import PregameTeamForm, H2H, \
+    EventManagers
+
+
+class SoccerEventApi:
+
+    async def get_pregame_form(self,event_id:str)->PregameTeamForm:
+        async with self:
+            result = self._get(f'api/v1/event/{event_id}/pregame-form')
+            return PregameTeamForm(**result)
+
+    async def get_h2h(self,event_id:str)->H2H:
+        async with self:
+            result = self._get(f'api/v1/event/{event_id}/h2h')
+            return H2H(**result)
+
+    async def get_managers(self,event_id:str)->EventManagers:
+        async with self:
+            result = self._get(f'api/v1/event/{event_id}/managers')
+            return EventManagers(**result)

aiosofascore-0.0.1/src/api/soccer/schemas/__init__.py

@@ -0,0 +1 @@
+from .base import *

aiosofascore-0.0.1/src/api/soccer/schemas/base.py

@@ -0,0 +1,267 @@
+from typing import Optional, Iterator
+from pydantic import BaseModel, fields, Field
+
+
+
+class Sport(BaseModel):
+    """
+    Represents a sport entity with essential attributes.
+
+    Attributes:
+        name (str): Name of the sport.
+        slug (str): URL-friendly identifier for the sport.
+        id (int): Unique identifier for the sport.
+    """
+    name: str
+    slug: str
+    id: int
+
+
+class Category(BaseModel):
+    """
+    Represents a category associated with a sport.
+
+    Attributes:
+        name (str): Name of the category.
+        slug (str): URL-friendly identifier for the category.
+        sport (Sport): The sport associated with this category.
+        priority (Optional[int]): Priority level for the category (if available).
+        id (int): Unique identifier for the category.
+        flag (str): Country flag or symbol associated with the category.
+    """
+    name: str
+    slug: str
+    sport: Sport
+    priority: Optional[int] = None
+    id: int
+    flag: str
+
+
+class CategoryList(BaseModel):
+    """
+    Represents a list of Category objects with search functionality.
+
+    Attributes:
+        categories (list[Category]): A list containing Category objects.
+
+    Methods:
+        find_all_by_name(name: str, search_amateur: bool = False) -> list[Category]:
+            Finds categories by name with an optional search for amateur categories.
+    """
+    categories: list[Category]
+
+    def find_all_by_name(self, name: str, search_amateur=False) -> list[
+        Category]:
+        """
+        Finds all categories whose names contain the given substring.
+
+        Args:
+            name (str): The substring to search for in category names.
+            search_amateur (bool, optional): Whether to include only amateur categories. Defaults to False.
+
+        Returns:
+            list[Category]: A list of categories matching the criteria.
+        """
+        return [c for c in self.categories if
+                name.lower() in c.name.lower() and
+                ('amateur' in c.name.lower()) == search_amateur]
+    def __iter__(self)->Iterator[Category]:
+        return iter(self.categories)
+
+class UniqueTournament(BaseModel):
+    """
+    Represents a unique soccer tournament.
+
+    Attributes:
+        name (str): Name of the tournament.
+        slug (str): URL-friendly identifier for the tournament.
+        primaryColorHex (Optional[str]): Primary color in hexadecimal format.
+        secondaryColorHex (Optional[str]): Secondary color in hexadecimal format.
+        category (Category): The category associated with the tournament.
+        userCount (int): Number of users following the tournament.
+        id (int): Unique identifier for the tournament.
+        displayInverseHomeAwayTeams (bool): Flag indicating if home/away teams should be inversed in display.
+    """
+    name: str
+    slug: str
+    primaryColorHex: Optional[str] = None
+    secondaryColorHex: Optional[str] = None
+    category: Category
+    userCount: int
+    id: int
+    displayInverseHomeAwayTeams: bool
+
+
+class Tournament(BaseModel):
+    category: Category
+    id: int
+    is_group: bool = Field(..., alias="isGroup")
+    is_live: bool = Field(..., alias="isLive")
+    name: str
+    priority: int
+    slug: str
+    uniqueTournament: UniqueTournament
+
+
+class Promotion(BaseModel):
+    id: int
+    text: str
+
+
+class Team(BaseModel):
+    disabled: bool
+    entityType: str
+    gender: str
+    id: int
+    name: str
+    name_code: str = Field(..., alias="nameCode")
+    national: bool
+    short_name: str = Field(..., alias="shortName")
+    slug: str
+
+
+class StandingsRow(BaseModel):
+    descriptions: list[str]
+    draws: int
+    id: int
+    losses: int
+    matches: int
+    points: int
+    position: int
+    promotion: Promotion = None
+    score_diff_formatted: str = Field(..., alias="scoreDiffFormatted")
+    scores_against: int = Field(..., alias="scoresAgainst")
+    scores_for: int = Field(..., alias="scoresFor")
+    team: Team
+    wins: int
+
+
+class Standings(BaseModel):
+    descriptions: list[str]
+    id: int
+    name: str
+    rows: list[StandingsRow]
+    tournament: Tournament
+
+
+class Season(BaseModel):
+    name: str
+    year: str
+    editor: bool
+    id: int
+
+
+class SeasonList(BaseModel):
+    seasons: list[Season]
+
+    def get_season_by_year(self, year: str) -> Season:
+        return next((season for season in self.seasons if season.year == year),
+                    None)
+
+    def get_current_season(self) -> Season:
+        return self.seasons[0]
+
+    def __iter__(self) ->Iterator[Season]:
+        return iter(self.seasons)
+
+
+class TeamForm(BaseModel):
+    avg_rating: str = Field(alias='avgRating')
+    form: list[str]
+    position: int
+    value: str
+
+
+class PregameTeamForm(BaseModel):
+    away_team: TeamForm = Field(alias='awayTeam')
+    home_team: TeamForm = Field(alias='homeTeam')
+
+
+class Duel(BaseModel):
+    away_wins: int = Field(alias='awayWins')
+    draws: int
+    home_wins: int = Field(alias='homeWins')
+
+
+class H2H(BaseModel):
+    manager_duel: Duel = Field(alias='managerDuel')
+    team_duel: Duel = Field(alias='teamDuel')
+
+
+class Manager(BaseModel):
+    name: str
+    slug: str
+    short_name: str = Field(alias='shortName')
+    id: str
+
+
+class EventManagers(BaseModel):
+    home_manager: Manager = Field(alias='homeManager')
+    away_manager: Manager = Field(alias='awayManager')
+
+
+class RoundInfo(BaseModel):
+    round: int
+
+
+class City:
+    name: str
+
+
+class VenueCoordinates(BaseModel):
+    latitude: str
+    longtitude: str
+
+
+class Country(BaseModel):
+    alpha2: str
+    alpha3: str
+    name: str
+    slug: str
+
+
+class Stadium(BaseModel):
+    name: str
+    capacity: int
+
+
+class Venue(BaseModel):
+    city: City
+    venue_coordinates: VenueCoordinates = Field(alias='venueCoordinates')
+    hidden: bool
+    slug: str
+    name: str
+    capacity: int
+    id: int
+    country: Country
+    stadium: Stadium
+
+
+class Referee(BaseModel):
+    name: str
+    slug: str
+    yellow_cards: int = Field(alias='yellowCards')
+    red_cards: int = Field(alias='redCards')
+    yellow_red_cards: int = Field(alias='yellowRedCards')
+    games: int
+    sport: Sport
+    id: int
+    country: Country
+
+
+class EventTeam(Team):
+    sport: Sport
+    manager: Manager
+    venue: Venue
+    country: Country
+
+
+# TODO: Create Prematch,live,fulltime Event
+class Event(BaseModel):
+    tournament: Tournament
+    season: Season
+    round_info: RoundInfo = Field(alias='roundInfo')
+    custom_id: str = Field(alias='customId')
+    venue: Venue
+    home_team: EventTeam = Field(alias='homeTeam')
+    away_team: EventTeam = Field(alias='awayTeam')

aiosofascore-0.0.1/src/api/soccer/tournaments.py

@@ -0,0 +1,48 @@
+from src.api.soccer.schemas.base import UniqueTournament, Category, \
+    SeasonList, Standings
+
+__all__ = ['SoccerTournamentApi']
+
+
+class SoccerTournamentApi:
+    async def get_tournament_by_category(self, category: Category) -> list[
+        UniqueTournament]:
+        """
+        Fetches a list of unique tournaments for a given soccer category.
+
+        Args:
+            category (Category): The soccer category for which to retrieve tournaments.
+
+        Returns:
+            list[UniqueTournament]: A list of unique tournaments for the given category.
+        """
+        async with self:
+            content = await self._get(
+                f'api/v1/category/{category.id}/unique-tournaments')
+            return [
+                UniqueTournament(**uniqueTournament)
+                for uniqueTournament in
+                content['groups'][0]['uniqueTournaments']
+            ]
+
+    async def get_tournament_seasons(self,
+                                     unique_tournament: UniqueTournament) -> SeasonList:
+        async with self:
+            response = await self._get(
+                f'api/v1/unique-tournament/{unique_tournament.id}/seasons')
+            seasons = response['seasons']
+            return SeasonList(seasons=seasons)
+
+    async def get_tournament_standings(self,
+                                       unique_tournament: UniqueTournament,
+                                       season_year: str = None):
+        if season_year:
+            season = await (await self.get_tournament_seasons(unique_tournament)).get_season_by_year(season_year)
+        else:
+            season = await (await self.get_tournament_seasons(unique_tournament)).get_current_season()
+
+        async with self:
+            response = await self._get(
+                f'api/v1/unique-tournament/{unique_tournament.id}/season/{season.id}/standings/home')
+            standings = response['standings'][0]
+            return Standings(**standings)

aiosofascore-0.0.1/src/execptions.py

@@ -0,0 +1,16 @@
+from aiohttp import ClientResponse
+
+
+class ResponseParseContentError(Exception):
+    def __init__(self,response:ClientResponse,path:str):
+        self._response = response
+        self._path = path
+    @property
+    def response(self):
+        return self._response
+
+    def __str__(self):
+        return ('Response processing error:\n'
+                f'api call: {self._path}'
+                f'response status:{self._response.status}'
+                f'response content:{self._response.content}')