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

ffbb_data_client/models/document_flyer.py

@@ -0,0 +1,205 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any
+from uuid import UUID
+
+from ..utils.converter_utils import (
+    from_datetime,
+    from_enum,
+    from_float,
+    from_int,
+    from_list,
+    from_obj,
+    from_str,
+    from_uuid,
+)
+from .document_flyer_type import DocumentFlyerType
+from .facet_stats import FacetStats
+from .folder import Folder
+from .source import Source
+
+
+@dataclass
+class DocumentFlyer:
+    id: UUID | None = None
+    storage: str | None = None
+    filename_disk: str | None = None
+    filename_download: str | None = None
+    title: str | None = None
+    type: DocumentFlyerType | None = None
+    uploaded_on: datetime | None = None
+    modified_on: datetime | None = None
+    charset: str | None = None
+    filesize: int | None = None
+    width: int | None = None
+    height: int | None = None
+    duration: int | None = None
+    embed: str | None = None
+    description: str | None = None
+    location: str | None = None
+    tags: str | None = None
+    metadata: FacetStats | None = None
+    source: Source | None = None
+    credits: str | None = None
+    gradient_color: str | None = None
+    md5: str | None = None
+    newsbridge_media_id: str | None = None
+    newsbridge_metadatas: str | None = None
+    newsbridge_name: str | None = None
+    newsbridge_recorded_at: datetime | None = None
+    focal_point_x: float | None = None
+    focal_point_y: float | None = None
+    newsbridge_labels: list[Any] | None = None
+    newsbridge_persons: list[Any] | None = None
+    folder: Folder | None = None
+    uploaded_by: UUID | None = None
+    modified_by: UUID | None = None
+    newsbridge_mission: str | None = None
+
+    @staticmethod
+    def from_dict(obj: Any) -> DocumentFlyer:
+        assert isinstance(obj, dict)
+        id = from_uuid(obj, "id")
+        storage = from_str(obj, "storage")
+        filename_disk = from_str(obj, "filename_disk")
+        filename_download = from_str(obj, "filename_download")
+        title = from_str(obj, "title")
+        type = from_enum(DocumentFlyerType, obj, "type")
+        uploaded_on = from_datetime(obj, "uploaded_on")
+        modified_on = from_datetime(obj, "modified_on")
+        charset = from_str(obj, "charset")
+        filesize = from_int(obj, "filesize")
+        width = from_int(obj, "width")
+        height = from_int(obj, "height")
+        duration = from_int(obj, "duration")
+        embed = from_str(obj, "embed")
+        description = from_str(obj, "description")
+        location = from_str(obj, "location")
+        tags = from_str(obj, "tags")
+        metadata = from_obj(FacetStats.from_dict, obj, "metadata")
+        source = from_enum(Source, obj, "source")
+        credits = from_str(obj, "credits")
+        gradient_color = from_str(obj, "gradient_color")
+        md5 = from_str(obj, "md5")
+        newsbridge_media_id = from_str(obj, "newsbridge_media_id")
+        newsbridge_metadatas = from_str(obj, "newsbridge_metadatas")
+        newsbridge_name = from_str(obj, "newsbridge_name")
+        newsbridge_recorded_at = from_datetime(obj, "newsbridge_recorded_at")
+        focal_point_x = from_float(obj, "focal_point_x")
+        focal_point_y = from_float(obj, "focal_point_y")
+        newsbridge_labels = from_list(lambda x: x, obj, "newsbridge_labels")
+        newsbridge_persons = from_list(lambda x: x, obj, "newsbridge_persons")
+        folder = from_obj(Folder.from_dict, obj, "folder")
+        uploaded_by = from_uuid(obj, "uploaded_by")
+        modified_by = from_uuid(obj, "modified_by")
+        newsbridge_mission = from_str(obj, "newsbridge_mission")
+        return DocumentFlyer(
+            id=id,
+            storage=storage,
+            filename_disk=filename_disk,
+            filename_download=filename_download,
+            title=title,
+            type=type,
+            uploaded_on=uploaded_on,
+            modified_on=modified_on,
+            charset=charset,
+            filesize=filesize,
+            width=width,
+            height=height,
+            duration=duration,
+            embed=embed,
+            description=description,
+            location=location,
+            tags=tags,
+            metadata=metadata,
+            source=source,
+            credits=credits,
+            gradient_color=gradient_color,
+            md5=md5,
+            newsbridge_media_id=newsbridge_media_id,
+            newsbridge_metadatas=newsbridge_metadatas,
+            newsbridge_name=newsbridge_name,
+            newsbridge_recorded_at=newsbridge_recorded_at,
+            focal_point_x=focal_point_x,
+            focal_point_y=focal_point_y,
+            newsbridge_labels=newsbridge_labels,
+            newsbridge_persons=newsbridge_persons,
+            folder=folder,
+            uploaded_by=uploaded_by,
+            modified_by=modified_by,
+            newsbridge_mission=newsbridge_mission,
+        )
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.id is not None:
+            result["id"] = str(self.id)
+        if self.storage is not None:
+            result["storage"] = self.storage
+        if self.filename_disk is not None:
+            result["filename_disk"] = self.filename_disk
+        if self.filename_download is not None:
+            result["filename_download"] = self.filename_download
+        if self.title is not None:
+            result["title"] = self.title
+        if self.type is not None:
+            result["type"] = self.type.value
+        if self.uploaded_on is not None:
+            result["uploaded_on"] = self.uploaded_on.isoformat()
+        if self.modified_on is not None:
+            result["modified_on"] = self.modified_on.isoformat()
+        if self.filesize is not None:
+            result["filesize"] = str(self.filesize)
+        if self.width is not None:
+            result["width"] = self.width
+        if self.height is not None:
+            result["height"] = self.height
+        if self.metadata is not None:
+            result["metadata"] = self.metadata.to_dict()
+        if self.source is not None:
+            result["source"] = self.source.value
+        if self.gradient_color is not None:
+            result["gradient_color"] = self.gradient_color
+        if self.md5 is not None:
+            result["md5"] = self.md5
+        if self.newsbridge_labels is not None:
+            result["newsbridge_labels"] = self.newsbridge_labels
+        if self.newsbridge_persons is not None:
+            result["newsbridge_persons"] = self.newsbridge_persons
+        if self.folder is not None:
+            result["folder"] = self.folder.to_dict()
+        if self.charset is not None:
+            result["charset"] = self.charset
+        if self.duration is not None:
+            result["duration"] = self.duration
+        if self.embed is not None:
+            result["embed"] = self.embed
+        if self.description is not None:
+            result["description"] = self.description
+        if self.location is not None:
+            result["location"] = self.location
+        if self.tags is not None:
+            result["tags"] = self.tags
+        if self.credits is not None:
+            result["credits"] = self.credits
+        if self.newsbridge_media_id is not None:
+            result["newsbridge_media_id"] = self.newsbridge_media_id
+        if self.newsbridge_metadatas is not None:
+            result["newsbridge_metadatas"] = self.newsbridge_metadatas
+        if self.newsbridge_name is not None:
+            result["newsbridge_name"] = self.newsbridge_name
+        if self.newsbridge_recorded_at is not None:
+            result["newsbridge_recorded_at"] = self.newsbridge_recorded_at.isoformat()
+        if self.focal_point_x is not None:
+            result["focal_point_x"] = self.focal_point_x
+        if self.focal_point_y is not None:
+            result["focal_point_y"] = self.focal_point_y
+        if self.uploaded_by is not None:
+            result["uploaded_by"] = str(self.uploaded_by)
+        if self.modified_by is not None:
+            result["modified_by"] = str(self.modified_by)
+        if self.newsbridge_mission is not None:
+            result["newsbridge_mission"] = self.newsbridge_mission
+        return result

ffbb_data_client/models/document_flyer_type.py

@@ -0,0 +1,6 @@
+from enum import Enum
+
+
+class DocumentFlyerType(Enum):
+    IMAGE_JPEG = "image/jpeg"
+    IMAGE_PNG = "image/png"

ffbb_data_client/models/engagement_contacts.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .contact_info import ContactInfo
+from .get_engagement_response import GetEngagementResponse
+from .get_entraineur_response import GetEntraineurResponse
+
+
+def _normalize_phone(raw: str | None) -> str | None:
+    if not raw:
+        return None
+    return str(raw).strip()
+
+
+def _sanitize_name(name: str | None) -> str | None:
+    return name.strip().title() if name else None
+
+
+@dataclass
+class EngagementContacts:
+    """Contacts for an engagement (team): correspondant + coaches."""
+
+    engagement: GetEngagementResponse
+    correspondant: ContactInfo | None
+    entraineur: ContactInfo | None
+    entraineur_adjoint: ContactInfo | None
+
+
+def extract_correspondant(engagement: GetEngagementResponse) -> ContactInfo | None:
+    """Extract correspondant contact from an engagement.
+
+    This is defensive: the engagement model in V3 may or may not include
+    correspondent phone/email fields. We try common attribute names and return
+    None if nothing usable is found.
+    """
+    phone = _normalize_phone(
+        getattr(engagement, "telephonePortableCorrespondantEquipe", None)
+        or getattr(engagement, "telephone_portable_correspondant_equipe", None)
+        or getattr(engagement, "telephoneFixeCorrespondantEquipe", None)
+        or getattr(engagement, "telephone_fixe_correspondant_equipe", None)
+        or getattr(engagement, "telephone", None)
+    )
+    email = (
+        getattr(engagement, "emailCorrespondantEquipe", None)
+        or getattr(engagement, "email_correspondant_equipe", None)
+        or getattr(engagement, "email", None)
+    )
+    if not phone and not email:
+        return None
+    return ContactInfo(
+        nom=_sanitize_name(
+            getattr(engagement, "nomCorrespondantEquipe", None)
+            or getattr(engagement, "nom", None)
+        ),
+        prenom=_sanitize_name(
+            getattr(engagement, "prenomCorrespondantEquipe", None)
+            or getattr(engagement, "prenom", None)
+        ),
+        telephone=phone,
+        email=email,
+        role="correspondant",
+    )
+
+
+def extract_entraineur_contact(
+    entraineur: GetEntraineurResponse | None, titre: str | None
+) -> ContactInfo | None:
+    """Extract contact info from an entraineur object.
+
+    If phone/email are missing we still return a name-only ContactInfo when
+    at least a name is present so callers can display a best-effort contact.
+    """
+    if not entraineur:
+        return None
+    phone = _normalize_phone(
+        getattr(entraineur, "telephonePortable", None)
+        or getattr(entraineur, "telephone_portable", None)
+        or getattr(entraineur, "telephoneDomicile", None)
+        or getattr(entraineur, "telephone_travail", None)
+        or getattr(entraineur, "telephone", None)
+    )
+    email = getattr(entraineur, "email", None) or None
+    if (
+        not phone
+        and not email
+        and not getattr(entraineur, "nom", None)
+        and not getattr(entraineur, "prenom", None)
+    ):
+        return None
+    return ContactInfo(
+        nom=_sanitize_name(getattr(entraineur, "nom", None)),
+        prenom=_sanitize_name(getattr(entraineur, "prenom", None)),
+        telephone=phone,
+        email=email,
+        role=titre,
+    )

ffbb_data_client/models/engagements_facet_distribution.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from .facet_distribution import FacetDistribution
+
+
+@dataclass
+class EngagementsFacetDistribution(FacetDistribution):
+    club_pro: dict[str, int] | None = None
+    id_competition_categorie_code: dict[str, int] | None = None
+    id_competition_categorie_libelle: dict[str, int] | None = None
+    id_competition_code: dict[str, int] | None = None
+    id_competition_nom: dict[str, int] | None = None
+    id_competition_sexe: dict[str, int] | None = None
+    id_poule_nom: dict[str, int] | None = None
+    niveau_code: dict[str, int] | None = None
+    niveau_libelle: dict[str, int] | None = None
+
+    @staticmethod
+    def from_dict(obj: Any) -> EngagementsFacetDistribution:
+        if not isinstance(obj, dict):
+            raise TypeError(f"Expected dict, got {obj.__class__.__name__}")
+        return EngagementsFacetDistribution(
+            club_pro=obj.get("clubPro"),
+            id_competition_categorie_code=obj.get("idCompetition.categorie.code"),
+            id_competition_categorie_libelle=obj.get("idCompetition.categorie.libelle"),
+            id_competition_code=obj.get("idCompetition.code"),
+            id_competition_nom=obj.get("idCompetition.nom"),
+            id_competition_sexe=obj.get("idCompetition.sexe"),
+            id_poule_nom=obj.get("idPoule.nom"),
+            niveau_code=obj.get("niveau.code"),
+            niveau_libelle=obj.get("niveau.libelle"),
+        )
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.club_pro is not None:
+            result["clubPro"] = self.club_pro
+        if self.id_competition_categorie_code is not None:
+            result["idCompetition.categorie.code"] = self.id_competition_categorie_code
+        if self.id_competition_categorie_libelle is not None:
+            result["idCompetition.categorie.libelle"] = (
+                self.id_competition_categorie_libelle
+            )
+        if self.id_competition_code is not None:
+            result["idCompetition.code"] = self.id_competition_code
+        if self.id_competition_nom is not None:
+            result["idCompetition.nom"] = self.id_competition_nom
+        if self.id_competition_sexe is not None:
+            result["idCompetition.sexe"] = self.id_competition_sexe
+        if self.id_poule_nom is not None:
+            result["idPoule.nom"] = self.id_poule_nom
+        if self.niveau_code is not None:
+            result["niveau.code"] = self.niveau_code
+        if self.niveau_libelle is not None:
+            result["niveau.libelle"] = self.niveau_libelle
+        return result

ffbb_data_client/models/engagements_facet_stats.py

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

ffbb_data_client/models/engagements_hit.py

@@ -0,0 +1,192 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from ..utils.converter_utils import (
+    from_bool,
+    from_obj,
+    from_str,
+)
+from .categorie import Categorie
+from .competition_origine import CompetitionOrigine
+from .geo import Geo
+from .hit import Hit
+from .poule import Poule
+
+
+@dataclass
+class EngagementsHit(Hit):
+    id: str | None = None
+    nom: str | None = None
+    age: str | None = None
+    sexe: str | None = None
+    club_pro: bool | None = None
+    code_abrege: str | None = None
+    code_club: str | None = None
+    code_comite: str | None = None
+    code_ligue: str | None = None
+    competitions_url: str | None = None
+    id_competition: CompetitionOrigine | None = None
+    id_poule: Poule | None = None
+    logo: str | None = None
+    niveau: Categorie | None = None
+    categorie: Categorie | None = None
+    nom_club: str | None = None
+    nom_club_pro: str | None = None
+    nom_comite: str | None = None
+    nom_ctc: str | None = None
+    nom_equipe: str | None = None
+    nom_ligue: str | None = None
+    nom_officiel: str | None = None
+    nom_organisme: str | None = None
+    nom_usuel: str | None = None
+    numero_equipe: str | None = None
+    thumbnail: str | None = None
+    gradient_color: str | None = None
+    geo: Geo | None = None
+
+    lower_nom: str | None = field(init=False, default=None, repr=False)
+    lower_nom_club: str | None = field(init=False, default=None, repr=False)
+    lower_nom_equipe: str | None = field(init=False, default=None, repr=False)
+    lower_nom_organisme: 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_nom_club = self.nom_club.lower() if self.nom_club else None
+        self.lower_nom_equipe = self.nom_equipe.lower() if self.nom_equipe else None
+        self.lower_nom_organisme = (
+            self.nom_organisme.lower() if self.nom_organisme else None
+        )
+
+    @staticmethod
+    def from_dict(obj: Any) -> EngagementsHit:
+        if not isinstance(obj, dict):
+            raise TypeError(f"Expected dict, got {obj.__class__.__name__}")
+        id = from_str(obj, "id")
+        nom = from_str(obj, "nom")
+        age = from_str(obj, "age")
+        sexe = from_str(obj, "sexe")
+        club_pro = from_bool(obj, "clubPro")
+        code_abrege = from_str(obj, "codeAbrege")
+        code_club = from_str(obj, "codeClub")
+        code_comite = from_str(obj, "codeComite")
+        code_ligue = from_str(obj, "codeLigue")
+        competitions_url = from_str(obj, "competitionsUrl")
+        id_competition = from_obj(CompetitionOrigine.from_dict, obj, "idCompetition")
+        id_poule = from_obj(Poule.from_dict, obj, "idPoule")
+        logo = from_str(obj, "logo")
+        niveau = from_obj(Categorie.from_dict, obj, "niveau")
+        categorie = from_obj(Categorie.from_dict, obj, "categorie")
+        nom_club = from_str(obj, "nomClub")
+        nom_club_pro = from_str(obj, "nomClubPro")
+        nom_comite = from_str(obj, "nomComite")
+        nom_ctc = from_str(obj, "nomCtc")
+        nom_equipe = from_str(obj, "nomEquipe")
+        nom_ligue = from_str(obj, "nomLigue")
+        nom_officiel = from_str(obj, "nomOfficiel")
+        nom_organisme = from_str(obj, "nomOrganisme")
+        nom_usuel = from_str(obj, "nomUsuel")
+        numero_equipe = from_str(obj, "numeroEquipe")
+        thumbnail = from_str(obj, "thumbnail")
+        gradient_color = from_str(obj, "gradient_color")
+        geo = from_obj(Geo.from_dict, obj, "_geo")
+        return EngagementsHit(
+            id=id,
+            nom=nom,
+            age=age,
+            sexe=sexe,
+            club_pro=club_pro,
+            code_abrege=code_abrege,
+            code_club=code_club,
+            code_comite=code_comite,
+            code_ligue=code_ligue,
+            competitions_url=competitions_url,
+            id_competition=id_competition,
+            id_poule=id_poule,
+            logo=logo,
+            niveau=niveau,
+            categorie=categorie,
+            nom_club=nom_club,
+            nom_club_pro=nom_club_pro,
+            nom_comite=nom_comite,
+            nom_ctc=nom_ctc,
+            nom_equipe=nom_equipe,
+            nom_ligue=nom_ligue,
+            nom_officiel=nom_officiel,
+            nom_organisme=nom_organisme,
+            nom_usuel=nom_usuel,
+            numero_equipe=numero_equipe,
+            thumbnail=thumbnail,
+            gradient_color=gradient_color,
+            geo=geo,
+        )
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.id is not None:
+            result["id"] = self.id
+        if self.nom is not None:
+            result["nom"] = self.nom
+        if self.age is not None:
+            result["age"] = self.age
+        if self.sexe is not None:
+            result["sexe"] = self.sexe
+        if self.club_pro is not None:
+            result["clubPro"] = self.club_pro
+        if self.code_abrege is not None:
+            result["codeAbrege"] = self.code_abrege
+        if self.code_club is not None:
+            result["codeClub"] = self.code_club
+        if self.code_comite is not None:
+            result["codeComite"] = self.code_comite
+        if self.code_ligue is not None:
+            result["codeLigue"] = self.code_ligue
+        if self.competitions_url is not None:
+            result["competitionsUrl"] = self.competitions_url
+        if self.id_competition is not None:
+            result["idCompetition"] = self.id_competition.to_dict()
+        if self.id_poule is not None:
+            result["idPoule"] = self.id_poule.to_dict()
+        if self.logo is not None:
+            result["logo"] = self.logo
+        if self.niveau is not None:
+            result["niveau"] = self.niveau.to_dict()
+        if self.categorie is not None:
+            result["categorie"] = self.categorie.to_dict()
+        if self.nom_club is not None:
+            result["nomClub"] = self.nom_club
+        if self.nom_club_pro is not None:
+            result["nomClubPro"] = self.nom_club_pro
+        if self.nom_comite is not None:
+            result["nomComite"] = self.nom_comite
+        if self.nom_ctc is not None:
+            result["nomCtc"] = self.nom_ctc
+        if self.nom_equipe is not None:
+            result["nomEquipe"] = self.nom_equipe
+        if self.nom_ligue is not None:
+            result["nomLigue"] = self.nom_ligue
+        if self.nom_officiel is not None:
+            result["nomOfficiel"] = self.nom_officiel
+        if self.nom_organisme is not None:
+            result["nomOrganisme"] = self.nom_organisme
+        if self.nom_usuel is not None:
+            result["nomUsuel"] = self.nom_usuel
+        if self.numero_equipe is not None:
+            result["numeroEquipe"] = str(self.numero_equipe)
+        if self.thumbnail is not None:
+            result["thumbnail"] = self.thumbnail
+        if self.gradient_color is not None:
+            result["gradient_color"] = self.gradient_color
+        if self.geo is not None:
+            result["_geo"] = self.geo.to_dict()
+        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_nom_club and query in self.lower_nom_club)
+            or (self.lower_nom_equipe and query in self.lower_nom_equipe)
+            or (self.lower_nom_organisme and query in self.lower_nom_organisme)
+        )

ffbb_data_client/models/engagements_multi_search_query.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from ..config import MEILISEARCH_FACETS_ENGAGEMENTS, MEILISEARCH_INDEX_ENGAGEMENTS
+from .engagements_facet_distribution import EngagementsFacetDistribution
+from .engagements_facet_stats import EngagementsFacetStats
+from .multi_search_query import MultiSearchQuery
+from .multi_search_result_engagements import EngagementsMultiSearchResult
+from .multi_search_results import MultiSearchResult
+
+
+class EngagementsMultiSearchQuery(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_ENGAGEMENTS,
+            q=q,
+            facets=MEILISEARCH_FACETS_ENGAGEMENTS,
+            limit=limit,
+            offset=offset,
+            filter=filter,
+            sort=sort,
+        )
+
+    def is_valid_result(self, result: MultiSearchResult):
+        return result and (
+            isinstance(result, EngagementsMultiSearchResult)
+            and (
+                result.facet_distribution is None
+                or isinstance(result.facet_distribution, EngagementsFacetDistribution)
+            )
+            and (
+                result.facet_stats is None
+                or isinstance(result.facet_stats, EngagementsFacetStats)
+            )
+        )

ffbb_data_client/models/etat.py

@@ -0,0 +1,6 @@
+from enum import Enum
+
+
+class Etat(Enum):
+    A = "A"
+    D = "D"

ffbb_data_client/models/external_competition_id.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from ..utils.converter_utils import (
+    from_str,
+)
+
+
+@dataclass
+class ExternalCompetitionID:
+    code: str | None = None
+    nom: str | None = None
+    sexe: str | None = None
+    type_competition: str | None = None
+
+    @staticmethod
+    def from_dict(obj: Any) -> ExternalCompetitionID:
+        assert isinstance(obj, dict)
+        code = from_str(obj, "code")
+        nom = from_str(obj, "nom")
+        sexe = from_str(obj, "sexe")
+        type_competition = from_str(obj, "typeCompetition")
+        return ExternalCompetitionID(
+            code=code,
+            nom=nom,
+            sexe=sexe,
+            type_competition=type_competition,
+        )
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.code is not None:
+            result["code"] = self.code
+        if self.nom is not None:
+            result["nom"] = self.nom
+        if self.sexe is not None:
+            result["sexe"] = self.sexe
+        if self.type_competition is not None:
+            result["typeCompetition"] = self.type_competition
+        return result