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

ffbb_data_client/models/get_configuration_response.py

@@ -0,0 +1,45 @@
+"""Configuration models for FFBB API."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class GetConfigurationResponse:
+    """Response model for /items/configuration endpoint."""
+
+    id: int
+    key_dh: str
+    key_ms: str
+    key_directus_website: str | None = None
+    key_directus_competitions: str | None = None
+    ios_version: str | None = None
+    android_version: str | None = None
+    date_created: str | None = None
+    date_updated: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> GetConfigurationResponse:
+        """Create a GetConfigurationResponse from a dictionary."""
+        return cls(
+            id=data.get("id", 0),
+            key_dh=data.get("key_dh", ""),
+            key_ms=data.get("key_ms", ""),
+            key_directus_website=data.get("key_directus_website"),
+            key_directus_competitions=data.get("key_directus_competitions"),
+            ios_version=data.get("ios_version"),
+            android_version=data.get("android_version"),
+            date_created=data.get("date_created"),
+            date_updated=data.get("date_updated"),
+        )
+
+    @property
+    def api_bearer_token(self) -> str:
+        """Alias for key_dh - the API bearer token."""
+        return self.key_dh
+
+    @property
+    def meilisearch_token(self) -> str:
+        """Alias for key_ms - the Meilisearch token."""
+        return self.key_ms

ffbb_data_client/models/get_engagement_response.py

@@ -0,0 +1,23 @@
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class GetEngagementResponse:
+    id: str
+    numeroEquipe: str | None = None
+    idPoule: Any | None = None
+    idCompetition: Any | None = None
+    idOrganisme: Any | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "GetEngagementResponse | None":
+        if not data or not isinstance(data, dict):
+            return None
+        return cls(
+            id=str(data.get("id", "")),
+            numeroEquipe=data.get("numeroEquipe"),
+            idPoule=data.get("idPoule"),
+            idCompetition=data.get("idCompetition"),
+            idOrganisme=data.get("idOrganisme"),
+        )

ffbb_data_client/models/get_entraineur_response.py

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

ffbb_data_client/models/get_formation_response.py

@@ -0,0 +1,28 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class GetFormationResponse:
+    id: str
+    theme: str | None = None
+    type: str | None = None
+    domain: str | None = None
+    mode: str | None = None
+    place: str | None = None
+    date_start: str | None = None
+    date_end: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "GetFormationResponse | None":
+        if not data or not isinstance(data, dict):
+            return None
+        return cls(
+            id=str(data.get("id", "")),
+            theme=data.get("theme"),
+            type=data.get("type"),
+            domain=data.get("domain"),
+            mode=data.get("mode"),
+            place=data.get("place"),
+            date_start=data.get("date_start"),
+            date_end=data.get("date_end"),
+        )

ffbb_data_client/models/get_officiel_response.py

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

ffbb_data_client/models/get_organisme_response.py

@@ -0,0 +1,476 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any
+
+from .niveau_models import NiveauInfo, get_niveau_from_idcompetition
+
+
+@dataclass
+class GetOrganismeResponse:
+    id: str
+    nom: str
+    code: str
+    telephone: str
+    adresse: str
+    mail: str
+    type: str = ""
+    nom_simple: Any | None = None
+    urlSiteWeb: str = ""
+    nomClubPro: str = ""
+    adresseClubPro: Any | None = None
+
+    @dataclass
+    class CommuneModel:
+        codePostal: str
+        libelle: str
+
+    commune: CommuneModel | None = None
+
+    @dataclass
+    class CartographieModel:
+        latitude: float
+        longitude: float
+
+    cartographie: CartographieModel | None = None
+    communeClubPro: Any | None = None
+
+    @dataclass
+    class MembresitemModel:
+        id: str
+        nom: str
+        prenom: str
+        adresse1: str
+        adresse2: Any | None = None
+        codePostal: str = ""
+        ville: str = ""
+        mail: str = ""
+        telephoneFixe: Any | None = None
+        telephonePortable: str = ""
+        codeFonction: str = ""
+
+    membres: list[MembresitemModel] = field(default_factory=list)
+    competitions: list[Any] = field(default_factory=list)
+
+    @dataclass
+    class EngagementsitemModel:
+        id: str
+        numeroEquipe: str | None = None
+
+        @property
+        def poule_id(self) -> str | None:
+            """Convenience property to access nested poule ID."""
+            return self.idPoule.id if self.idPoule else None
+
+        @property
+        def competition_nom(self) -> str | None:
+            """Convenience property to access nested competition name."""
+            return self.idCompetition.nom if self.idCompetition else None
+
+        @property
+        def numero_equipe(self) -> str | None:
+            """Convenience alias for .numeroEquipe."""
+            return self.numeroEquipe
+
+        @dataclass
+        class IdpouleModel:
+            id: str
+
+        idPoule: IdpouleModel | None = None
+
+        @dataclass
+        class IdcompetitionModel:
+            id: str
+            nom: str
+            code: str
+            sexe: str
+            competition_origine: str
+            competition_origine_nom: str
+            competition_origine_niveau: int
+            typeCompetition: str
+            logo: Any | None = None
+
+            @dataclass
+            class SaisonModel:
+                id: str
+
+            saison: SaisonModel | None = None
+            idCompetitionPere: Any | None = None
+
+            @dataclass
+            class OrganisateurModel:
+                type: str
+
+            organisateur: OrganisateurModel | None = None
+
+            @dataclass
+            class TypecompetitiongeneriqueModel:
+
+                @dataclass
+                class LogoModel:
+                    id: str
+                    gradient_color: str
+
+                logo: LogoModel | None = None
+
+            typeCompetitionGenerique: TypecompetitiongeneriqueModel | None = None
+
+            @dataclass
+            class CategorieModel:
+                code: str
+                ordre: int
+
+            categorie: CategorieModel | None = None
+
+            @property
+            def niveau(self) -> NiveauInfo | None:
+                """Extrait automatiquement le niveau depuis le nom de la competition."""
+                return get_niveau_from_idcompetition(self)
+
+        idCompetition: IdcompetitionModel | None = None
+
+    engagements: list[EngagementsitemModel] = field(default_factory=list)
+    organismes_fils: list[Any] = field(default_factory=list)
+
+    @dataclass
+    class OffrespratiquesitemModel:
+
+        @dataclass
+        class Ffbbserver_Offres_Pratiques_IdModel:
+            id: str
+            title: str
+            categoriePratique: str
+            typePratique: str
+
+        ffbbserver_offres_pratiques_id: Ffbbserver_Offres_Pratiques_IdModel | None = (
+            None
+        )
+
+    offresPratiques: list[OffrespratiquesitemModel] = field(default_factory=list)
+
+    @dataclass
+    class LabellisationitemModel:
+        id: str
+        debut: datetime
+        fin: datetime
+
+        @dataclass
+        class IdlabellisationprogrammeModel:
+            id: str
+            libelle: str
+            labellisationLabel: str
+            logo_vertical: Any | None = None
+
+        idLabellisationProgramme: IdlabellisationprogrammeModel | None = None
+
+    labellisation: list[LabellisationitemModel] = field(default_factory=list)
+
+    @dataclass
+    class SalleModel:
+        id: str
+        numero: str
+        libelle: str
+        libelle2: str
+        adresse: str
+        adresseComplement: str
+
+        @dataclass
+        class CommuneModel:
+            codePostal: str
+            libelle: str
+
+        commune: CommuneModel | None = None
+
+        @dataclass
+        class CartographieModel:
+            latitude: float
+            longitude: float
+
+        cartographie: CartographieModel | None = None
+
+    salle: SalleModel | None = None
+
+    @dataclass
+    class LogoModel:
+        id: str
+        gradient_color: str
+
+    logo: LogoModel | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> GetOrganismeResponse | None:
+        """Convert dictionary to OrganismesModel 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
+
+        # Extract nested commune data
+        commune_data = data.get("commune", {})
+        commune = (
+            cls.CommuneModel(
+                codePostal=commune_data.get("codePostal", ""),
+                libelle=commune_data.get("libelle", ""),
+            )
+            if commune_data
+            else None
+        )
+
+        # Extract nested cartographie data
+        cartographie_data = data.get("cartographie", {})
+        cartographie = (
+            cls.CartographieModel(
+                latitude=float(cartographie_data.get("latitude", 0.0)),
+                longitude=float(cartographie_data.get("longitude", 0.0)),
+            )
+            if cartographie_data
+            else None
+        )
+
+        # Extract membres data
+        membres = []
+        for membre_data in data.get("membres", []):
+            if membre_data:
+                membre = cls.MembresitemModel(
+                    id=str(membre_data.get("id", "")),
+                    nom=str(membre_data.get("nom", "")),
+                    prenom=str(membre_data.get("prenom", "")),
+                    adresse1=str(membre_data.get("adresse1", "")),
+                    adresse2=membre_data.get("adresse2"),
+                    codePostal=str(membre_data.get("codePostal", "")),
+                    ville=str(membre_data.get("ville", "")),
+                    mail=str(membre_data.get("mail", "")),
+                    telephoneFixe=membre_data.get("telephoneFixe"),
+                    telephonePortable=str(membre_data.get("telephonePortable", "")),
+                    codeFonction=str(membre_data.get("codeFonction", "")),
+                )
+                membres.append(membre)
+
+        # Extract engagements data
+        engagements = []
+        for engagement_data in data.get("engagements", []):
+            if engagement_data:
+                # Extract idPoule
+                poule_data = engagement_data.get("idPoule", {})
+                id_poule = (
+                    cls.EngagementsitemModel.IdpouleModel(
+                        id=str(poule_data.get("id", ""))
+                    )
+                    if poule_data
+                    else None
+                )
+
+                # Extract idCompetition
+                competition_data = engagement_data.get("idCompetition", {})
+                id_competition = None
+                if competition_data:
+                    saison_data = competition_data.get("saison", {})
+                    saison = (
+                        cls.EngagementsitemModel.IdcompetitionModel.SaisonModel(
+                            id=str(saison_data.get("id", ""))
+                        )
+                        if saison_data
+                        else None
+                    )
+
+                    organisateur_data = competition_data.get("organisateur", {})
+                    organisateur = (
+                        cls.EngagementsitemModel.IdcompetitionModel.OrganisateurModel(
+                            type=str(organisateur_data.get("type", ""))
+                        )
+                        if organisateur_data
+                        else None
+                    )
+
+                    type_comp_generique_data = competition_data.get(
+                        "typeCompetitionGenerique", {}
+                    )
+                    type_comp_generique = None
+                    if type_comp_generique_data:
+                        logo_data = type_comp_generique_data.get("logo", {})
+                        # Use shorter aliases to avoid line length issues
+                        IdComp = cls.EngagementsitemModel.IdcompetitionModel
+                        LogoClass = IdComp.TypecompetitiongeneriqueModel.LogoModel
+                        logo_tcg = (
+                            LogoClass(
+                                id=str(logo_data.get("id", "")),
+                                gradient_color=str(logo_data.get("gradient_color", "")),
+                            )
+                            if logo_data
+                            else None
+                        )
+
+                        TypeCompGenClass = IdComp.TypecompetitiongeneriqueModel
+                        type_comp_generique = TypeCompGenClass(logo=logo_tcg)
+
+                    categorie_data = competition_data.get("categorie", {})
+                    categorie = (
+                        cls.EngagementsitemModel.IdcompetitionModel.CategorieModel(
+                            code=str(categorie_data.get("code", "")),
+                            ordre=int(categorie_data.get("ordre", 0)),
+                        )
+                        if categorie_data
+                        else None
+                    )
+
+                    id_competition = cls.EngagementsitemModel.IdcompetitionModel(
+                        id=str(competition_data.get("id", "")),
+                        nom=str(competition_data.get("nom", "")),
+                        code=str(competition_data.get("code", "")),
+                        sexe=str(competition_data.get("sexe", "")),
+                        competition_origine=str(
+                            competition_data.get("competition_origine", "")
+                        ),
+                        competition_origine_nom=str(
+                            competition_data.get("competition_origine_nom", "")
+                        ),
+                        competition_origine_niveau=int(
+                            competition_data.get("competition_origine_niveau", 0)
+                        ),
+                        typeCompetition=str(
+                            competition_data.get("typeCompetition", "")
+                        ),
+                        logo=competition_data.get("logo"),
+                        saison=saison,
+                        idCompetitionPere=competition_data.get("idCompetitionPere"),
+                        organisateur=organisateur,
+                        typeCompetitionGenerique=type_comp_generique,
+                        categorie=categorie,
+                    )
+
+                engagement = cls.EngagementsitemModel(
+                    id=str(engagement_data.get("id", "")),
+                    numeroEquipe=engagement_data.get("numeroEquipe"),
+                    idPoule=id_poule,
+                    idCompetition=id_competition,
+                )
+                engagements.append(engagement)
+
+        # Extract offres pratiques
+        offres_pratiques = []
+        for offre_data in data.get("offresPratiques", []):
+            if offre_data:
+                ffbb_pratique_data = offre_data.get(
+                    "ffbbserver_offres_pratiques_id", {}
+                )
+                ffbb_pratique = (
+                    cls.OffrespratiquesitemModel.Ffbbserver_Offres_Pratiques_IdModel(
+                        id=str(ffbb_pratique_data.get("id", "")),
+                        title=str(ffbb_pratique_data.get("title", "")),
+                        categoriePratique=str(
+                            ffbb_pratique_data.get("categoriePratique", "")
+                        ),
+                        typePratique=str(ffbb_pratique_data.get("typePratique", "")),
+                    )
+                    if ffbb_pratique_data
+                    else None
+                )
+
+                offre = cls.OffrespratiquesitemModel(
+                    ffbbserver_offres_pratiques_id=ffbb_pratique
+                )
+                offres_pratiques.append(offre)
+
+        # Extract labellisation
+        labellisations = []
+        for label_data in data.get("labellisation", []):
+            if label_data:
+                programme_data = label_data.get("idLabellisationProgramme", {})
+                programme = (
+                    cls.LabellisationitemModel.IdlabellisationprogrammeModel(
+                        id=str(programme_data.get("id", "")),
+                        libelle=str(programme_data.get("libelle", "")),
+                        labellisationLabel=str(
+                            programme_data.get("labellisationLabel", "")
+                        ),
+                        logo_vertical=programme_data.get("logo_vertical"),
+                    )
+                    if programme_data
+                    else None
+                )
+
+                label = cls.LabellisationitemModel(
+                    id=str(label_data.get("id", "")),
+                    debut=datetime.fromisoformat(label_data.get("debut", "1970-01-01")),
+                    fin=datetime.fromisoformat(label_data.get("fin", "1970-01-01")),
+                    idLabellisationProgramme=programme,
+                )
+                labellisations.append(label)
+
+        # Extract salle
+        salle_data = data.get("salle", {})
+        salle = None
+        if salle_data:
+            salle_commune_data = salle_data.get("commune", {})
+            salle_commune = (
+                cls.SalleModel.CommuneModel(
+                    codePostal=str(salle_commune_data.get("codePostal", "")),
+                    libelle=str(salle_commune_data.get("libelle", "")),
+                )
+                if salle_commune_data
+                else None
+            )
+
+            salle_cartographie_data = salle_data.get("cartographie", {})
+            salle_cartographie = (
+                cls.SalleModel.CartographieModel(
+                    latitude=float(salle_cartographie_data.get("latitude", 0.0)),
+                    longitude=float(salle_cartographie_data.get("longitude", 0.0)),
+                )
+                if salle_cartographie_data
+                else None
+            )
+
+            salle = cls.SalleModel(
+                id=str(salle_data.get("id", "")),
+                numero=str(salle_data.get("numero", "")),
+                libelle=str(salle_data.get("libelle", "")),
+                libelle2=str(salle_data.get("libelle2", "")),
+                adresse=str(salle_data.get("adresse", "")),
+                adresseComplement=str(salle_data.get("adresseComplement", "")),
+                commune=salle_commune,
+                cartographie=salle_cartographie,
+            )
+
+        # Extract logo
+        logo_data = data.get("logo", {})
+        logo = (
+            cls.LogoModel(
+                id=str(logo_data.get("id", "")),
+                gradient_color=str(logo_data.get("gradient_color", "")),
+            )
+            if logo_data
+            else None
+        )
+
+        return cls(
+            id=str(data.get("id", "")),
+            nom=str(data.get("nom", "")),
+            code=str(data.get("code", "")),
+            telephone=str(data.get("telephone", "")),
+            adresse=str(data.get("adresse", "")),
+            mail=str(data.get("mail", "")),
+            type=str(data.get("type", "")),
+            nom_simple=data.get("nom_simple"),
+            urlSiteWeb=str(data.get("urlSiteWeb", "")),
+            nomClubPro=str(data.get("nomClubPro", "")),
+            adresseClubPro=data.get("adresseClubPro"),
+            commune=commune,
+            cartographie=cartographie,
+            communeClubPro=data.get("communeClubPro"),
+            membres=membres,
+            competitions=data.get("competitions", []),
+            engagements=engagements,
+            organismes_fils=data.get("organismes_fils", []),
+            offresPratiques=offres_pratiques,
+            labellisation=labellisations,
+            salle=salle,
+            logo=logo,
+        )

ffbb_data_client/models/get_poule_response.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any
+
+from .poule_rencontre_item_model import PouleRencontreItemModel
+from .team_ranking import TeamRanking
+
+
+@dataclass
+class GetPouleResponse:
+    id: str
+
+    # Keep nested alias for backward compatibility
+    RencontresitemModel = PouleRencontreItemModel
+
+    rencontres: list[PouleRencontreItemModel] = field(default_factory=list)
+    classements: list[TeamRanking] | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> GetPouleResponse | None:
+        """Convert dictionary to PoulesModel 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
+
+        # Basic implementation - can be expanded later
+        rencontres = []
+        for rencontre_data in data.get("rencontres", []):
+            if rencontre_data:
+                rencontre = PouleRencontreItemModel(
+                    id=str(rencontre_data.get("id", "")),
+                    numero=str(rencontre_data.get("numero", "")),
+                    numeroJournee=str(rencontre_data.get("numeroJournee", "")),
+                    idPoule=str(rencontre_data.get("idPoule", "")),
+                    competitionId=str(rencontre_data.get("competitionId", "")),
+                    resultatEquipe1=str(rencontre_data.get("resultatEquipe1", "")),
+                    resultatEquipe2=str(rencontre_data.get("resultatEquipe2", "")),
+                    joue=int(rencontre_data.get("joue", 0)),
+                    nomEquipe1=str(rencontre_data.get("nomEquipe1", "")),
+                    nomEquipe2=str(rencontre_data.get("nomEquipe2", "")),
+                    date_rencontre=datetime.fromisoformat(
+                        rencontre_data.get("date_rencontre", "1970-01-01")
+                    ),
+                )
+                rencontres.append(rencontre)
+
+        # Process classements
+        classements = []
+        for classement_data in data.get("classements", []):
+            if classement_data:
+                classement = TeamRanking.from_dict(classement_data)
+                if classement:
+                    classements.append(classement)
+
+        return cls(
+            id=str(data.get("id", "")),
+            rencontres=rencontres,
+            classements=classements if classements else None,
+        )