ffbb-api-client-v2 1.0__py3-none-any.whl

ffbb_api_client_v2/Affiche.py

@@ -0,0 +1,34 @@
+from typing import Any, Optional
+from uuid import UUID
+
+from .converters import from_int, from_none, from_str, from_union
+
+
+class Affiche:
+    affiche_id: Optional[UUID] = None
+    gradient_color: Optional[str] = None
+    width: Optional[int] = None
+    height: Optional[int] = None
+
+    @staticmethod
+    def from_dict(obj: Any) -> "Affiche":
+        assert isinstance(obj, dict)
+        affiche_id = from_union([lambda x: UUID(x), from_none], obj.get("id"))
+        gradient_color = from_union([from_none, from_str], obj.get("gradient_color"))
+        width = from_union([from_int, from_none], obj.get("width"))
+        height = from_union([from_int, from_none], obj.get("height"))
+        return Affiche(affiche_id, gradient_color, width, height)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.affiche_id is not None:
+            result["id"] = from_union([lambda x: str(x), from_none], self.affiche_id)
+        if self.gradient_color is not None:
+            result["gradient_color"] = from_union(
+                [from_none, from_str], self.gradient_color
+            )
+        if self.width is not None:
+            result["width"] = from_union([from_int, from_none], self.width)
+        if self.height is not None:
+            result["height"] = from_union([from_int, from_none], self.height)
+        return result

ffbb_api_client_v2/Cartographie.py

@@ -0,0 +1,120 @@
+from typing import Any, Optional
+
+from .converters import (
+    from_float,
+    from_none,
+    from_str,
+    from_union,
+    is_type,
+    to_class,
+    to_float,
+)
+from .Coordonnees import Coordonnees
+
+
+class Cartographie:
+    adresse: Optional[str] = None
+    code_postal: Optional[int] = None
+    coordonnees: Optional[Coordonnees] = None
+    date_created: None
+    date_updated: None
+    cartographie_id: Optional[str] = None
+    latitude: Optional[float] = None
+    longitude: Optional[float] = None
+    title: Optional[str] = None
+    ville: Optional[str] = None
+    status: Optional[str] = None
+
+    def __init__(
+        self,
+        adresse: Optional[str],
+        code_postal: Optional[int],
+        coordonnees: Optional[Coordonnees],
+        date_created: None,
+        date_updated: None,
+        id: Optional[str],
+        latitude: Optional[float],
+        longitude: Optional[float],
+        title: Optional[str],
+        ville: Optional[str],
+        status: Optional[str],
+    ):
+        self.adresse = adresse
+        self.code_postal = code_postal
+        self.coordonnees = coordonnees
+        self.date_created = date_created
+        self.date_updated = date_updated
+        self.cartographie_id = id
+        self.latitude = latitude
+        self.longitude = longitude
+        self.title = title
+        self.ville = ville
+        self.status = status
+
+    @staticmethod
+    def from_dict(obj: Any) -> "Cartographie":
+        assert isinstance(obj, dict)
+        adresse = from_union([from_str, from_none], obj.get("adresse"))
+        code_postal = from_union(
+            [lambda x: int(from_str(x)), from_none], obj.get("codePostal")
+        )
+        coordonnees = from_union(
+            [Coordonnees.from_dict, from_none], obj.get("coordonnees")
+        )
+        date_created = from_none(obj.get("date_created"))
+        date_updated = from_none(obj.get("date_updated"))
+        cartographie_id = from_union([from_str, from_none], obj.get("id"))
+        latitude = from_union([from_float, from_none], obj.get("latitude"))
+        longitude = from_union([from_float, from_none], obj.get("longitude"))
+        title = from_union([from_str, from_none], obj.get("title"))
+        ville = from_union([from_str, from_none], obj.get("ville"))
+        status = from_union([from_str, from_none], obj.get("status"))
+        return Cartographie(
+            adresse,
+            code_postal,
+            coordonnees,
+            date_created,
+            date_updated,
+            cartographie_id,
+            latitude,
+            longitude,
+            title,
+            ville,
+            status,
+        )
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.adresse is not None:
+            result["adresse"] = from_union([from_str, from_none], self.adresse)
+        if self.code_postal is not None:
+            result["codePostal"] = from_union(
+                [
+                    lambda x: from_none((lambda x: is_type(type(None), x))(x)),
+                    lambda x: from_str(
+                        (lambda x: str((lambda x: is_type(int, x))(x)))(x)
+                    ),
+                ],
+                self.code_postal,
+            )
+        if self.coordonnees is not None:
+            result["coordonnees"] = from_union(
+                [lambda x: to_class(Coordonnees, x), from_none], self.coordonnees
+            )
+        if self.date_created is not None:
+            result["date_created"] = from_none(self.date_created)
+        if self.date_updated is not None:
+            result["date_updated"] = from_none(self.date_updated)
+        if self.cartographie_id is not None:
+            result["id"] = from_union([from_str, from_none], self.cartographie_id)
+        if self.latitude is not None:
+            result["latitude"] = from_union([to_float, from_none], self.latitude)
+        if self.longitude is not None:
+            result["longitude"] = from_union([to_float, from_none], self.longitude)
+        if self.title is not None:
+            result["title"] = from_union([from_str, from_none], self.title)
+        if self.ville is not None:
+            result["ville"] = from_union([from_str, from_none], self.ville)
+        if self.status is not None:
+            result["status"] = from_union([from_str, from_none], self.status)
+        return result

ffbb_api_client_v2/Categorie.py

@@ -0,0 +1,60 @@
+from datetime import datetime
+from typing import Any, Optional
+
+from .converters import from_datetime, from_int, from_none, from_str, from_union
+
+
+class Categorie:
+    code: Optional[str] = None
+    date_created: Optional[datetime] = None
+    date_updated: Optional[datetime] = None
+    categorie_id: Optional[str] = None
+    libelle: Optional[str] = None
+    ordre: Optional[int] = None
+
+    def __init__(
+        self,
+        code: Optional[str] = None,
+        date_created: Optional[datetime] = None,
+        date_updated: Optional[datetime] = None,
+        id: Optional[str] = None,
+        libelle: Optional[str] = None,
+        ordre: Optional[int] = None,
+    ) -> None:
+        self.code = code
+        self.date_created = date_created
+        self.date_updated = date_updated
+        self.categorie_id = id
+        self.libelle = libelle
+        self.ordre = ordre
+
+    @staticmethod
+    def from_dict(obj: Any) -> "Categorie":
+        assert isinstance(obj, dict)
+        code = from_union([from_str, from_none], obj.get("code"))
+        date_created = from_union([from_datetime, from_none], obj.get("date_created"))
+        date_updated = from_union([from_datetime, from_none], obj.get("date_updated"))
+        categorie_id = from_union([from_str, from_none], obj.get("id"))
+        libelle = from_union([from_str, from_none], obj.get("libelle"))
+        ordre = from_union([from_int, from_none], obj.get("ordre"))
+        return Categorie(code, date_created, date_updated, categorie_id, libelle, ordre)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.code is not None:
+            result["code"] = from_union([from_str, from_none], self.code)
+        if self.date_created is not None:
+            result["date_created"] = from_union(
+                [lambda x: x.isoformat(), from_none], self.date_created
+            )
+        if self.date_updated is not None:
+            result["date_updated"] = from_union(
+                [lambda x: x.isoformat(), from_none], self.date_updated
+            )
+        if self.categorie_id is not None:
+            result["id"] = from_union([from_str, from_none], self.categorie_id)
+        if self.libelle is not None:
+            result["libelle"] = from_union([from_str, from_none], self.libelle)
+        if self.ordre is not None:
+            result["ordre"] = from_union([from_int, from_none], self.ordre)
+        return result

ffbb_api_client_v2/Code.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+
+class Code(Enum):
+    BIT = "BIT"
+    BT = "BT"
+    SS = "SS"

ffbb_api_client_v2/Commune.py

@@ -0,0 +1,95 @@
+from datetime import datetime
+from typing import Any, Optional
+
+from .converters import from_datetime, from_none, from_str, from_union, is_type
+
+
+class Commune:
+    code_insee: None
+    code_postal: Optional[int] = None
+    date_created: Optional[datetime] = None
+    date_updated: Optional[datetime] = None
+    commune_id: Optional[int] = None
+    libelle: Optional[str] = None
+    departement: Optional[str] = None
+
+    def __init__(
+        self,
+        code_insee: None,
+        code_postal: Optional[int],
+        date_created: Optional[datetime],
+        date_updated: Optional[datetime],
+        id: Optional[int],
+        libelle: Optional[str],
+        departement: Optional[str],
+    ):
+        self.code_insee = code_insee
+        self.code_postal = code_postal
+        self.date_created = date_created
+        self.date_updated = date_updated
+        self.commune_id = id
+        self.libelle = libelle
+        self.lower_libelle = libelle.lower() if libelle else None
+
+        self.departement = departement
+        self.lower_departement = departement.lower() if departement else None
+
+    @staticmethod
+    def from_dict(obj: Any) -> "Commune":
+        assert isinstance(obj, dict)
+        code_insee = from_none(obj.get("codeInsee"))
+        code_postal = from_union(
+            [lambda x: int(from_str(x)), from_none], obj.get("codePostal")
+        )
+        date_created = from_union([from_datetime, from_none], obj.get("date_created"))
+        date_updated = from_union([from_datetime, from_none], obj.get("date_updated"))
+        commune_id = from_union([lambda x: int(from_str(x)), from_none], obj.get("id"))
+        libelle = from_union([from_str, from_none], obj.get("libelle"))
+        departement = from_union([from_str, from_none], obj.get("departement"))
+        return Commune(
+            code_insee,
+            code_postal,
+            date_created,
+            date_updated,
+            commune_id,
+            libelle,
+            departement,
+        )
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.code_insee is not None:
+            result["codeInsee"] = from_none(self.code_insee)
+        if self.code_postal is not None:
+            result["codePostal"] = from_union(
+                [
+                    lambda x: from_none((lambda x: is_type(type(None), x))(x)),
+                    lambda x: from_str(
+                        (lambda x: str((lambda x: is_type(int, x))(x)))(x)
+                    ),
+                ],
+                self.code_postal,
+            )
+        if self.date_created is not None:
+            result["date_created"] = from_union(
+                [lambda x: x.isoformat(), from_none], self.date_created
+            )
+        if self.date_updated is not None:
+            result["date_updated"] = from_union(
+                [lambda x: x.isoformat(), from_none], self.date_updated
+            )
+        if self.commune_id is not None:
+            result["id"] = from_union(
+                [
+                    lambda x: from_none((lambda x: is_type(type(None), x))(x)),
+                    lambda x: from_str(
+                        (lambda x: str((lambda x: is_type(int, x))(x)))(x)
+                    ),
+                ],
+                self.commune_id,
+            )
+        if self.libelle is not None:
+            result["libelle"] = from_union([from_str, from_none], self.libelle)
+        if self.departement is not None:
+            result["departement"] = from_union([from_str, from_none], self.departement)
+        return result

ffbb_api_client_v2/CompetitionID.py

@@ -0,0 +1,170 @@
+from typing import Any, Optional
+
+from .CompetitionIDCategorie import CompetitionIDCategorie
+from .CompetitionIDTypeCompetitionGenerique import CompetitionIDTypeCompetitionGenerique
+from .CompetitionOrigine import CompetitionOrigine
+from .converters import from_bool, from_none, from_str, from_union, to_class
+from .logo import Logo
+
+
+class CompetitionID:
+    id: Optional[str] = None
+    nom: Optional[str] = None
+    competition_origine_nom: Optional[str] = None
+    code: Optional[str] = None
+    creation_en_cours: Optional[bool] = None
+    live_stat: Optional[bool] = None
+    publication_internet: Optional[str] = None
+    sexe: Optional[str] = None
+    type_competition: Optional[str] = None
+    pro: Optional[bool] = None
+    logo: Logo
+    categorie: Optional[str] = None
+    type_competition_generique: Optional[CompetitionIDTypeCompetitionGenerique] = None
+    competition_origine: Optional[CompetitionOrigine] = None
+    nom_extended: Optional[str] = None
+
+    def __init__(
+        self,
+        id: Optional[str],
+        nom: Optional[str],
+        competition_origine_nom: Optional[str],
+        code: Optional[str],
+        creation_en_cours: Optional[bool],
+        live_stat: Optional[bool],
+        publication_internet: Optional[str],
+        sexe: Optional[str],
+        type_competition: Optional[str],
+        pro: Optional[bool],
+        logo: Logo,
+        categorie: Optional[str],
+        type_competition_generique: Optional[CompetitionIDTypeCompetitionGenerique],
+        competition_origine: Optional[CompetitionOrigine],
+        nom_extended: Optional[str],
+    ) -> None:
+        self.id = id
+        self.nom = nom
+        self.competition_origine_nom = competition_origine_nom
+        self.code = code
+        self.creation_en_cours = creation_en_cours
+        self.live_stat = live_stat
+        self.publication_internet = publication_internet
+        self.sexe = sexe
+        self.type_competition = type_competition
+        self.pro = pro
+        self.logo = logo
+        self.categorie = categorie
+        self.type_competition_generique = type_competition_generique
+        self.competition_origine = competition_origine
+        self.nom_extended = nom_extended
+
+    @staticmethod
+    def from_dict(obj: Any) -> "CompetitionID":
+        try:
+            assert isinstance(obj, dict)
+            id = from_union([from_str, from_none], obj.get("id"))
+            nom = from_union([from_str, from_none], obj.get("nom"))
+            competition_origine_nom = from_union(
+                [from_str, from_none], obj.get("competition_origine_nom")
+            )
+            code = from_union([from_str, from_none], obj.get("code"))
+            creation_en_cours = from_union(
+                [from_bool, from_none], obj.get("creationEnCours")
+            )
+            live_stat = from_union([from_bool, from_none], obj.get("liveStat"))
+            publication_internet = from_union(
+                [from_str, from_none], obj.get("publicationInternet")
+            )
+            sexe = from_union([from_str, from_none], obj.get("sexe"))
+            type_competition = from_union(
+                [from_str, from_none], obj.get("typeCompetition")
+            )
+            pro = from_union([from_bool, from_none], obj.get("pro"))
+            logo = from_union([Logo.from_dict, from_none], obj.get("logo"))
+            categorie = from_union(
+                [CompetitionIDCategorie.from_dict, from_none], obj.get("categorie")
+            )
+            type_competition_generique = from_union(
+                [CompetitionIDTypeCompetitionGenerique.from_dict, from_none],
+                obj.get("typeCompetitionGenerique"),
+            )
+            competition_origine = from_union(
+                [CompetitionOrigine.from_dict, from_none],
+                obj.get("competition_origine"),
+            )
+            nom_extended = from_union([from_str, from_none], obj.get("nomExtended"))
+            return CompetitionID(
+                id,
+                nom,
+                competition_origine_nom,
+                code,
+                creation_en_cours,
+                live_stat,
+                publication_internet,
+                sexe,
+                type_competition,
+                pro,
+                logo,
+                categorie,
+                type_competition_generique,
+                competition_origine,
+                nom_extended,
+            )
+        except Exception as e:
+            raise ValueError("Invalid CompetitionID object") from e
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.id is not None:
+            result["id"] = from_union([from_str, from_none], self.id)
+        if self.nom is not None:
+            result["nom"] = from_union([from_str, from_none], self.nom)
+        if self.competition_origine_nom is not None:
+            result["competition_origine_nom"] = from_union(
+                [from_str, from_none], self.competition_origine_nom
+            )
+        if self.code is not None:
+            result["code"] = from_union([from_str, from_none], self.code)
+        if self.creation_en_cours is not None:
+            result["creationEnCours"] = from_union(
+                [from_bool, from_none], self.creation_en_cours
+            )
+        if self.live_stat is not None:
+            result["liveStat"] = from_union([from_bool, from_none], self.live_stat)
+        if self.publication_internet is not None:
+            result["publicationInternet"] = from_union(
+                [from_str, from_none],
+                self.publication_internet,
+            )
+        if self.sexe is not None:
+            result["sexe"] = from_union([from_str, from_none], self.sexe)
+        if self.type_competition is not None:
+            result["typeCompetition"] = from_union(
+                [from_str, from_none],
+                self.type_competition,
+            )
+        if self.pro is not None:
+            result["pro"] = from_union([from_bool, from_none], self.pro)
+        if self.logo is not None:
+            result["logo"] = from_none(self.logo)
+        if self.categorie is not None:
+            result["categorie"] = from_union(
+                [lambda x: to_class(CompetitionIDCategorie, x), from_none],
+                self.categorie,
+            )
+        if self.type_competition_generique is not None:
+            result["typeCompetitionGenerique"] = from_union(
+                [
+                    lambda x: to_class(CompetitionIDTypeCompetitionGenerique, x),
+                    from_none,
+                ],
+                self.type_competition_generique,
+            )
+        if self.competition_origine is not None:
+            result["competition_origine"] = from_union(
+                [lambda x: to_class(CompetitionOrigine, x), from_none],
+                self.competition_origine,
+            )
+        if self.nom_extended is not None:
+            result["nomExtended"] = from_union([from_str, from_none], self.nom_extended)
+        return result

ffbb_api_client_v2/CompetitionIDCategorie.py

@@ -0,0 +1,34 @@
+from typing import Any, Optional
+
+from .converters import from_int, from_none, from_str, from_union
+
+
+class CompetitionIDCategorie:
+    code: Optional[str] = None
+    libelle: Optional[str] = None
+    ordre: Optional[int] = None
+
+    def __init__(
+        self, code: Optional[str], libelle: Optional[str], ordre: Optional[int]
+    ) -> None:
+        self.code = code
+        self.libelle = libelle
+        self.ordre = ordre
+
+    @staticmethod
+    def from_dict(obj: Any) -> "CompetitionIDCategorie":
+        assert isinstance(obj, dict)
+        code = from_union([from_str, from_none], obj.get("code"))
+        libelle = from_union([from_str, from_none], obj.get("libelle"))
+        ordre = from_union([from_int, from_none], obj.get("ordre"))
+        return CompetitionIDCategorie(code, libelle, ordre)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.code is not None:
+            result["code"] = from_union([from_str, from_none], self.code)
+        if self.libelle is not None:
+            result["libelle"] = from_union([from_str, from_none], self.libelle)
+        if self.ordre is not None:
+            result["ordre"] = from_union([from_int, from_none], self.ordre)
+        return result

ffbb_api_client_v2/CompetitionIDSexe.py

@@ -0,0 +1,34 @@
+from typing import Any, Optional
+
+from .converters import from_int, from_none, from_union
+
+
+class CompetitionIDSexe:
+    féminin: Optional[int] = None
+    masculin: Optional[int] = None
+    mixte: Optional[int] = None
+
+    def __init__(
+        self, féminin: Optional[int], masculin: Optional[int], mixte: Optional[int]
+    ) -> None:
+        self.féminin = féminin
+        self.masculin = masculin
+        self.mixte = mixte
+
+    @staticmethod
+    def from_dict(obj: Any) -> "CompetitionIDSexe":
+        assert isinstance(obj, dict)
+        féminin = from_union([from_int, from_none], obj.get("Féminin"))
+        masculin = from_union([from_int, from_none], obj.get("Masculin"))
+        mixte = from_union([from_int, from_none], obj.get("Mixte"))
+        return CompetitionIDSexe(féminin, masculin, mixte)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.féminin is not None:
+            result["Féminin"] = from_union([from_int, from_none], self.féminin)
+        if self.masculin is not None:
+            result["Masculin"] = from_union([from_int, from_none], self.masculin)
+        if self.mixte is not None:
+            result["Mixte"] = from_union([from_int, from_none], self.mixte)
+        return result

ffbb_api_client_v2/CompetitionIDTypeCompetition.py

@@ -0,0 +1,27 @@
+from typing import Any, Optional
+
+from .converters import from_int, from_none, from_union
+
+
+class CompetitionIDTypeCompetition:
+    championnat: Optional[int] = None
+    coupe: Optional[int] = None
+
+    def __init__(self, championnat: Optional[int], coupe: Optional[int]) -> None:
+        self.championnat = championnat
+        self.coupe = coupe
+
+    @staticmethod
+    def from_dict(obj: Any) -> "CompetitionIDTypeCompetition":
+        assert isinstance(obj, dict)
+        championnat = from_union([from_int, from_none], obj.get("Championnat"))
+        coupe = from_union([from_int, from_none], obj.get("Coupe"))
+        return CompetitionIDTypeCompetition(championnat, coupe)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.championnat is not None:
+            result["Championnat"] = from_union([from_int, from_none], self.championnat)
+        if self.coupe is not None:
+            result["Coupe"] = from_union([from_int, from_none], self.coupe)
+        return result

ffbb_api_client_v2/CompetitionIDTypeCompetitionGenerique.py

@@ -0,0 +1,27 @@
+from typing import Any, Optional
+
+from .converters import from_none, from_union, to_class
+from .IDOrganismeEquipe1Logo import IDOrganismeEquipe1Logo
+
+
+class CompetitionIDTypeCompetitionGenerique:
+    logo: Optional[IDOrganismeEquipe1Logo] = None
+
+    def __init__(self, logo: Optional[IDOrganismeEquipe1Logo]) -> None:
+        self.logo = logo
+
+    @staticmethod
+    def from_dict(obj: Any) -> "CompetitionIDTypeCompetitionGenerique":
+        assert isinstance(obj, dict)
+        logo = from_union(
+            [IDOrganismeEquipe1Logo.from_dict, from_none], obj.get("logo")
+        )
+        return CompetitionIDTypeCompetitionGenerique(logo)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.logo is not None:
+            result["logo"] = from_union(
+                [lambda x: to_class(IDOrganismeEquipe1Logo, x), from_none], self.logo
+            )
+        return result