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

ffbb_data_client/models/salles_hit.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any
+
+from ..utils.converter_utils import (
+    from_datetime,
+    from_obj,
+    from_str,
+)
+from .cartographie import Cartographie
+from .commune import Commune
+from .geo import Geo
+from .hit import Hit
+from .type_association import TypeAssociation
+
+
+@dataclass
+class SallesHit(Hit):
+    libelle: str | None = None
+    adresse: str | None = None
+    id: str | None = None
+    adresse_complement: str | None = None
+    capacite_spectateur: str | None = None
+    date_created: datetime | None = None
+    date_updated: datetime | None = None
+    libelle2: str | None = None
+    mail: str | None = None
+    numero: str | None = None
+    telephone: str | None = None
+    cartographie: Cartographie | None = None
+    commune: Commune | None = None
+    geo: Geo | None = None
+    thumbnail: str | None = None
+    type: str | None = None
+    type_association: TypeAssociation | None = None
+    lower_libelle: str | None = field(init=False, default=None, repr=False)
+    lower_addresse: str | None = field(init=False, default=None, repr=False)
+    lower_adresse_complement: str | None = field(init=False, default=None, repr=False)
+    lower_libelle2: str | None = field(init=False, default=None, repr=False)
+
+    @property
+    def name(self) -> str | None:
+        """Alias for .libelle — unified name accessor across all Hit types."""
+        return self.libelle
+
+    def __post_init__(self) -> None:
+        self.lower_libelle = self.libelle.lower() if self.libelle else None
+        self.lower_addresse = self.adresse.lower() if self.adresse else None
+        self.lower_adresse_complement = (
+            self.adresse_complement.lower() if self.adresse_complement else None
+        )
+        self.lower_libelle2 = self.libelle2.lower() if self.libelle2 else None
+
+    @staticmethod
+    def from_dict(obj: Any) -> SallesHit:
+        assert isinstance(obj, dict)
+        libelle = from_str(obj, "libelle")
+        adresse = from_str(obj, "adresse")
+        id = from_str(obj, "id")
+        adresse_complement = from_str(obj, "adresseComplement")
+        capacite_spectateur = from_str(obj, "capaciteSpectateur")
+        date_created = from_datetime(obj, "date_created")
+        date_updated = from_datetime(obj, "date_updated")
+        libelle2 = from_str(obj, "libelle2")
+        mail = from_str(obj, "mail")
+        numero = from_str(obj, "numero")
+        telephone = from_str(obj, "telephone")
+        cartographie = from_obj(Cartographie.from_dict, obj, "cartographie")
+        commune = from_obj(Commune.from_dict, obj, "commune")
+        geo = from_obj(Geo.from_dict, obj, "_geo")
+        thumbnail = from_str(obj, "thumbnail")
+        type = from_str(obj, "type")
+        type_association = from_obj(TypeAssociation.from_dict, obj, "type_association")
+        return SallesHit(
+            libelle=libelle,
+            adresse=adresse,
+            id=id,
+            adresse_complement=adresse_complement,
+            capacite_spectateur=capacite_spectateur,
+            date_created=date_created,
+            date_updated=date_updated,
+            libelle2=libelle2,
+            mail=mail,
+            numero=numero,
+            telephone=telephone,
+            cartographie=cartographie,
+            commune=commune,
+            geo=geo,
+            thumbnail=thumbnail,
+            type=type,
+            type_association=type_association,
+        )
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.libelle is not None:
+            result["libelle"] = self.libelle
+        if self.adresse is not None:
+            result["adresse"] = self.adresse
+        if self.id is not None:
+            result["id"] = self.id
+        if self.adresse_complement is not None:
+            result["adresseComplement"] = self.adresse_complement
+        if self.capacite_spectateur is not None:
+            result["capaciteSpectateur"] = self.capacite_spectateur
+        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.libelle2 is not None:
+            result["libelle2"] = self.libelle2
+        if self.mail is not None:
+            result["mail"] = self.mail
+        if self.numero is not None:
+            result["numero"] = self.numero
+        if self.telephone is not None:
+            result["telephone"] = self.telephone
+        if self.cartographie is not None:
+            result["cartographie"] = self.cartographie.to_dict()
+        if self.commune is not None:
+            result["commune"] = self.commune.to_dict()
+        if self.geo is not None:
+            result["_geo"] = self.geo.to_dict()
+        if self.thumbnail is not None:
+            result["thumbnail"] = self.thumbnail
+        if self.type is not None:
+            result["type"] = self.type
+        if self.type_association is not None:
+            result["type_association"] = self.type_association.to_dict()
+        return result
+
+    def is_valid_for_query(self, query: str) -> bool:
+        return bool(
+            not query
+            or (self.lower_addresse and query in self.lower_addresse)
+            or (
+                self.lower_adresse_complement and query in self.lower_adresse_complement
+            )
+            or (self.lower_libelle and query in self.lower_libelle)
+            or (self.lower_libelle2 and query in self.lower_libelle2)
+            or (
+                self.commune
+                and (
+                    (self.commune.lower_libelle and query in self.commune.lower_libelle)
+                    or (
+                        self.commune.lower_departement
+                        and query in self.commune.lower_departement
+                    )
+                )
+            )
+        )

ffbb_data_client/models/salles_multi_search_query.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from ..config import MEILISEARCH_INDEX_SALLES
+from .multi_search_query import MultiSearchQuery
+from .multi_search_result_salles import SallesMultiSearchResult
+from .multi_search_results import MultiSearchResult
+from .salles_facet_distribution import SallesFacetDistribution
+from .salles_facet_stats import SallesFacetStats
+
+
+class SallesMultiSearchQuery(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_SALLES,
+            q=q,
+            limit=limit,
+            offset=offset,
+            filter=filter,
+            sort=sort,
+        )
+
+    def is_valid_result(self, result: MultiSearchResult):
+        return result and (
+            isinstance(result, SallesMultiSearchResult)
+            and (
+                result.facet_distribution is None
+                or isinstance(result.facet_distribution, SallesFacetDistribution)
+            )
+            and (
+                result.facet_stats is None
+                or isinstance(result.facet_stats, SallesFacetStats)
+            )
+        )

ffbb_data_client/models/sexe.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from enum import Enum
+
+
+class Sexe(Enum):
+    FEMININE = "Féminin"
+    MASCULINE = "Masculin"
+    MIXED = "Mixte"

ffbb_data_client/models/sexe_class.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from ..utils.converter_utils import from_int
+
+
+@dataclass
+class SexeClass:
+    feminine: int | None = None
+    masculine: int | None = None
+    mixed: int | None = None
+
+    @staticmethod
+    def from_dict(obj: Any) -> SexeClass:
+        assert isinstance(obj, dict)
+        feminine = from_int(obj, "Féminin")
+        masculine = from_int(obj, "Masculin")
+        mixed = from_int(obj, "Mixte")
+        return SexeClass(feminine=feminine, masculine=masculine, mixed=mixed)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.feminine is not None:
+            result["Féminin"] = self.feminine
+        if self.masculine is not None:
+            result["Masculin"] = self.masculine
+        if self.mixed is not None:
+            result["Mixte"] = self.mixed
+        return result

ffbb_data_client/models/source.py

@@ -0,0 +1,5 @@
+from enum import Enum
+
+
+class Source(Enum):
+    FFBB_SERVEUR = "FFBB Serveur"

ffbb_data_client/models/status.py

@@ -0,0 +1,5 @@
+from enum import Enum
+
+
+class Status(Enum):
+    DRAFT = "draft"

ffbb_data_client/models/team_engagement.py

@@ -0,0 +1,56 @@
+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 TeamEngagement:
+    nom_officiel: str | None = None
+    nom_usuel: str | None = None
+    code_abrege: str | None = None
+    logo: Logo | None = None
+
+    @staticmethod
+    def from_dict(obj: Any) -> TeamEngagement:
+        """
+        Convert a dictionary object to a TeamEngagement instance.
+
+        Args:
+            obj (Any): The dictionary object to convert.
+
+        Returns:
+            TeamEngagement: The converted TeamEngagement instance.
+        """
+        assert isinstance(obj, dict)
+        nom_officiel = from_str(obj, "nomOfficiel")
+        nom_usuel = from_str(obj, "nomUsuel")
+        code_abrege = from_str(obj, "codeAbrege")
+        logo = from_obj(Logo.from_dict, obj, "logo")
+        return TeamEngagement(
+            nom_officiel=nom_officiel,
+            nom_usuel=nom_usuel,
+            code_abrege=code_abrege,
+            logo=logo,
+        )
+
+    def to_dict(self) -> dict:
+        """
+        Convert the TeamEngagement instance to a dictionary object.
+
+        Returns:
+            dict: The converted dictionary object.
+        """
+        result: dict = {}
+        if self.nom_officiel is not None:
+            result["nomOfficiel"] = self.nom_officiel
+        if self.nom_usuel is not None:
+            result["nomUsuel"] = self.nom_usuel
+        if self.code_abrege is not None:
+            result["codeAbrege"] = self.code_abrege
+        if self.logo is not None:
+            result["logo"] = self.logo.to_dict()
+        return result

ffbb_data_client/models/team_ranking.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from ..utils.converter_utils import from_bool, from_float, from_int, from_str
+from .ranking_engagement import RankingEngagement
+
+
+@dataclass
+class TeamRanking:
+    """Modèle pour un classement d'équipe."""
+
+    # Fields with defaults for lightweight API responses
+    id: str = ""
+    id_engagement: RankingEngagement | str | None = None
+    position: int = 0
+    points: int = 0
+    match_joues: int = 0
+    gagnes: int = 0
+    perdus: int = 0
+    nombre_forfaits: int = 0
+    paniers_marques: int = 0
+    paniers_encaisses: int = 0
+    difference: int = 0
+    quotient: float = 0.0
+    # Optional fields with defaults
+    nuls: int | None = None
+    nombre_defauts: int | None = None
+    point_initiaux: int | None = None
+    penalites_arbitrage: int | None = None
+    penalites_entraineur: int | None = None
+    penalites_diverses: int | None = None
+    hors_classement: bool | None = None
+    # Relation fields
+    organisme_id: str | None = None
+    organisme_nom: str | None = None
+    organisme_logo_id: str | None = None
+    organisme_nom_simple: str | None = None
+    id_competition: str | None = None
+    id_poule: str | None = None
+    id_poule_id: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> TeamRanking | None:
+        """Convert dictionary to TeamRanking instance."""
+        if not data:
+            return None
+
+        # Handle case where data is not a dictionary
+        if not isinstance(data, dict):
+            return None
+
+        id_engagement_raw = data.get("idEngagement")
+        if isinstance(id_engagement_raw, dict):
+            id_engagement = RankingEngagement.from_dict(id_engagement_raw)
+        elif isinstance(id_engagement_raw, (str, int)):
+            id_engagement = str(id_engagement_raw)
+        else:
+            id_engagement = None
+
+        # Handle organisme data
+        organisme_data = data.get("organisme", {})
+        if not isinstance(organisme_data, dict):
+            organisme_data = {}
+        organisme_id = from_str(organisme_data, "id")
+        organisme_nom = from_str(organisme_data, "nom")
+        organisme_nom_simple = from_str(organisme_data, "nom_simple")
+
+        # Handle organisme logo
+        organisme_logo_data = organisme_data.get("logo", {})
+        if not isinstance(organisme_logo_data, dict):
+            organisme_logo_data = {}
+        organisme_logo_id = from_str(organisme_logo_data, "id")
+
+        # Handle idPoule data
+        id_poule_data = data.get("idPoule", {})
+        if not isinstance(id_poule_data, dict):
+            id_poule_data = {}
+        id_poule_id = from_str(id_poule_data, "id")
+
+        return cls(
+            id=from_str(data, "id") or "",
+            id_engagement=id_engagement,
+            position=from_int(data, "position") or 0,
+            points=from_int(data, "points") or 0,
+            match_joues=from_int(data, "matchJoues") or 0,
+            gagnes=from_int(data, "gagnes") or 0,
+            perdus=from_int(data, "perdus") or 0,
+            nuls=from_int(data, "nuls"),
+            nombre_forfaits=from_int(data, "nombreForfaits") or 0,
+            nombre_defauts=from_int(data, "nombreDefauts"),
+            paniers_marques=from_int(data, "paniersMarques") or 0,
+            paniers_encaisses=from_int(data, "paniersEncaisses") or 0,
+            difference=from_int(data, "difference") or 0,
+            quotient=from_float(data, "quotient") or 0.0,
+            point_initiaux=from_int(data, "pointInitiaux"),
+            penalites_arbitrage=from_int(data, "penalitesArbitrage"),
+            penalites_entraineur=from_int(data, "penalitesEntraineur"),
+            penalites_diverses=from_int(data, "penalitesDiverses"),
+            hors_classement=from_bool(data, "horsClassement"),
+            organisme_id=organisme_id,
+            organisme_nom=organisme_nom,
+            organisme_logo_id=organisme_logo_id,
+            organisme_nom_simple=organisme_nom_simple,
+            id_competition=from_str(data, "idCompetition"),
+            id_poule=from_str(data, "idPoule"),
+            id_poule_id=id_poule_id,
+        )

ffbb_data_client/models/terrains_categorie_championnat_3x3_libelle.py

@@ -0,0 +1,5 @@
+from enum import Enum
+
+
+class CategorieChampionnat3X3Libelle(Enum):
+    U18 = "U18"

ffbb_data_client/models/terrains_facet_distribution.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from ..utils.converter_utils import from_obj
+from .facet_distribution import FacetDistribution
+from .sexe_class import SexeClass
+from .tournoi_type_class import TournoiTypeClass
+from .tournoi_types_3x3_libelle import TournoiTypes3X3Libelle
+
+
+@dataclass
+class TerrainsFacetDistribution(FacetDistribution):
+    sexe: SexeClass | None = None
+    tournoi_type: TournoiTypeClass | None = None
+    tournoi_types3_x3_libelle: TournoiTypes3X3Libelle | None = None
+
+    @staticmethod
+    def from_dict(obj: Any) -> TerrainsFacetDistribution:
+        assert isinstance(obj, dict)
+        sexe = from_obj(SexeClass.from_dict, obj, "sexe")
+        tournoi_type = from_obj(TournoiTypeClass.from_dict, obj, "tournoiType")
+        tournoi_types3_x3_libelle = from_obj(
+            TournoiTypes3X3Libelle.from_dict, obj, "tournoiTypes3x3.libelle"
+        )
+        return TerrainsFacetDistribution(
+            sexe=sexe,
+            tournoi_type=tournoi_type,
+            tournoi_types3_x3_libelle=tournoi_types3_x3_libelle,
+        )
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.sexe is not None:
+            result["sexe"] = self.sexe.to_dict()
+        if self.tournoi_type is not None:
+            result["tournoiType"] = self.tournoi_type.to_dict()
+        if self.tournoi_types3_x3_libelle is not None:
+            result["tournoiTypes3x3.libelle"] = self.tournoi_types3_x3_libelle.to_dict()
+        return result

ffbb_data_client/models/terrains_facet_stats.py

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