The Descriptor Protocol & Attribute Lookup

class DataDesc:
    def __get__(self, obj, objtype=None):
        return "data_desc __get__"
    def __set__(self, obj, value):
        pass   # makes this a DATA descriptor

class NonDataDesc:
    def __get__(self, obj, objtype=None):
        return "non_data_desc __get__"
    # no __set__ → NON-DATA descriptor

class MyClass:
    data     = DataDesc()
    non_data = NonDataDesc()

obj = MyClass()
obj.__dict__["data"]     = "instance value (data)"
obj.__dict__["non_data"] = "instance value (non_data)"

print(obj.data)      # "data_desc __get__"         — DATA desc wins over instance __dict__
print(obj.non_data)  # "instance value (non_data)" — instance __dict__ wins over non-data desc

class Descriptor:
    """
    __get__(self, obj, objtype=None)
        - obj is None when accessed via the class: MyClass.attr
        - obj is the instance when accessed via instance: my_obj.attr

    __set__(self, obj, value)
        - called on instance attribute assignment: my_obj.attr = value

    __delete__(self, obj)
        - called on del my_obj.attr
    """
    def __set_name__(self, owner, name):
        # Called at class creation time (Python 3.6+)
        self.name = name
        self.private_name = f"_{owner.__name__}__{name}"

    def __get__(self, obj, objtype=None):
        if obj is None:
            return self          # class-level access: return the descriptor itself
        return getattr(obj, self.private_name, None)

    def __set__(self, obj, value):
        setattr(obj, self.private_name, value)

    def __delete__(self, obj):
        delattr(obj, self.private_name)

class Point:
    x = Descriptor()
    y = Descriptor()

p = Point()
p.x = 10          # calls Descriptor.__set__(p, 10)
p.y = 20
print(p.x)        # calls Descriptor.__get__(p, Point) → 10
del p.x           # calls Descriptor.__delete__(p)
print(Point.x)    # Descriptor.__get__(None, Point) → the descriptor object itself

from typing import Any, Type, Callable

class TypedField:
    """A descriptor that enforces a type constraint on assignment."""

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

    def __init__(self, expected_type: type, *, nullable: bool = False) -> None:
        self.expected_type = expected_type
        self.nullable      = nullable

    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:
        if value is None and self.nullable:
            setattr(obj, self.private_name, value)
            return
        if not isinstance(value, self.expected_type):
            raise TypeError(
                f"{self.public_name!r} expects {self.expected_type.__name__}, "
                f"got {type(value).__name__}"
            )
        setattr(obj, self.private_name, value)

    def __delete__(self, obj) -> None:
        setattr(obj, self.private_name, None)


class RangedField(TypedField):
    """Adds min/max bounds on top of type checking."""

    def __init__(self, expected_type: type, *, lo=None, hi=None, **kw) -> None:
        super().__init__(expected_type, **kw)
        self.lo, self.hi = lo, hi

    def __set__(self, obj, value) -> None:
        super().__set__(obj, value)   # type check first
        v = getattr(obj, self.private_name)
        if v is not None:
            if self.lo is not None and v < self.lo:
                raise ValueError(f"{self.public_name!r} must be >= {self.lo}, got {v}")
            if self.hi is not None and v > self.hi:
                raise ValueError(f"{self.public_name!r} must be <= {self.hi}, got {v}")


class Employee:
    name   = TypedField(str)
    age    = RangedField(int, lo=18, hi=120)
    salary = RangedField(float, lo=0.0)

    def __init__(self, name, age, salary):
        self.name   = name
        self.age    = age
        self.salary = salary

    def __repr__(self):
        return f"Employee({self.name!r}, age={self.age}, salary={self.salary})"

e = Employee("Alice", 30, 95000.0)
print(e)   # Employee('Alice', age=30, salary=95000.0)

try:
    e.age = 15
except ValueError as err:
    print(err)   # 'age' must be >= 18, got 15

try:
    e.name = 123
except TypeError as err:
    print(err)   # 'name' expects str, got int

# Rough Python equivalent of the built-in property descriptor
class property_:
    def __init__(self, fget=None, fset=None, fdel=None, doc=None):
        self.fget = fget
        self.fset = fset
        self.fdel = fdel
        self.__doc__ = doc or (fget.__doc__ if fget else None)

    def __set_name__(self, owner, name):
        self.__name__ = name

    def __get__(self, obj, objtype=None):
        if obj is None:
            return self          # accessed on the class
        if self.fget is None:
            raise AttributeError(f"unreadable attribute '{self.__name__}'")
        return self.fget(obj)

    def __set__(self, obj, value):
        if self.fset is None:
            raise AttributeError(f"can't set attribute '{self.__name__}'")
        self.fset(obj, value)

    def __delete__(self, obj):
        if self.fdel is None:
            raise AttributeError(f"can't delete attribute '{self.__name__}'")
        self.fdel(obj)

    # These methods return a NEW property with the extra function wired in
    def getter(self, fget):   return type(self)(fget, self.fset, self.fdel, self.__doc__)
    def setter(self, fset):   return type(self)(self.fget, fset, self.fdel, self.__doc__)
    def deleter(self, fdel):  return type(self)(self.fget, self.fset, fdel, self.__doc__)


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("Radius must be non-negative")
        self._radius = value

    @property
    def area(self) -> float:
        import math
        return math.pi * self._radius ** 2

c = Circle(5.0)
print(c.radius)        # 5.0
print(c.area)          # 78.539...
c.radius = 10.0
print(Circle.radius)   # <property object at 0x...> — descriptor itself

class MyClass:
    @staticmethod
    def static_fn(x):
        return x * 2

    @classmethod
    def class_fn(cls, x):
        return f"{cls.__name__}: {x * 2}"

# staticmethod.__get__ returns the raw function (no binding)
print(MyClass.__dict__["static_fn"])                          # <staticmethod object>
print(MyClass.__dict__["static_fn"].__get__(None, MyClass))  # <function static_fn ...>
print(MyClass.static_fn(5))                                   # 10

# classmethod.__get__ returns a bound method with cls already bound
print(MyClass.__dict__["class_fn"])          # <classmethod object>
print(MyClass.class_fn(5))                   # "MyClass: 10"

# Plain function is a non-data descriptor — __get__ returns a bound method
def greet(self):
    return f"Hello from {type(self).__name__}"

class Greeter:
    hello = greet      # assign a function as a class attribute

g = Greeter()
print(g.hello())                                              # "Hello from Greeter"
print(Greeter.__dict__["hello"])                              # <function greet ...>
print(Greeter.__dict__["hello"].__get__(g, Greeter))         # <bound method greet of ...>

# This is exactly how def creates methods in a class body
class MyClass2:
    def method(self):   # stored as a plain function in __dict__
        return "called"

print(type(MyClass2.__dict__["method"]))     # <class 'function'>
print(type(MyClass2().method))               # <class 'method'>  — bound on access

import sys

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

class WithSlots:
    __slots__ = ("x", "y")

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

d_obj = WithDict(1, 2)
s_obj = WithSlots(1, 2)

print(sys.getsizeof(d_obj))    # ~48 bytes (slots) + ~232 bytes (__dict__ overhead)
print(sys.getsizeof(s_obj))    # ~56 bytes — no __dict__ overhead

# __slots__ creates member_descriptor objects in the class dict
print(type(WithSlots.__dict__["x"]))   # <class 'member_descriptor'>
print(WithSlots.__dict__["x"])         # <member 'x' of 'WithSlots' objects>

# member_descriptor IS a data descriptor (has __get__ and __set__)
desc = WithSlots.__dict__["x"]
print(desc.__get__(s_obj, WithSlots))   # 1
desc.__set__(s_obj, 99)
print(s_obj.x)                           # 99

# No __dict__ on slotted objects
try:
    print(s_obj.__dict__)
except AttributeError as e:
    print(e)   # 'WithSlots' object has no attribute '__dict__'

# ── Inheritance: must redeclare __slots__ or __dict__ is added back ──
class Child(WithSlots):
    __slots__ = ("z",)   # inherits x, y slots from parent + adds z
    def __init__(self, x, y, z):
        super().__init__(x, y)
        self.z = z

c = Child(1, 2, 3)
print(c.x, c.y, c.z)   # 1 2 3

# ── weakref support: add __weakref__ to __slots__ ──
class Cached:
    __slots__ = ("data", "__weakref__")
    def __init__(self, data):
        self.data = data

import weakref
obj = Cached([1, 2, 3])
ref = weakref.ref(obj)
print(ref())   # <Cached object at 0x...>

class LoggedAccess:
    """Every attribute access is logged."""

    def __getattribute__(self, name: str):
        """Called for EVERY attribute access (including __dict__, methods, etc.)"""
        print(f"  __getattribute__({name!r})")
        return super().__getattribute__(name)

    def __setattr__(self, name: str, value):
        """Called for EVERY attribute assignment."""
        print(f"  __setattr__({name!r}, {value!r})")
        super().__setattr__(name, value)

    def __delattr__(self, name: str):
        print(f"  __delattr__({name!r})")
        super().__delattr__(name)

    def __getattr__(self, name: str):
        """ONLY called when normal lookup fails — the last resort."""
        print(f"  __getattr__({name!r}) — not found via normal lookup")
        raise AttributeError(name)


class MyObj(LoggedAccess):
    def __init__(self):
        self.x = 10    # triggers __setattr__

obj = MyObj()
print(obj.x)           # triggers __getattribute__
del obj.x              # triggers __delattr__
print(obj.missing)     # triggers __getattribute__ first, then __getattr__

class Proxy:
    """Transparently wrap any object, intercepting all attribute access."""

    def __init__(self, target):
        object.__setattr__(self, "_target", target)   # bypass our own __setattr__

    def __getattr__(self, name):
        # Called only when the proxy itself doesn't have 'name'
        return getattr(object.__getattribute__(self, "_target"), name)

    def __setattr__(self, name, value):
        if name == "_target":
            object.__setattr__(self, name, value)
        else:
            setattr(object.__getattribute__(self, "_target"), name, value)


class Config:
    debug   = False
    version = "1.0"

proxy = Proxy(Config)
print(proxy.debug)     # False  — forwarded to Config.debug
proxy.debug = True     # forwarded to Config.debug = True
print(Config.debug)    # True   — the real object was mutated

import time, functools

class lazy_property:
    """
    Non-data descriptor: computes value on first access,
    then stores it in instance __dict__ so subsequent accesses
    bypass the descriptor entirely (instance __dict__ wins over non-data desc).
    """
    def __init__(self, func):
        self.func = func
        self.attrname = None
        self.__doc__ = func.__doc__

    def __set_name__(self, owner, name):
        self.attrname = name

    def __get__(self, obj, objtype=None):
        if obj is None:
            return self
        if self.attrname is None:
            raise TypeError("lazy_property must be used as a class attribute")
        val = obj.__dict__.get(self.attrname, _MISSING := object())
        if val is _MISSING:
            val = self.func(obj)
            obj.__dict__[self.attrname] = val   # cache in instance dict
        return val


class DataProcessor:
    def __init__(self, data: list[int]):
        self._data = data

    @lazy_property
    def stats(self) -> dict:
        print("  Computing stats (expensive)…")
        time.sleep(0.01)   # simulate work
        return {
            "mean": sum(self._data) / len(self._data),
            "min":  min(self._data),
            "max":  max(self._data),
        }

dp = DataProcessor(list(range(1000)))
print(dp.stats)   # computes and caches
print(dp.stats)   # returns cached value — descriptor not called again
print("stats" in dp.__dict__)   # True — stored in instance dict

from typing import Any
import sqlite3

class Column:
    """Descriptor that represents a database column on a Model class."""

    def __set_name__(self, owner, name: str) -> None:
        self.name = name
        # Register on the owner class so the metaclass can find all columns
        if not hasattr(owner, "_columns"):
            owner._columns = {}
        owner._columns[name] = self

    def __init__(self, col_type: str, *, primary_key: bool = False,
                 nullable: bool = True, default=None):
        self.col_type    = col_type
        self.primary_key = primary_key
        self.nullable    = nullable
        self.default     = default
        self.name        = None   # filled by __set_name__

    def __get__(self, obj, objtype=None):
        if obj is None:
            return self
        return obj.__dict__.get(self.name, self.default)

    def __set__(self, obj, value) -> None:
        if value is None and not self.nullable:
            raise ValueError(f"Column '{self.name}' is NOT NULL")
        obj.__dict__[self.name] = value

    def sql_definition(self) -> str:
        parts = [self.name, self.col_type]
        if self.primary_key: parts.append("PRIMARY KEY AUTOINCREMENT")
        if not self.nullable: parts.append("NOT NULL")
        return " ".join(parts)


class Model:
    """Base class for ORM models — introspects Column descriptors."""

    @classmethod
    def create_table_sql(cls) -> str:
        cols = ", ".join(
            desc.sql_definition()
            for desc in cls._columns.values()
        )
        return f"CREATE TABLE IF NOT EXISTS {cls.__name__} ({cols});"

    def to_dict(self) -> dict:
        return {name: getattr(self, name) for name in self._columns}


class User(Model):
    id       = Column("INTEGER", primary_key=True, nullable=False)
    username = Column("TEXT",    nullable=False)
    email    = Column("TEXT",    nullable=False)
    age      = Column("INTEGER", nullable=True, default=None)

print(User.create_table_sql())
# CREATE TABLE IF NOT EXISTS User (id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
#   username TEXT NOT NULL, email TEXT NOT NULL, age INTEGER);

u = User()
u.username = "alice"
u.email    = "alice@example.com"
u.age      = 30
print(u.to_dict())
# {'id': None, 'username': 'alice', 'email': 'alice@example.com', 'age': 30}

try:
    u.username = None   # NOT NULL violation
except ValueError as e:
    print(e)   # Column 'username' is NOT NULL

# Demonstration of all six levels in one class
class AllLevels:
    # Level 1: data descriptor
    data_desc = property(lambda self: "data_desc")

    # Level 3: non-data descriptor (regular function)
    def method(self): return "method"

    # Level 4: plain class attribute
    class_attr = "class_attr"

    def __getattr__(self, name):
        # Level 5: only called when levels 1-4 all fail
        return f"__getattr__({name!r})"

obj = AllLevels()
obj.__dict__["data_desc"] = "instance (shadow attempt)"  # level 2
obj.__dict__["method"]    = "instance method shadow"      # level 2

print(obj.data_desc)    # "data_desc"      — data desc wins over instance dict
print(obj.method)       # "instance method shadow" — instance dict wins over non-data desc
print(obj.class_attr)   # "class_attr"     — falls through to class
print(obj.missing)      # "__getattr__('missing')" — final fallback