Classes et dataclasses en Python (POO)

# classe.py : une classe Serveur, ses attributs et ses méthodes
class Serveur:
    """Un serveur du parc."""

    def __init__(self, nom, ip, systeme):
        self.nom = nom              # attributs propres à chaque objet
        self.ip = ip
        self.systeme = systeme
        self.en_service = True

    def est_linux(self):
        return self.systeme.startswith(("Debian", "Ubuntu"))

    def mettre_hors_service(self):
        self.en_service = False

    def __str__(self):              # ce qu'affiche print()
        etat = "en service" if self.en_service else "hors service"
        return f"{self.nom} ({self.ip}, {self.systeme}) : {etat}"

    def __repr__(self):             # ce qu'affiche la console, et une liste d'objets
        return f"Serveur({self.nom!r}, {self.ip!r}, {self.systeme!r})"


ad = Serveur("srv-ad", "192.168.10.177", "Windows Server 2025")
journaux = Serveur("srv-journaux", "192.168.10.180", "Debian 13")
journaux.mettre_hors_service()

print(ad)
print(journaux)
print(ad.est_linux(), journaux.est_linux())
print([ad, journaux])

srv-ad (192.168.10.177, Windows Server 2025) : en service
srv-journaux (192.168.10.180, Debian 13) : hors service
False True
[Serveur('srv-ad', '192.168.10.177', 'Windows Server 2025'), Serveur('srv-journaux', '192.168.10.180', 'Debian 13')]

# propriete.py : un attribut calculé et un attribut protégé par une validation
class Volume:
    def __init__(self, nom, capacite_go, utilise_go):
        self.nom = nom
        self.capacite_go = capacite_go
        self.utilise_go = utilise_go        # passe par le setter ci-dessous

    @property
    def taux(self):
        """Taux d'occupation en pourcentage, calculé à chaque lecture."""
        return self.utilise_go / self.capacite_go * 100

    @property
    def utilise_go(self):
        return self._utilise_go

    @utilise_go.setter
    def utilise_go(self, valeur):
        if not 0 <= valeur <= self.capacite_go:
            raise ValueError(f"{self.nom} : {valeur} Go utilisés pour {self.capacite_go} Go")
        self._utilise_go = valeur


partages = Volume("partages", 500, 437.5)
print(f"{partages.taux:.1f} %")
partages.utilise_go = 450
print(f"{partages.taux:.1f} %")
partages.utilise_go = 520

87.5 %
90.0 %
Traceback (most recent call last):
  File "/home/etudiant/cours-python/propriete.py", line 28, in <module>
    partages.utilise_go = 520
    ^^^^^^^^^^^^^^^^^^^
  File "/home/etudiant/cours-python/propriete.py", line 20, in utilise_go
    raise ValueError(f"{self.nom} : {valeur} Go utilisés pour {self.capacite_go} Go")
ValueError: partages : 520 Go utilisés pour 500 Go

# heritage.py : une classe mère Machine et deux classes filles
class Machine:
    def __init__(self, nom, ip):
        self.nom = nom
        self.ip = ip

    def description(self):
        return f"{self.nom} ({self.ip})"


class Serveur(Machine):
    def __init__(self, nom, ip, role):
        super().__init__(nom, ip)       # la classe mère initialise nom et ip
        self.role = role

    def description(self):              # redéfinition
        return f"Serveur {super().description()} : {self.role}"


class Imprimante(Machine):
    def __init__(self, nom, ip, toner):
        super().__init__(nom, ip)
        self.toner = toner

    def description(self):
        alerte = " - toner à commander" if self.toner < 15 else ""
        return f"Imprimante {super().description()}, toner {self.toner} %{alerte}"


parc = [Serveur("srv-nas", "192.168.10.183", "stockage TrueNAS"),
        Imprimante("IMP-COMPTA", "192.168.10.88", 12),
        Machine("PC-0042", "192.168.10.92")]

for machine in parc:
    print(machine.description())          # chaque objet utilise SA méthode
print(isinstance(parc[0], Machine), isinstance(parc[2], Serveur))

Serveur srv-nas (192.168.10.183) : stockage TrueNAS
Imprimante IMP-COMPTA (192.168.10.88), toner 12 % - toner à commander
PC-0042 (192.168.10.92)
True False

# donnees.py : des dataclasses pour l'inventaire
import json
from dataclasses import asdict, dataclass, field
from datetime import date
from enum import StrEnum


class Etat(StrEnum):
    EN_SERVICE = "en service"
    EN_STOCK = "en stock"
    REBUT = "rebut"


@dataclass
class Poste:
    nom: str
    service: str
    fin_garantie: date
    etat: Etat = Etat.EN_SERVICE
    logiciels: list[str] = field(default_factory=list)    # une nouvelle liste par objet

    def sous_garantie(self, jour: date) -> bool:
        return jour <= self.fin_garantie


p1 = Poste("PC-0012", "Comptabilité", date(2025, 3, 15), logiciels=["Sage 100"])
p2 = Poste("PC-0050", "Logistique", date(2028, 2, 17))
print(p1)
print(p1.sous_garantie(date(2026, 11, 8)), p2.sous_garantie(date(2026, 11, 8)))
print(p2 == Poste("PC-0050", "Logistique", date(2028, 2, 17)))

p2.etat = Etat("en stock")                 # retrouver un membre de l'énumération par sa valeur
print(repr(p2.etat), p2.etat)

dico = asdict(p1)
print(json.dumps(dico, default=str, ensure_ascii=False))

Poste(nom='PC-0012', service='Comptabilité', fin_garantie=datetime.date(2025, 3, 15), etat=<Etat.EN_SERVICE: 'en service'>, logiciels=['Sage 100'])
False True
True
<Etat.EN_STOCK: 'en stock'> en stock
{"nom": "PC-0012", "service": "Comptabilité", "fin_garantie": "2025-03-15", "etat": "en service", "logiciels": ["Sage 100"]}