class Sensor:
    def __init__(self, name: str):
        self.name = name
        self.temperature = 0.0

s = Sensor("Кімнатний")
s.temperature = 22.5   # нормально
s.temperature = -500   # фізично неможливо, але Python мовчить
s.temperature = "дуже гаряче"  # взагалі рядок — і знову тиша

class Sensor:
    def __init__(self, name: str):
        self.name = name
        self._temperature = 0.0

    @property
    def temperature(self) -> float:
        return self._temperature

    @temperature.setter
    def temperature(self, value: float) -> None:
        if not isinstance(value, (int, float)):
            raise TypeError(f"Температура має бути числом, отримано {type(value).__name__}")
        if value < -273.15:
            raise ValueError(f"Температура {value}°C нижча за абсолютний нуль")
        self._temperature = float(value)

# descriptors_intro.py

class LoggedAttribute:
    """
    Найпростіший дескриптор: логує кожен read та write до атрибуту.
    Зберігає значення у словнику __dict__ самого екземпляра,
    використовуючи своє ім'я як ключ.
    """

    def __set_name__(self, owner: type, name: str) -> None:
        # Викликається при оголошенні класу.
        # owner = клас, де оголошено дескриптор (наприклад, Person)
        # name  = ім'я атрибуту класу (наприклад, 'age')
        self.public_name = name           # 'age'
        self.private_name = f"_{name}"   # '_age' — для зберігання у __dict__ екземпляра

    def __get__(self, obj, objtype=None):
        # obj = None, якщо доступ через клас: Person.age
        if obj is None:
            return self  # повертаємо сам дескриптор
        value = getattr(obj, self.private_name, None)
        print(f"[GET] {type(obj).__name__}.{self.public_name} → {value!r}")
        return value

    def __set__(self, obj, value) -> None:
        print(f"[SET] {type(obj).__name__}.{self.public_name} = {value!r}")
        setattr(obj, self.private_name, value)


class Person:
    # LoggedAttribute() — це екземпляр класу-дескриптора,
    # присвоєний як атрибут КЛАСУ (не __init__)
    name = LoggedAttribute()
    age  = LoggedAttribute()

    def __init__(self, name: str, age: int) -> None:
        self.name = name  # → викличе LoggedAttribute.__set__
        self.age  = age   # → викличе LoggedAttribute.__set__

    def __repr__(self) -> str:
        return f"Person({self.name!r}, {self.age})"  # → викличе __get__ двічі


p = Person("Олена", 28)
print(p)
print(f"\nРоки через 5 років: {p.age + 5}")

# Доступ через клас — повертає сам дескриптор
print(f"\nДескриптор через клас: {Person.age}")

# data_vs_nondata.py

class DataDescriptor:
    """Data descriptor — має і __get__, і __set__."""

    def __get__(self, obj, objtype=None):
        if obj is None:
            return self
        return obj.__dict__.get(f"_dd_val", "значення не встановлено")

    def __set__(self, obj, value):
        print(f"  [DataDescriptor.__set__] value={value!r}")
        obj.__dict__["_dd_val"] = value


class NonDataDescriptor:
    """Non-data descriptor — лише __get__, без __set__."""

    def __get__(self, obj, objtype=None):
        if obj is None:
            return self
        print(f"  [NonDataDescriptor.__get__] повертаю 'дескриптор'")
        return "значення від дескриптора"


class MyClass:
    data_attr     = DataDescriptor()
    nondata_attr  = NonDataDescriptor()


obj = MyClass()

# === Experiment 1: Data Descriptor ===
print("=== Data Descriptor ===")
print(f"До запису: {obj.data_attr}")      # виклик __get__, значення відсутнє

obj.data_attr = 42                         # → DataDescriptor.__set__
print(f"Після запису: {obj.data_attr}")   # → DataDescriptor.__get__

# Спроба "обійти" дескриптор — записати у __dict__ напряму
obj.__dict__["data_attr"] = 9999
print(f"Після __dict__['data_attr']=9999: {obj.data_attr}")
# Data descriptor ігнорує __dict__ і все одно викликає __get__!

# === Experiment 2: Non-data Descriptor ===
print("\n=== Non-data Descriptor ===")
print(f"До запису: {obj.nondata_attr}")   # → NonDataDescriptor.__get__

# Запис через звичайне присвоєння — обходить дескриптор!
obj.nondata_attr = "моє власне значення"
print(f"Після запису: {obj.nondata_attr}") # тепер читаємо з __dict__ екземпляра!

print(f"obj.__dict__: {obj.__dict__}")

class Dog:
    def bark(self) -> str:
        return f"{self.name} гавкає!"

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

d = Dog("Рекс")

# Що відбувається при d.bark()?
# 1. Python шукає 'bark' у type(d).__mro__ → знаходить функцію Dog.bark
# 2. Dog.bark — non-data descriptor (є __get__, немає __set__)
# 3. Перевіряє d.__dict__ — там 'bark' немає
# 4. Викликає Dog.bark.__get__(d, Dog) → отримує "зв'язаний метод"
# 5. Викликає зв'язаний метод → self автоматично = d

# Доведемо це явно:
raw_function = Dog.__dict__['bark']    # сама функція, без дескрипторної магії
print(type(raw_function))              # <class 'function'>
print(type(d.bark))                    # <class 'method'> ← результат __get__

# Вони еквівалентні:
print(d.bark())                        # Рекс гавкає!
print(raw_function(d))                 # Рекс гавкає! (self передаємо вручну)

# Дескриптор можна викликати явно:
bound_method = raw_function.__get__(d, Dog)
print(bound_method())                  # Рекс гавкає!

# property — це data descriptor: має __get__, __set__ і __delete__
print(hasattr(property, '__get__'))     # True
print(hasattr(property, '__set__'))     # True  ← саме тому це data descriptor
print(hasattr(property, '__delete__'))  # True

class Circle:
    def __init__(self, radius: float):
        self._radius = radius

    @property
    def radius(self) -> float:
        return self._radius

    @radius.setter
    def radius(self, value: float) -> None:
        if value < 0:
            raise ValueError("Радіус не може бути від'ємним")
        self._radius = value


c = Circle(5.0)

# Спроба обійти @property через __dict__:
c.__dict__['radius'] = -100  # записуємо напряму у словник екземпляра

# Але @property (data descriptor) ігнорує __dict__!
print(c.radius)          # 5.0 — повертає self._radius, а не -100
print(c.__dict__)        # {'_radius': 5.0, 'radius': -100} — запис є, але ігнорується

# validators.py
from abc import ABC, abstractmethod


class Validator(ABC):
    """
    Абстрактний базовий клас для дескрипторів-валідаторів.
    Реалізує загальний протокол __get__/__set__/__set_name__,
    делегуючи специфічну логіку перевірки методу validate().
    """

    def __set_name__(self, owner: type, name: str) -> None:
        self.public_name  = name
        self.private_name = f"_{name}"

    def __get__(self, obj, objtype=None):
        if obj is None:
            return self
        return getattr(obj, self.private_name, None)

    def __set__(self, obj, value) -> None:
        # Спочатку валідуємо, потім зберігаємо
        self.validate(value)
        setattr(obj, self.private_name, value)

    @abstractmethod
    def validate(self, value) -> None:
        """
        Перевіряє значення. Має підняти TypeError або ValueError
        при невалідному вводі.
        """
        ...

# validators.py (продовження)

class TypedField(Validator):
    """
    Дескриптор: перевіряє тип значення.
    
    name = TypedField(str)         # лише рядки
    count = TypedField((int, float))  # int або float
    """

    def __init__(self, expected_type: type | tuple):
        self.expected_type = expected_type

    def validate(self, value) -> None:
        if not isinstance(value, self.expected_type):
            type_name = (
                self.expected_type.__name__
                if isinstance(self.expected_type, type)
                else " | ".join(t.__name__ for t in self.expected_type)
            )
            raise TypeError(
                f"Атрибут '{self.public_name}' очікує тип {type_name}, "
                f"отримано {type(value).__name__!r}: {value!r}"
            )


class RangedField(Validator):
    """
    Дескриптор: перевіряє числове значення на входження в діапазон [min_val, max_val].
    None означає «без обмеження» з відповідного боку.
    
    temperature = RangedField(-273.15, 1_000_000)
    percentage  = RangedField(0.0, 100.0)
    """

    def __init__(
        self,
        min_val: float | None = None,
        max_val: float | None = None,
        *,
        inclusive: bool = True,
    ):
        self.min_val   = min_val
        self.max_val   = max_val
        self.inclusive = inclusive

    def validate(self, value) -> None:
        if not isinstance(value, (int, float)):
            raise TypeError(
                f"Атрибут '{self.public_name}' має бути числом, "
                f"отримано {type(value).__name__!r}"
            )
        too_low  = (self.min_val is not None and
                    (value < self.min_val if self.inclusive else value <= self.min_val))
        too_high = (self.max_val is not None and
                    (value > self.max_val if self.inclusive else value >= self.max_val))
        if too_low or too_high:
            bound = f"[{self.min_val}, {self.max_val}]" if self.inclusive else f"({self.min_val}, {self.max_val})"
            raise ValueError(
                f"Атрибут '{self.public_name}' = {value} виходить за межі {bound}"
            )


class NonEmptyString(Validator):
    """
    Дескриптор: гарантує, що рядок непустий після strip().
    Опціонально обмежує максимальну довжину.
    
    title       = NonEmptyString()
    description = NonEmptyString(max_length=500)
    """

    def __init__(self, max_length: int | None = None):
        self.max_length = max_length

    def validate(self, value) -> None:
        if not isinstance(value, str):
            raise TypeError(
                f"Атрибут '{self.public_name}' має бути рядком, "
                f"отримано {type(value).__name__!r}"
            )
        stripped = value.strip()
        if not stripped:
            raise ValueError(
                f"Атрибут '{self.public_name}' не може бути порожнім рядком"
            )
        if self.max_length is not None and len(stripped) > self.max_length:
            raise ValueError(
                f"Атрибут '{self.public_name}' перевищує максимальну довжину "
                f"{self.max_length} символів (фактично: {len(stripped)})"
            )

# domain_classes.py
from validators import TypedField, RangedField, NonEmptyString


class PhysicalSensor:
    """
    Датчик фізичних вимірювань.
    Всі поля з автоматичною валідацією — жодного @property, жодного дублювання.
    """
    name        = NonEmptyString(max_length=100)
    temperature = RangedField(-273.15, 1_000_000.0)   # в Цельсіях
    humidity    = RangedField(0.0, 100.0)              # у відсотках
    pressure    = RangedField(0.0, None)               # тиск ≥ 0, верхньої межі немає

    def __init__(
        self,
        name: str,
        temperature: float,
        humidity: float,
        pressure: float,
    ) -> None:
        self.name        = name
        self.temperature = temperature
        self.humidity    = humidity
        self.pressure    = pressure

    def __repr__(self) -> str:
        return (
            f"PhysicalSensor({self.name!r}, "
            f"T={self.temperature}°C, "
            f"H={self.humidity}%, "
            f"P={self.pressure} hPa)"
        )


class Product:
    """Товар в інтернет-магазині."""
    title    = NonEmptyString(max_length=200)
    price    = RangedField(0.01, None)                 # ціна > 0
    quantity = RangedField(0, None)                    # кількість ≥ 0
    sku      = NonEmptyString()

    def __init__(self, title: str, price: float, quantity: int, sku: str) -> None:
        self.title    = title
        self.price    = price
        self.quantity = quantity
        self.sku      = sku


# --- Тестування ---
sensor = PhysicalSensor("Кімнатний #1", temperature=22.5, humidity=55.0, pressure=1013.25)
print(sensor)

# Валідні зміни
sensor.temperature = 25.0
sensor.humidity    = 60.0

# Невалідні зміни — кожна підіймає виключення
try:
    sensor.temperature = -300  # нижче абсолютного нуля
except ValueError as e:
    print(f"ValueError: {e}")

try:
    sensor.humidity = 150      # вологість > 100%
except ValueError as e:
    print(f"ValueError: {e}")

try:
    sensor.name = ""           # порожній рядок
except ValueError as e:
    print(f"ValueError: {e}")

try:
    sensor.pressure = "висока"  # рядок замість числа
except TypeError as e:
    print(f"TypeError: {e}")

# lazy_property.py
import time
from typing import Callable, TypeVar, Any

T = TypeVar("T")


class lazy_property:
    """
    Non-data descriptor для ледачого обчислення атрибутів.
    
    При першому зверненні до атрибуту викликає обгорнуту функцію,
    зберігає результат у obj.__dict__ під тим самим ім'ям і повертає його.
    Усі наступні звернення отримують значення напряму з __dict__,
    оминаючи дескриптор повністю.
    
    Використання:
        class MyClass:
            @lazy_property
            def expensive_value(self) -> int:
                return heavy_computation()
    """

    def __init__(self, func: Callable) -> None:
        self.func      = func
        self.attr_name = None           # заповниться у __set_name__
        self.__doc__   = func.__doc__   # зберігаємо документацію

    def __set_name__(self, owner: type, name: str) -> None:
        self.attr_name = name

    def __get__(self, obj, objtype=None) -> Any:
        if obj is None:
            return self  # доступ через клас → повертаємо сам дескриптор

        if self.attr_name is None:
            raise TypeError(
                "lazy_property не можна використовувати без __set_name__. "
                "Переконайтесь, що він оголошений як атрибут класу."
            )

        # Обчислюємо значення і одразу записуємо у __dict__ екземпляра.
        # Наступного разу Python знайде його там і не дійде до нас (non-data!).
        print(f"  [lazy_property] Обчислюємо '{self.attr_name}' для {type(obj).__name__}...")
        value = self.func(obj)
        obj.__dict__[self.attr_name] = value
        return value

    # Немає __set__ → це non-data descriptor → __dict__ екземпляра має пріоритет


class Document:
    """
    Документ із текстовим вмістом.
    Всі похідні атрибути обчислюються ледаче — лише при першому зверненні.
    """

    def __init__(self, text: str) -> None:
        self.text = text

    @lazy_property
    def word_count(self) -> int:
        """Кількість слів у документі."""
        time.sleep(0.05)  # симуляція важкого NLP-аналізу
        return len(self.text.split())

    @lazy_property
    def unique_words(self) -> set[str]:
        """Множина унікальних слів (у нижньому регістрі)."""
        time.sleep(0.05)
        return {w.lower().strip(".,!?;:") for w in self.text.split()}

    @lazy_property
    def char_frequency(self) -> dict[str, int]:
        """Частота кожного символу (без пробілів)."""
        time.sleep(0.05)
        freq: dict[str, int] = {}
        for ch in self.text.replace(" ", ""):
            freq[ch] = freq.get(ch, 0) + 1
        return dict(sorted(freq.items(), key=lambda x: x[1], reverse=True))

    @lazy_property
    def reading_time_minutes(self) -> float:
        """Приблизний час читання (200 слів/хв — середня швидкість)."""
        return round(self.word_count / 200, 2)

    def __repr__(self) -> str:
        return f"Document({len(self.text)} chars)"

# Повна демонстрація використання
import time

doc = Document(
    "Python дескриптори — потужний механізм мови. "
    "Вони лежать в основі @property, методів та ORM-полів. "
    "Розуміння дескрипторів відкриває глибину Python."
)

print(f"Документ створено: {doc}")
print(f"__dict__ одразу після створення: {doc.__dict__}\n")

# Перший доступ до word_count — обчислення
t0 = time.perf_counter()
wc = doc.word_count
t1 = time.perf_counter()
print(f"word_count = {wc}  (час: {(t1 - t0) * 1000:.1f}мс)")

# Другий доступ — миттєво, з __dict__
t0 = time.perf_counter()
wc2 = doc.word_count
t1 = time.perf_counter()
print(f"word_count = {wc2}  (час: {(t1 - t0) * 1000:.3f}мс)  ← з кешу\n")

# unique_words — обчислюється вперше
print(f"unique_words: {doc.unique_words}\n")

# reading_time використовує word_count — той вже в __dict__, тому lazy обчислення
# word_count не запускається заново
print(f"Час читання: {doc.reading_time_minutes} хв")

# __dict__ після всіх звернень
print(f"\nОстаточний __dict__: {list(doc.__dict__.keys())}")

from functools import cached_property


class HeavyModel:
    """
    Модель з дорогими обчисленнями — використовує вбудований cached_property.
    """

    def __init__(self, data: list[int]) -> None:
        self.data = data

    @cached_property
    def mean(self) -> float:
        """Середнє значення (обчислюється один раз)."""
        return sum(self.data) / len(self.data)

    @cached_property
    def variance(self) -> float:
        """Дисперсія (залежить від mean — також обчислюється один раз)."""
        m = self.mean
        return sum((x - m) ** 2 for x in self.data) / len(self.data)

    @cached_property
    def std_deviation(self) -> float:
        """Стандартне відхилення."""
        return self.variance ** 0.5


model = HeavyModel([2, 4, 4, 4, 5, 5, 7, 9])

print(f"Середнє:             {model.mean:.2f}")        # обчислюється
print(f"Дисперсія:           {model.variance:.2f}")    # обчислюється (mean — з кешу)
print(f"Стандартне відхил.: {model.std_deviation:.2f}") # обчислюється (variance — з кешу)
print(f"Середнє знову:       {model.mean:.2f}")        # миттєво з __dict__

doc = Document("Початковий текст документа")
print(doc.word_count)        # обчислюється: 3

# Змінюємо базові дані — кеш застарів!
doc.text = "Новий набагато довший текст із великою кількістю слів у цьому документі"

# Старий кеш досі у __dict__:
print(doc.word_count)        # 3 — НЕПРАВИЛЬНО! читає застарілий кеш

# Скидаємо кеш вручну:
del doc.__dict__['word_count']

# Тепер обчислюється заново:
print(doc.word_count)        # 14 — правильно

# mini_orm.py
from __future__ import annotations
from typing import Any


# ─── Базовий клас поля ───────────────────────────────────────────────────────

class Field:
    """
    Базовий дескриптор для ORM-полів.
    Зберігає метадані колонки: тип, обов'язковість, значення за замовчуванням.
    При присвоєнні перевіряє тип і обов'язковість.
    """

    # Глобальний лічильник для збереження порядку оголошення полів
    _creation_counter: int = 0

    def __init__(
        self,
        *,
        null: bool = False,
        default: Any = ...,    # Ellipsis означає «значення за замовчуванням відсутнє»
        primary_key: bool = False,
        db_column: str | None = None,
    ) -> None:
        self.null        = null
        self.default     = default
        self.primary_key = primary_key
        self.db_column   = db_column    # ім'я колонки у БД (якщо відрізняється від атрибуту)

        # Запам'ятовуємо порядок оголошення (як у Django)
        Field._creation_counter += 1
        self._order = Field._creation_counter

        self.attr_name: str = ""        # встановлюється у __set_name__

    def __set_name__(self, owner: type, name: str) -> None:
        self.attr_name = name
        if self.db_column is None:
            self.db_column = name       # за замовчуванням ім'я колонки = ім'я атрибуту

    def __get__(self, obj, objtype=None) -> Any:
        if obj is None:
            return self
        # Повертаємо значення зі сховища екземпляра, або default
        value = obj.__dict__.get(f"_field_{self.attr_name}", ...)
        if value is ...:
            if self.default is not ...:
                return self.default() if callable(self.default) else self.default
            return None
        return value

    def __set__(self, obj, value) -> None:
        if value is None:
            if not self.null:
                raise ValueError(
                    f"Поле '{self.attr_name}' не може бути NULL "
                    f"(встановіть null=True щоб дозволити)"
                )
        else:
            self.validate(value)
        obj.__dict__[f"_field_{self.attr_name}"] = value

    def validate(self, value: Any) -> None:
        """Перевірка, специфічна для типу поля. Перевизначається у підкласах."""
        pass

    def to_sql_type(self) -> str:
        """SQL-тип колонки. Перевизначається у підкласах."""
        return "TEXT"

    def __repr__(self) -> str:
        return (
            f"{type(self).__name__}("
            f"null={self.null}, "
            f"default={self.default!r}, "
            f"db_column={self.db_column!r})"
        )


# ─── Конкретні типи полів ─────────────────────────────────────────────────────

class IntegerField(Field):
    """Цілочисельна колонка. Відповідає INTEGER у SQL."""

    def __init__(self, *, min_value: int | None = None, max_value: int | None = None, **kwargs):
        super().__init__(**kwargs)
        self.min_value = min_value
        self.max_value = max_value

    def validate(self, value: Any) -> None:
        if not isinstance(value, int) or isinstance(value, bool):
            raise TypeError(
                f"Поле '{self.attr_name}' очікує int, отримано {type(value).__name__!r}"
            )
        if self.min_value is not None and value < self.min_value:
            raise ValueError(f"Поле '{self.attr_name}': {value} < мінімум {self.min_value}")
        if self.max_value is not None and value > self.max_value:
            raise ValueError(f"Поле '{self.attr_name}': {value} > максимум {self.max_value}")

    def to_sql_type(self) -> str:
        return "INTEGER"


class CharField(Field):
    """Рядкова колонка з обмеженням довжини. Відповідає VARCHAR(n) у SQL."""

    def __init__(self, max_length: int = 255, **kwargs):
        super().__init__(**kwargs)
        self.max_length = max_length

    def validate(self, value: Any) -> None:
        if not isinstance(value, str):
            raise TypeError(
                f"Поле '{self.attr_name}' очікує str, отримано {type(value).__name__!r}"
            )
        if len(value) > self.max_length:
            raise ValueError(
                f"Поле '{self.attr_name}': рядок завдовжки {len(value)} "
                f"перевищує max_length={self.max_length}"
            )

    def to_sql_type(self) -> str:
        return f"VARCHAR({self.max_length})"


class FloatField(Field):
    """Поле з плаваючою крапкою. Відповідає REAL / DOUBLE у SQL."""

    def validate(self, value: Any) -> None:
        if not isinstance(value, (int, float)) or isinstance(value, bool):
            raise TypeError(
                f"Поле '{self.attr_name}' очікує число, отримано {type(value).__name__!r}"
            )

    def to_sql_type(self) -> str:
        return "REAL"


class BooleanField(Field):
    """Булеве поле. Відповідає BOOLEAN / INTEGER(0/1) у SQLite."""

    def validate(self, value: Any) -> None:
        if not isinstance(value, bool):
            raise TypeError(
                f"Поле '{self.attr_name}' очікує bool, отримано {type(value).__name__!r}"
            )

    def to_sql_type(self) -> str:
        return "BOOLEAN"

# mini_orm.py (продовження)

class ModelMeta(type):
    """
    Метаклас для ORM-моделей.
    При створенні класу збирає всі Field-атрибути у впорядкований словник _fields.
    """

    def __new__(mcs, name: str, bases: tuple, namespace: dict) -> type:
        fields: dict[str, Field] = {}

        # Збираємо поля з батьківських класів (успадкування моделей)
        for base in bases:
            if hasattr(base, "_fields"):
                fields.update(base._fields)

        # Збираємо поля поточного класу (у порядку оголошення)
        for attr_name, value in namespace.items():
            if isinstance(value, Field):
                fields[attr_name] = value

        # Сортуємо за порядком оголошення (через _creation_counter)
        namespace["_fields"] = dict(
            sorted(fields.items(), key=lambda item: item[1]._order)
        )

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


class Model(metaclass=ModelMeta):
    """
    Базовий клас для всіх ORM-моделей.
    Надає загальний __init__, __repr__, to_dict() та generate_sql().
    """

    def __init__(self, **kwargs: Any) -> None:
        # Встановлюємо значення полів через дескриптори (з валідацією)
        for field_name, field in self._fields.items():
            if field_name in kwargs:
                setattr(self, field_name, kwargs[field_name])
            elif field.default is not ...:
                pass    # __get__ поверне default автоматично
            elif not field.null:
                raise ValueError(
                    f"Обов'язкове поле '{field_name}' не передано у конструктор"
                )

    def __repr__(self) -> str:
        parts = []
        for name in self._fields:
            val = getattr(self, name)
            parts.append(f"{name}={val!r}")
        return f"{type(self).__name__}({', '.join(parts)})"

    def to_dict(self) -> dict[str, Any]:
        """Серіалізація у словник (для JSON, API-відповідей тощо)."""
        return {name: getattr(self, name) for name in self._fields}

    @classmethod
    def generate_create_table_sql(cls) -> str:
        """Генерує SQL-запит CREATE TABLE на основі оголошених полів."""
        table_name = cls.__name__.lower() + "s"  # проста конвенція: User → users
        columns: list[str] = []
        for field_name, field in cls._fields.items():
            col  = f"    {field.db_column} {field.to_sql_type()}"
            if field.primary_key:
                col += " PRIMARY KEY AUTOINCREMENT"
            if not field.null and not field.primary_key:
                col += " NOT NULL"
            if field.default is not ... and not callable(field.default):
                default_val = (
                    f"'{field.default}'" if isinstance(field.default, str)
                    else str(field.default).upper() if isinstance(field.default, bool)
                    else str(field.default)
                )
                col += f" DEFAULT {default_val}"
            columns.append(col)
        cols_sql = ",\n".join(columns)
        return f"CREATE TABLE IF NOT EXISTS {table_name} (\n{cols_sql}\n);"

# models.py
from mini_orm import Model, IntegerField, CharField, FloatField, BooleanField


class User(Model):
    """Модель користувача — відповідає таблиці users у БД."""
    id         = IntegerField(primary_key=True, null=True)
    username   = CharField(max_length=50)
    email      = CharField(max_length=200)
    age        = IntegerField(min_value=0, max_value=150, null=True)
    is_active  = BooleanField(default=True)
    score      = FloatField(default=0.0, null=True)


class Article(Model):
    """Модель статті — відповідає таблиці articles у БД."""
    id         = IntegerField(primary_key=True, null=True)
    title      = CharField(max_length=255)
    content    = CharField(max_length=10_000)
    views      = IntegerField(default=0)
    published  = BooleanField(default=False)


# ─── Використання ─────────────────────────────────────────────────────────────

# Створення екземплярів — повна валідація при ініціалізації
user = User(username="arakviel", email="arakviel@example.com", age=30)
print(user)
print(f"to_dict: {user.to_dict()}\n")

# Генерація SQL
print(User.generate_create_table_sql())
print()
print(Article.generate_create_table_sql())

# Валідація при зміні полів
try:
    user.age = 200          # перевищує max_value=150
except ValueError as e:
    print(f"\nValueError: {e}")

try:
    user.username = "a" * 100  # перевищує max_length=50
except ValueError as e:
    print(f"ValueError: {e}")

try:
    user.is_active = 1      # int замість bool
except TypeError as e:
    print(f"TypeError: {e}")