aiosofascore 0.0.4__py3-none-any.whl

aiosofascore/__init__.py

@@ -0,0 +1,3 @@
+from .api.soccer.base import BaseSoccerApi
+
+__all__ = ["BaseSoccerApi"]

aiosofascore/api/mixins.py

@@ -0,0 +1,30 @@
+from aiohttp import ClientSession, ClientResponse
+
+from ..exeptions 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/api/soccer/base.py

@@ -0,0 +1,17 @@
+from aiosofascore.api.mixins import ClientSessionManagerMixin
+from aiosofascore.api.soccer.categories import SoccerCategoriesApi
+from aiosofascore.api.soccer.event import SoccerEventApi
+from aiosofascore.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/api/soccer/categories.py

@@ -0,0 +1,21 @@
+from typing import Union
+
+from aiosofascore.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/api/soccer/event.py

@@ -0,0 +1,19 @@
+from aiosofascore.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/api/soccer/schemas/__init__.py

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

aiosofascore/api/soccer/schemas/base.py

@@ -0,0 +1,289 @@
+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)
+
+    def __getitem__(self, index: int) -> Category:
+        return self.categories[index]
+
+
+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 UniqueTournamentsList(BaseModel):
+    unique_tournaments: list[UniqueTournament]
+
+    def __iter__(self) -> Iterator[UniqueTournament]:
+        return iter(self.unique_tournaments)
+
+    def __getitem__(self, index: int) -> UniqueTournament:
+        return self.unique_tournaments[index]
+
+
+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)
+
+    def __getitem__(self, index: int) -> Season:
+        return self.seasons[index]
+
+
+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(BaseModel):
+    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/api/soccer/tournaments.py

@@ -0,0 +1,60 @@
+from aiosofascore.api.soccer.schemas.base import (
+    UniqueTournament,
+    Category,
+    SeasonList,
+    Standings,
+    UniqueTournamentsList,
+)
+
+__all__ = ["SoccerTournamentApi"]
+
+
+class SoccerTournamentApi:
+    async def get_tournaments_by_category(
+        self, category: Category
+    ) -> UniqueTournamentsList:
+        """
+        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 UniqueTournamentsList(
+                unique_tournaments=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/exeptions.py

@@ -0,0 +1,19 @@
+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}"
+        )

aiosofascore-0.0.4.dist-info/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.4.dist-info/METADATA

@@ -0,0 +1,77 @@
+Metadata-Version: 2.2
+Name: aiosofascore
+Version: 0.0.4
+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
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+![PyPI Version](https://img.shields.io/pypi/v/aiosofascore)
+![LICENSE](https://img.shields.io/badge/License-MIT-blue.svg)
+
+# 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 aiosofascore
+
+```
+## Usage Example
+
+Here's how you can use aiosofascore to get data about football tournaments
+
+```python
+import asyncio
+from aiosofascore import BaseSoccerApi
+
+
+async def main():
+    # Create a client
+    client = BaseSoccerApi()
+
+    # Fetch categories
+    categories = await client.get_categories()
+    for category in categories:
+        print(f"Category: {category.name}")
+
+    # Fetch tournaments by category
+    tournaments = await client.get_tournaments_by_category(categories[0])
+    for tournament in tournaments:
+        print(f"Tournament: {tournament.name}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## License
+This project is licensed under the MIT License — see the LICENSE file for details.

aiosofascore-0.0.4.dist-info/RECORD

@@ -0,0 +1,16 @@
+aiosofascore/__init__.py,sha256=7arRme7PkLjECpXc3uVx1e3ym1OAsIwKrHOHgq3SEEY,72
+aiosofascore/exeptions.py,sha256=g038BodDoqW_HegQX8XGx0QAMnWlHwLJWYrknGx6si8,515
+aiosofascore/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aiosofascore/api/mixins.py,sha256=FvCyIY4x_Z3G3TOhqAvykQwSK6ZlRdRaFJja3XoNHC4,1067
+aiosofascore/api/soccer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aiosofascore/api/soccer/base.py,sha256=jPHewJQ7sgibEDG52zk3uuM-DcZWMYLyFG6htocWnz8,592
+aiosofascore/api/soccer/categories.py,sha256=G02dSCJ9HQFsT_US5IWB9ktegUNINhPUNLNcXV8JUs4,731
+aiosofascore/api/soccer/event.py,sha256=zL0GczfnmwPGnhAPBBD11vByu0fvWXBJnzZj4gociwk,700
+aiosofascore/api/soccer/tournaments.py,sha256=zK-OF7vFVD6d4MQT-pF7nAGdd94RcscrirqkuxyRKmE,1969
+aiosofascore/api/soccer/schemas/__init__.py,sha256=ERmmOxz_9mUkIuccNbzUa5Y6gVLLVDdyc4cCxbCCUbY,20
+aiosofascore/api/soccer/schemas/base.py,sha256=WHWLcwcHGT0TTvXqQTtDR-lPpslMYWmY7nn_gocqmb4,7055
+aiosofascore-0.0.4.dist-info/LICENSE,sha256=O-0zMbcEi6wXz1DiSdVgzMlQjJcNqNe5KDv08uYzqR0,1055
+aiosofascore-0.0.4.dist-info/METADATA,sha256=_ZFBttObMPr29YeeoNBs5N72sQKao1t2VvsFHVDH9uA,2195
+aiosofascore-0.0.4.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+aiosofascore-0.0.4.dist-info/top_level.txt,sha256=ClavTMe9yHQjALo6Pa4E1h-HW1HU8Hf5Gx9-j6sRpSQ,13
+aiosofascore-0.0.4.dist-info/RECORD,,

aiosofascore-0.0.4.dist-info/WHEEL

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

aiosofascore-0.0.4.dist-info/top_level.txt

@@ -0,0 +1 @@
+aiosofascore