# En Python, TOUT est objet -- meme les classes sont des instances (de "type")
class MaClasse:
    pass

print(type(MaClasse))          # <class 'type'>
print(type(42))                 # <class 'int'>
print(type(int))                 # <class 'type'>
print(isinstance(MaClasse, type))  # True

# --- Metaclasses : les "classes des classes" ---
# type() peut aussi CREER une classe dynamiquement : type(nom, bases, namespace)
Dynamique = type("Dynamique", (), {"x": 1, "dire_bonjour": lambda self: "bonjour"})
instance = Dynamique()
print(instance.x, instance.dire_bonjour())

# Definir une metaclasse personnalisee : herite de "type"
class MetaValidation(type):
    def __new__(mcs, nom, bases, namespace):
        # s'execute a la CREATION de la classe, pas de l'instance
        for attr_nom, attr_valeur in namespace.items():
            if callable(attr_valeur) and not attr_nom.startswith("__"):
                print(f"Methode enregistree : {attr_nom}")
        return super().__new__(mcs, nom, bases, namespace)

class MonService(metaclass=MetaValidation):
    def traiter(self):
        pass
    def valider(self):
        pass
# Affiche "Methode enregistree : traiter" et "Methode enregistree : valider"
# au moment de la DEFINITION de la classe, avant meme toute instanciation

# Cas d'usage reel : pattern Singleton via metaclasse
class MetaSingleton(type):
    _instances = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super().__call__(*args, **kwargs)
        return cls._instances[cls]

class Configuration(metaclass=MetaSingleton):
    def __init__(self):
        self.parametres = {}

c1, c2 = Configuration(), Configuration()
print(c1 is c2)      # True

# __init_subclass__ : alternative souvent plus simple qu'une metaclasse (Python 3.6+)
class RegistrePlugin:
    plugins = []
    def __init_subclass__(cls, **kwargs):
        super().__init_subclass__(**kwargs)
        RegistrePlugin.plugins.append(cls)     # auto-enregistrement a chaque sous-classe

class PluginA(RegistrePlugin):
    pass

class PluginB(RegistrePlugin):
    pass

print(RegistrePlugin.plugins)     # [PluginA, PluginB]

# --- Descriptors : le protocole derriere @property, methodes, slots ---
class Positif:
    """Descriptor validant qu'une valeur numerique reste positive."""
    def __set_name__(self, owner, name):
        self.nom_prive = f"_{name}"

    def __get__(self, instance, owner):
        if instance is None:
            return self
        return getattr(instance, self.nom_prive, 0)

    def __set__(self, instance, valeur):
        if valeur < 0:
            raise ValueError(f"{self.nom_prive} doit etre positif")
        setattr(instance, self.nom_prive, valeur)

class Produit:
    prix = Positif()          # descriptor partage, mais stocke une valeur par instance
    quantite = Positif()

    def __init__(self, prix, quantite):
        self.prix = prix           # declenche Positif.__set__
        self.quantite = quantite

p = Produit(10, 5)
print(p.prix)                  # declenche Positif.__get__
try:
    p.prix = -5
except ValueError as e:
    print(f"Refuse : {e}")

# __slots__ : optimisation memoire, empeche la creation dynamique d'attributs
class PointOptimise:
    __slots__ = ("x", "y")     # pas de __dict__ par instance -> memoire reduite

    def __init__(self, x, y):
        self.x = x
        self.y = y

pt = PointOptimise(1, 2)
try:
    pt.z = 3          # AttributeError : __slots__ interdit les attributs non declares
except AttributeError as e:
    print(f"Refuse : {e}")

import sys
print(sys.getsizeof(pt))    # sensiblement plus petit qu'un objet equivalent sans __slots__