De l'UML
au Code

class Voiture:
    def __init__(self, marque: str, id: int):
        self.__marque = marque    # -  privé
        self.__vitesse: int = 0  # -  privé, défaut 0
        self._id = id             # #  protégé

    def accelerer(self, v: int) -> None:  # +
        if self.__valider_vitesse():
            self.__vitesse += v

    def __valider_vitesse(self) -> bool:  # -
        return self.__vitesse < 300

from abc import ABC, abstractmethod

class Forme(ABC):              # «abstract»
    def __init__(self, couleur: str):
        self._couleur = couleur  # # protégé

    @abstractmethod
    def aire(self) -> float:    # méth. italique
        pass

    def getCouleur(self) -> str: # concrète
        return self._couleur

# Forme()  →  TypeError (ne peut s'instancier)
# Cercle() →  OK si aire() est définie

from abc import ABC, abstractmethod

class Serialisable(ABC):  # «interface»

    @abstractmethod
    def serialiser(self) -> str: ...

    @abstractmethod
    def deserialiser(self, s: str): ...


# Réalisation ──────────────────────────
class Document(Serialisable):  # «realize»
    def serialiser(self) -> str:
        return "..."
    def deserialiser(self, s: str):
        pass

class Compteur:
    nb_instances: int = 0     # statique (souligné)

    def __init__(self):
        Compteur.nb_instances += 1

    @classmethod                # méthode statique
    def getNb(cls) -> int:
        return cls.nb_instances

# Alternative avec @staticmethod
# si pas d'accès à cls/self

from abc import ABC, abstractmethod

class Animal(ABC):
    def __init__(self, nom: str):
        self.nom = nom

    @abstractmethod
    def parler(self) -> str: ...


class Chien(Animal):           # ──▷ Animal
    def __init__(self, nom: str):
        super().__init__(nom)     # toujours !
    def parler(self) -> str:
        return "Wouf"

class Chat(Animal):            # ──▷ Animal
    def parler(self) -> str:
        return "Miaou"

class Piece:
    def __init__(self, nom: str):
        self.nom = nom

class Maison:             # ◆── Pièce
    def __init__(self, nb_pieces: int):
        # Créées ICI → composition
        self.pieces = [
            Piece(f"Pièce {i+1}")
            for i in range(nb_pieces)
        ]

# Quand maison = None → pieces perdues aussi

class Joueur:
    def __init__(self, nom: str):
        self.nom = nom

class Equipe:              # ◇── Joueur
    def __init__(self):
        self.joueurs: list[Joueur] = []

    def ajouter(self, j: Joueur):
        self.joueurs.append(j)  # reçu !

# Equipe dissoute → joueurs survivent

from __future__ import annotations
from typing import Optional

class Client:
    def __init__(self, nom: str):
        self.nom = nom
        # 1     → objet direct
        self.compte: Compte

        # 0..1  → Optional
        self.fidélité: Optional[CarteF] = None

        # *     → liste
        self.commandes: list[Commande] = []

        # non ord. unique → set
        self.tags: set[str] = set()

class Rapport:
    # Rapport - -▶ Formateur
    # Formateur utilisé seulement dans generer()
    # → pas d'attribut self.formateur !

    def generer(self, fmt: Formateur) -> str:
        return fmt.formater(self.contenu)

    def exporter(self) -> None:
        # usage local seulement
        logger = Logger()
        logger.log("export")

import pytest
from auth import AuthService, AuthException

class TestSeConnecter:
    # Scénario principal ─────────────────
    def test_identifiants_valides(self, svc):
        token = svc.connecter("alice", "pass")
        assert token is not None
        assert len(token) > 0

    # Scénario alternatif ────────────────
    def test_mauvais_mot_de_passe(self, svc):
        with pytest.raises(AuthException):
            svc.connecter("alice", "faux")

    # Précondition ────────────────────────
    def test_utilisateur_inconnu(self, svc):
        with pytest.raises(AuthException):
            svc.connecter("inconnu", "x")

class AuthController:
    def __init__(self):
        self.svc = UserService()    # create

    def connecter(self, user, pw) -> str:
        # msg 1 : valider(user, pass)
        return self.svc.valider(user, pw)

class UserService:
    def __init__(self):
        self.db = Database()

    def valider(self, user, pw) -> str:
        # alt [valide] ──────────────────
        u = self.db.findUser(user)  # msg2
        if u and u.check(pw):       # [valide]
            return generer_token(u)  # retour
        # alt [invalide] ─────────────────
        raise AuthException(         # retour
            "Identifiants invalides"
        )