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

ffbb_data_client/models/terrains_hit.py

@@ -0,0 +1,223 @@
+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_enum,
+    from_int,
+    from_list,
+    from_obj,
+    from_str,
+)
+from .cartographie import Cartographie
+from .commune import Commune
+from .document_flyer import DocumentFlyer
+from .geo import Geo
+from .hit import Hit
+from .terrains_categorie_championnat_3x3_libelle import CategorieChampionnat3X3Libelle
+from .terrains_sexe_enum import SexeEnum
+from .tournoi_type_enum import TournoiTypeEnum
+from .tournoi_types_3x3 import TournoiTypes3X3
+
+
+@dataclass
+class TerrainsHit(Hit):
+    nom: str | None = None
+    sexe: SexeEnum | None = None
+    adresse: str | None = None
+    nom_organisateur: str | None = None
+    description: str | None = None
+    site_choisi: str | None = None
+    id: int | None = None
+    code: str | None = None
+    date_created: datetime | None = None
+    date_updated: datetime | None = None
+    age_max: int | None = None
+    age_min: int | None = None
+    categorie_championnat3_x3_id: int | None = None
+    categorie_championnat3_x3_libelle: CategorieChampionnat3X3Libelle | None = None
+    debut: datetime | None = None
+    fin: datetime | None = None
+    mail_organisateur: str | None = None
+    nb_participant_prevu: int | None = None
+    tarif_organisateur: int | None = None
+    telephone_organisateur: str | None = None
+    url_organisateur: str | None = None
+    adresse_complement: str | None = None
+    tournoi_types3_x3: list[TournoiTypes3X3] | None = None
+    cartographie: Cartographie | None = None
+    commune: Commune | None = None
+    document_flyer: DocumentFlyer | None = None
+    tournoi_type: TournoiTypeEnum | None = None
+    geo: Geo | None = None
+    debut_timestamp: int | None = None
+    fin_timestamp: int | None = None
+    thumbnail: str | None = None
+    lower_nom: str | None = field(init=False, default=None, repr=False)
+    lower_addresse: str | None = field(init=False, default=None, repr=False)
+    lower_nom_organisateur: str | None = field(init=False, default=None, repr=False)
+    lower_description: str | None = field(init=False, default=None, repr=False)
+    lower_site_choisi: str | None = field(init=False, default=None, repr=False)
+    lower_code: str | None = field(init=False, default=None, repr=False)
+
+    def __post_init__(self) -> None:
+        self.lower_nom = self.nom.lower() if self.nom else None
+        self.lower_addresse = self.adresse.lower() if self.adresse else None
+        self.lower_nom_organisateur = (
+            self.nom_organisateur.lower() if self.nom_organisateur else None
+        )
+        self.lower_description = self.description.lower() if self.description else None
+        self.lower_site_choisi = self.site_choisi.lower() if self.site_choisi else None
+        self.lower_code = self.code.lower() if self.code else None
+
+    @staticmethod
+    def from_dict(obj: Any) -> TerrainsHit:
+        assert isinstance(obj, dict)
+        nom = from_str(obj, "nom")
+        sexe = from_enum(SexeEnum, obj, "sexe")
+        adresse = from_str(obj, "adresse")
+        nom_organisateur = from_str(obj, "nomOrganisateur")
+        description = from_str(obj, "description")
+        site_choisi = from_str(obj, "siteChoisi")
+        id = from_int(obj, "id")
+        code = from_str(obj, "code")
+        date_created = from_datetime(obj, "date_created")
+        date_updated = from_datetime(obj, "date_updated")
+        age_max = from_int(obj, "ageMax")
+        age_min = from_int(obj, "ageMin")
+        categorie_championnat3_x3_id = from_int(obj, "categorieChampionnat3x3Id")
+        categorie_championnat3_x3_libelle = from_enum(
+            CategorieChampionnat3X3Libelle, obj, "categorieChampionnat3x3Libelle"
+        )
+        debut = from_datetime(obj, "debut")
+        fin = from_datetime(obj, "fin")
+        mail_organisateur = from_str(obj, "mailOrganisateur")
+        nb_participant_prevu = from_int(obj, "nbParticipantPrevu")
+        tarif_organisateur = from_int(obj, "tarifOrganisateur")
+        telephone_organisateur = from_str(obj, "telephoneOrganisateur")
+        url_organisateur = from_str(obj, "urlOrganisateur")
+        adresse_complement = from_str(obj, "adresseComplement")
+        tournoi_types3_x3 = from_list(TournoiTypes3X3.from_dict, obj, "tournoiTypes3x3")
+        cartographie = from_obj(Cartographie.from_dict, obj, "cartographie")
+        commune = from_obj(Commune.from_dict, obj, "commune")
+        document_flyer = from_obj(DocumentFlyer.from_dict, obj, "document_flyer")
+        tournoi_type = from_enum(TournoiTypeEnum, obj, "tournoiType")
+        geo = from_obj(Geo.from_dict, obj, "_geo")
+        debut_timestamp = from_int(obj, "debut_timestamp")
+        fin_timestamp = from_int(obj, "fin_timestamp")
+        thumbnail = from_str(obj, "thumbnail")
+        return TerrainsHit(
+            nom=nom,
+            sexe=sexe,
+            adresse=adresse,
+            nom_organisateur=nom_organisateur,
+            description=description,
+            site_choisi=site_choisi,
+            id=id,
+            code=code,
+            date_created=date_created,
+            date_updated=date_updated,
+            age_max=age_max,
+            age_min=age_min,
+            categorie_championnat3_x3_id=categorie_championnat3_x3_id,
+            categorie_championnat3_x3_libelle=categorie_championnat3_x3_libelle,
+            debut=debut,
+            fin=fin,
+            mail_organisateur=mail_organisateur,
+            nb_participant_prevu=nb_participant_prevu,
+            tarif_organisateur=tarif_organisateur,
+            telephone_organisateur=telephone_organisateur,
+            url_organisateur=url_organisateur,
+            adresse_complement=adresse_complement,
+            tournoi_types3_x3=tournoi_types3_x3,
+            cartographie=cartographie,
+            commune=commune,
+            document_flyer=document_flyer,
+            tournoi_type=tournoi_type,
+            geo=geo,
+            debut_timestamp=debut_timestamp,
+            fin_timestamp=fin_timestamp,
+            thumbnail=thumbnail,
+        )
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.nom is not None:
+            result["nom"] = self.nom
+        if self.sexe is not None:
+            result["sexe"] = self.sexe.value
+        if self.adresse is not None:
+            result["adresse"] = self.adresse
+        if self.nom_organisateur is not None:
+            result["nomOrganisateur"] = self.nom_organisateur
+        if self.description is not None:
+            result["description"] = self.description
+        if self.site_choisi is not None:
+            result["siteChoisi"] = self.site_choisi
+        if self.id is not None:
+            result["id"] = str(self.id)
+        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.age_max is not None:
+            result["ageMax"] = self.age_max
+        if self.age_min is not None:
+            result["ageMin"] = self.age_min
+        if self.categorie_championnat3_x3_id is not None:
+            result["categorieChampionnat3x3Id"] = str(self.categorie_championnat3_x3_id)
+        if self.categorie_championnat3_x3_libelle is not None:
+            result["categorieChampionnat3x3Libelle"] = (
+                self.categorie_championnat3_x3_libelle.value
+            )
+        if self.debut is not None:
+            result["debut"] = self.debut.isoformat()
+        if self.fin is not None:
+            result["fin"] = self.fin.isoformat()
+        if self.mail_organisateur is not None:
+            result["mailOrganisateur"] = self.mail_organisateur
+        if self.nb_participant_prevu is not None:
+            result["nbParticipantPrevu"] = str(self.nb_participant_prevu)
+        if self.tarif_organisateur is not None:
+            result["tarifOrganisateur"] = str(self.tarif_organisateur)
+        if self.telephone_organisateur is not None:
+            result["telephoneOrganisateur"] = self.telephone_organisateur
+        if self.url_organisateur is not None:
+            result["urlOrganisateur"] = self.url_organisateur
+        if self.adresse_complement is not None:
+            result["adresseComplement"] = self.adresse_complement
+        if self.tournoi_types3_x3 is not None:
+            result["tournoiTypes3x3"] = [t.to_dict() for t in self.tournoi_types3_x3]
+        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.document_flyer is not None:
+            result["document_flyer"] = self.document_flyer.to_dict()
+        if self.tournoi_type is not None:
+            result["tournoiType"] = self.tournoi_type.value
+        if self.geo is not None:
+            result["_geo"] = self.geo.to_dict()
+        if self.debut_timestamp is not None:
+            result["debut_timestamp"] = self.debut_timestamp
+        if self.fin_timestamp is not None:
+            result["fin_timestamp"] = self.fin_timestamp
+        if self.thumbnail is not None:
+            result["thumbnail"] = self.thumbnail
+        return result
+
+    def is_valid_for_query(self, query: str) -> bool:
+        return bool(
+            not query
+            or (self.lower_nom and query in self.lower_nom)
+            or (self.lower_addresse and query in self.lower_addresse)
+            or (self.lower_description and query in self.lower_description)
+            or (self.lower_code and query in self.lower_code)
+            or (self.lower_nom_organisateur and query in self.lower_nom_organisateur)
+            or (self.lower_site_choisi and query in self.lower_site_choisi)
+        )

ffbb_data_client/models/terrains_multi_search_query.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from ..config import MEILISEARCH_INDEX_TERRAINS
+from .multi_search_query import MultiSearchQuery
+from .multi_search_result_terrains import TerrainsMultiSearchResult
+from .multi_search_results import MultiSearchResult
+from .terrains_facet_distribution import TerrainsFacetDistribution
+from .terrains_facet_stats import TerrainsFacetStats
+
+
+class TerrainsMultiSearchQuery(MultiSearchQuery):
+    def __init__(
+        self,
+        q: str | None,
+        facets: list[str] | None = 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_TERRAINS,
+            q=q,
+            facets=facets,
+            limit=limit,
+            offset=offset,
+            filter=filter,
+            sort=sort,
+        )
+
+    def is_valid_result(self, result: MultiSearchResult):
+        return result and (
+            isinstance(result, TerrainsMultiSearchResult)
+            and (
+                result.facet_distribution is None
+                or isinstance(result.facet_distribution, TerrainsFacetDistribution)
+            )
+            and (
+                result.facet_stats is None
+                or isinstance(result.facet_stats, TerrainsFacetStats)
+            )
+        )

ffbb_data_client/models/terrains_name.py

@@ -0,0 +1,5 @@
+from enum import Enum
+
+
+class Name(Enum):
+    TOURNOIS = "Tournois"

ffbb_data_client/models/terrains_sexe_enum.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+
+class SexeEnum(Enum):
+    FEMININE = "Féminin"
+    MASCULINE = "Masculin"
+    MIXTE = "Mixte"

ffbb_data_client/models/terrains_storage.py

@@ -0,0 +1,5 @@
+from enum import Enum
+
+
+class Storage(Enum):
+    MINIO = "minio"

ffbb_data_client/models/tournoi_type_class.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from ..utils.converter_utils import from_int
+
+
+@dataclass
+class TournoiTypeClass:
+    open_plus: int | None = None
+    open_plus_access: int | None = None
+    open_start: int | None = None
+
+    @staticmethod
+    def from_dict(obj: Any) -> TournoiTypeClass:
+        assert isinstance(obj, dict)
+        open_plus = from_int(obj, "Open Plus")
+        open_plus_access = from_int(obj, "Open Plus Access")
+        open_start = from_int(obj, "Open Start")
+        return TournoiTypeClass(
+            open_plus=open_plus,
+            open_plus_access=open_plus_access,
+            open_start=open_start,
+        )
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.open_plus is not None:
+            result["Open Plus"] = self.open_plus
+        if self.open_plus_access is not None:
+            result["Open Plus Access"] = self.open_plus_access
+        if self.open_start is not None:
+            result["Open Start"] = self.open_start
+        return result

ffbb_data_client/models/tournoi_type_enum.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+
+class TournoiTypeEnum(Enum):
+    OPEN_PLUS = "Open Plus"
+    OPEN_PLUS_ACCESS = "Open Plus Access"
+    OPEN_START = "Open Start"

ffbb_data_client/models/tournoi_types_3x3.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+from uuid import UUID
+
+from ..utils.converter_utils import from_enum, from_int, from_uuid
+from .tournoi_types_3x3_libelle_enum import Libelle
+from .type_league import TypeLeague
+
+
+@dataclass
+class TournoiTypes3X3:
+    libelle: Libelle | None = None
+    logo: UUID | None = None
+    type_league: TypeLeague | None = None
+    type_tournois: int | None = None
+
+    @staticmethod
+    def from_dict(obj: Any) -> TournoiTypes3X3:
+        assert isinstance(obj, dict)
+        libelle = from_enum(Libelle, obj, "libelle")
+        logo = from_uuid(obj, "logo")
+        type_league = from_enum(TypeLeague, obj, "type_league")
+        type_tournois = from_int(obj, "type_tournois")
+        return TournoiTypes3X3(
+            libelle=libelle,
+            logo=logo,
+            type_league=type_league,
+            type_tournois=type_tournois,
+        )
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.libelle is not None:
+            result["libelle"] = self.libelle.value
+        if self.logo is not None:
+            result["logo"] = str(self.logo)
+        if self.type_league is not None:
+            result["type_league"] = self.type_league.value
+        if self.type_tournois is not None:
+            result["type_tournois"] = str(self.type_tournois)
+        return result

ffbb_data_client/models/tournoi_types_3x3_libelle.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from ..utils.converter_utils import from_int
+
+
+@dataclass
+class TournoiTypes3X3Libelle:
+    open_plus_junior_league_3_x3: int | None = None
+    open_plus_super_league_3_x3: int | None = None
+    open_plus_access_junior_league_3_x3: int | None = None
+    open_plus_access_super_league_3_x3: int | None = None
+    open_start_junior_league_3_x3: int | None = None
+    open_start_super_league_3_x3: int | None = None
+
+    @staticmethod
+    def from_dict(obj: Any) -> TournoiTypes3X3Libelle:
+        assert isinstance(obj, dict)
+        open_plus_junior_league_3_x3 = from_int(obj, "Open Plus - Junior league 3x3")
+        open_plus_super_league_3_x3 = from_int(obj, "Open Plus - Super league 3x3")
+        open_plus_access_junior_league_3_x3 = from_int(
+            obj, "Open Plus Access - Junior league 3x3"
+        )
+        open_plus_access_super_league_3_x3 = from_int(
+            obj, "Open Plus Access - Super league 3x3"
+        )
+        open_start_junior_league_3_x3 = from_int(obj, "Open Start - Junior league 3x3")
+        open_start_super_league_3_x3 = from_int(obj, "Open Start - Super league 3x3")
+        return TournoiTypes3X3Libelle(
+            open_plus_junior_league_3_x3=open_plus_junior_league_3_x3,
+            open_plus_super_league_3_x3=open_plus_super_league_3_x3,
+            open_plus_access_junior_league_3_x3=open_plus_access_junior_league_3_x3,
+            open_plus_access_super_league_3_x3=open_plus_access_super_league_3_x3,
+            open_start_junior_league_3_x3=open_start_junior_league_3_x3,
+            open_start_super_league_3_x3=open_start_super_league_3_x3,
+        )
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.open_plus_junior_league_3_x3 is not None:
+            result["Open Plus - Junior league 3x3"] = self.open_plus_junior_league_3_x3
+        if self.open_plus_super_league_3_x3 is not None:
+            result["Open Plus - Super league 3x3"] = self.open_plus_super_league_3_x3
+        if self.open_plus_access_junior_league_3_x3 is not None:
+            result["Open Plus Access - Junior league 3x3"] = (
+                self.open_plus_access_junior_league_3_x3
+            )
+        if self.open_plus_access_super_league_3_x3 is not None:
+            result["Open Plus Access - Super league 3x3"] = (
+                self.open_plus_access_super_league_3_x3
+            )
+        if self.open_start_junior_league_3_x3 is not None:
+            result["Open Start - Junior league 3x3"] = (
+                self.open_start_junior_league_3_x3
+            )
+        if self.open_start_super_league_3_x3 is not None:
+            result["Open Start - Super league 3x3"] = self.open_start_super_league_3_x3
+        return result

ffbb_data_client/models/tournoi_types_3x3_libelle_enum.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class Libelle(Enum):
+    OPEN_PLUS_ACCESS_JUNIOR_LEAGUE_3_X3 = "Open Plus Access - Junior league 3x3"
+    OPEN_PLUS_ACCESS_SUPER_LEAGUE_3_X3 = "Open Plus Access - Super league 3x3"
+    OPEN_PLUS_JUNIOR_LEAGUE_3_X3 = "Open Plus - Junior league 3x3"
+    OPEN_PLUS_SUPER_LEAGUE_3_X3 = "Open Plus - Super league 3x3"
+    OPEN_START_JUNIOR_LEAGUE_3_X3 = "Open Start - Junior league 3x3"
+    OPEN_START_SUPER_LEAGUE_3_X3 = "Open Start - Super league 3x3"

ffbb_data_client/models/tournois_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 TournoisFacetDistribution(FacetDistribution):
+    sexe: SexeClass | None = None
+    tournoi_type: TournoiTypeClass | None = None
+    tournoi_types3_x3_libelle: TournoiTypes3X3Libelle | None = None
+
+    @staticmethod
+    def from_dict(obj: Any) -> TournoisFacetDistribution:
+        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 TournoisFacetDistribution(
+            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/tournois_facet_stats.py

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

ffbb_data_client/models/tournois_hit.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any
+
+from ..utils.converter_utils import (
+    from_bool,
+    from_datetime,
+    from_enum,
+    from_int,
+    from_obj,
+    from_str,
+)
+from .cartographie import Cartographie
+from .commune import Commune
+from .geo import Geo
+from .hit import Hit
+from .nature_sol import NatureSol
+from .tournois_hit_type import HitType
+
+
+@dataclass
+class TournoisHit(Hit):
+    nom: str | None = None
+    rue: str | None = None
+    id: int | None = None
+    acces_libre: bool | None = None
+    date_created: datetime | None = None
+    date_updated: datetime | None = None
+    largeur: int | None = None
+    longueur: int | None = None
+    numero: int | None = None
+    cartographie: Cartographie | None = None
+    commune: Commune | None = None
+    nature_sol: NatureSol | None = None
+    geo: Geo | None = None
+    thumbnail: str | None = None
+    type: HitType | None = None
+    lower_nom: str | None = field(init=False, default=None, repr=False)
+    lower_rue: str | None = field(init=False, default=None, repr=False)
+
+    def __post_init__(self) -> None:
+        self.lower_nom = self.nom.lower() if self.nom else None
+        self.lower_rue = self.rue.lower() if self.rue else None
+
+    @staticmethod
+    def from_dict(obj: Any) -> TournoisHit:
+        assert isinstance(obj, dict)
+        nom = from_str(obj, "nom")
+        rue = from_str(obj, "rue")
+        id = from_int(obj, "id")
+        acces_libre = from_bool(obj, "accesLibre")
+        date_created = from_datetime(obj, "date_created")
+        date_updated = from_datetime(obj, "date_updated")
+        largeur = from_int(obj, "largeur")
+        longueur = from_int(obj, "longueur")
+        numero = from_int(obj, "numero")
+        cartographie = from_obj(Cartographie.from_dict, obj, "cartographie")
+        commune = from_obj(Commune.from_dict, obj, "commune")
+        nature_sol = from_obj(NatureSol.from_dict, obj, "natureSol")
+        geo = from_obj(Geo.from_dict, obj, "_geo")
+        thumbnail = from_str(obj, "thumbnail")
+        type = from_enum(HitType, obj, "type")
+        return TournoisHit(
+            nom=nom,
+            rue=rue,
+            id=id,
+            acces_libre=acces_libre,
+            date_created=date_created,
+            date_updated=date_updated,
+            largeur=largeur,
+            longueur=longueur,
+            numero=numero,
+            cartographie=cartographie,
+            commune=commune,
+            nature_sol=nature_sol,
+            geo=geo,
+            thumbnail=thumbnail,
+            type=type,
+        )
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.nom is not None:
+            result["nom"] = self.nom
+        if self.rue is not None:
+            result["rue"] = self.rue
+        if self.id is not None:
+            result["id"] = str(self.id)
+        if self.acces_libre is not None:
+            result["accesLibre"] = self.acces_libre
+        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.largeur is not None:
+            result["largeur"] = self.largeur
+        if self.longueur is not None:
+            result["longueur"] = self.longueur
+        if self.numero is not None:
+            result["numero"] = self.numero
+        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.nature_sol is not None:
+            result["natureSol"] = self.nature_sol.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.value
+        return result
+
+    def is_valid_for_query(self, query: str) -> bool:
+        return bool(
+            not query
+            or (self.lower_nom and query in self.lower_nom)
+            or (self.lower_rue and query in self.lower_rue)
+            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/tournois_hit_type.py

@@ -0,0 +1,5 @@
+from enum import Enum
+
+
+class HitType(Enum):
+    TERRAIN = "Terrain"

ffbb_data_client/models/tournois_libelle.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+
+class Libelle(Enum):
+    BITUME = "BITUME"
+    BÉTON = "Béton"
+    SOL_SYNTHÉTIQUE = "Sol synthétique"