ffbb-data-client 2.0.0__py3-none-any.whl

ffbb_data_client/models/get_pratique_response.py

@@ -0,0 +1,18 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class GetPratiqueResponse:
+    id: str
+    label: str | None = None
+    type: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "GetPratiqueResponse | None":
+        if not data or not isinstance(data, dict):
+            return None
+        return cls(
+            id=str(data.get("id", "")),
+            label=data.get("label"),
+            type=data.get("type"),
+        )

ffbb_data_client/models/get_rencontre_response.py

@@ -0,0 +1,93 @@
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any
+
+
+@dataclass
+class GetRencontreResponse:
+    id: str
+    numero: str | None = None
+    numeroJournee: str | None = None
+    date_rencontre: datetime | None = None
+    date: str | None = None
+    horaire: str | None = None
+    resultatEquipe1: str | None = None
+    resultatEquipe2: str | None = None
+    joue: int = 0
+    nomEquipe1: str | None = None
+    nomEquipe2: str | None = None
+    idPoule: str | None = None
+    competitionId: Any | None = None
+    idOrganismeEquipe1: Any | None = None
+    idOrganismeEquipe2: Any | None = None
+    idEngagementEquipe1: Any | None = None
+    idEngagementEquipe2: Any | None = None
+    salle: Any | None = None
+    officiels: list[Any] | None = None
+    rematch_videos: list[Any] | None = None
+    gsId: str | None = None
+    etat: str | None = None
+    handicap1: Any | None = None
+    handicap2: Any | None = None
+    pratique: str | None = None
+    uniqueKey: str | None = None
+    url_competition: str | None = None
+    validee: bool | None = None
+    remise: bool | None = None
+    defautEquipe1: bool | None = None
+    defautEquipe2: bool | None = None
+    forfaitEquipe1: bool | None = None
+    forfaitEquipe2: bool | None = None
+    penaliteEquipe1: bool | None = None
+    penaliteEquipe2: bool | None = None
+    raw_data: dict[str, Any] | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "GetRencontreResponse | None":
+        if not data or not isinstance(data, dict):
+            return None
+        date_str = data.get("date_rencontre")
+        date = None
+        if date_str:
+            try:
+                date = datetime.fromisoformat(date_str.replace("Z", "+00:00"))
+            except (ValueError, AttributeError):
+                pass
+        return cls(
+            id=str(data.get("id", "")),
+            numero=data.get("numero"),
+            numeroJournee=data.get("numeroJournee"),
+            date_rencontre=date,
+            date=data.get("date"),
+            horaire=data.get("horaire"),
+            resultatEquipe1=data.get("resultatEquipe1"),
+            resultatEquipe2=data.get("resultatEquipe2"),
+            joue=int(data.get("joue", 0)),
+            nomEquipe1=data.get("nomEquipe1"),
+            nomEquipe2=data.get("nomEquipe2"),
+            idPoule=data.get("idPoule"),
+            competitionId=data.get("competitionId"),
+            idOrganismeEquipe1=data.get("idOrganismeEquipe1"),
+            idOrganismeEquipe2=data.get("idOrganismeEquipe2"),
+            idEngagementEquipe1=data.get("idEngagementEquipe1"),
+            idEngagementEquipe2=data.get("idEngagementEquipe2"),
+            salle=data.get("salle"),
+            officiels=data.get("officiels"),
+            rematch_videos=data.get("rematch_videos"),
+            gsId=data.get("gsId"),
+            etat=data.get("etat"),
+            handicap1=data.get("handicap1"),
+            handicap2=data.get("handicap2"),
+            pratique=data.get("pratique"),
+            uniqueKey=data.get("uniqueKey"),
+            url_competition=data.get("url_competition"),
+            validee=data.get("validee"),
+            remise=data.get("remise"),
+            defautEquipe1=data.get("defautEquipe1"),
+            defautEquipe2=data.get("defautEquipe2"),
+            forfaitEquipe1=data.get("forfaitEquipe1"),
+            forfaitEquipe2=data.get("forfaitEquipe2"),
+            penaliteEquipe1=data.get("penaliteEquipe1"),
+            penaliteEquipe2=data.get("penaliteEquipe2"),
+            raw_data=data,
+        )

ffbb_data_client/models/get_saisons_response.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class GetSaisonsResponse:
+    id: str
+    nom: str | None = None
+    actif: bool | None = None
+    debut: str | None = None
+    fin: str | None = None
+    code: str | None = None
+    libelle: str | None = None
+    enCours: bool | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> GetSaisonsResponse | None:
+        """Convert dictionary to GetSaisonsResponse instance."""
+        if not data:
+            return None
+
+        # Handle case where data is not a dictionary
+        if not isinstance(data, dict):
+            return None
+
+        # Handle API error responses
+        if "errors" in data:
+            return None
+
+        return cls(
+            id=str(data.get("id", "")),
+            nom=str(data.get("nom", "")) if data.get("nom") else None,
+            actif=bool(data.get("actif", False)) if "actif" in data else None,
+            debut=str(data.get("debut", "")) if data.get("debut") else None,
+            fin=str(data.get("fin", "")) if data.get("fin") else None,
+            code=str(data.get("code", "")) if data.get("code") else None,
+            libelle=str(data.get("libelle", "")) if data.get("libelle") else None,
+            enCours=bool(data.get("enCours", False)) if "enCours" in data else None,
+        )
+
+    @classmethod
+    def from_list(cls, data_list: list[dict[str, Any]]) -> list[GetSaisonsResponse]:
+        """Convert list of dictionaries to list of SaisonsModel instances."""
+        if not data_list:
+            return []
+
+        # Filter out None results from from_dict (invalid items)
+        return [
+            result
+            for item in data_list
+            if item
+            for result in [cls.from_dict(item)]
+            if result is not None
+        ]

ffbb_data_client/models/get_salle_response.py

@@ -0,0 +1,20 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class GetSalleResponse:
+    id: str
+    numero: str | None = None
+    libelle: str | None = None
+    adresse: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "GetSalleResponse | None":
+        if not data or not isinstance(data, dict):
+            return None
+        return cls(
+            id=str(data.get("id", "")),
+            numero=data.get("numero"),
+            libelle=data.get("libelle"),
+            adresse=data.get("adresse"),
+        )

ffbb_data_client/models/get_terrain_response.py

@@ -0,0 +1,16 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class GetTerrainResponse:
+    id: str
+    nom: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "GetTerrainResponse | None":
+        if not data or not isinstance(data, dict):
+            return None
+        return cls(
+            id=str(data.get("id", "")),
+            nom=data.get("nom"),
+        )

ffbb_data_client/models/get_tournoi_response.py

@@ -0,0 +1,16 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class GetTournoiResponse:
+    id: str
+    libelle: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "GetTournoiResponse | None":
+        if not data or not isinstance(data, dict):
+            return None
+        return cls(
+            id=str(data.get("id", "")),
+            libelle=data.get("libelle"),
+        )

ffbb_data_client/models/gradient_color.py

@@ -0,0 +1,27 @@
+from enum import Enum
+
+
+class GradientColor(Enum):
+    A01_A17 = "#a01a17"
+    B1_B3_B3 = "#b1b3b3"
+    B3_B2_B2 = "#b3b2b2"
+    BCBCBB = "#bcbcbb"
+    BDBCBC = "#bdbcbc"
+    BEBEBE = "#bebebe"
+    BFCED9 = "#bfced9"
+    BFD8_EC = "#bfd8ec"
+    E30066 = "#e30066"
+    E30072 = "#e30072"
+    E50069 = "#e50069"
+    E5_C0_BF = "#e5c0bf"
+    E60066 = "#e60066"
+    F5_AEBB = "#f5aebb"
+    THE_00_BEF5 = "#00bef5"
+    THE_01_B5_EA = "#01b5ea"
+    THE_01_B6_E8 = "#01b6e8"
+    THE_01_B6_ED = "#01b6ed"
+    THE_23328_A = "#23328a"
+    THE_2_F2_A85 = "#2f2a85"
+    THE_401407 = "#401407"
+    THE_878888 = "#878888"
+    THE_9_D9_E9_E = "#9d9e9e"

ffbb_data_client/models/hit.py

@@ -0,0 +1,16 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class Hit(ABC):
+    @staticmethod
+    def from_dict(obj: Any) -> "Hit":
+        raise NotImplementedError
+
+    @abstractmethod
+    def to_dict(self) -> dict:
+        raise NotImplementedError
+
+    @abstractmethod
+    def is_valid_for_query(self, query: str) -> bool:
+        raise NotImplementedError

ffbb_data_client/models/id_engagement_equipe.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from ..utils.converter_utils import from_obj, from_str
+from .logo import Logo
+
+
+@dataclass
+class IDEngagementEquipe:
+    id: str | None = None
+    nom_usuel: str | None = None
+    logo: Logo | None = None
+
+    @staticmethod
+    def from_dict(obj: Any) -> IDEngagementEquipe:
+        assert isinstance(obj, dict)
+        id = from_str(obj, "id")
+        nom_usuel = from_str(obj, "nomUsuel")
+        logo = from_obj(Logo.from_dict, obj, "logo")
+        return IDEngagementEquipe(id=id, nom_usuel=nom_usuel, logo=logo)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.id is not None:
+            result["id"] = self.id
+        if self.nom_usuel is not None:
+            result["nomUsuel"] = self.nom_usuel
+        if self.logo is not None:
+            result["logo"] = self.logo.to_dict()
+        return result

ffbb_data_client/models/id_organisme_equipe.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from ..utils.converter_utils import from_obj, from_str
+from .id_organisme_equipe1_logo import IDOrganismeEquipe1Logo
+
+
+@dataclass
+class IDOrganismeEquipe:
+    id: str | None = None
+    nom: str | None = None
+    nom_simple: str | None = None
+    code: str | None = None
+    nom_club_pro: str | None = None
+    logo: IDOrganismeEquipe1Logo | None = None
+
+    @staticmethod
+    def from_dict(obj: Any) -> IDOrganismeEquipe:
+        assert isinstance(obj, dict)
+        id = from_str(obj, "id")
+        nom = from_str(obj, "nom")
+        nom_simple = from_str(obj, "nom_simple")
+        code = from_str(obj, "code")
+        nom_club_pro = from_str(obj, "nomClubPro")
+        logo = from_obj(IDOrganismeEquipe1Logo.from_dict, obj, "logo")
+        return IDOrganismeEquipe(
+            id=id,
+            nom=nom,
+            nom_simple=nom_simple,
+            code=code,
+            nom_club_pro=nom_club_pro,
+            logo=logo,
+        )
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.id is not None:
+            result["id"] = self.id
+        if self.nom is not None:
+            result["nom"] = self.nom
+        if self.nom_simple is not None:
+            result["nom_simple"] = self.nom_simple
+        if self.code is not None:
+            result["code"] = self.code
+        if self.nom_club_pro is not None:
+            result["nomClubPro"] = self.nom_club_pro
+        if self.logo is not None:
+            result["logo"] = self.logo.to_dict()
+        return result

ffbb_data_client/models/id_organisme_equipe1_logo.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+from uuid import UUID
+
+from ..utils.converter_utils import from_str, from_uuid
+
+
+@dataclass
+class IDOrganismeEquipe1Logo:
+    id: UUID | None = None
+    gradient_color: str | None = None
+
+    @staticmethod
+    def from_dict(obj: Any) -> IDOrganismeEquipe1Logo:
+        assert isinstance(obj, dict)
+        id = from_uuid(obj, "id")
+        gradient_color = from_str(obj, "gradient_color")
+        return IDOrganismeEquipe1Logo(id=id, gradient_color=gradient_color)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.id is not None:
+            result["id"] = str(self.id)
+        if self.gradient_color is not None:
+            result["gradient_color"] = self.gradient_color
+        return result

ffbb_data_client/models/id_poule.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from ..utils.converter_utils import from_str
+
+
+@dataclass
+class IDPoule:
+    id: str | None = None
+    nom: str | None = None
+
+    @staticmethod
+    def from_dict(obj: Any) -> IDPoule:
+        assert isinstance(obj, dict)
+        id = from_str(obj, "id")
+        nom = from_str(obj, "nom")
+        return IDPoule(id=id, nom=nom)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.id is not None:
+            result["id"] = self.id
+        if self.nom is not None:
+            result["nom"] = self.nom
+        return result

ffbb_data_client/models/jour.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class Jour(Enum):
+    SUNDAY = "dimanche"
+    THURSDAY = "jeudi"
+    MONDAY = "lundi"
+    TUESDAY = "mardi"
+    WEDNESDAY = "mercredi"
+    SATURDAY = "samedi"
+    FRIDAY = "vendredi"

ffbb_data_client/models/label.py

@@ -0,0 +1,15 @@
+from enum import Enum
+
+
+class Label(Enum):
+    BASKET_INCLUSIF = "Basket Inclusif"
+    BASKET_SANTÉ_CONFORT = "Basket Santé Confort"
+    BASKET_SANTÉ_DÉCOUVERTE = "Basket Santé Découverte"
+    BASKET_SANTÉ_RÉSOLUTIONS = "Basket Santé Résolutions"
+    BASKE_TONIK = "BaskeTonik"
+    BASKE_TONIK_FORME = "BaskeTonik forme"
+    DÉCOUVERTE_BASKET_INCLUSIF = "Découverte Basket Inclusif"
+    DÉCOUVERTE_BASKE_TONIK = "Découverte BaskeTonik"
+    DÉCOUVERTE_MICRO_BASKET = "Découverte Micro Basket"
+    EMPTY = ""
+    MICRO_BASKET = "Micro Basket"

ffbb_data_client/models/labellisation.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from ..utils.converter_utils import from_int
+
+
+@dataclass
+class Labellisation:
+    basket_santé_résolutions: int | None = None
+    micro_basket: int | None = None
+
+    @staticmethod
+    def from_dict(obj: Any) -> Labellisation:
+        assert isinstance(obj, dict)
+        basket_santé_résolutions = from_int(obj, "Basket Santé / Résolutions")
+        micro_basket = from_int(obj, "Micro Basket")
+        return Labellisation(
+            basket_santé_résolutions=basket_santé_résolutions,
+            micro_basket=micro_basket,
+        )
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.basket_santé_résolutions is not None:
+            result["Basket Santé / Résolutions"] = self.basket_santé_résolutions
+        if self.micro_basket is not None:
+            result["Micro Basket"] = self.micro_basket
+        return result

ffbb_data_client/models/live.py

@@ -0,0 +1,192 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any
+
+from ..utils.converter_utils import (
+    from_datetime,
+    from_int,
+    from_obj,
+    from_str,
+)
+from .clock import Clock
+from .external_id import ExternalID
+from .team_engagement import TeamEngagement
+
+
+@dataclass
+class Live:
+    match_id: int | None = None
+    match_time: datetime | None = None
+    competition_abg_name: str | None = None
+    score_q1_home: int | None = None
+    score_q2_home: int | None = None
+    score_q3_home: int | None = None
+    score_q4_home: int | None = None
+    score_q1_out: int | None = None
+    score_q2_out: int | None = None
+    score_q3_out: int | None = None
+    score_q4_out: int | None = None
+    score_ot1_home: int | None = None
+    score_ot2_home: int | None = None
+    score_ot1_out: int | None = None
+    score_ot2_out: int | None = None
+    score_home: int | None = None
+    score_out: int | None = None
+    clock: Clock | None = None
+    competition_name: str | None = None
+    current_status: str | None = None
+    current_period: str | None = None
+    match_status: str | None = None
+    team_name_home: str | None = None
+    team_name_out: str | None = None
+    external_id: ExternalID | None = None
+    team_engagement_home: TeamEngagement | None = None
+    team_engagement_out: TeamEngagement | None = None
+
+    @staticmethod
+    def from_dict(obj: Any) -> Live:
+        assert isinstance(obj, dict)
+        match_id = from_int(obj, "matchId")
+        match_time = from_datetime(obj, "matchTime")
+        competition_abg_name = from_str(obj, "competitionAbgName")
+        score_q1_home = from_int(obj, "score_q1_home")
+        score_q2_home = from_int(obj, "score_q2_home")
+        score_q3_home = from_int(obj, "score_q3_home")
+        score_q4_home = from_int(obj, "score_q4_home")
+        score_q1_out = from_int(obj, "score_q1_out")
+        score_q2_out = from_int(obj, "score_q2_out")
+        score_q3_out = from_int(obj, "score_q3_out")
+        score_q4_out = from_int(obj, "score_q4_out")
+        score_ot1_home = from_int(obj, "score_ot1_home")
+        score_ot2_home = from_int(obj, "score_ot2_home")
+        score_ot1_out = from_int(obj, "score_ot1_out")
+        score_ot2_out = from_int(obj, "score_ot2_out")
+        score_home = from_int(obj, "score_home")
+        score_out = from_int(obj, "score_out")
+        clock_val = obj.get("clock")
+        clock = Clock.from_str(clock_val) if clock_val is not None else None
+        competition_name = from_str(obj, "competitionName")
+        current_status = from_str(obj, "currentStatus")
+        current_period = from_str(obj, "currentPeriod")
+        match_status = from_str(obj, "matchStatus")
+        team_name_home = from_str(obj, "teamName_home")
+        team_name_out = from_str(obj, "teamName_out")
+        external_id = from_obj(ExternalID.from_dict, obj, "externalId")
+        team_engagement_home = from_obj(
+            TeamEngagement.from_dict, obj, "teamEngagement_home"
+        )
+        team_engagement_out = from_obj(
+            TeamEngagement.from_dict, obj, "teamEngagement_out"
+        )
+        return Live(
+            match_id=match_id,
+            match_time=match_time,
+            competition_abg_name=competition_abg_name,
+            score_q1_home=score_q1_home,
+            score_q2_home=score_q2_home,
+            score_q3_home=score_q3_home,
+            score_q4_home=score_q4_home,
+            score_q1_out=score_q1_out,
+            score_q2_out=score_q2_out,
+            score_q3_out=score_q3_out,
+            score_q4_out=score_q4_out,
+            score_ot1_home=score_ot1_home,
+            score_ot2_home=score_ot2_home,
+            score_ot1_out=score_ot1_out,
+            score_ot2_out=score_ot2_out,
+            score_home=score_home,
+            score_out=score_out,
+            clock=clock,
+            competition_name=competition_name,
+            current_status=current_status,
+            current_period=current_period,
+            match_status=match_status,
+            team_name_home=team_name_home,
+            team_name_out=team_name_out,
+            external_id=external_id,
+            team_engagement_home=team_engagement_home,
+            team_engagement_out=team_engagement_out,
+        )
+
+    @classmethod
+    def __get_pydantic_core_schema__(cls, _source_type: Any, handler: Any) -> Any:
+        from pydantic_core import core_schema
+
+        return core_schema.no_info_before_validator_function(
+            cls._parse_pydantic,
+            handler(_source_type),
+        )
+
+    @classmethod
+    def _parse_pydantic(cls, value: Any) -> Any:
+        if isinstance(value, dict):
+            try:
+                # Use our own custom dict logic so key mappings apply naturally
+                return cls.from_dict(value)
+            except Exception:
+                pass
+        return value
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.match_id is not None:
+            result["matchId"] = str(self.match_id)
+        if self.match_time is not None:
+            result["matchTime"] = self.match_time.isoformat()
+        if self.competition_abg_name is not None:
+            result["competitionAbgName"] = self.competition_abg_name
+        if self.score_q1_home is not None:
+            result["score_q1_home"] = self.score_q1_home
+        if self.score_q2_home is not None:
+            result["score_q2_home"] = self.score_q2_home
+        if self.score_q3_home is not None:
+            result["score_q3_home"] = self.score_q3_home
+        if self.score_q4_home is not None:
+            result["score_q4_home"] = self.score_q4_home
+        if self.score_q1_out is not None:
+            result["score_q1_out"] = self.score_q1_out
+        if self.score_q2_out is not None:
+            result["score_q2_out"] = self.score_q2_out
+        if self.score_q3_out is not None:
+            result["score_q3_out"] = self.score_q3_out
+        if self.score_q4_out is not None:
+            result["score_q4_out"] = self.score_q4_out
+        if self.score_ot1_home is not None:
+            result["score_ot1_home"] = self.score_ot1_home
+        if self.score_ot2_home is not None:
+            result["score_ot2_home"] = self.score_ot2_home
+        if self.score_ot1_out is not None:
+            result["score_ot1_out"] = self.score_ot1_out
+        if self.score_ot2_out is not None:
+            result["score_ot2_out"] = self.score_ot2_out
+        if self.score_home is not None:
+            result["score_home"] = self.score_home
+        if self.score_out is not None:
+            result["score_out"] = self.score_out
+        if self.clock is not None:
+            result["clock"] = self.clock.to_str()
+        if self.competition_name is not None:
+            result["competitionName"] = self.competition_name
+        if self.current_status is not None:
+            result["currentStatus"] = self.current_status
+        if self.current_period is not None:
+            result["currentPeriod"] = self.current_period
+        if self.match_status is not None:
+            result["matchStatus"] = self.match_status
+        if self.team_name_home is not None:
+            result["teamName_home"] = self.team_name_home
+        if self.team_name_out is not None:
+            result["teamName_out"] = self.team_name_out
+        if self.external_id is not None:
+            result["externalId"] = self.external_id.to_dict()
+        if self.team_engagement_home is not None:
+            result["teamEngagement_home"] = self.team_engagement_home.to_dict()
+        if self.team_engagement_out is not None:
+            result["teamEngagement_out"] = self.team_engagement_out.to_dict()
+        return result
+
+
+def lives_from_dict(s: Any) -> list[Live]:
+    return [Live.from_dict(item) for item in s]

ffbb_data_client/models/lives.py

@@ -0,0 +1,6 @@
+"""Backward-compatibility re-export shim for Clock, Live, lives_from_dict."""
+
+from .clock import Clock
+from .live import Live, lives_from_dict
+
+__all__ = ["Clock", "Live", "lives_from_dict"]