from pydantic import BaseModel
from pydantic._internal._model_construction import ModelMetaclass
from pydantic_core import PydanticUndefined
from typing import Any


class FieldDescriptor:
    """ Example descriptor, just to show storage somewhere other than __dict__ """

    def __init__(self, name: str, default: Any):
        self.__default = default
        self.__name = name
        self.__values = {}

    def __get__(self, instance, owner):
        if instance is not None:
            try:
                return self.__values[id(instance)][self.__name]
            except KeyError:
                return self.__default

        return self

    def __set__(self, instance, value):
        self.__values.setdefault(id(instance), {})[self.__name] = value


class DescriptorMeta:
    def __new__(cls, cls_name: str, bases: tuple[type[Any], ...], namespace: dict[str, Any], **kwargs):
        # Convert all the model fields into FieldDescriptors
        descriptors = {}
        for name, typ in namespace.get("__annotations__", {}).items():
            value = namespace.get(name, PydanticUndefined)
            if value is PydanticUndefined or not hasattr(value, "__get__"):
                descriptors[name] = FieldDescriptor(name, value)

        ret = super().__new__(cls, cls_name, bases, namespace, **kwargs)
        for name, descriptor in descriptors.items():
            # We can't just put them in namespace because collect_model_fields() will delete them
            setattr(ret, name, descriptor)

        return ret


class PydanticDescriptorMeta(DescriptorMeta, ModelMetaclass):
    pass


class Foo(BaseModel, metaclass=PydanticDescriptorMeta):
    s: str
    i: int


>>> f = Foo(s="mystr", i=123)
>>> f.model_dump()
{'s': 'nick', 'i': 123}
>>>
>>> f.i
PydanticUndefined

from dataclasses import dataclass
from pydantic import TypeAdapter


class DataclassDescriptorMeta(DescriptorMeta, type):
    pass


@dataclass
class Bar(metaclass=DataclassDescriptorMeta):
    s: str
    i: int


>>> b = Bar(s="mystr", i=123)
>>> TypeAdapter(Bar).dump_json(b)
b'{"s":"mystr","i":123}'
>>>
>>> b.i
123