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

ffbb_data_client/models/logo.py

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

ffbb_data_client/models/multi_search_queries.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from ..utils.converter_utils import from_list
+from .multi_search_query import MultiSearchQuery
+
+
+@dataclass
+class MultiSearchQueries:
+    queries: list[MultiSearchQuery] | None = None
+
+    @staticmethod
+    def from_dict(obj: Any) -> MultiSearchQueries:
+        assert isinstance(obj, dict)
+        queries = from_list(MultiSearchQuery.from_dict, obj, "queries")
+        return MultiSearchQueries(queries=queries)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.queries is not None:
+            result["queries"] = [q.to_dict() for q in self.queries]
+        return result

ffbb_data_client/models/multi_search_query.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from ..utils.converter_utils import (
+    from_int,
+    from_list,
+    from_str,
+)
+from .facet_distribution import FacetDistribution
+from .facet_stats import FacetStats
+from .hit import Hit
+from .multi_search_results import MultiSearchResult
+
+
+@dataclass
+class MultiSearchQuery:
+    index_uid: str | None = None
+    q: str | None = None
+    facets: list[str] | None = None
+    limit: int | None = 10
+    offset: int | None = 0
+    filter: list[Any] | None = None
+    sort: list[Any] | None = None
+    lower_q: str | None = field(init=False, default=None, repr=False)
+
+    def __post_init__(self) -> None:
+        self.lower_q = self.q.lower() if self.q else None
+
+    @staticmethod
+    def from_dict(obj: Any) -> MultiSearchQuery:
+        assert isinstance(obj, dict)
+        index_uid = from_str(obj, "indexUid")
+        q = from_str(obj, "q")
+        facets = from_list(str, obj, "facets")
+        limit = from_int(obj, "limit")
+        offset = from_int(obj, "offset")
+        filter = from_list(lambda x: x, obj, "filter")
+        sort = from_list(lambda x: x, obj, "sort")
+        return MultiSearchQuery(
+            index_uid=index_uid,
+            q=q,
+            facets=facets,
+            limit=limit,
+            offset=offset,
+            filter=filter,
+            sort=sort,
+        )
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.index_uid is not None:
+            result["indexUid"] = self.index_uid
+        if self.q is not None:
+            result["q"] = self.q
+        if self.facets is not None:
+            result["facets"] = self.facets
+        if self.limit is not None:
+            result["limit"] = self.limit
+        if self.offset is not None:
+            result["offset"] = self.offset
+        if self.filter is not None:
+            result["filter"] = self.filter
+        if self.sort is not None:
+            result["sort"] = self.sort
+        return result
+
+    def is_valid_result(self, result: MultiSearchResult):
+        return result and (
+            isinstance(result, MultiSearchResult)
+            and (
+                result.facet_distribution is None
+                or isinstance(result.facet_distribution, FacetDistribution)
+            )
+            and (
+                result.facet_stats is None or isinstance(result.facet_stats, FacetStats)
+            )
+        )
+
+    def is_valid_hit(self, _hit: Hit):
+        return True
+
+    def filter_result(self, result: MultiSearchResult) -> MultiSearchResult:
+        if self.lower_q and result.hits:
+            # ⚡ Bolt optimization: Replace O(n²) list.remove in a loop with O(n) list comprehension for filtering hits.
+            valid_hits = [
+                hit for hit in result.hits if hit.is_valid_for_query(self.lower_q)
+            ]
+
+            if len(valid_hits) < len(result.hits):
+                if result.estimated_total_hits is not None:
+                    result.estimated_total_hits -= len(result.hits) - len(valid_hits)
+
+                result.hits = valid_hits
+        return result

ffbb_data_client/models/multi_search_result_competitions.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from .competitions_facet_distribution import CompetitionsFacetDistribution
+from .competitions_facet_stats import CompetitionsFacetStats
+from .competitions_hit import CompetitionsHit
+from .multi_search_results import MultiSearchResult
+
+
+class CompetitionsMultiSearchResult(
+    MultiSearchResult[
+        CompetitionsHit, CompetitionsFacetDistribution, CompetitionsFacetStats
+    ]
+):
+    """MultiSearchResult for Competitions."""

ffbb_data_client/models/multi_search_result_engagements.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from .engagements_facet_distribution import EngagementsFacetDistribution
+from .engagements_facet_stats import EngagementsFacetStats
+from .engagements_hit import EngagementsHit
+from .multi_search_results import MultiSearchResult
+
+
+class EngagementsMultiSearchResult(
+    MultiSearchResult[
+        EngagementsHit, EngagementsFacetDistribution, EngagementsFacetStats
+    ]
+):
+    """MultiSearchResult for Engagements."""

ffbb_data_client/models/multi_search_result_formations.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from .formations_facet_distribution import FormationsFacetDistribution
+from .formations_facet_stats import FormationsFacetStats
+from .formations_hit import FormationsHit
+from .multi_search_results import MultiSearchResult
+
+
+class FormationsMultiSearchResult(
+    MultiSearchResult[FormationsHit, FormationsFacetDistribution, FormationsFacetStats]
+):
+    """MultiSearchResult for Formations."""

ffbb_data_client/models/multi_search_result_organismes.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from .multi_search_results import MultiSearchResult
+from .organismes_facet_distribution import OrganismesFacetDistribution
+from .organismes_facet_stats import OrganismesFacetStats
+from .organismes_hit import OrganismesHit
+
+
+class OrganismesMultiSearchResult(
+    MultiSearchResult[OrganismesHit, OrganismesFacetDistribution, OrganismesFacetStats]
+):
+    """MultiSearchResult for Organismes."""

ffbb_data_client/models/multi_search_result_pratiques.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from .multi_search_results import MultiSearchResult
+from .pratiques_facet_distribution import PratiquesFacetDistribution
+from .pratiques_facet_stats import PratiquesFacetStats
+from .pratiques_hit import PratiquesHit
+
+
+class PratiquesMultiSearchResult(
+    MultiSearchResult[PratiquesHit, PratiquesFacetDistribution, PratiquesFacetStats]
+):
+    """MultiSearchResult for Pratiques."""

ffbb_data_client/models/multi_search_result_rencontres.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from .multi_search_results import MultiSearchResult
+from .rencontres_facet_distribution import RencontresFacetDistribution
+from .rencontres_facet_stats import RencontresFacetStats
+from .rencontres_hit import RencontresHit
+
+
+class RencontresMultiSearchResult(
+    MultiSearchResult[RencontresHit, RencontresFacetDistribution, RencontresFacetStats]
+):
+    """MultiSearchResult for Rencontres."""

ffbb_data_client/models/multi_search_result_salles.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from .multi_search_results import MultiSearchResult
+from .salles_facet_distribution import SallesFacetDistribution
+from .salles_facet_stats import SallesFacetStats
+from .salles_hit import SallesHit
+
+
+class SallesMultiSearchResult(
+    MultiSearchResult[SallesHit, SallesFacetDistribution, SallesFacetStats]
+):
+    """MultiSearchResult for Salles."""

ffbb_data_client/models/multi_search_result_terrains.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from .multi_search_results import MultiSearchResult
+from .terrains_facet_distribution import TerrainsFacetDistribution
+from .terrains_facet_stats import TerrainsFacetStats
+from .terrains_hit import TerrainsHit
+
+
+class TerrainsMultiSearchResult(
+    MultiSearchResult[TerrainsHit, TerrainsFacetDistribution, TerrainsFacetStats]
+):
+    """MultiSearchResult for Terrains."""

ffbb_data_client/models/multi_search_result_tournois.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from .multi_search_results import MultiSearchResult
+from .tournois_facet_distribution import TournoisFacetDistribution
+from .tournois_facet_stats import TournoisFacetStats
+from .tournois_hit import TournoisHit
+
+
+class TournoisMultiSearchResult(
+    MultiSearchResult[TournoisHit, TournoisFacetDistribution, TournoisFacetStats]
+):
+    """MultiSearchResult for Tournois."""

ffbb_data_client/models/multi_search_results.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Generic, TypeVar, get_args
+
+from ..utils.converter_utils import (
+    from_int,
+    from_list,
+    from_str,
+)
+from .facet_distribution import FacetDistribution
+from .facet_stats import FacetStats
+from .hit import Hit
+
+HitType = TypeVar("HitType", bound=Hit)
+FacetDistributionType = TypeVar("FacetDistributionType", bound=FacetDistribution)
+FacetStatsType = TypeVar("FacetStatsType", bound=FacetStats)
+
+
+@dataclass
+class MultiSearchResult(Generic[HitType, FacetDistributionType, FacetStatsType]):
+    index_uid: str | None = None
+    hits: list[HitType] | None = None
+    query: str | None = None
+    processing_time_ms: int | None = None
+    limit: int | None = None
+    offset: int | None = None
+    estimated_total_hits: int | None = None
+    facet_distribution: FacetDistributionType | None = None
+    facet_stats: FacetStatsType | None = None
+
+    @classmethod
+    def from_dict(
+        cls,
+        obj: Any,
+    ) -> MultiSearchResult[HitType, FacetDistributionType, FacetStatsType]:
+        """
+        Parse dict into the concrete MultiSearchResult subclass.
+        Types are extracted from the class's generic parameters.
+        """
+        assert isinstance(obj, dict)
+
+        # Extract generic type arguments from class definition
+        # e.g., OrganismesMultiSearchResult inherits from
+        # MultiSearchResult[OrganismesHit, OrganismesFacetDistribution, OrganismesFacetStats]
+        orig_bases = getattr(cls, "__orig_bases__", ())
+        if not orig_bases:
+            raise TypeError(f"{cls.__name__} must be a generic subclass")
+        type_args = get_args(orig_bases[0])
+        hit_type: type[HitType] = type_args[0]
+        facet_distribution_type: type[FacetDistributionType] = type_args[1]
+        facet_stats_type: type[FacetStatsType] = type_args[2]
+
+        index_uid = from_str(obj, "indexUid")
+        hits = from_list(hit_type.from_dict, obj, "hits")
+        query = from_str(obj, "query")
+        processing_time_ms = from_int(obj, "processingTimeMs")
+        limit = from_int(obj, "limit")
+        offset = from_int(obj, "offset")
+        estimated_total_hits = from_int(obj, "estimatedTotalHits")
+        fd_val = obj.get("facetDistribution")
+        facet_distribution = (
+            facet_distribution_type.from_dict(fd_val)
+            if isinstance(fd_val, dict)
+            else None
+        )
+        fs_val = obj.get("facetStats")
+        facet_stats = (
+            facet_stats_type.from_dict(fs_val) if isinstance(fs_val, dict) else None
+        )
+        return cls(
+            index_uid=index_uid,
+            hits=hits,  # type: ignore[arg-type]  # from_dict returns Hit base type
+            query=query,
+            processing_time_ms=processing_time_ms,
+            limit=limit,
+            offset=offset,
+            estimated_total_hits=estimated_total_hits,
+            facet_distribution=facet_distribution,  # type: ignore[arg-type]  # dynamic type from generics
+            facet_stats=facet_stats,  # type: ignore[arg-type]  # dynamic type from generics
+        )
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.index_uid is not None:
+            result["indexUid"] = self.index_uid
+        if self.hits is not None:
+            result["hits"] = [hit.to_dict() for hit in self.hits]
+        if self.query is not None:
+            result["query"] = self.query
+        if self.processing_time_ms is not None:
+            result["processingTimeMs"] = self.processing_time_ms
+        if self.limit is not None:
+            result["limit"] = self.limit
+        if self.offset is not None:
+            result["offset"] = self.offset
+        if self.estimated_total_hits is not None:
+            result["estimatedTotalHits"] = self.estimated_total_hits
+        if self.facet_distribution is not None:
+            result["facetDistribution"] = self.facet_distribution.to_dict()
+        if self.facet_stats is not None:
+            result["facetStats"] = self.facet_stats.to_dict()
+        return result

ffbb_data_client/models/multi_search_results_class.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+
+from ..config import (
+    MEILISEARCH_INDEX_COMPETITIONS,
+    MEILISEARCH_INDEX_ENGAGEMENTS,
+    MEILISEARCH_INDEX_FORMATIONS,
+    MEILISEARCH_INDEX_GALERIES,
+    MEILISEARCH_INDEX_NEWS,
+    MEILISEARCH_INDEX_ORGANISMES,
+    MEILISEARCH_INDEX_PRATIQUES,
+    MEILISEARCH_INDEX_RENCONTRES,
+    MEILISEARCH_INDEX_RSS,
+    MEILISEARCH_INDEX_SALLES,
+    MEILISEARCH_INDEX_TERRAINS,
+    MEILISEARCH_INDEX_TOURNOIS,
+    MEILISEARCH_INDEX_UIDS,
+    MEILISEARCH_INDEX_YOUTUBE_VIDEOS,
+)
+from .generic_search import (
+    GaleriesMultiSearchResult,
+    NewsMultiSearchResult,
+    RssMultiSearchResult,
+    YoutubeVideosMultiSearchResult,
+)
+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
+
+# Re-export for backward compatibility
+index_uids = MEILISEARCH_INDEX_UIDS
+
+index_uids_converters: dict[str, Callable[[Any], MultiSearchResult[Any, Any, Any]]] = {
+    MEILISEARCH_INDEX_ORGANISMES: OrganismesMultiSearchResult.from_dict,
+    MEILISEARCH_INDEX_RENCONTRES: RencontresMultiSearchResult.from_dict,
+    MEILISEARCH_INDEX_TERRAINS: TerrainsMultiSearchResult.from_dict,
+    MEILISEARCH_INDEX_SALLES: SallesMultiSearchResult.from_dict,
+    MEILISEARCH_INDEX_TOURNOIS: TournoisMultiSearchResult.from_dict,
+    MEILISEARCH_INDEX_COMPETITIONS: CompetitionsMultiSearchResult.from_dict,
+    MEILISEARCH_INDEX_PRATIQUES: PratiquesMultiSearchResult.from_dict,
+    MEILISEARCH_INDEX_ENGAGEMENTS: EngagementsMultiSearchResult.from_dict,
+    MEILISEARCH_INDEX_FORMATIONS: FormationsMultiSearchResult.from_dict,
+    MEILISEARCH_INDEX_NEWS: NewsMultiSearchResult.from_dict,
+    MEILISEARCH_INDEX_YOUTUBE_VIDEOS: YoutubeVideosMultiSearchResult.from_dict,
+    MEILISEARCH_INDEX_RSS: RssMultiSearchResult.from_dict,
+    MEILISEARCH_INDEX_GALERIES: GaleriesMultiSearchResult.from_dict,
+}
+
+
+def result_from_list(s: list[Any]) -> list[MultiSearchResult[Any, Any, Any]]:
+    results: list[MultiSearchResult[Any, Any, Any]] = []
+
+    if s:
+        for element in s:
+            try:
+                index_uid = element["indexUid"]
+                from_dict_func = index_uids_converters[index_uid]
+                result = from_dict_func(element)
+                results.append(result)
+            except (KeyError, TypeError, ValueError, AssertionError):
+                # Skip invalid or unsupported index results
+                pass
+
+    return results
+
+
+@dataclass
+class MultiSearchResults:
+    results: list[MultiSearchResult[Any, Any, Any]] | None = None
+
+    @staticmethod
+    def from_dict(obj: Any) -> MultiSearchResults:
+        assert isinstance(obj, dict)
+        results_raw = obj.get("results")
+        results = result_from_list(results_raw) if results_raw is not None else None
+        return MultiSearchResults(results=results)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.results is not None:
+            result["results"] = [r.to_dict() for r in self.results]
+        return result
+
+
+def multi_search_results_from_dict(s: Any) -> MultiSearchResults:
+    return MultiSearchResults.from_dict(s)

ffbb_data_client/models/nature_sol.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any
+
+from ..utils.converter_utils import (
+    from_bool,
+    from_datetime,
+    from_enum,
+    from_str,
+)
+from .code import Code
+
+
+@dataclass
+class NatureSol:
+    code: Code | None = None
+    date_created: datetime | None = None
+    date_updated: datetime | None = None
+    id: str | None = None
+    libelle: str | None = None
+    terrain: bool | None = None
+
+    @staticmethod
+    def from_dict(obj: Any) -> NatureSol:
+        assert isinstance(obj, dict)
+        code = from_enum(Code, obj, "code")
+        date_created = from_datetime(obj, "date_created")
+        date_updated = from_datetime(obj, "date_updated")
+        id = from_str(obj, "id")
+        libelle = from_str(obj, "libelle")
+        terrain = from_bool(obj, "terrain")
+        return NatureSol(
+            code=code,
+            date_created=date_created,
+            date_updated=date_updated,
+            id=id,
+            libelle=libelle,
+            terrain=terrain,
+        )
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.code is not None:
+            result["code"] = self.code.value
+        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.id is not None:
+            result["id"] = self.id
+        if self.libelle is not None:
+            result["libelle"] = self.libelle
+        if self.terrain is not None:
+            result["terrain"] = str(self.terrain).lower()
+        return result

ffbb_data_client/models/niveau.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class Niveau(Enum):
+    DÉPARTEMENTAL = "Départemental"
+    HANDIBASKET = "Handibasket"
+    INTERNATIONAL = "International"
+    NATIONAL = "National"
+    PRO = "Pro"
+    RÉGIONAL = "Régional"

ffbb_data_client/models/niveau_class.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from ..utils.converter_utils import from_int
+
+
+@dataclass
+class NiveauClass:
+    départemental: int | None = None
+    régional: int | None = None
+
+    @staticmethod
+    def from_dict(obj: Any) -> NiveauClass:
+        assert isinstance(obj, dict)
+        départemental = from_int(obj, "Départemental")
+        régional = from_int(obj, "Régional")
+        return NiveauClass(départemental=départemental, régional=régional)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.départemental is not None:
+            result["Départemental"] = self.départemental
+        if self.régional is not None:
+            result["Régional"] = self.régional
+        return result