class Dummy:
    pass

print(type(Dummy))  # Виведе: <class 'type'>

# dynamic_class.py

# 1. Класичний опис класу
class User:
    species = "Homo sapiens"

    def __init__(self, username: str):
        self.username = username

    def greet(self) -> str:
        return f"Вітаю, я {self.username}!"


# 2. Динамічне створення еквівалентного класу через type()
def user_init(self, username: str):
    self.username = username

def user_greet(self) -> str:
    return f"Вітаю, я {self.username}!"

# Створюємо клас і записуємо в змінну DynamicUser
DynamicUser = type(
    "User",                 # Ім'я класу
    (object,),              # Кортеж базових класів (наслідуємось від object)
    {
        "species": "Homo sapiens",   # Атрибут класу
        "__init__": user_init,       # Метод ініціалізації
        "greet": user_greet,         # Звичайний метод
    }
)

# Продовження dynamic_class.py

# Створюємо екземпляр звичайного класу
user1 = User("arakviel")
print(f"User 1: {user1.greet()} ({user1.species})")

# Створюємо екземпляр динамічного класу
user2 = DynamicUser("kostyl_dev")
print(f"User 2: {user2.greet()} ({user2.species})")

# Перевіряємо їхні класи
print(f"Тип User: {type(User)}")
print(f"Тип DynamicUser: {type(DynamicUser)}")
print(f"Чи є user2 екземпляром DynamicUser? {isinstance(user2, DynamicUser)}")

# type_hierarchy.py

class Animal:
    pass

class Dog(Animal):
    pass

d = Dog()

# Звичайна ієрархія екземпляра
print(type(d))          # <class '__main__.Dog'>
print(type(Dog))        # <class 'type'>       ← клас Dog є об'єктом type
print(type(Animal))     # <class 'type'>
print(type(type))       # <class 'type'>       ← type є об'єктом самого себе!

# Ієрархія наслідування (між класами)
print(Dog.__bases__)    # (<class '__main__.Animal'>,)
print(Animal.__bases__) # (<class 'object'>,)
print(type.__bases__)   # (<class 'object'>,) ← type наслідується від object
print(object.__bases__) # ()                   ← object є коренем ієрархії

class MyMeta(type):
    ...

class MyClass(metaclass=MyMeta):
    ...

# first_metaclass.py

class LoggingMeta(type):
    """Метаклас-спостерігач: логує кожне створення класу."""

    def __new__(mcs, name: str, bases: tuple, namespace: dict):
        print(f"[META __new__] Починаємо створення класу '{name}'")
        print(f"  Базові класи: {[b.__name__ for b in bases]}")
        print(f"  Атрибути простору імен: {[k for k in namespace if not k.startswith('__')]}")

        # Делегуємо реальне створення класу базовому type.__new__
        cls = super().__new__(mcs, name, bases, namespace)
        print(f"[META __new__] Клас '{name}' створено. Об'єкт: {cls}")
        return cls

    def __init__(cls, name: str, bases: tuple, namespace: dict):
        print(f"[META __init__] Ініціалізуємо клас '{name}'")
        super().__init__(name, bases, namespace)
        print(f"[META __init__] Клас '{name}' готовий до використання.\n")


# Оголошуємо класи з нашим метакласом
class Vehicle(metaclass=LoggingMeta):
    max_speed: int = 0

    def move(self) -> str:
        return "Рухаюсь"


class Car(Vehicle):  # Car теж отримає LoggingMeta через спадкування!
    max_speed: int = 200

    def honk(self) -> str:
        return "Бі-бі!"

# strict_model_meta.py
from typing import Any


class StrictModelMeta(type):
    """
    Метаклас для ORM-моделей.
    Гарантує, що кожна не-абстрактна модель визначає __tablename__.
    """
    _REQUIRED_ATTRS = {"__tablename__"}

    def __new__(mcs, name: str, bases: tuple, namespace: dict) -> type:
        cls = super().__new__(mcs, name, bases, namespace)

        # Пропускаємо сам базовий клас Model та абстрактні класи
        is_base = not bases  # клас без батьків — сам є базовим
        is_abstract = namespace.get("__abstract__", False)

        if not is_base and not is_abstract:
            missing = mcs._REQUIRED_ATTRS - set(namespace)
            if missing:
                raise TypeError(
                    f"Клас '{name}' не визначає обов'язкові атрибути: "
                    f"{', '.join(sorted(missing))}. "
                    f"Кожна модель повинна мати атрибут __tablename__."
                )

        return cls


class Model(metaclass=StrictModelMeta):
    """Абстрактний базовий клас для всіх моделей."""
    __abstract__ = True  # Сам Model пропускається перевіркою


# ✅ Правильно — є __tablename__
class User(Model):
    __tablename__ = "users"

    def __init__(self, name: str):
        self.name = name


class Article(Model):
    __tablename__ = "articles"


# ❌ Неправильно — немає __tablename__ → TypeError при оголошенні класу!
try:
    class BadModel(Model):
        pass  # Забули __tablename__!
except TypeError as e:
    print(f"TypeError: {e}")

# plugin_registry.py
from __future__ import annotations
from typing import ClassVar


class PluginMeta(type):
    """
    Метаклас, що автоматично реєструє всі підкласи у словнику _registry.
    Базовий клас, що його використовує, виключається з реєстру.
    """

    def __init__(cls, name: str, bases: tuple, namespace: dict) -> None:
        super().__init__(name, bases, namespace)

        # Реєструємо лише нащадків (не сам базовий клас)
        if bases:
            plugin_name = namespace.get("name", name.lower())
            # Отримуємо реєстр з першого батьківського класу, що має метаклас
            root = bases[0]
            while hasattr(root, "__bases__") and root.__bases__:
                potential_root = root.__bases__[0]
                if not hasattr(potential_root, "_registry"):
                    break
                root = potential_root

            # Знаходимо справжній корінь з _registry
            for base in bases:
                if hasattr(base, "_registry"):
                    base._registry[plugin_name] = cls
                    break


class Formatter(metaclass=PluginMeta):
    """Базовий клас для форматерів виводу."""
    _registry: ClassVar[dict[str, type[Formatter]]] = {}

    def format(self, data: object) -> str:
        raise NotImplementedError


# Реєструються автоматично при оголошенні!
class JSONFormatter(Formatter):
    name = "json"

    def format(self, data: object) -> str:
        import json
        return json.dumps(data, ensure_ascii=False, indent=2)


class CSVFormatter(Formatter):
    name = "csv"

    def format(self, data: object) -> str:
        if isinstance(data, list) and data:
            keys = data[0].keys() if isinstance(data[0], dict) else []
            rows = [",".join(keys)]
            rows += [",".join(str(row.get(k, "")) for k in keys) for row in data]
            return "\n".join(rows)
        return str(data)


class PlainTextFormatter(Formatter):
    name = "text"

    def format(self, data: object) -> str:
        return str(data)


# Використання через реєстр
def get_formatter(fmt_name: str) -> Formatter:
    cls = Formatter._registry.get(fmt_name)
    if cls is None:
        available = ", ".join(Formatter._registry)
        raise ValueError(f"Невідомий формат '{fmt_name}'. Доступні: {available}")
    return cls()


# ─── Демонстрація ────────────────────────────────────────────────────────────

print("Зареєстровані форматери:", list(Formatter._registry.keys()))

data = [{"name": "Іван", "age": 30}, {"name": "Марія", "age": 25}]

for fmt in ("json", "csv", "text"):
    formatter = get_formatter(fmt)
    print(f"\n[{fmt.upper()}]")
    print(formatter.format(data))

# snake_case_meta.py
import re


def to_snake_case(name: str) -> str:
    """CamelCase → snake_case."""
    s1 = re.sub(r"(.)([A-Z][a-z]+)", r"\1_\2", name)
    return re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", s1).lower()


class SnakeCaseMeta(type):
    """
    Метаклас, що автоматично переіменовує методи з camelCase у snake_case.
    Корисно при інтеграції з Java/JS бібліотеками або при рефакторингу.
    """

    def __new__(mcs, name: str, bases: tuple, namespace: dict) -> type:
        new_namespace: dict = {}

        for key, value in namespace.items():
            snake_key = to_snake_case(key)
            if snake_key != key and callable(value):
                print(f"  Перейменовано: {key!r} → {snake_key!r}")
                new_namespace[snake_key] = value
                # Також залишаємо оригінал для зворотної сумісності
                new_namespace[key] = value
            else:
                new_namespace[key] = value

        return super().__new__(mcs, name, bases, new_namespace)


class APIClient(metaclass=SnakeCaseMeta):
    """Клас з методами у camelCase — метаклас додасть snake_case-аліаси."""

    def getUserById(self, user_id: int) -> dict:
        return {"id": user_id, "name": "Тестовий користувач"}

    def createNewOrder(self, product: str, quantity: int) -> dict:
        return {"product": product, "quantity": quantity, "status": "created"}

    def deleteExpiredSessions(self) -> int:
        return 42  # кількість видалених сесій


# Обидва варіанти працюють!
client = APIClient()
print(client.getUserById(1))        # camelCase (оригінал)
print(client.get_user_by_id(1))     # snake_case (автоматично додано метакласом)

class Base:
    def __init_subclass__(cls, **kwargs):
        super().__init_subclass__(**kwargs)
        # cls — це щойно оголошений підклас
        print(f"Зареєстровано новий підклас: {cls.__name__}")

class Child(Base):  # ← __init_subclass__ викликається тут!
    pass

class GrandChild(Child):  # ← і тут!
    pass

# modern_registry.py
from __future__ import annotations
from typing import ClassVar


class Formatter:
    """
    Базовий клас для форматерів.
    Замість метакласу використовуємо __init_subclass__.
    """
    _registry: ClassVar[dict[str, type[Formatter]]] = {}

    def __init_subclass__(cls, name: str = "", **kwargs) -> None:
        """
        Автоматично викликається при оголошенні будь-якого підкласу Formatter.
        Параметр name береться з заголовка класу: class JSON(Formatter, name="json")
        """
        super().__init_subclass__(**kwargs)
        # Якщо name не задано явно — використовуємо ім'я класу в нижньому регістрі
        plugin_name = name or cls.__name__.lower()
        Formatter._registry[plugin_name] = cls
        print(f"  [Registry] Зареєстровано: {plugin_name!r} → {cls.__name__}")

    def format(self, data: object) -> str:
        raise NotImplementedError


# Параметр name передається через заголовок класу!
class JSONFormatter(Formatter, name="json"):
    def format(self, data: object) -> str:
        import json
        return json.dumps(data, ensure_ascii=False)


class CSVFormatter(Formatter, name="csv"):
    def format(self, data: object) -> str:
        return str(data)


class PlainTextFormatter(Formatter, name="text"):
    def format(self, data: object) -> str:
        return str(data)


print("\nРеєстр:", list(Formatter._registry.keys()))

# modern_validation.py

class Model:
    """Базовий клас моделей з валідацією через __init_subclass__."""

    def __init_subclass__(cls, abstract: bool = False, **kwargs) -> None:
        super().__init_subclass__(**kwargs)

        if abstract:
            return  # Абстрактні класи пропускаємо

        if not hasattr(cls, "__tablename__"):
            raise TypeError(
                f"Клас '{cls.__name__}' не визначає __tablename__. "
                f"Кожна модель бази даних повинна мати цей атрибут."
            )
        print(f"  [Model] Модель '{cls.__name__}' → таблиця '{cls.__tablename__}'")


class TimestampedModel(Model, abstract=True):
    """Абстрактний міксін — додає created_at та updated_at."""
    created_at: str = ""
    updated_at: str = ""


# ✅ Правильно
class User(Model):
    __tablename__ = "users"

class Article(TimestampedModel):   # TimestampedModel абстрактний → не вимагає tablename
    __tablename__ = "articles"     # але Article вже конкретна, тому вимагає

# ❌ Неправильно
try:
    class BadModel(Model):
        pass
except TypeError as e:
    print(f"\nTypeError: {e}")