kmodels 0.1.0.0__py3-none-any.whl

kmodels/_old/_old_models.py

@@ -0,0 +1,182 @@
+from __future__ import annotations
+
+from typing import Any, ClassVar, Type, Iterable, TypeVar, Generic, Self
+from pydantic import BaseModel, model_validator, Field, model_serializer, PlainSerializer
+from typeguard import typechecked
+from abc import abstractmethod, ABC
+from lib.kmodels.error import IsAbstract
+from lib.kmodels.types import OmitIfNone
+from lib.kmodels.utils import AbstractUtils
+
+
+def deserialize_single(data: Any) -> Any:
+    return CoreModel.deserializer_helper(data)
+
+
+def deserialize_dict(data: Any, *, key: bool, value: bool, generator: Any = dict) -> Any:
+    """
+    Función auxiliar que deserializa un diccionario (o algo que se comporta como él)
+    :param data:
+    :param key:
+    :param value:
+    :param generator:
+    :return:
+    """
+    if not key and not value:
+        return data
+
+    deserialized = (
+        (deserialize_single(k) if key else k, deserialize_single(v) if value else v,) for k, v in data.items()
+    )
+
+    if generator is not None:
+        return generator(deserialized)
+    return deserialized
+
+
+def deserialize_iterable(
+        data: Iterable, *,
+        generator: Any = tuple
+) -> Any:
+    deserialized = (deserialize_single(item) for item in data)
+    if generator is not None:
+        return generator(deserialized)
+    return deserialized
+
+
+class CoreModel(BaseModel):
+    __class_registry__: ClassVar[dict[str, Type[CoreModel]]] = {}
+    __auto_register__: ClassVar[bool] = False
+
+    __cls_key_name__: ClassVar[str] = 'cls_key'
+    cls_key: OmitIfNone[str | None] = Field(default=None)
+
+    @model_serializer
+    def _no_serialize_exclude_if_none(self):
+        skip_if_none = set()
+        serialize_aliases = dict()
+
+        # Gather fields that should omit if None
+        for name, field_info in self.model_fields.items():
+            # noinspection PyTypeHints
+            if any(
+                    isinstance(metadata, OmitIfNone) for metadata in field_info.metadata
+            ):
+                skip_if_none.add(name)
+            elif field_info.serialization_alias:
+                serialize_aliases[name] = field_info.serialization_alias
+
+        serialized = dict()
+        for name, value in self:
+            # Skip serializing None if it was marked with "OmitIfNone"
+            if value is None and name in skip_if_none:
+                continue
+            serialize_key = serialize_aliases.get(name, name)
+
+            # Run Annotated PlainSerializer
+            for metadata in self.model_fields[name].metadata:
+                if isinstance(metadata, PlainSerializer):
+                    value = metadata.func(value)
+
+            serialized[serialize_key] = value
+
+        return serialized
+
+    @classmethod
+    def __pydantic_init_subclass__(cls, **kwargs):
+        super().__pydantic_init_subclass__(**kwargs)
+        if cls.__auto_register__ and not cls.is_registered():
+            cls.register()
+
+    @model_validator(mode="before")
+    @classmethod
+    def _type_key_handler(cls, data: Any) -> Any:
+        if isinstance(data, dict):
+            # Autoasignar type_key si la clase está registrada y type_key es None
+            type_key = data.get(cls.__cls_key_name__)
+
+            # Autoasignamos type_key si no está definido
+            if type_key is None:
+                type_key = cls.generate_type_key()
+                if type_key in cls.__class_registry__:
+                    data[cls.__cls_key_name__] = type_key
+
+            elif type_key not in cls.__class_registry__:
+                # Si type_key está definido entonces validamos que la clase esté registrada
+                raise ValueError(f"La clase '{cls.__cls_key_name__}' no está registrada.")
+        return data
+
+    @classmethod
+    def is_registered(cls, type_key: str | None = None) -> bool:
+        if type_key is None:
+            type_key = cls.generate_type_key()
+        return type_key in cls.__class_registry__
+
+    @classmethod
+    def _register_single(cls, target_class: Type[CoreModel]):
+        type_key = target_class.generate_type_key()
+        if type_key in cls.__class_registry__:
+            raise KeyError(f"La clase '{type_key}' ya está registrada.")
+        cls.__class_registry__[type_key] = target_class
+
+    @typechecked
+    @classmethod
+    def register(cls, target_classes: Type[CoreModel] | Iterable[Type[CoreModel]] | None = None) -> None:
+        """
+        Registra la clase manualmente en el class_registry.
+
+        Args:
+            name (str | None): Nombre opcional para registrar la clase. Si es None, se usa el nombre de la clase.
+            target_classes (Type[CoreModel] | None): Clase a registrar, si no se especifica se registrará esta clase.
+        """
+        if target_classes is None:
+            target_classes = (cls,)
+        elif isinstance(target_classes, CoreModel):
+            target_classes = (target_classes,)
+
+        for tgt_class in target_classes:
+            cls._register_single(tgt_class)
+
+    @classmethod
+    def get_registered_class(cls, type_key: str) -> Type[CoreModel]:
+        """
+        Obtiene la clase registrada a partir del nombre de clase. Revisar __pydantic_init_subclass__ para más
+        información.
+        """
+        if not cls.is_registered(type_key):
+            raise ValueError(f"Unknown or missing class_name: {type_key}")
+        target_cls = cls.__class_registry__[type_key]
+
+        if AbstractUtils.is_abstract(target_cls):
+            raise IsAbstract(f"Cannot use abstract class {type_key} directly.")
+        return target_cls
+
+    @classmethod
+    def generate_type_key(cls) -> str:
+        type_params = getattr(cls, '__pydantic_generic_metadata__', {}).get('args', ())
+        if type_params:
+            return f"{cls.__name__}[{','.join(tp.__name__ for tp in type_params)}]"
+        return cls.__name__
+
+    @classmethod
+    def deserializer_helper(cls, data: Any) -> Any:
+        if isinstance(data, dict):
+            cls_key = data.get(cls.__cls_key_name__)
+            if cls_key is not None:
+                target_cls = cls.__class_registry__[cls_key]
+                return target_cls(**data)
+        return data
+
+
+CoreModelT = TypeVar('CoreModelT', bound=CoreModel)
+
+
+class Modelable(Generic[CoreModelT], ABC):
+    @abstractmethod
+    def to_model(self) -> CoreModelT:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def from_model(cls, model: CoreModelT) -> Self:
+        ...

kmodels/error.py

@@ -0,0 +1,3 @@
+
+class IsAbstract(Exception):
+    ...

kmodels/models/__init__.py

@@ -0,0 +1,5 @@
+from .coremodel import CoreModel, CoreModelT, Leave, Unset
+
+__all__ = [
+    'CoreModel', 'CoreModelT', 'Leave', 'Unset'
+]

kmodels/models/coremodel/__init__.py

@@ -0,0 +1,6 @@
+from .coremodel import CoreModel, CoreModelT
+from .leave_unset import Leave, Unset
+
+__all__ = [
+    'CoreModel', 'CoreModelT', 'Leave', 'Unset'
+]

kmodels/models/coremodel/coremodel.py

@@ -0,0 +1,276 @@
+from __future__ import annotations
+
+from abc import abstractmethod, ABC
+from typing import Any, ClassVar, Type, Iterable, TypeVar
+from pydantic import BaseModel, model_validator, Field, model_serializer, PlainSerializer
+from typeguard import typechecked
+
+from kmodels.types import OmitIfNone
+
+
+class _CustomSerializator(BaseModel, ABC):
+    def _get_skip_if_none_fields(self) -> set[str]:
+        """
+        Averigua que fields deben ser omitidos si son None por ser OmitIfNone
+        """
+        return {
+            name
+            for name, field_info in self.model_fields.items()
+            if any(isinstance(metadata, OmitIfNone) for metadata in field_info.metadata)
+        }
+
+    def _get_serialize_aliases(self) -> dict[str, str]:
+        """
+        Crea un diccionario de alias a partir de self.model_fields()
+        """
+        return {
+            name: field_info.serialization_alias
+            for name, field_info in self.model_fields.items()
+            if field_info.serialization_alias
+        }
+
+    @model_serializer
+    def _core_serializer(self) -> dict[str, Any]:
+        """
+        Serializador personalizado que omite los miembros OmitIfNone si es que son None
+        """
+        skip_if_none = self._get_skip_if_none_fields()
+        serialize_aliases = self._get_serialize_aliases()
+
+        serialized = dict()
+        for name, value in self:
+            # Skip serializing None if it was marked with "OmitIfNone"
+            if value is None and name in skip_if_none:
+                continue
+
+            serialize_key = serialize_aliases.get(name, name)
+
+            # Run Annotated PlainSerializer
+            for metadata in self.model_fields[name].metadata:
+                if isinstance(metadata, PlainSerializer):
+                    value = metadata.func(value)
+
+            serialized[serialize_key] = value
+
+        return serialized
+
+
+class _PrivateCoreModel(_CustomSerializator, ABC):
+    __class_registry__: ClassVar[dict[str, Type[CoreModel]]] = {}
+    __auto_register__: ClassVar[bool] = False
+
+    __cls_key_name__: ClassVar[str] = 'cls_key'
+    cls_key: OmitIfNone[str | None] = Field(default=None)
+
+    @classmethod
+    def __pydantic_init_subclass__(cls, **kwargs):
+        """
+        Incorpora la funcionalidad de registrar las subclases automáticamente si __auto_register__ == True.
+        Si no se quiere/puede utilizar en una rama de clases entonces puedes usar CoreModel.register(CLASE) o
+        simplemente CLASE.register() con las clases que lo requieran.
+        """
+        super().__pydantic_init_subclass__(**kwargs)
+        if cls.__auto_register__ and not cls.is_registered():
+            cls.register()
+
+    @model_validator(mode="before")
+    @classmethod
+    def _cls_key_handler(cls, data: Any) -> Any:
+        """
+        Si la clase está registrada:
+        - Asigna automáticamente cls_key.
+        Si la clase no está registrada:
+        - Lanza excepción si se ha indicado cls_key.
+        - Lanza excepción si el cls_key
+        """
+        if isinstance(data, dict):
+            # Autoasignar cls_key si la clase está registrada y cls_key es None
+            cls_key = data.get(cls.__cls_key_name__)
+            valid_cls_key = cls.generate_cls_key()
+
+            # Si data no contiene cls_key lo deducimos para averiguar si la clase está registrada
+            if cls_key is None:
+                # Si está registrada entonces agregamos el cls_key a la data
+                if cls.is_registered(valid_cls_key):
+                    data[cls.__cls_key_name__] = valid_cls_key
+                return data
+
+            # data contiene cls_key (no es None)
+            # El cls_key debe ser válido
+            if cls_key != valid_cls_key:
+                raise ValueError(
+                    f"El cls_key indicado no es válido. Trata de no asignar este valor manualmente "
+                    f"(cls_key={cls_key}, valid_cls_key={valid_cls_key})\n\t"
+                )
+            # La clase debe estar registrada
+            if not cls.is_registered(cls_key):
+                # Si type_key está definido entonces validamos que la clase esté registrada
+                raise ValueError(f"La clase '{cls_key}' no está registrada.")
+
+        return data
+
+    @classmethod
+    def _register_single(cls, target_class: Type[CoreModel]):
+        """
+        Registra target_class.
+        """
+        cls_key = target_class.generate_cls_key()
+        if cls_key in cls.__class_registry__:
+            raise KeyError(f"La clase '{cls_key}' ya está registrada.")
+        cls.__class_registry__[cls_key] = target_class
+
+    @classmethod
+    @abstractmethod
+    def register(cls, target_classes: Type[CoreModel] | Iterable[Type[CoreModel]] | None = None) -> None:
+        ...
+
+    @classmethod
+    @abstractmethod
+    def is_registered(cls, cls_key: str | None = None) -> bool:
+        ...
+
+    @classmethod
+    @abstractmethod
+    def generate_cls_key(cls) -> str:
+        ...
+
+
+class CoreModel(_PrivateCoreModel):
+    @classmethod
+    def is_registered(cls, cls_key: str | None = None) -> bool:
+        """
+        Retorna True si la clase está registrada.
+        (TIP: Puedes obtener cls_key mediante Clase.cls_key)
+        """
+        if cls_key is None:
+            cls_key = cls.generate_cls_key()
+        return cls_key in cls.__class_registry__
+
+    @typechecked
+    @classmethod
+    def register(cls, target_classes: Type[CoreModel] | Iterable[Type[CoreModel]] | None = None) -> None:
+        """
+
+        """
+        if target_classes is None:
+            target_classes = (cls,)
+        elif isinstance(target_classes, CoreModel):
+            target_classes = (target_classes,)
+
+        for tgt_class in target_classes:
+            cls._register_single(tgt_class)
+
+    @classmethod
+    def get_registered_class(cls, cls_key: str) -> Type[CoreModel]:
+        """
+        Obtiene la clase asociada al cls_key o lanza excepción KeyError en caso de no encontrarse.
+        (TIP: Puedes obtener cls_key mediante Clase.cls_key)
+        """
+        if not cls.is_registered(cls_key):
+            raise KeyError(f"Unknown or missing class_name: {cls_key}")
+        target_cls = cls.__class_registry__[cls_key]
+
+        # Puede que sea necesario sino remover en un futuro
+        # if AbstractUtils.is_abstract(target_cls):
+        #     raise IsAbstract(f"Cannot use abstract class {cls_key} directly.")
+        return target_cls
+
+    @classmethod
+    def generate_cls_key(cls) -> str:
+        """
+        Genera una key única para cada clase que va a funcionar incluso con tipos genéricos.
+        """
+        type_params = getattr(cls, '__pydantic_generic_metadata__', {}).get('args', ())
+        if type_params:
+            return f"{cls.__name__}[{','.join(tp.__name__ for tp in type_params)}]"
+        return cls.__name__
+
+    @classmethod
+    def polymorphic_single(cls, data: Any) -> Any:
+        """
+        Función auxiliar de los model_validator del usuario. Se debe usar con un miembro polimórfico como por ejemplo
+        animal: Animal, y si se ha registrado previamente 'Gato' y 'Perro' y los datos se corresponden con los de un
+        'Gato' entonces se usará el registro de clases para averiguar la clase correcta y construir un objeto Gato.
+
+        users_dict: SerializeAsAny[dict[str, User]]
+
+        ...
+
+        @model_validator(mode="before")
+        @classmethod
+        def _handle_polymorphic_fields(cls, data: Any) -> dict[str, Any]:
+            if isinstance(data, dict):
+                field_name = 'mascota'
+                _mascota = data.get(field_name)
+                if _mascota is not None:
+                    data[field_name] = cls.polymorphic_single(_mascota)
+            return data
+        """
+
+        if isinstance(data, dict):
+            cls_key = data.get(cls.__cls_key_name__)
+            if cls_key is not None:
+                target_cls = cls.__class_registry__[cls_key]
+                return target_cls(**data)
+        return data
+
+    @classmethod
+    def polymorphic_iterable(cls, data: Iterable, *, generator: Any = tuple) -> Any:
+        """
+        Función auxiliar de los model_validator del usuario. Similar a polymorphic_single, pero ayuda con los iterables
+        en general. Debes usar generator para especificar el tipo de salida (eg. list, tuple, etc.).
+        """
+        deserialized = (cls.polymorphic_single(item) for item in data)
+        if generator is not None:
+            return generator(deserialized)
+        return
+
+    @classmethod
+    def polymorphic_dict(cls, data: Any, *, key: bool = False, value: bool = False, generator: Any = dict) -> Any:
+        """
+        Función auxiliar de los model_validator del usuario. Similar a polymorphic_single, pero ayuda con los
+        diccionarios en lugar de objetos sencillos. Hay que indicar que es polimórfico si el key, el value o ambos,
+        y el tipo que se quiere construir (ej. dict, OrderedDict).
+
+        Esta función llamará a polymorphic_single con todas las keys/valores (dependiendo de lo que sea polimórfico)
+        y finalmente retornará el tipo indicado en generator.
+
+        class ContainerOfAbstractContainers(CoreModel):
+            abs_field: SerializeAsAny[SampleContainerBase]
+            dict_fields: SerializeAsAny[dict[str, SampleContainerBase]]
+            list_field: SerializeAsAny[list[SampleBaseClass]]
+            tuple_field: SerializeAsAny[tuple[SampleBaseClass, ...]]
+
+            @model_validator(mode="before")
+            @classmethod
+            def validate_fields(cls, data: Any) -> Any:
+                if isinstance(data, dict):
+                    deserialization_map = {
+                        'abs_field': cls.polymorphic_single,
+                        'dict_fields': lambda d: cls.polymorphic_dict(d, key=False, value=True, generator=dict),
+                        'list_field': lambda d: cls.polymorphic_iterable(d or [], generator=list),
+                        'tuple_field': lambda d: cls.polymorphic_iterable(d or (), generator=tuple),
+                    }
+
+                    for field, func in deserialization_map.items():
+                        if field in data:
+                            data[field] = func(data.get(field))
+
+                return data
+        """
+        if not key and not value:
+            return data
+
+        deserialized = (
+            (
+                cls.polymorphic_single(k) if key else k,
+                cls.polymorphic_single(v) if value else v,
+            ) for k, v in data.items()
+        )
+
+        if generator is not None:
+            return generator(deserialized)
+        return deserialized
+
+
+CoreModelT = TypeVar('CoreModelT', bound=CoreModel)

kmodels/models/coremodel/leave_unset.py

@@ -0,0 +1,23 @@
+from typing import final, Literal
+
+from kmodels.models.coremodel import CoreModel
+
+
+@final
+class Unset(CoreModel):
+    discriminator: Literal['Unset'] = 'Unset'
+
+    def __repr__(self) -> str:
+        return "<unset>"
+
+
+@final
+class Leave(CoreModel):
+    discriminator: Literal['Leave'] = 'Leave'
+
+    def __repr__(self) -> str:
+        return "<leave>"
+
+
+unset = Unset()
+leave = Leave()

kmodels/test/test.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import SerializeAsAny, model_validator
+from kmodels.models.coremodel import CoreModel
+
+
+def complex_test():
+    # TypeModel.__auto_register__ = True
+
+    class SampleBaseClass(CoreModel):
+        # __auto_register__: ClassVar[bool] = True
+        ...
+
+    class SampleDerivedA(SampleBaseClass):
+        ...
+
+    class SampleContainerBase(CoreModel):
+        # __auto_register__: ClassVar[bool] = True
+        ...
+
+    class SampleContainerA(SampleContainerBase):
+        abs_field: SerializeAsAny[SampleBaseClass]
+
+        @model_validator(mode="before")
+        @classmethod
+        def validate_fields(cls, data: Any) -> Any:
+            if isinstance(data, dict):
+                data['abs_field'] = cls.polymorphic_single(data.get('abs_field'))
+            return data
+
+    class ContainerOfAbstractContainers(CoreModel):
+        abs_field: SerializeAsAny[SampleContainerBase]
+        dict_fields: SerializeAsAny[dict[str, SampleContainerBase]]
+        list_field: SerializeAsAny[list[SampleBaseClass]]
+        tuple_field: SerializeAsAny[tuple[SampleBaseClass, ...]]
+
+        @model_validator(mode="before")
+        @classmethod
+        def validate_fields(cls, data: Any) -> Any:
+            if isinstance(data, dict):
+                deserialization_map = {
+                    'abs_field': cls.polymorphic_single,
+                    'dict_fields': lambda d: cls.polymorphic_dict(d, key=False, value=True, generator=dict),
+                    'list_field': lambda d: cls.polymorphic_iterable(d or [], generator=list),
+                    'tuple_field': lambda d: cls.polymorphic_iterable(d or (), generator=tuple),
+                }
+
+                for field, func in deserialization_map.items():
+                    if field in data:
+                        data[field] = func(data.get(field))
+
+            return data
+
+    CoreModel.register((SampleDerivedA, SampleContainerA))
+
+    print('__class_registry__:', CoreModel.__class_registry__)
+
+    print('1. Jerarquía sencilla sin muchas complicaciones')
+    derived_a = SampleDerivedA()
+    container_a = SampleContainerA(abs_field=derived_a)
+    print(container_a)
+
+    dumped = container_a.model_dump()
+    print(dumped)
+
+    cc2 = SampleContainerA.model_validate(dumped)
+    print(cc2)
+
+    print('\n2. Jerarquía anidada con nuevos campos')
+    super_container = ContainerOfAbstractContainers(
+        abs_field=container_a,
+        dict_fields={'test': container_a, 'test2': container_a},
+        list_field=[derived_a, derived_a],
+        tuple_field=(derived_a, derived_a),
+    )
+    print(super_container)
+
+    dumped = super_container.model_dump()
+    print(dumped)
+
+    super_container2 = ContainerOfAbstractContainers.model_validate(dumped)
+    print(super_container2)
+
+    print(CoreModel.__class_registry__)
+
+
+def simple_test():
+    class User(CoreModel):
+        name: str
+
+    class DiscordUser(User):
+        description: str
+
+    class UserBundle(CoreModel):
+        users: tuple[User, ...]
+        users_dict: SerializeAsAny[dict[str, User]]
+
+        @model_validator(mode="before")
+        @classmethod
+        def _handle_polymorphic_fields(cls, data: Any) -> Any:
+            field_name = 'users'
+            _users = data.get(field_name)
+            if _users is not None:
+                data[field_name] = cls.polymorphic_iterable(_users, generator=tuple)
+
+            field_name = 'users_dict'
+            _users_dict = data.get(field_name)
+            if _users_dict is not None:
+                data[field_name] = cls.polymorphic_dict(_users_dict, value=True, generator=dict)
+
+            return data
+
+    DiscordUser.register()
+
+    user = DiscordUser(
+        name='火星「マールス」',
+        description='''Developer
+Computer science student
+日本語を勉強してる'''
+    )
+
+    users_dict = {'kasei': user}
+
+    user_bundle = UserBundle(users=(user,), users_dict=users_dict)
+    print('user_bundle', user_bundle)
+    json_data = user_bundle.model_dump_json(indent=2)
+    print('json_data', json_data)
+    rebuild_of_bundle = UserBundle.model_validate_json(json_data)
+    print('rebuild_of_bundle', rebuild_of_bundle)
+
+
+if __name__ == '__main__':
+    # complex_test()
+    simple_test()

kmodels/types.py

@@ -0,0 +1,10 @@
+from typing import TypeVar, TYPE_CHECKING, Annotated, Any
+
+AnyType = TypeVar("AnyType")
+
+if TYPE_CHECKING:
+    OmitIfNone = Annotated[AnyType, ...]
+else:
+    class OmitIfNone:
+        def __class_getitem__(cls, item: Any) -> Any:
+            return Annotated[item, OmitIfNone()]

kmodels/utils.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+import inspect
+from abc import ABC
+from typing import Type
+
+from kmodels.error import IsAbstract
+
+
+# Utilidad para manejar clases abstractas
+class AbstractUtils:
+    @classmethod
+    def is_abstract(cls, target_class: Type):
+        return inspect.isabstract(target_class) or ABC in target_class.__bases__
+
+    @classmethod
+    def raise_abstract_class(cls, target_class: Type):
+        if cls.is_abstract(target_class):
+            cname = target_class.__name__
+            raise IsAbstract(f"{cname} is an abstract class (inherits from ABC) and you cannot instantiate it.")
+
+
+# # Utilidad para manejar la validación de class_name
+# class ClassNameUtils:
+#     @classmethod
+#     def validate_class_name(cls, target_class: Type):
+#         # Detectar si es una clase genérica intermedia generada por Pydantic
+#         is_generic_intermediate = '[' in target_class.__name__ and ']' in target_class.__name__
+#         if is_generic_intermediate:
+#             return
+#
+#         # Si es una clase abstracta, no aplicar validación
+#         if cls.is_abstract(target_class):
+#             return
+#
+#         # Validar la existencia y tipo de class_name
+#         class_name_annotation = target_class.__annotations__.get('class_name', None)
+#
+#         if class_name_annotation is None:
+#             raise AttributeError(
+#                 f'Si {target_class.__name__} es abstracta entonces debe heredar de ABC o definir al menos un método '
+#                 f'abstracto, si no lo es entonces debes definirle el atributo class_name de la siguiente manera:\n'
+#                 f'\tclass_name: Literal["{target_class.__name__}"] = "{target_class.__name__}"'
+#             )
+#
+#         # noinspection PyUnresolvedReferences
+#         class_name_type = target_class.model_fields['class_name'].annotation
+#
+#         origin_type = get_origin(class_name_type)
+#         if origin_type is not Literal:
+#             raise AttributeError(
+#                 f"El atributo 'class_name' en la clase {target_class.__name__} debe ser un Literal con el valor "
+#                 f"exacto del nombre de la clase.\n"
+#                 f"\t(Definición de tipo esperada)\n\t\tclass_name: Literal['{target_class.__name__}'] = '{target_class.__name__}'\n"
+#                 f"\t(Definición de tipo encontrada)\n\t\tclass_name: {class_name_annotation} ..."
+#             )
+#
+#         literal_args = list(get_args(class_name_type))
+#         if len(literal_args) != 1:
+#             raise AttributeError(
+#                 f"El atributo 'class_name' en la clase {target_class.__name__} debe ser un Literal con un único valor,\n"
+#                 f"pero se encontraron múltiples opciones: {literal_args}\n"
+#                 f"\t(Definición esperada)\n\t\tclass_name: "
+#                 f"Literal['{target_class.__name__}'] = '{target_class.__name__}'\n"
+#                 f"\t(Definición encontrada)\n\t\tclass_name: Literal{literal_args}"
+#             )
+#
+#         if literal_args[0] != target_class.__name__:
+#             raise AttributeError(
+#                 f"El atributo 'class_name' en la clase {target_class.__name__} debe ser un Literal con el valor exacto de su nombre.\n"
+#                 f"\t(Definición esperada)\n\t\tclass_name: Literal['{target_class.__name__}'] = '{target_class.__name__}'\n"
+#                 f"\t(Definición encontrada)\n\t\tclass_name: Literal['{literal_args[0]}'] = '{literal_args[0]}'"
+#             )
+#
+#     @classmethod
+#     def is_abstract(cls, target_class: Type):
+#         return AbstractUtils.is_abstract(target_class)

kmodels-0.1.0.0.dist-info/METADATA

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: kmodels
+Version: 0.1.0.0
+Summary: KModels
+Home-page: https://github.com/kokaito-git/knotification
+Author: kokaito-git
+Author-email: kokaito.git@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.13
+License-File: LICENSE
+Requires-Dist: pydantic
+Requires-Dist: typeguard
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

kmodels-0.1.0.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+kmodels/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kmodels/error.py,sha256=9VbKUbFA_R_YcuhYNymyFHwzsEiBuvBIHwlc17F0eKw,38
+kmodels/types.py,sha256=1a8G2CSxJcskBFhgGjyZeYuSK1ctB0CRqgAwvWrY6SE,279
+kmodels/utils.py,sha256=H5Z_scnL30UQssS3FU3I-tjRGCWntbWaBh5s150WCLA,3602
+kmodels/_old/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kmodels/_old/_old_models.py,sha256=jeO3C9y1RL857xHORTQT2YjPcASLcz7kHEiwMPQwEoc,6377
+kmodels/models/__init__.py,sha256=lyRGkUSjap79kOjy5n-q7XwU7laN3Sd3rMp0dJtr7Ck,121
+kmodels/models/coremodel/__init__.py,sha256=AFakx3Ukc1dYR7N30hnYLCPM8gB4bU0RzJu6VDwZgV4,146
+kmodels/models/coremodel/coremodel.py,sha256=ny44joj--97ft9G24see8Oub8ZABuQbLOzvIabR_HHg,10684
+kmodels/models/coremodel/leave_unset.py,sha256=B6hH973B0jy0zhJZmtK7MEPPDc4SD34StnsiXUCtUqA,388
+kmodels/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kmodels/test/test.py,sha256=WqrVwpEbRuhxq7qQ9GKXweusS3QRU9jWcWzXyeC3uMU,4265
+kmodels-0.1.0.0.dist-info/licenses/LICENSE,sha256=IMGJwRbv0HTEuPVu4apLyiXc1vyd7jpbIaUAw1J8S9c,1068
+kmodels-0.1.0.0.dist-info/METADATA,sha256=CBedb2wkjVH4Jcdw6HsCM6sTdgo_jUbx-TboAYZdGiM,725
+kmodels-0.1.0.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+kmodels-0.1.0.0.dist-info/top_level.txt,sha256=XeaAElJ1c9V1JGq7Lbl7IPc_OEnf40LsHmnO1tjbR20,8
+kmodels-0.1.0.0.dist-info/RECORD,,

kmodels-0.1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (78.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

kmodels-0.1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 kokaito-git
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

kmodels-0.1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+kmodels