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

ffbb_data_client/helpers/meilisearch_client_extension.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import httpx
+from httpx import Client
+
+from ..clients.meilisearch_client import MeilisearchClient
+from ..models.multi_search_query import MultiSearchQuery
+from ..models.multi_search_results_class import MultiSearchResults
+
+
+class MeilisearchClientExtension(MeilisearchClient):
+    def __init__(
+        self,
+        bearer_token: str,
+        url: str,
+        debug: bool = False,
+        cached_session: Client | None = None,
+        *,
+        async_cached_session: httpx.AsyncClient | None = None,
+    ):
+        super().__init__(
+            bearer_token,
+            url,
+            debug,
+            cached_session,
+            async_cached_session=async_cached_session,
+        )
+
+    def smart_multi_search(
+        self,
+        queries: Sequence[MultiSearchQuery] | None = None,
+        cached_session: Client | None = None,
+    ) -> MultiSearchResults | None:
+        results = self.multi_search(queries, cached_session)
+
+        # Should filter results.hits according to query.q
+        if queries and results and results.results:
+            results.results = [
+                query.filter_result(res) if query.q else res
+                for query, res in zip(queries, results.results, strict=True)
+            ]
+
+        return results
+
+    async def smart_multi_search_async(
+        self,
+        queries: Sequence[MultiSearchQuery] | None = None,
+        cached_session: httpx.AsyncClient | None = None,
+    ) -> MultiSearchResults | None:
+        results = await self.multi_search_async(queries, cached_session)
+
+        # Should filter results.hits according to query.q
+        if queries and results and results.results:
+            results.results = [
+                query.filter_result(res) if query.q else res
+                for query, res in zip(queries, results.results, strict=True)
+            ]
+
+        return results
+
+    def recursive_smart_multi_search(
+        self,
+        queries: Sequence[MultiSearchQuery] | None = None,
+        cached_session: Client | None = None,
+    ) -> MultiSearchResults | None:
+        result = self.smart_multi_search(queries, cached_session)
+        if not result or not queries or not result.results:
+            return result
+
+        next_queries: list[MultiSearchQuery] = []
+        # Store original query indexes to merge results correctly later
+        query_indices: list[int] = []
+
+        for i, (querie, query_result) in enumerate(
+            zip(queries, result.results, strict=True)
+        ):
+            nb_hits = len(query_result.hits) if query_result.hits else 0
+            querie_offset = querie.offset or 0
+            querie_limit = querie.limit or 10
+
+            if query_result.estimated_total_hits is not None and nb_hits < (
+                query_result.estimated_total_hits - querie_offset
+            ):
+                querie.offset = querie_offset + querie_limit
+                querie.limit = query_result.estimated_total_hits - nb_hits
+                next_queries.append(querie)
+                query_indices.append(i)
+
+        if next_queries:
+            new_result = self.recursive_smart_multi_search(next_queries, cached_session)
+
+            if new_result and new_result.results:
+                for orig_idx, query_result in zip(
+                    query_indices, new_result.results, strict=True
+                ):
+                    orig_result = result.results[orig_idx]
+                    hits_list = orig_result.hits
+                    if query_result.hits and hits_list is not None:
+                        hits_list.extend(query_result.hits)
+        return result
+
+    async def recursive_smart_multi_search_async(
+        self,
+        queries: Sequence[MultiSearchQuery] | None = None,
+        cached_session: httpx.AsyncClient | None = None,
+    ) -> MultiSearchResults | None:
+        result = await self.smart_multi_search_async(queries, cached_session)
+        if not result or not queries or not result.results:
+            return result
+
+        next_queries: list[MultiSearchQuery] = []
+        # Store original query indexes to merge results correctly later
+        query_indices: list[int] = []
+
+        for i, (querie, query_result) in enumerate(
+            zip(queries, result.results, strict=True)
+        ):
+            nb_hits = len(query_result.hits) if query_result.hits else 0
+            querie_offset = querie.offset or 0
+            querie_limit = querie.limit or 10
+
+            if query_result.estimated_total_hits is not None and nb_hits < (
+                query_result.estimated_total_hits - querie_offset
+            ):
+                querie.offset = querie_offset + querie_limit
+                querie.limit = query_result.estimated_total_hits - nb_hits
+                next_queries.append(querie)
+                query_indices.append(i)
+
+        if next_queries:
+            new_result = await self.recursive_smart_multi_search_async(
+                next_queries, cached_session
+            )
+
+            if new_result and new_result.results:
+                for orig_idx, query_result in zip(
+                    query_indices, new_result.results, strict=True
+                ):
+                    orig_result = result.results[orig_idx]
+                    hits_list = orig_result.hits
+                    if query_result.hits and hits_list is not None:
+                        hits_list.extend(query_result.hits)
+        return result
+
+    def recursive_multi_search(
+        self,
+        queries: Sequence[MultiSearchQuery] | None = None,
+        cached_session: Client | None = None,
+    ) -> MultiSearchResults | None:
+        """Alias for recursive_smart_multi_search for backward compatibility."""
+        return self.recursive_smart_multi_search(queries, cached_session)

ffbb_data_client/helpers/multi_search_query_helper.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from ..models.competitions_multi_search_query import CompetitionsMultiSearchQuery
+from ..models.content_multi_search_query import (
+    GaleriesMultiSearchQuery,
+    NewsMultiSearchQuery,
+    RssMultiSearchQuery,
+    YoutubeVideosMultiSearchQuery,
+)
+from ..models.engagements_multi_search_query import EngagementsMultiSearchQuery
+from ..models.formations_multi_search_query import FormationsMultiSearchQuery
+from ..models.organismes_multi_search_query import OrganismesMultiSearchQuery
+from ..models.pratiques_multi_search_query import PratiquesMultiSearchQuery
+from ..models.rencontres_multi_search_query import RencontresMultiSearchQuery
+from ..models.salles_multi_search_query import SallesMultiSearchQuery
+from ..models.terrains_multi_search_query import TerrainsMultiSearchQuery
+from ..models.tournois_multi_search_query import TournoisMultiSearchQuery
+
+
+def generate_queries(search_name: str | None = None, limit: int | None = 1):
+    return [
+        OrganismesMultiSearchQuery(search_name, limit=limit),
+        RencontresMultiSearchQuery(search_name, limit=limit),
+        TerrainsMultiSearchQuery(search_name, limit=limit),
+        CompetitionsMultiSearchQuery(search_name, limit=limit),
+        SallesMultiSearchQuery(search_name, limit=limit),
+        TournoisMultiSearchQuery(search_name, limit=limit),
+        PratiquesMultiSearchQuery(search_name, limit=limit),
+        EngagementsMultiSearchQuery(search_name, limit=limit),
+        FormationsMultiSearchQuery(search_name, limit=limit),
+        NewsMultiSearchQuery(search_name, limit=limit),
+        YoutubeVideosMultiSearchQuery(search_name, limit=limit),
+        RssMultiSearchQuery(search_name, limit=limit),
+        GaleriesMultiSearchQuery(search_name, limit=limit),
+    ]

ffbb_data_client/models/__init__.py

@@ -0,0 +1,241 @@
+"""Data models for FFBB API client."""
+
+# Import existing model files (all now in snake_case)
+from .affiche import Affiche
+from .cartographie import Cartographie
+from .categorie import Categorie
+from .clock import Clock
+from .code import Code
+from .commune import Commune
+from .competition_fields import CompetitionFields
+from .competition_id import CompetitionID
+from .competition_id_categorie import CompetitionIDCategorie
+from .competition_id_sexe import CompetitionIDSexe
+from .competition_id_type_competition import CompetitionIDTypeCompetition
+from .competition_id_type_competition_generique import (
+    CompetitionIDTypeCompetitionGenerique,
+)
+from .competition_origine import CompetitionOrigine
+from .competition_origine_categorie import CompetitionOrigineCategorie
+from .competition_origine_type_competition import CompetitionOrigineTypeCompetition
+from .competition_origine_type_competition_generique import (
+    CompetitionOrigineTypeCompetitionGenerique,
+)
+from .competition_type import CompetitionType
+from .competitions_multi_search_query import CompetitionsMultiSearchQuery
+from .competitions_query import CompetitionsQuery
+from .coordonnees import Coordonnees
+from .coordonnees_type import CoordonneesType
+from .document_flyer import DocumentFlyer
+from .document_flyer_type import DocumentFlyerType
+from .engagements_facet_distribution import EngagementsFacetDistribution
+from .engagements_facet_stats import EngagementsFacetStats
+from .engagements_hit import EngagementsHit
+from .engagements_multi_search_query import EngagementsMultiSearchQuery
+from .etat import Etat
+from .external_competition_id import ExternalCompetitionID
+from .external_id import ExternalID
+from .facet_distribution import FacetDistribution
+from .facet_stats import FacetStats
+from .field_set import FieldSet
+from .folder import Folder
+from .formation_session import FormationSession
+from .formations_facet_distribution import FormationsFacetDistribution
+from .formations_facet_stats import FormationsFacetStats
+from .formations_hit import FormationsHit
+from .formations_multi_search_query import FormationsMultiSearchQuery
+from .game_stats_model import GameStatsModel
+from .geo import Geo
+from .get_competition_response import GetCompetitionResponse
+from .get_configuration_response import GetConfigurationResponse
+from .get_organisme_response import GetOrganismeResponse
+from .get_poule_response import GetPouleResponse
+from .get_saisons_response import GetSaisonsResponse
+from .gradient_color import GradientColor
+from .hit import Hit
+from .id_engagement_equipe import IDEngagementEquipe
+from .id_organisme_equipe import IDOrganismeEquipe
+from .id_organisme_equipe1_logo import IDOrganismeEquipe1Logo
+from .id_poule import IDPoule
+from .jour import Jour
+from .label import Label
+from .labellisation import Labellisation
+from .live import Live, lives_from_dict
+from .logo import Logo
+from .multi_search_queries import MultiSearchQueries
+from .multi_search_query import MultiSearchQuery
+from .multi_search_result_competitions import CompetitionsMultiSearchResult
+from .multi_search_result_engagements import EngagementsMultiSearchResult
+from .multi_search_result_formations import FormationsMultiSearchResult
+from .multi_search_result_organismes import OrganismesMultiSearchResult
+from .multi_search_result_pratiques import PratiquesMultiSearchResult
+from .multi_search_result_rencontres import RencontresMultiSearchResult
+from .multi_search_result_salles import SallesMultiSearchResult
+from .multi_search_result_terrains import TerrainsMultiSearchResult
+from .multi_search_result_tournois import TournoisMultiSearchResult
+from .multi_search_results import MultiSearchResult
+from .multi_search_results_class import multi_search_results_from_dict
+from .nature_sol import NatureSol
+from .niveau import Niveau
+from .niveau_class import NiveauClass
+from .objectif import Objectif
+from .organisateur import Organisateur
+from .organisateur_type import OrganisateurType
+from .organisme_fields import OrganismeFields
+from .organisme_id_pere import OrganismeIDPere
+from .organismes_multi_search_query import OrganismesMultiSearchQuery
+from .organismes_query import OrganismesQuery
+from .phase_code import PhaseCode
+from .poule import Poule
+from .poule_fields import PouleFields
+from .poules_query import PoulesQuery
+from .pratique import Pratique
+from .pratiques_multi_search_query import PratiquesMultiSearchQuery
+from .pratiques_type_class import PratiquesTypeClass
+from .publication_internet import PublicationInternet
+from .purple_logo import PurpleLogo
+from .query_fields_manager import QueryFieldsManager
+from .ranking_engagement import RankingEngagement
+from .rencontres_multi_search_query import RencontresMultiSearchQuery
+from .saison import Saison
+from .saison_fields import SaisonFields
+from .saisons_query import SaisonsQuery
+from .salle import Salle
+from .salles_multi_search_query import SallesMultiSearchQuery
+from .sexe import Sexe
+from .sexe_class import SexeClass
+from .source import Source
+from .status import Status
+from .team_engagement import TeamEngagement
+from .team_ranking import TeamRanking
+from .terrains_multi_search_query import TerrainsMultiSearchQuery
+from .tournoi_type_class import TournoiTypeClass
+from .tournoi_type_enum import TournoiTypeEnum
+from .tournois_multi_search_query import TournoisMultiSearchQuery
+from .type_association import TypeAssociation
+from .type_association_libelle import TypeAssociationLibelle
+from .type_class import TypeClass
+from .type_competition import TypeCompetition
+from .type_competition_generique import TypeCompetitionGenerique
+from .type_enum import TypeEnum
+from .type_league import TypeLeague
+
+__all__ = [
+    # Classes from snake_case files
+    "Affiche",
+    "Cartographie",
+    "Categorie",
+    "Clock",
+    "Code",
+    "Commune",
+    "CompetitionID",
+    "CompetitionIDCategorie",
+    "CompetitionIDSexe",
+    "CompetitionIDTypeCompetition",
+    "CompetitionIDTypeCompetitionGenerique",
+    "CompetitionOrigine",
+    "CompetitionOrigineCategorie",
+    "CompetitionOrigineTypeCompetition",
+    "CompetitionOrigineTypeCompetitionGenerique",
+    "CompetitionType",
+    "CompetitionsMultiSearchQuery",
+    "CompetitionsMultiSearchResult",
+    "CompetitionsQuery",
+    "Coordonnees",
+    "CoordonneesType",
+    "DocumentFlyer",
+    "DocumentFlyerType",
+    "EngagementsFacetDistribution",
+    "EngagementsFacetStats",
+    "EngagementsHit",
+    "EngagementsMultiSearchQuery",
+    "EngagementsMultiSearchResult",
+    "Etat",
+    "ExternalCompetitionID",
+    "ExternalID",
+    "FacetDistribution",
+    "FacetStats",
+    "Folder",
+    "FormationSession",
+    "FormationsFacetDistribution",
+    "FormationsFacetStats",
+    "FormationsHit",
+    "FormationsMultiSearchQuery",
+    "FormationsMultiSearchResult",
+    "GameStatsModel",
+    "Geo",
+    "GetCompetitionResponse",
+    "GetConfigurationResponse",
+    "GetOrganismeResponse",
+    "GetPouleResponse",
+    "GetSaisonsResponse",
+    "GradientColor",
+    "Hit",
+    "IDEngagementEquipe",
+    "IDOrganismeEquipe",
+    "IDOrganismeEquipe1Logo",
+    "IDPoule",
+    "Jour",
+    "Label",
+    "Labellisation",
+    "Live",
+    "Logo",
+    "MultiSearchQueries",
+    "MultiSearchQuery",
+    "MultiSearchResult",
+    "NatureSol",
+    "Niveau",
+    "NiveauClass",
+    "Objectif",
+    "Organisateur",
+    "OrganisateurType",
+    "OrganismeIDPere",
+    "OrganismesMultiSearchQuery",
+    "OrganismesMultiSearchResult",
+    "OrganismesQuery",
+    "PhaseCode",
+    "Poule",
+    "PoulesQuery",
+    "Pratique",
+    "RankingEngagement",
+    "PratiquesMultiSearchQuery",
+    "PratiquesMultiSearchResult",
+    "PublicationInternet",
+    "PurpleLogo",
+    "QueryFieldsManager",
+    "OrganismeFields",
+    "CompetitionFields",
+    "PouleFields",
+    "SaisonFields",
+    "FieldSet",
+    "RencontresMultiSearchQuery",
+    "RencontresMultiSearchResult",
+    "Saison",
+    "SaisonsQuery",
+    "Salle",
+    "SallesMultiSearchQuery",
+    "SallesMultiSearchResult",
+    "Sexe",
+    "Source",
+    "Status",
+    "TeamEngagement",
+    "TerrainsMultiSearchQuery",
+    "TerrainsMultiSearchResult",
+    "TournoisMultiSearchQuery",
+    "TeamRanking",
+    "TournoisMultiSearchResult",
+    "TournoiTypeClass",
+    "TournoiTypeEnum",
+    "TypeAssociation",
+    "TypeAssociationLibelle",
+    "TypeClass",
+    "TypeCompetition",
+    "TypeCompetitionGenerique",
+    "TypeEnum",
+    "PratiquesTypeClass",
+    "SexeClass",
+    "TypeLeague",
+    # Functions
+    "lives_from_dict",
+    "multi_search_results_from_dict",
+]

ffbb_data_client/models/affiche.py

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

ffbb_data_client/models/cartographie.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any
+
+from ..utils.converter_utils import (
+    from_datetime,
+    from_float,
+    from_obj,
+    from_str,
+)
+from .coordonnees import Coordonnees
+
+
+@dataclass
+class Cartographie:
+    adresse: str | None = None
+    code_postal: str | None = None
+    coordonnees: Coordonnees | None = None
+    date_created: datetime | None = None
+    date_updated: datetime | None = None
+    cartographie_id: str | None = None
+    latitude: float | None = None
+    longitude: float | None = None
+    title: str | None = None
+    ville: str | None = None
+    status: str | None = None
+
+    @staticmethod
+    def from_dict(obj: Any) -> Cartographie:
+        assert isinstance(obj, dict)
+        adresse = from_str(obj, "adresse")
+        code_postal = from_str(obj, "codePostal")
+        coordonnees = from_obj(Coordonnees.from_dict, obj, "coordonnees")
+        date_created = from_datetime(obj, "date_created")
+        date_updated = from_datetime(obj, "date_updated")
+        cartographie_id = from_str(obj, "id")
+        latitude = from_float(obj, "latitude")
+        longitude = from_float(obj, "longitude")
+        title = from_str(obj, "title")
+        ville = from_str(obj, "ville")
+        status = from_str(obj, "status")
+        return Cartographie(
+            adresse=adresse,
+            code_postal=code_postal,
+            coordonnees=coordonnees,
+            date_created=date_created,
+            date_updated=date_updated,
+            cartographie_id=cartographie_id,
+            latitude=latitude,
+            longitude=longitude,
+            title=title,
+            ville=ville,
+            status=status,
+        )
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.adresse is not None:
+            result["adresse"] = self.adresse
+        if self.code_postal is not None:
+            result["codePostal"] = self.code_postal
+        if self.coordonnees is not None:
+            result["coordonnees"] = self.coordonnees.to_dict()
+        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.cartographie_id is not None:
+            result["id"] = self.cartographie_id
+        if self.latitude is not None:
+            result["latitude"] = self.latitude
+        if self.longitude is not None:
+            result["longitude"] = self.longitude
+        if self.title is not None:
+            result["title"] = self.title
+        if self.ville is not None:
+            result["ville"] = self.ville
+        if self.status is not None:
+            result["status"] = self.status
+        return result

ffbb_data_client/models/categorie.py

@@ -0,0 +1,55 @@
+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_str,
+)
+
+
+@dataclass
+class Categorie:
+    code: str | None = None
+    date_created: datetime | None = None
+    date_updated: datetime | None = None
+    categorie_id: str | None = None
+    libelle: str | None = None
+    ordre: int | None = None
+
+    @staticmethod
+    def from_dict(obj: Any) -> Categorie:
+        assert isinstance(obj, dict)
+        code = from_str(obj, "code")
+        date_created = from_datetime(obj, "date_created")
+        date_updated = from_datetime(obj, "date_updated")
+        categorie_id = from_str(obj, "id")
+        libelle = from_str(obj, "libelle")
+        ordre = from_int(obj, "ordre")
+        return Categorie(
+            code=code,
+            date_created=date_created,
+            date_updated=date_updated,
+            categorie_id=categorie_id,
+            libelle=libelle,
+            ordre=ordre,
+        )
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.code is not None:
+            result["code"] = self.code
+        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.categorie_id is not None:
+            result["id"] = self.categorie_id
+        if self.libelle is not None:
+            result["libelle"] = self.libelle
+        if self.ordre is not None:
+            result["ordre"] = self.ordre
+        return result

ffbb_data_client/models/categorie_type.py

@@ -0,0 +1,42 @@
+from enum import Enum
+
+
+class CategorieType(Enum):
+    """Enumération des catégories d'âge en basketball."""
+
+    # Catégories jeunes
+    U7 = "U7"
+    U9 = "U9"
+    U11 = "U11"
+    U13 = "U13"
+    U15 = "U15"
+    U17 = "U17"
+    U18 = "U18"
+    U20 = "U20"
+    U21 = "U21"
+
+    # Catégories seniors
+    SENIOR = "SENIOR"
+    SENIORS = "SENIORS"
+
+    # Catégories vétérans
+    VETERAN = "VETERAN"
+    VETERANS = "VETERANS"
+    V35 = "V35"
+    V40 = "V40"
+    V45 = "V45"
+    V50 = "V50"
+
+    # Catégories spéciales
+    ESPOIR = "ESPOIR"
+    ESPOIRS = "ESPOIRS"
+    CADET = "CADET"
+    CADETS = "CADETS"
+    MINIME = "MINIME"
+    MINIMES = "MINIMES"
+    BENJAMIN = "BENJAMIN"
+    BENJAMINS = "BENJAMINS"
+    POUSSIN = "POUSSIN"
+    POUSSINS = "POUSSINS"
+    MINI_POUSSIN = "MINI_POUSSIN"
+    MINI_POUSSINS = "MINI_POUSSINS"

ffbb_data_client/models/clock.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class Clock:
+    minutes: int = 0
+    seconds: int = 0
+    milliseconds: int = 0
+
+    @staticmethod
+    def from_str(obj: str) -> Clock:
+        minutes, seconds, milliseconds = obj.split(":") if obj else ["0", "0", "0"]
+        return Clock(
+            minutes=int(minutes), seconds=int(seconds), milliseconds=int(milliseconds)
+        )
+
+    @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, str):
+            return cls.from_str(value)
+        elif isinstance(value, dict):
+            return Clock(**value)
+        return value
+
+    def to_str(self) -> str:
+        return f"{self.minutes}:{self.seconds}:{self.milliseconds}"