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

ffbb_data_client/models/rencontres_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 RencontresFacetDistribution(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) -> RencontresFacetDistribution:
+        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 RencontresFacetDistribution(
+            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/rencontres_facet_stats.py

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

ffbb_data_client/models/rencontres_hit.py

@@ -0,0 +1,271 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime, time
+from typing import Any
+
+from ..utils.converter_utils import (
+    from_datetime,
+    from_enum,
+    from_int,
+    from_obj,
+    from_officiels_list,
+    from_str,
+    from_time,
+)
+from .competition_id import CompetitionID
+from .geo import Geo
+from .hit import Hit
+from .id_engagement_equipe import IDEngagementEquipe
+from .id_organisme_equipe import IDOrganismeEquipe
+from .id_poule import IDPoule
+from .niveau import Niveau
+from .organisateur import Organisateur
+from .pratique import Pratique
+from .saison import Saison
+from .salle import Salle
+
+
+@dataclass
+class RencontresHit(Hit):
+    niveau: Niveau | None = None
+    id: str | None = None
+    date: datetime | None = None
+    date_rencontre: datetime | None = None
+    horaire: time | None = None
+    nom_equipe1: str | None = None
+    nom_equipe2: str | None = None
+    numero_journee: int | None = None
+    pratique: Pratique | None = None
+    gs_id: str | None = None
+    officiels: list[str] | None = None
+    competition_id: CompetitionID | None = None
+    id_organisme_equipe1: IDOrganismeEquipe | None = None
+    id_organisme_equipe2: IDOrganismeEquipe | None = None
+    id_poule: IDPoule | None = None
+    saison: Saison | None = None
+    salle: Salle | None = None
+    id_engagement_equipe1: IDEngagementEquipe | None = None
+    id_engagement_equipe2: IDEngagementEquipe | None = None
+    geo: Geo | None = None
+    date_timestamp: int | None = None
+    date_rencontre_timestamp: int | None = None
+    creation_timestamp: int | None = None
+    date_saisie_resultat_timestamp: int | None = None
+    modification_timestamp: int | None = None
+    thumbnail: str | None = None
+    organisateur: Organisateur | None = None
+    niveau_nb: int | None = None
+    lower_id: str | None = field(init=False, default=None, repr=False)
+    lower_nom_equipe1: str | None = field(init=False, default=None, repr=False)
+    lower_nom_equipe2: str | None = field(init=False, default=None, repr=False)
+    lower_gs_id: str | None = field(init=False, default=None, repr=False)
+    lower_officiels: list[str] | None = field(init=False, default=None, repr=False)
+
+    @property
+    def name(self) -> str | None:
+        """Alias for convenience — returns 'Team A vs Team B'."""
+        if self.nom_equipe1 and self.nom_equipe2:
+            return f"{self.nom_equipe1} vs {self.nom_equipe2}"
+        return self.nom_equipe1 or self.nom_equipe2
+
+    @property
+    def team1_name(self) -> str | None:
+        """Alias for .nom_equipe1 for DX consistency."""
+        return self.nom_equipe1
+
+    @property
+    def team2_name(self) -> str | None:
+        """Alias for .nom_equipe2 for DX consistency."""
+        return self.nom_equipe2
+
+    def __post_init__(self) -> None:
+        self._normalize_string_fields()
+        self._normalize_officiels()
+
+    def _normalize_string_fields(self) -> None:
+        """Normalize string fields to lowercase."""
+        self.lower_id = self.id.lower() if self.id else None
+        self.lower_nom_equipe1 = self.nom_equipe1.lower() if self.nom_equipe1 else None
+        self.lower_nom_equipe2 = self.nom_equipe2.lower() if self.nom_equipe2 else None
+        self.lower_gs_id = self.gs_id.lower() if self.gs_id else None
+
+    def _normalize_officiels(self) -> None:
+        """Normalize the officiels list for search and consistency.
+
+        Handles both old format (list of strings) and new format (list of dicts).
+        """
+        if not self.officiels:
+            self.lower_officiels = None
+            return
+
+        lower_officiels = []
+        for o in self.officiels:
+            if isinstance(o, str):
+                lower_officiels.append(o.lower())
+            elif isinstance(o, dict):
+                off = o.get("officiel", {})
+                name = f"{off.get('nom', '')} {off.get('prenom', '')}".strip()
+                lower_officiels.append(name.lower() if name else "")
+
+        self.lower_officiels = lower_officiels if lower_officiels else None
+
+    @staticmethod
+    def from_dict(obj: Any) -> RencontresHit:
+        try:
+            assert isinstance(obj, dict)
+            niveau = from_enum(Niveau, obj, "niveau")
+            id = from_str(obj, "id")
+            date = from_datetime(obj, "date")
+            date_rencontre = from_datetime(obj, "date_rencontre")
+            horaire = from_time(obj, "horaire")
+            nom_equipe1 = from_str(obj, "nomEquipe1")
+            nom_equipe2 = from_str(obj, "nomEquipe2")
+
+            numero_journee = from_int(obj, "numeroJournee")
+            pratique = from_enum(Pratique, obj, "pratique")
+            gs_id = from_str(obj, "gsId")
+            officiels = from_officiels_list(obj.get("officiels"))
+            competition_id = from_obj(CompetitionID.from_dict, obj, "competitionId")
+            id_organisme_equipe1 = from_obj(
+                IDOrganismeEquipe.from_dict, obj, "idOrganismeEquipe1"
+            )
+            id_organisme_equipe2 = from_obj(
+                IDOrganismeEquipe.from_dict, obj, "idOrganismeEquipe2"
+            )
+            id_poule = from_obj(IDPoule.from_dict, obj, "idPoule")
+            saison = from_obj(Saison.from_dict, obj, "saison")
+            salle = from_obj(Salle.from_dict, obj, "salle")
+            id_engagement_equipe1 = from_obj(
+                IDEngagementEquipe.from_dict, obj, "idEngagementEquipe1"
+            )
+            id_engagement_equipe2 = from_obj(
+                IDEngagementEquipe.from_dict, obj, "idEngagementEquipe2"
+            )
+            geo = from_obj(Geo.from_dict, obj, "_geo")
+            date_timestamp = from_int(obj, "date_timestamp")
+            date_rencontre_timestamp = from_int(obj, "date_rencontre_timestamp")
+            creation_timestamp = from_int(obj, "creation_timestamp")
+            date_saisie_resultat_timestamp = from_int(
+                obj, "dateSaisieResultat_timestamp"
+            )
+            modification_timestamp = from_int(obj, "modification_timestamp")
+            thumbnail = from_str(obj, "thumbnail")
+            organisateur = from_obj(Organisateur.from_dict, obj, "organisateur")
+            niveau_nb = from_int(obj, "niveau_nb")
+            return RencontresHit(
+                niveau=niveau,
+                id=id,
+                date=date,
+                date_rencontre=date_rencontre,
+                horaire=horaire,
+                nom_equipe1=nom_equipe1,
+                nom_equipe2=nom_equipe2,
+                numero_journee=numero_journee,
+                pratique=pratique,
+                gs_id=gs_id,
+                officiels=officiels,
+                competition_id=competition_id,
+                id_organisme_equipe1=id_organisme_equipe1,
+                id_organisme_equipe2=id_organisme_equipe2,
+                id_poule=id_poule,
+                saison=saison,
+                salle=salle,
+                id_engagement_equipe1=id_engagement_equipe1,
+                id_engagement_equipe2=id_engagement_equipe2,
+                geo=geo,
+                date_timestamp=date_timestamp,
+                date_rencontre_timestamp=date_rencontre_timestamp,
+                creation_timestamp=creation_timestamp,
+                date_saisie_resultat_timestamp=date_saisie_resultat_timestamp,
+                modification_timestamp=modification_timestamp,
+                thumbnail=thumbnail,
+                organisateur=organisateur,
+                niveau_nb=niveau_nb,
+            )
+        except Exception as e:
+            raise ValueError(f"Invalid `Hit` object: {e}") from e
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.niveau is not None:
+            result["niveau"] = self.niveau.value
+        if self.id is not None:
+            result["id"] = self.id
+        if self.date is not None:
+            result["date"] = self.date.isoformat()
+        if self.date_rencontre is not None:
+            result["date_rencontre"] = self.date_rencontre.isoformat()
+        if self.horaire is not None:
+            result["horaire"] = self.horaire.isoformat()
+        if self.nom_equipe1 is not None:
+            result["nomEquipe1"] = self.nom_equipe1
+        if self.nom_equipe2 is not None:
+            result["nomEquipe2"] = self.nom_equipe2
+        if self.numero_journee is not None:
+            result["numeroJournee"] = str(self.numero_journee)
+        if self.pratique is not None:
+            result["pratique"] = self.pratique.value
+        if self.gs_id is not None:
+            result["gsId"] = self.gs_id
+        if self.officiels is not None:
+            result["officiels"] = self.officiels
+        if self.competition_id is not None:
+            result["competitionId"] = self.competition_id.to_dict()
+        if self.id_organisme_equipe1 is not None:
+            result["idOrganismeEquipe1"] = self.id_organisme_equipe1.to_dict()
+        if self.id_organisme_equipe2 is not None:
+            result["idOrganismeEquipe2"] = self.id_organisme_equipe2.to_dict()
+        if self.id_poule is not None:
+            result["idPoule"] = self.id_poule.to_dict()
+        if self.saison is not None:
+            result["saison"] = self.saison.to_dict()
+        if self.salle is not None:
+            result["salle"] = self.salle.to_dict()
+        if self.id_engagement_equipe1 is not None:
+            result["idEngagementEquipe1"] = self.id_engagement_equipe1.to_dict()
+        if self.id_engagement_equipe2 is not None:
+            result["idEngagementEquipe2"] = self.id_engagement_equipe2.to_dict()
+        if self.geo is not None:
+            result["_geo"] = self.geo.to_dict()
+        if self.date_timestamp is not None:
+            result["date_timestamp"] = self.date_timestamp
+        if self.date_rencontre_timestamp is not None:
+            result["date_rencontre_timestamp"] = self.date_rencontre_timestamp
+        if self.creation_timestamp is not None:
+            result["creation_timestamp"] = self.creation_timestamp
+        if self.date_saisie_resultat_timestamp is not None:
+            result["dateSaisieResultat_timestamp"] = self.date_saisie_resultat_timestamp
+        if self.modification_timestamp is not None:
+            result["modification_timestamp"] = self.modification_timestamp
+        if self.thumbnail is not None:
+            result["thumbnail"] = self.thumbnail
+        if self.organisateur is not None:
+            result["organisateur"] = self.organisateur.to_dict()
+        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_gs_id and query in self.lower_gs_id)
+            or (self.lower_id and query in self.lower_id)
+            or (self.lower_nom_equipe1 and query in self.lower_nom_equipe1)
+            or (self.lower_nom_equipe2 and query in self.lower_nom_equipe2)
+            or (
+                self.lower_officiels
+                and any(query in off for off in self.lower_officiels)
+            )
+            or (
+                self.salle
+                and (
+                    (self.salle.lower_adresse and query in self.salle.lower_adresse)
+                    or (
+                        self.salle.lower_adresse_complement
+                        and query in self.salle.lower_adresse_complement
+                    )
+                    or (self.salle.lower_libelle and query in self.salle.lower_libelle)
+                )
+            )
+        )

ffbb_data_client/models/rencontres_multi_search_query.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from ..config import MEILISEARCH_FACETS_RENCONTRES, MEILISEARCH_INDEX_RENCONTRES
+from .multi_search_query import MultiSearchQuery
+from .multi_search_result_rencontres import RencontresMultiSearchResult
+from .multi_search_results import MultiSearchResult
+from .rencontres_facet_distribution import RencontresFacetDistribution
+from .rencontres_facet_stats import RencontresFacetStats
+
+
+class RencontresMultiSearchQuery(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_RENCONTRES,
+            q=q,
+            facets=MEILISEARCH_FACETS_RENCONTRES,
+            limit=limit,
+            offset=offset,
+            filter=filter,
+            sort=sort,
+        )
+
+    def is_valid_result(self, result: MultiSearchResult):
+        return result and (
+            isinstance(result, RencontresMultiSearchResult)
+            and (
+                result.facet_distribution is None
+                or isinstance(result.facet_distribution, RencontresFacetDistribution)
+            )
+            and (
+                result.facet_stats is None
+                or isinstance(result.facet_stats, RencontresFacetStats)
+            )
+        )

ffbb_data_client/models/saison.py

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

ffbb_data_client/models/saison_fields.py

@@ -0,0 +1,36 @@
+class SaisonFields:
+    """Default fields for saison queries."""
+
+    # Basic fields
+    ID = "id"
+    NOM = "nom"
+    ACTIF = "actif"
+    DEBUT = "debut"
+    FIN = "fin"
+    CODE = "code"
+    LIBELLE = "libelle"
+    EN_COURS = "enCours"
+    DATE_CREATED = "date_created"
+    DATE_UPDATED = "date_updated"
+
+    @classmethod
+    def get_default_fields(cls) -> list[str]:
+        """Get default fields for saison queries."""
+        return [
+            cls.ID,
+            cls.NOM,
+            cls.ACTIF,
+            cls.DEBUT,
+            cls.FIN,
+            cls.CODE,
+            cls.LIBELLE,
+            cls.EN_COURS,
+        ]
+
+    @classmethod
+    def get_detailed_fields(cls) -> list[str]:
+        """Get detailed fields for saison queries."""
+        return cls.get_default_fields() + [
+            cls.DATE_CREATED,
+            cls.DATE_UPDATED,
+        ]

ffbb_data_client/models/saisons_models.py

@@ -0,0 +1,6 @@
+"""Backward-compatibility re-export shim for saisons models."""
+
+from .get_saisons_response import GetSaisonsResponse
+from .saisons_query import SaisonsQuery
+
+__all__ = ["GetSaisonsResponse", "SaisonsQuery"]

ffbb_data_client/models/saisons_query.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class SaisonsQuery:
+    fields_: list[str] | None = field(default=None)  # Original: fields[]
+    filter: str | None = '{"actif":{"_eq":true}}'  # Original: filter

ffbb_data_client/models/salle.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from ..utils.converter_utils import from_obj, from_str
+from .cartographie import Cartographie
+
+
+@dataclass
+class Salle:
+    id: str | None = None
+    libelle: str | None = None
+    adresse: str | None = None
+    adresse_complement: str | None = None
+    cartographie: Cartographie | None = None
+    lower_libelle: str | None = field(init=False, default=None, repr=False)
+    lower_adresse: str | None = field(init=False, default=None, repr=False)
+    lower_adresse_complement: str | None = field(init=False, default=None, repr=False)
+
+    def __post_init__(self) -> None:
+        self.lower_libelle = self.libelle.lower() if self.libelle else None
+        self.lower_adresse = self.adresse.lower() if self.adresse else None
+        self.lower_adresse_complement = (
+            self.adresse_complement.lower() if self.adresse_complement else None
+        )
+
+    @staticmethod
+    def from_dict(obj: Any) -> Salle:
+        assert isinstance(obj, dict)
+        id = from_str(obj, "id")
+        libelle = from_str(obj, "libelle")
+        adresse = from_str(obj, "adresse")
+        adresse_complement = from_str(obj, "adresseComplement")
+        cartographie = from_obj(Cartographie.from_dict, obj, "cartographie")
+        return Salle(
+            id=id,
+            libelle=libelle,
+            adresse=adresse,
+            adresse_complement=adresse_complement,
+            cartographie=cartographie,
+        )
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.id is not None:
+            result["id"] = self.id
+        if self.libelle is not None:
+            result["libelle"] = self.libelle
+        if self.adresse is not None:
+            result["adresse"] = self.adresse
+        if self.adresse_complement is not None:
+            result["adresseComplement"] = self.adresse_complement
+        if self.cartographie is not None:
+            result["cartographie"] = self.cartographie.to_dict()
+        return result

ffbb_data_client/models/salles_facet_distribution.py

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

ffbb_data_client/models/salles_facet_stats.py

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