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

ffbb_data_client/models/competition_id_type_competition_generique.py

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

ffbb_data_client/models/competition_origine.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from ..utils.converter_utils import (
+    from_obj,
+    from_str,
+)
+from .competition_origine_categorie import CompetitionOrigineCategorie
+from .competition_origine_type_competition import CompetitionOrigineTypeCompetition
+from .competition_origine_type_competition_generique import (
+    CompetitionOrigineTypeCompetitionGenerique,
+)
+
+
+@dataclass
+class CompetitionOrigine:
+    id: str | None = None
+    code: str | None = None
+    nom: str | None = None
+    type_competition: CompetitionOrigineTypeCompetition | None = None
+    categorie: CompetitionOrigineCategorie | None = None
+    type_competition_generique: CompetitionOrigineTypeCompetitionGenerique | None = None
+
+    @staticmethod
+    def from_dict(obj: Any) -> CompetitionOrigine:
+        assert isinstance(obj, dict)
+        id = from_str(obj, "id")
+        code = from_str(obj, "code")
+        nom = from_str(obj, "nom")
+        tc_val = obj.get("typeCompetition")
+        type_competition = (
+            CompetitionOrigineTypeCompetition.parse(tc_val)
+            if tc_val is not None
+            else None
+        )
+        categorie = from_obj(CompetitionOrigineCategorie.from_dict, obj, "categorie")
+        type_competition_generique = from_obj(
+            CompetitionOrigineTypeCompetitionGenerique.from_dict,
+            obj,
+            "typeCompetitionGenerique",
+        )
+        return CompetitionOrigine(
+            id=id,
+            code=code,
+            nom=nom,
+            type_competition=type_competition,
+            categorie=categorie,
+            type_competition_generique=type_competition_generique,
+        )
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.id is not None:
+            result["id"] = self.id
+        if self.code is not None:
+            result["code"] = self.code
+        if self.nom is not None:
+            result["nom"] = self.nom
+        if self.type_competition is not None:
+            result["typeCompetition"] = self.type_competition.value
+        if self.categorie is not None:
+            result["categorie"] = self.categorie.to_dict()
+        if self.type_competition_generique is not None:
+            result["typeCompetitionGenerique"] = (
+                self.type_competition_generique.to_dict()
+            )
+        return result

ffbb_data_client/models/competition_origine_categorie.py

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

ffbb_data_client/models/competition_origine_type_competition.py

@@ -0,0 +1,14 @@
+from enum import Enum
+
+
+class CompetitionOrigineTypeCompetition(Enum):
+    COUPE = "COUPE"
+    DIV = "DIV"
+    PLAT = "PLAT"
+
+    @staticmethod
+    def parse(str):
+        try:
+            return CompetitionOrigineTypeCompetition(str)
+        except ValueError:
+            return CompetitionOrigineTypeCompetition(str.upper())

ffbb_data_client/models/competition_origine_type_competition_generique.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from ..utils.converter_utils import from_obj
+from .purple_logo import PurpleLogo
+
+
+@dataclass
+class CompetitionOrigineTypeCompetitionGenerique:
+    logo: PurpleLogo | None = None
+
+    @staticmethod
+    def from_dict(obj: Any) -> CompetitionOrigineTypeCompetitionGenerique:
+        assert isinstance(obj, dict)
+        logo = from_obj(PurpleLogo.from_dict, obj, "logo")
+        return CompetitionOrigineTypeCompetitionGenerique(logo=logo)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.logo is not None:
+            result["logo"] = self.logo.to_dict()
+        return result

ffbb_data_client/models/competition_type.py

@@ -0,0 +1,6 @@
+from enum import Enum
+
+
+class CompetitionType(Enum):
+    CHAMPIONSHIP = "championship"
+    CUP = "cup"

ffbb_data_client/models/competitions_facet_distribution.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from ..utils.converter_utils import from_obj
+from .competition_id_sexe import CompetitionIDSexe
+from .competition_id_type_competition import CompetitionIDTypeCompetition
+from .facet_distribution import FacetDistribution
+from .niveau_class import NiveauClass
+
+
+@dataclass
+class CompetitionsFacetDistribution(FacetDistribution):
+    competition_id_categorie_code: dict[str, int] | None = None
+    competition_id_nom_extended: dict[str, int] | None = None
+    competition_id_sexe: CompetitionIDSexe | None = None
+    competition_id_type_competition: CompetitionIDTypeCompetition | None = None
+    niveau: NiveauClass | None = None
+    organisateur_id: dict[str, int] | None = None
+    organisateur_nom: dict[str, int] | None = None
+
+    @staticmethod
+    def from_dict(obj: Any) -> CompetitionsFacetDistribution:
+        assert isinstance(obj, dict)
+        competition_id_categorie_code = obj.get("competitionId.categorie.code")
+        competition_id_nom_extended = obj.get("competitionId.nomExtended")
+        competition_id_sexe = from_obj(
+            CompetitionIDSexe.from_dict, obj, "competitionId.sexe"
+        )
+        competition_id_type_competition = from_obj(
+            CompetitionIDTypeCompetition.from_dict, obj, "competitionId.typeCompetition"
+        )
+        niveau = from_obj(NiveauClass.from_dict, obj, "niveau")
+        organisateur_id = obj.get("organisateur.id")
+        organisateur_nom = obj.get("organisateur.nom")
+        return CompetitionsFacetDistribution(
+            competition_id_categorie_code=competition_id_categorie_code,
+            competition_id_nom_extended=competition_id_nom_extended,
+            competition_id_sexe=competition_id_sexe,
+            competition_id_type_competition=competition_id_type_competition,
+            niveau=niveau,
+            organisateur_id=organisateur_id,
+            organisateur_nom=organisateur_nom,
+        )
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.competition_id_categorie_code is not None:
+            result["competitionId.categorie.code"] = self.competition_id_categorie_code
+        if self.competition_id_nom_extended is not None:
+            result["competitionId.nomExtended"] = self.competition_id_nom_extended
+        if self.competition_id_sexe is not None:
+            result["competitionId.sexe"] = self.competition_id_sexe.to_dict()
+        if self.competition_id_type_competition is not None:
+            result["competitionId.typeCompetition"] = (
+                self.competition_id_type_competition.to_dict()
+            )
+        if self.niveau is not None:
+            result["niveau"] = self.niveau.to_dict()
+        if self.organisateur_id is not None:
+            result["organisateur.id"] = self.organisateur_id
+        if self.organisateur_nom is not None:
+            result["organisateur.nom"] = self.organisateur_nom
+        return result

ffbb_data_client/models/competitions_facet_stats.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from typing import Any
+
+from .facet_stats import FacetStats
+
+
+class CompetitionsFacetStats(FacetStats):
+    @staticmethod
+    def from_dict(obj: Any) -> CompetitionsFacetStats:
+        return CompetitionsFacetStats()
+
+    def to_dict(self) -> dict:
+        return super().to_dict()

ffbb_data_client/models/competitions_hit.py

@@ -0,0 +1,232 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any
+
+from ..utils.converter_utils import (
+    from_bool,
+    from_datetime,
+    from_enum,
+    from_int,
+    from_list,
+    from_obj,
+    from_str,
+)
+from .categorie import Categorie
+from .etat import Etat
+from .hit import Hit
+from .logo import Logo
+from .niveau import Niveau
+from .organisateur import Organisateur
+from .phase_code import PhaseCode
+from .poule import Poule
+from .publication_internet import PublicationInternet
+from .saison import Saison
+from .sexe import Sexe
+from .type_competition import TypeCompetition
+from .type_competition_generique import TypeCompetitionGenerique
+
+
+@dataclass
+class CompetitionsHit(Hit):
+    nom: str | None = None
+    code: str | None = None
+    niveau: Niveau | None = None
+    type_competition: TypeCompetition | None = None
+    sexe: Sexe | None = None
+    id: str | None = None
+    creation_en_cours: bool | None = None
+    date_created: datetime | None = None
+    date_updated: datetime | None = None
+    emarque_v2: bool | None = None
+    live_stat: bool | None = None
+    publication_internet: PublicationInternet | None = None
+    pro: bool | None = None
+    competition_origine: str | None = None
+    competition_origine_niveau: int | None = None
+    phase_code: PhaseCode | None = None
+    competition_origine_nom: str | None = None
+    etat: Etat | None = None
+    poules: list[Poule] | None = None
+    phases: list[str] | None = None
+    categorie: Categorie | None = None
+    id_competition_pere: str | None = None
+    organisateur: Organisateur | None = None
+    saison: Saison | None = None
+    logo: Logo | None = None
+    type_competition_generique: TypeCompetitionGenerique | None = None
+    thumbnail: str | None = None
+    niveau_nb: int | None = None
+    lower_nom: str | None = field(init=False, default=None, repr=False)
+    lower_code: str | None = field(init=False, default=None, repr=False)
+    lower_id: str | None = field(init=False, default=None, repr=False)
+    lower_competition_origine: str | None = field(init=False, default=None, repr=False)
+    lower_competition_origine_nom: str | None = field(
+        init=False, default=None, repr=False
+    )
+
+    @property
+    def name(self) -> str | None:
+        """Alias for .nom — unified name accessor across all Hit types."""
+        return self.nom
+
+    def __post_init__(self) -> None:
+        self.lower_nom = self.nom.lower() if self.nom else None
+        self.lower_code = self.code.lower() if self.code else None
+        self.lower_id = self.id.lower() if self.id else None
+        self.lower_competition_origine = (
+            self.competition_origine.lower() if self.competition_origine else None
+        )
+        self.lower_competition_origine_nom = (
+            self.competition_origine_nom.lower()
+            if self.competition_origine_nom
+            else None
+        )
+
+    @staticmethod
+    def from_dict(obj: Any) -> CompetitionsHit:
+        try:
+            assert isinstance(obj, dict)
+            nom = from_str(obj, "nom")
+            code = from_str(obj, "code")
+            niveau = from_enum(Niveau, obj, "niveau")
+            type_competition = from_enum(TypeCompetition, obj, "typeCompetition")
+            sexe = from_enum(Sexe, obj, "sexe")
+            id = from_str(obj, "id")
+            creation_en_cours = from_bool(obj, "creationEnCours")
+            date_created = from_datetime(obj, "date_created")
+            date_updated = from_datetime(obj, "date_updated")
+            emarque_v2 = from_bool(obj, "emarqueV2")
+            live_stat = from_bool(obj, "liveStat")
+            publication_internet = from_enum(
+                PublicationInternet, obj, "publicationInternet"
+            )
+            pro = from_bool(obj, "pro")
+            competition_origine = from_str(obj, "competition_origine")
+            competition_origine_niveau = from_int(obj, "competition_origine_niveau")
+            phase_code = from_enum(PhaseCode, obj, "phase_code")
+            competition_origine_nom = from_str(obj, "competition_origine_nom")
+            etat = from_enum(Etat, obj, "etat")
+            poules = from_list(Poule.from_dict, obj, "poules")
+            phases = from_list(str, obj, "phases")
+            categorie = from_obj(Categorie.from_dict, obj, "categorie")
+            id_competition_pere = from_str(obj, "idCompetitionPere")
+            organisateur = from_obj(Organisateur.from_dict, obj, "organisateur")
+            saison = from_obj(Saison.from_dict, obj, "saison")
+            logo = from_obj(Logo.from_dict, obj, "logo")
+            type_competition_generique = from_obj(
+                TypeCompetitionGenerique.from_dict, obj, "typeCompetitionGenerique"
+            )
+            thumbnail = from_str(obj, "thumbnail")
+            niveau_nb = from_int(obj, "niveau_nb")
+            return CompetitionsHit(
+                nom=nom,
+                code=code,
+                niveau=niveau,
+                type_competition=type_competition,
+                sexe=sexe,
+                id=id,
+                creation_en_cours=creation_en_cours,
+                date_created=date_created,
+                date_updated=date_updated,
+                emarque_v2=emarque_v2,
+                live_stat=live_stat,
+                publication_internet=publication_internet,
+                pro=pro,
+                competition_origine=competition_origine,
+                competition_origine_niveau=competition_origine_niveau,
+                phase_code=phase_code,
+                competition_origine_nom=competition_origine_nom,
+                etat=etat,
+                poules=poules,
+                phases=phases,
+                categorie=categorie,
+                id_competition_pere=id_competition_pere,
+                organisateur=organisateur,
+                saison=saison,
+                logo=logo,
+                type_competition_generique=type_competition_generique,
+                thumbnail=thumbnail,
+                niveau_nb=niveau_nb,
+            )
+        except Exception as e:
+            raise ValueError(f"Invalid `Hit.from_dict` input: {e}") from e
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.nom is not None:
+            result["nom"] = self.nom
+        if self.code is not None:
+            result["code"] = self.code
+        if self.niveau is not None:
+            result["niveau"] = self.niveau.value
+        if self.type_competition is not None:
+            result["typeCompetition"] = self.type_competition.value
+        if self.sexe is not None:
+            result["sexe"] = self.sexe.value
+        if self.id is not None:
+            result["id"] = self.id
+        if self.creation_en_cours is not None:
+            result["creationEnCours"] = self.creation_en_cours
+        if self.date_created is not None:
+            result["date_created"] = self.date_created.isoformat()
+        if self.date_updated is not None:
+            result["date_updated"] = self.date_updated.isoformat()
+        if self.emarque_v2 is not None:
+            result["emarqueV2"] = self.emarque_v2
+        if self.live_stat is not None:
+            result["liveStat"] = self.live_stat
+        if self.publication_internet is not None:
+            result["publicationInternet"] = self.publication_internet.value
+        if self.pro is not None:
+            result["pro"] = self.pro
+        if self.competition_origine is not None:
+            result["competition_origine"] = self.competition_origine
+        if self.competition_origine_niveau is not None:
+            result["competition_origine_niveau"] = self.competition_origine_niveau
+        if self.phase_code is not None:
+            result["phase_code"] = self.phase_code.value
+        if self.competition_origine_nom is not None:
+            result["competition_origine_nom"] = self.competition_origine_nom
+        if self.etat is not None:
+            result["etat"] = self.etat.value
+        if self.poules is not None:
+            result["poules"] = [p.to_dict() for p in self.poules]
+        if self.phases is not None:
+            result["phases"] = self.phases
+        if self.categorie is not None:
+            result["categorie"] = self.categorie.to_dict()
+        if self.id_competition_pere is not None:
+            result["idCompetitionPere"] = self.id_competition_pere
+        if self.organisateur is not None:
+            result["organisateur"] = self.organisateur.to_dict()
+        if self.saison is not None:
+            result["saison"] = self.saison.to_dict()
+        if self.logo is not None:
+            result["logo"] = self.logo.to_dict()
+        if self.type_competition_generique is not None:
+            result["typeCompetitionGenerique"] = (
+                self.type_competition_generique.to_dict()
+            )
+        if self.thumbnail is not None:
+            result["thumbnail"] = self.thumbnail
+        if self.niveau_nb is not None:
+            result["niveau_nb"] = str(self.niveau_nb)
+        return result
+
+    def is_valid_for_query(self, query: str) -> bool:
+        return bool(
+            not query
+            or (self.lower_nom and query in self.lower_nom)
+            or (self.lower_code and query in self.lower_code)
+            or (self.lower_id and query in self.lower_id)
+            or (
+                self.lower_competition_origine
+                and query in self.lower_competition_origine
+            )
+            or (
+                self.lower_competition_origine_nom
+                and query in self.lower_competition_origine_nom
+            )
+        )

ffbb_data_client/models/competitions_multi_search_query.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from ..config import MEILISEARCH_INDEX_COMPETITIONS
+from .competitions_facet_distribution import CompetitionsFacetDistribution
+from .competitions_facet_stats import CompetitionsFacetStats
+from .multi_search_query import MultiSearchQuery
+from .multi_search_result_competitions import CompetitionsMultiSearchResult
+from .multi_search_results import MultiSearchResult
+
+
+class CompetitionsMultiSearchQuery(MultiSearchQuery):
+    def __init__(
+        self,
+        q: str | None,
+        limit: int | None = 10,
+        offset: int | None = 0,
+        filter: list[str] | None = None,
+        sort: list[str] | None = None,
+    ):
+        super().__init__(
+            index_uid=MEILISEARCH_INDEX_COMPETITIONS,
+            q=q,
+            limit=limit,
+            offset=offset,
+            filter=filter,
+            sort=sort,
+        )
+
+    def is_valid_result(self, result: MultiSearchResult):
+        return result and (
+            isinstance(result, CompetitionsMultiSearchResult)
+            and (
+                result.facet_distribution is None
+                or isinstance(result.facet_distribution, CompetitionsFacetDistribution)
+            )
+            and (
+                result.facet_stats is None
+                or isinstance(result.facet_stats, CompetitionsFacetStats)
+            )
+        )

ffbb_data_client/models/competitions_query.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class CompetitionsQuery:
+    deep_phases_poules_rencontres__limit: str | None = (
+        "1000"  # Original: deep[phases][poules][rencontres][_limit]
+    )
+    fields_: list[str] | None = field(default=None)  # Original: fields[]

ffbb_data_client/models/configuration_models.py

@@ -0,0 +1,5 @@
+"""Backward-compatibility re-export shim for GetConfigurationResponse."""
+
+from .get_configuration_response import GetConfigurationResponse
+
+__all__ = ["GetConfigurationResponse"]

ffbb_data_client/models/contact_info.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class ContactInfo:
+    """Compact contact information used by V3 composite helpers.
+
+    Fields are intentionally simple (no enums) to keep the model lightweight
+    and avoid tight coupling with Directus-specific enums.
+    """
+
+    nom: str | None = None
+    prenom: str | None = None
+    email: str | None = None
+    telephone: str | None = None
+    role: str | None = None

ffbb_data_client/models/content_multi_search_query.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from ..config import (
+    MEILISEARCH_FACETS_GALERIES,
+    MEILISEARCH_FACETS_NEWS,
+    MEILISEARCH_FACETS_RSS,
+    MEILISEARCH_FACETS_YOUTUBE_VIDEOS,
+    MEILISEARCH_INDEX_GALERIES,
+    MEILISEARCH_INDEX_NEWS,
+    MEILISEARCH_INDEX_RSS,
+    MEILISEARCH_INDEX_YOUTUBE_VIDEOS,
+)
+from .multi_search_query import MultiSearchQuery
+
+
+class NewsMultiSearchQuery(MultiSearchQuery):
+    def __init__(
+        self,
+        q: str | None,
+        limit: int | None = 10,
+        offset: int | None = 0,
+        filter: list[str] | None = None,
+        sort: list[str] | None = None,
+    ):
+        super().__init__(
+            index_uid=MEILISEARCH_INDEX_NEWS,
+            q=q,
+            facets=MEILISEARCH_FACETS_NEWS,
+            limit=limit,
+            offset=offset,
+            filter=filter,
+            sort=sort,
+        )
+
+
+class YoutubeVideosMultiSearchQuery(MultiSearchQuery):
+    def __init__(
+        self,
+        q: str | None,
+        limit: int | None = 10,
+        offset: int | None = 0,
+        filter: list[str] | None = None,
+        sort: list[str] | None = None,
+    ):
+        super().__init__(
+            index_uid=MEILISEARCH_INDEX_YOUTUBE_VIDEOS,
+            q=q,
+            facets=MEILISEARCH_FACETS_YOUTUBE_VIDEOS,
+            limit=limit,
+            offset=offset,
+            filter=filter,
+            sort=sort,
+        )
+
+
+class RssMultiSearchQuery(MultiSearchQuery):
+    def __init__(
+        self,
+        q: str | None,
+        limit: int | None = 10,
+        offset: int | None = 0,
+        filter: list[str] | None = None,
+        sort: list[str] | None = None,
+    ):
+        super().__init__(
+            index_uid=MEILISEARCH_INDEX_RSS,
+            q=q,
+            facets=MEILISEARCH_FACETS_RSS,
+            limit=limit,
+            offset=offset,
+            filter=filter,
+            sort=sort,
+        )
+
+
+class GaleriesMultiSearchQuery(MultiSearchQuery):
+    def __init__(
+        self,
+        q: str | None,
+        limit: int | None = 10,
+        offset: int | None = 0,
+        filter: list[str] | None = None,
+        sort: list[str] | None = None,
+    ):
+        super().__init__(
+            index_uid=MEILISEARCH_INDEX_GALERIES,
+            q=q,
+            facets=MEILISEARCH_FACETS_GALERIES,
+            limit=limit,
+            offset=offset,
+            filter=filter,
+            sort=sort,
+        )

ffbb_data_client/models/coordonnees.py

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

ffbb_data_client/models/coordonnees_type.py

@@ -0,0 +1,5 @@
+from enum import Enum
+
+
+class CoordonneesType(Enum):
+    POINT = "Point"