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

ffbb_data_client/models/external_id.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from ..utils.converter_utils import (
+    from_int,
+    from_obj,
+    from_str,
+)
+from .external_competition_id import ExternalCompetitionID
+from .id_organisme_equipe import IDOrganismeEquipe
+from .id_poule import IDPoule
+from .salle import Salle
+
+
+@dataclass
+class ExternalID:
+    nom_equipe1: str | None = None
+    nom_equipe2: str | None = None
+    numero_journee: int | None = None
+    competition_id: ExternalCompetitionID | None = None
+    id_organisme_equipe1: IDOrganismeEquipe | None = None
+    id_organisme_equipe2: IDOrganismeEquipe | None = None
+    salle: Salle | None = None
+    id_poule: IDPoule | None = None
+
+    @staticmethod
+    def from_dict(obj: Any) -> ExternalID:
+        assert isinstance(obj, dict)
+        nom_equipe1 = from_str(obj, "nomEquipe1")
+        nom_equipe2 = from_str(obj, "nomEquipe2")
+        numero_journee = from_int(obj, "numeroJournee")
+        competition_id = from_obj(ExternalCompetitionID.from_dict, obj, "competitionId")
+        id_organisme_equipe1 = from_obj(
+            IDOrganismeEquipe.from_dict, obj, "idOrganismeEquipe1"
+        )
+        id_organisme_equipe2 = from_obj(
+            IDOrganismeEquipe.from_dict, obj, "idOrganismeEquipe2"
+        )
+        salle = from_obj(Salle.from_dict, obj, "salle")
+        id_poule = from_obj(IDPoule.from_dict, obj, "idPoule")
+        return ExternalID(
+            nom_equipe1=nom_equipe1,
+            nom_equipe2=nom_equipe2,
+            numero_journee=numero_journee,
+            competition_id=competition_id,
+            id_organisme_equipe1=id_organisme_equipe1,
+            id_organisme_equipe2=id_organisme_equipe2,
+            salle=salle,
+            id_poule=id_poule,
+        )
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        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.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.salle is not None:
+            result["salle"] = self.salle.to_dict()
+        if self.id_poule is not None:
+            result["idPoule"] = self.id_poule.to_dict()
+        return result

ffbb_data_client/models/facet_distribution.py

@@ -0,0 +1,13 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class FacetDistribution(ABC):
+    @staticmethod
+    def from_dict(obj: Any) -> "FacetDistribution":
+        # Cannot instantiate abstract class - should be implemented by subclasses
+        assert False
+
+    @abstractmethod
+    def to_dict(self) -> dict[str, Any]:
+        return {}

ffbb_data_client/models/facet_stats.py

@@ -0,0 +1,13 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class FacetStats(ABC):
+    @staticmethod
+    def from_dict(obj: Any) -> "FacetStats":
+        # This should be implemented by concrete subclasses
+        assert False, "FacetStats is abstract and cannot be instantiated"
+
+    @abstractmethod
+    def to_dict(self) -> dict[str, Any]:
+        return {}

ffbb_data_client/models/field_set.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class FieldSet(Enum):
+    """Enum for different field sets."""
+
+    BASIC = "basic"
+    DEFAULT = "default"
+    DETAILED = "detailed"
+    MINIMAL = "minimal"

ffbb_data_client/models/folder.py

@@ -0,0 +1,35 @@
+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 Folder:
+    id: UUID | None = None
+    name: str | None = None
+    parent: str | None = None
+
+    @staticmethod
+    def from_dict(obj: Any) -> Folder:
+        assert isinstance(obj, dict)
+        id = from_uuid(obj, "id")
+        name = from_str(obj, "name")
+        parent = from_str(obj, "parent")
+        return Folder(id=id, name=name, parent=parent)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.id is not None:
+            result["id"] = str(self.id)
+        if self.name is not None:
+            result["name"] = self.name
+        if self.parent is not None:
+            result["parent"] = self.parent
+        return result

ffbb_data_client/models/formation_session.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any
+
+from ..utils.converter_utils import from_datetime, from_str
+
+
+@dataclass
+class FormationSession:
+    """A session within a formation (MeiliSearch denormalized data)."""
+
+    id: str | None = None
+    title: str | None = None
+    date_start: datetime | None = None
+    date_end: datetime | None = None
+    place: str | None = None
+    postal_code: str | None = None
+    reference: str | None = None
+    entity: str | None = None
+    subscribe_btn: str | None = None
+
+    @staticmethod
+    def from_dict(obj: Any) -> FormationSession:
+        if not isinstance(obj, dict):
+            raise TypeError(f"Expected dict, got {obj.__class__.__name__}")
+        return FormationSession(
+            id=from_str(obj, "id"),
+            title=from_str(obj, "title"),
+            date_start=from_datetime(obj, "date_start"),
+            date_end=from_datetime(obj, "date_end"),
+            place=from_str(obj, "place"),
+            postal_code=from_str(obj, "postal_code"),
+            reference=from_str(obj, "reference"),
+            entity=from_str(obj, "entity"),
+            subscribe_btn=from_str(obj, "subscribeBtn"),
+        )
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.id is not None:
+            result["id"] = self.id
+        if self.title is not None:
+            result["title"] = self.title
+        if self.date_start is not None:
+            result["date_start"] = self.date_start.isoformat()
+        if self.date_end is not None:
+            result["date_end"] = self.date_end.isoformat()
+        if self.place is not None:
+            result["place"] = self.place
+        if self.postal_code is not None:
+            result["postal_code"] = self.postal_code
+        if self.reference is not None:
+            result["reference"] = self.reference
+        if self.entity is not None:
+            result["entity"] = self.entity
+        if self.subscribe_btn is not None:
+            result["subscribeBtn"] = self.subscribe_btn
+        return result

ffbb_data_client/models/formations_facet_distribution.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from .facet_distribution import FacetDistribution
+
+
+@dataclass
+class FormationsFacetDistribution(FacetDistribution):
+    domain: dict[str, int] | None = None
+    mode: dict[str, int] | None = None
+    theme: dict[str, int] | None = None
+    type: dict[str, int] | None = None
+    place: dict[str, int] | None = None
+    places: dict[str, int] | None = None
+    postal_code: dict[str, int] | None = None
+    postal_codes: dict[str, int] | None = None
+    date_start_formatted: dict[str, int] | None = None
+    date_end_formatted: dict[str, int] | None = None
+
+    @staticmethod
+    def from_dict(obj: Any) -> FormationsFacetDistribution:
+        if not isinstance(obj, dict):
+            raise TypeError(f"Expected dict, got {obj.__class__.__name__}")
+        return FormationsFacetDistribution(
+            domain=obj.get("domain"),
+            mode=obj.get("mode"),
+            theme=obj.get("theme"),
+            type=obj.get("type"),
+            place=obj.get("place"),
+            places=obj.get("places"),
+            postal_code=obj.get("postal_code"),
+            postal_codes=obj.get("postal_codes"),
+            date_start_formatted=obj.get("date_start_formatted"),
+            date_end_formatted=obj.get("date_end_formatted"),
+        )
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.domain is not None:
+            result["domain"] = self.domain
+        if self.mode is not None:
+            result["mode"] = self.mode
+        if self.theme is not None:
+            result["theme"] = self.theme
+        if self.type is not None:
+            result["type"] = self.type
+        if self.place is not None:
+            result["place"] = self.place
+        if self.places is not None:
+            result["places"] = self.places
+        if self.postal_code is not None:
+            result["postal_code"] = self.postal_code
+        if self.postal_codes is not None:
+            result["postal_codes"] = self.postal_codes
+        if self.date_start_formatted is not None:
+            result["date_start_formatted"] = self.date_start_formatted
+        if self.date_end_formatted is not None:
+            result["date_end_formatted"] = self.date_end_formatted
+        return result

ffbb_data_client/models/formations_facet_stats.py

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

ffbb_data_client/models/formations_hit.py

@@ -0,0 +1,277 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta
+from typing import Any
+from uuid import UUID
+
+from ..utils.converter_utils import (
+    from_datetime,
+    from_duration,
+    from_int,
+    from_list,
+    from_str,
+    from_uuid,
+)
+from .formation_session import FormationSession
+from .hit import Hit
+
+
+@dataclass
+class FormationsHit(Hit):
+    id: str | None = None
+    title: str | None = None
+    type: str | None = None
+    mode: str | None = None
+    domain: str | None = None
+    theme: str | None = None
+    description: str | None = None
+    goals: str | None = None
+    public: str | None = None
+    prerequisites: str | None = None
+    content: str | None = None
+    pedagogy: str | None = None
+    certification: str | None = None
+    results: str | None = None
+    modalities: str | None = None
+    level: str | None = None
+    reference: str | None = None
+    program_id_fbi: str | None = None
+    duration_hours: timedelta | None = None
+    sessions: list[FormationSession] | None = None
+    files: list[Any] | None = None
+    image: str | None = None
+    thumbnail: str | None = None
+    mode_hidden: str | None = None
+    postal_codes: list[str] | None = None
+    places: list[str] | None = None
+    id_origin_hash: str | None = None
+    date_end: datetime | None = None
+    date_end_formatted: int | None = None
+    date_start: datetime | None = None
+    date_start_formatted: int | None = None
+    entity: str | None = None
+    formation_domain: str | None = None
+    formation_duration_hours: str | None = None
+    formation_id: UUID | None = None
+    formation_image: str | None = None
+    formation_mode: str | None = None
+    formation_theme: str | None = None
+    formation_thumbnail: str | None = None
+    formation_title: str | None = None
+    place: str | None = None
+    postal_code: str | None = None
+    reference_hidden: str | None = None
+    subscribe_btn: str | None = None
+    subscribe_button: str | None = None
+
+    lower_title: str | None = field(init=False, default=None, repr=False)
+    lower_domain: str | None = field(init=False, default=None, repr=False)
+    lower_theme: str | None = field(init=False, default=None, repr=False)
+
+    def __post_init__(self) -> None:
+        self.lower_title = self.title.lower() if self.title else None
+        self.lower_domain = self.domain.lower() if self.domain else None
+        self.lower_theme = self.theme.lower() if self.theme else None
+
+    @staticmethod
+    def from_dict(obj: Any) -> FormationsHit:
+        if not isinstance(obj, dict):
+            raise TypeError(f"Expected dict, got {obj.__class__.__name__}")
+        id = from_str(obj, "id")
+        title = from_str(obj, "title")
+        type = from_str(obj, "type")
+        mode = from_str(obj, "mode")
+        domain = from_str(obj, "domain")
+        theme = from_str(obj, "theme")
+        description = from_str(obj, "description")
+        goals = from_str(obj, "goals")
+        public = from_str(obj, "public")
+        prerequisites = from_str(obj, "prerequisites")
+        content = from_str(obj, "content")
+        pedagogy = from_str(obj, "pedagogy")
+        certification = from_str(obj, "certification")
+        results = from_str(obj, "results")
+        modalities = from_str(obj, "modalities")
+        level = from_str(obj, "level")
+        reference = from_str(obj, "reference")
+        program_id_fbi = from_str(obj, "programIdFbi")
+        duration_hours = from_duration(obj, "duration_hours")
+        sessions = from_list(FormationSession.from_dict, obj, "sessions")
+        files = from_list(lambda x: x, obj, "files")
+        image = from_str(obj, "image")
+        thumbnail = from_str(obj, "thumbnail")
+        mode_hidden = from_str(obj, "mode_hidden")
+        postal_codes = from_list(str, obj, "postal_codes")
+        places = from_list(str, obj, "places")
+        id_origin_hash = from_str(obj, "id_origin_hash")
+        date_end = from_datetime(obj, "date_end")
+        date_end_formatted = from_int(obj, "date_end_formatted")
+        date_start = from_datetime(obj, "date_start")
+        date_start_formatted = from_int(obj, "date_start_formatted")
+        entity = from_str(obj, "entity")
+        formation_domain = from_str(obj, "formation_domain")
+        formation_duration_hours = from_str(obj, "formation_duration_hours")
+        formation_id = from_uuid(obj, "formation_id")
+        formation_image = from_str(obj, "formation_image")
+        formation_mode = from_str(obj, "formation_mode")
+        formation_theme = from_str(obj, "formation_theme")
+        formation_thumbnail = from_str(obj, "formation_thumbnail")
+        formation_title = from_str(obj, "formation_title")
+        place = from_str(obj, "place")
+        postal_code = from_str(obj, "postal_code")
+        reference_hidden = from_str(obj, "reference_hidden")
+        subscribe_btn = from_str(obj, "subscribeBtn")
+        subscribe_button = from_str(obj, "subscribe_button")
+        return FormationsHit(
+            id=id,
+            title=title,
+            type=type,
+            mode=mode,
+            domain=domain,
+            theme=theme,
+            description=description,
+            goals=goals,
+            public=public,
+            prerequisites=prerequisites,
+            content=content,
+            pedagogy=pedagogy,
+            certification=certification,
+            results=results,
+            modalities=modalities,
+            level=level,
+            reference=reference,
+            program_id_fbi=program_id_fbi,
+            duration_hours=duration_hours,
+            sessions=sessions,
+            files=files,
+            image=image,
+            thumbnail=thumbnail,
+            mode_hidden=mode_hidden,
+            postal_codes=postal_codes,
+            places=places,
+            id_origin_hash=id_origin_hash,
+            date_end=date_end,
+            date_end_formatted=date_end_formatted,
+            date_start=date_start,
+            date_start_formatted=date_start_formatted,
+            entity=entity,
+            formation_domain=formation_domain,
+            formation_duration_hours=formation_duration_hours,
+            formation_id=formation_id,
+            formation_image=formation_image,
+            formation_mode=formation_mode,
+            formation_theme=formation_theme,
+            formation_thumbnail=formation_thumbnail,
+            formation_title=formation_title,
+            place=place,
+            postal_code=postal_code,
+            reference_hidden=reference_hidden,
+            subscribe_btn=subscribe_btn,
+            subscribe_button=subscribe_button,
+        )
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.id is not None:
+            result["id"] = self.id
+        if self.title is not None:
+            result["title"] = self.title
+        if self.type is not None:
+            result["type"] = self.type
+        if self.mode is not None:
+            result["mode"] = self.mode
+        if self.domain is not None:
+            result["domain"] = self.domain
+        if self.theme is not None:
+            result["theme"] = self.theme
+        if self.description is not None:
+            result["description"] = self.description
+        if self.goals is not None:
+            result["goals"] = self.goals
+        if self.public is not None:
+            result["public"] = self.public
+        if self.prerequisites is not None:
+            result["prerequisites"] = self.prerequisites
+        if self.content is not None:
+            result["content"] = self.content
+        if self.pedagogy is not None:
+            result["pedagogy"] = self.pedagogy
+        if self.certification is not None:
+            result["certification"] = self.certification
+        if self.results is not None:
+            result["results"] = self.results
+        if self.modalities is not None:
+            result["modalities"] = self.modalities
+        if self.level is not None:
+            result["level"] = self.level
+        if self.reference is not None:
+            result["reference"] = self.reference
+        if self.program_id_fbi is not None:
+            result["programIdFbi"] = self.program_id_fbi
+        if self.duration_hours is not None:
+            total_seconds = int(self.duration_hours.total_seconds())
+            hours, remainder = divmod(total_seconds, 3600)
+            minutes = remainder // 60
+            result["duration_hours"] = f"{hours}h{minutes:02d}"
+        if self.sessions is not None:
+            result["sessions"] = [s.to_dict() for s in self.sessions]
+        if self.files is not None:
+            result["files"] = self.files
+        if self.image is not None:
+            result["image"] = self.image
+        if self.thumbnail is not None:
+            result["thumbnail"] = self.thumbnail
+        if self.mode_hidden is not None:
+            result["mode_hidden"] = self.mode_hidden
+        if self.postal_codes is not None:
+            result["postal_codes"] = self.postal_codes
+        if self.places is not None:
+            result["places"] = self.places
+        if self.id_origin_hash is not None:
+            result["id_origin_hash"] = self.id_origin_hash
+        if self.date_end is not None:
+            result["date_end"] = self.date_end.isoformat()
+        if self.date_end_formatted is not None:
+            result["date_end_formatted"] = self.date_end_formatted
+        if self.date_start is not None:
+            result["date_start"] = self.date_start.isoformat()
+        if self.date_start_formatted is not None:
+            result["date_start_formatted"] = self.date_start_formatted
+        if self.entity is not None:
+            result["entity"] = self.entity
+        if self.formation_domain is not None:
+            result["formation_domain"] = self.formation_domain
+        if self.formation_duration_hours is not None:
+            result["formation_duration_hours"] = self.formation_duration_hours
+        if self.formation_id is not None:
+            result["formation_id"] = str(self.formation_id)
+        if self.formation_image is not None:
+            result["formation_image"] = self.formation_image
+        if self.formation_mode is not None:
+            result["formation_mode"] = self.formation_mode
+        if self.formation_theme is not None:
+            result["formation_theme"] = self.formation_theme
+        if self.formation_thumbnail is not None:
+            result["formation_thumbnail"] = self.formation_thumbnail
+        if self.formation_title is not None:
+            result["formation_title"] = self.formation_title
+        if self.place is not None:
+            result["place"] = self.place
+        if self.postal_code is not None:
+            result["postal_code"] = self.postal_code
+        if self.reference_hidden is not None:
+            result["reference_hidden"] = self.reference_hidden
+        if self.subscribe_btn is not None:
+            result["subscribeBtn"] = self.subscribe_btn
+        if self.subscribe_button is not None:
+            result["subscribe_button"] = self.subscribe_button
+        return result
+
+    def is_valid_for_query(self, query: str) -> bool:
+        return bool(
+            not query
+            or (self.lower_title and query in self.lower_title)
+            or (self.lower_domain and query in self.lower_domain)
+            or (self.lower_theme and query in self.lower_theme)
+        )

ffbb_data_client/models/formations_multi_search_query.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from ..config import MEILISEARCH_FACETS_FORMATIONS, MEILISEARCH_INDEX_FORMATIONS
+from .formations_facet_distribution import FormationsFacetDistribution
+from .formations_facet_stats import FormationsFacetStats
+from .multi_search_query import MultiSearchQuery
+from .multi_search_result_formations import FormationsMultiSearchResult
+from .multi_search_results import MultiSearchResult
+
+
+class FormationsMultiSearchQuery(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_FORMATIONS,
+            q=q,
+            facets=MEILISEARCH_FACETS_FORMATIONS,
+            limit=limit,
+            offset=offset,
+            filter=filter,
+            sort=sort,
+        )
+
+    def is_valid_result(self, result: MultiSearchResult):
+        return result and (
+            isinstance(result, FormationsMultiSearchResult)
+            and (
+                result.facet_distribution is None
+                or isinstance(result.facet_distribution, FormationsFacetDistribution)
+            )
+            and (
+                result.facet_stats is None
+                or isinstance(result.facet_stats, FormationsFacetStats)
+            )
+        )

ffbb_data_client/models/game_stats_model.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class GameStatsModel:
+    """Model for live game statistics from gsId field."""
+
+    match_id: str | None = None
+    current_status: str | None = None
+    current_period: str | None = None
+
+    # Score domicile (home team)
+    score_q1_home: int | None = None
+    score_q2_home: int | None = None
+    score_q3_home: int | None = None
+    score_q4_home: int | None = None
+    score_ot1_home: int | None = None
+    score_ot2_home: int | None = None
+
+    # Score extérieur (away team)
+    score_q1_out: int | None = None
+    score_q2_out: int | None = None
+    score_q3_out: int | None = None
+    score_q4_out: int | None = None
+    score_ot1_out: int | None = None
+    score_ot2_out: int | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> GameStatsModel | None:
+        """Convert dictionary to GameStatsModel instance."""
+        if not data:
+            return None
+
+        # Handle case where data is not a dictionary
+        if not isinstance(data, dict):
+            return None
+
+        return cls(
+            match_id=data.get("matchId"),
+            current_status=data.get("currentStatus"),
+            current_period=data.get("currentPeriod"),
+            score_q1_home=data.get("score_q1_home"),
+            score_q2_home=data.get("score_q2_home"),
+            score_q3_home=data.get("score_q3_home"),
+            score_q4_home=data.get("score_q4_home"),
+            score_ot1_home=data.get("score_ot1_home"),
+            score_ot2_home=data.get("score_ot2_home"),
+            score_q1_out=data.get("score_q1_out"),
+            score_q2_out=data.get("score_q2_out"),
+            score_q3_out=data.get("score_q3_out"),
+            score_q4_out=data.get("score_q4_out"),
+            score_ot1_out=data.get("score_ot1_out"),
+            score_ot2_out=data.get("score_ot2_out"),
+        )

ffbb_data_client/models/game_stats_models.py

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