python-datamodel 0.6.28__cp313-cp313-win_amd64.whl

datamodel/libs/mutables.py

@@ -0,0 +1,116 @@
+import sys
+from collections.abc import MutableMapping, Iterator, Iterable
+from typing import Any, Optional, Union
+from datamodel import Field
+
+if sys.version_info < (3, 10):
+    from typing_extensions import ParamSpec
+else:
+    from typing import ParamSpec
+P = ParamSpec("P")
+
+class ClassDict(dict, MutableMapping):
+    """ClassDict.
+
+    Mapping that works like both a simple Dictionary or a Mutable Object.
+    """
+    def __init__(self, *args: P.args, data: Optional[Union[tuple, dict]] = None, default: Any = None, **kwargs: P.kwargs):
+        self._columns: list = []
+        self.mapping = {}
+        self.default = default
+        self.mapping.update(*args, **kwargs)
+        self.update(data, **kwargs)
+
+    def update(self, items: Optional[Iterable] = None, **kwargs): # pylint: disable=W0221
+        if isinstance(items, dict):
+            for key, value in items.items():
+                # self.mapping[key] = value
+                self.mapping[key] = value
+        else:
+            for k,v in kwargs.items():
+                attr = getattr(self, k)
+                if isinstance(attr, Field):
+                    try:
+                        fn = attr.default
+                        if callable(fn):
+                            v = fn(v)
+                            setattr(self, k, v)
+                        else:
+                            setattr(self, k, fn)
+                    except KeyError:
+                        pass
+                # self.mapping[k] = v
+                self.mapping[k] = v
+        self._columns = list(self.mapping.keys())
+
+    def __missing__(self, key):
+        return self.default
+
+    def items(self) -> zip:  # type: ignore
+        return zip(self._columns, self.mapping)
+
+    def keys(self) -> list:
+        return self._columns
+
+    def set(self, key, value) -> None:
+        self.mapping[key] = value
+        if not key in self._columns:
+            self._columns.append(key)
+
+    ### Section: Simple magic methods
+    def __len__(self) -> int:
+        return len(self.mapping)
+
+    def __str__(self) -> str:
+        return f"<{type(self).__name__}({self.mapping})>"
+
+    def __repr__(self) -> str:
+        return f"<{type(self).__name__}({self.mapping})>"
+
+    def __contains__(self, key: str) -> bool:
+        return key in self._columns
+
+    def __delitem__(self, key) -> None:
+        value = self[key]
+        del self.mapping[key]
+        self._columns.remove(key)
+        self.pop(value, None)
+
+    def __delattr__(self, name: str) -> None:
+        value = self[name]
+        del self.mapping[name]
+        self._columns.remove(name)
+        self.pop(value, None)
+
+    def __setitem__(self, key, value):
+        self.mapping[key] = value
+        if not key in self._columns:
+            self._columns.append(key)
+
+    def __getitem__(self, key: Union[str, int]) -> Any:
+        """
+        Sequence-like operators
+        """
+        try:
+            return self.mapping[key]
+        except (KeyError, TypeError):
+            return None
+
+    def __getattr__(self, attr: str) -> Any:
+        """
+        Attributes for dict keys
+        """
+        try:
+            return self.__getitem__(attr)
+        except KeyError as ex:
+            raise KeyError(
+                f"User Error: invalid field name {attr} on {self.mapping!r}"
+            ) from ex
+        except TypeError as ex:
+            raise TypeError(
+                f"User Error: invalid attribute value on {self.mapping!r} for {attr}"
+            ) from ex
+
+    def __iter__(self) -> Iterator:
+        for value in self.mapping:
+            yield value

datamodel/models.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+from typing import Any
+# Dataclass
+from dataclasses import asdict as as_dict
+from operator import attrgetter
+from datamodel.fields import fields
+from .abstract import ModelMeta, Meta
+from .fields import Field
+
+class ModelMixin:
+    """Interface for shared methods on Model classes.
+    """
+    def __unicode__(self):
+        return str(__class__)
+
+    def columns(self):
+        return self.__columns__
+
+    @classmethod
+    def get_columns(cls):
+        return cls.__columns__
+
+    @classmethod
+    def get_column(cls, name: str) -> Field:
+        try:
+            return cls.__columns__[name]
+        except KeyError:
+            raise AttributeError(
+                f"{cls.__name__} has no column {name}"
+            )
+
+    def get_fields(self):
+        return self.__fields__
+
+    def __getitem__(self, item):
+        return getattr(self, item)
+
+    def reset_values(self):
+        try:
+            self.__values__ = {}
+        except AttributeError:
+            pass
+
+    def old_value(self, name: str) -> Any:
+        """
+        old_value.
+        Get the old value of an attribute.
+        Args:
+            name (str): name of the attribute.
+        Returns:
+            Any: value of the attribute.
+        """
+        try:
+            return self.__values__[name]
+        except KeyError:
+            raise AttributeError(
+                f"{self.__class__.__name__} has no attribute {name}"
+            )
+
+    def column(self, name: str) -> Field:
+        return self.__columns__[name]
+
+    def __repr__(self) -> str:
+        f_repr = ", ".join(f"{f.name}={getattr(self, f.name)}" for f in fields(self))
+        return f"{self.__class__.__name__}({f_repr})"
+
+    def remove_nulls(self, obj: Any) -> dict[str, Any]:
+        """Recursively removes any fields with None values from the given object."""
+        if isinstance(obj, list):
+            return [self.remove_nulls(item) for item in obj]
+        elif isinstance(obj, dict):
+            return {
+                key: self.remove_nulls(value) for key, value in obj.items()
+                if value is not None
+            }
+        else:
+            return obj
+
+    def to_dict(self):
+        if self.Meta.remove_nulls is True:
+            return self.remove_nulls(as_dict(self, dict_factory=dict))
+        return as_dict(self)
+
+    def json(self, **kwargs):
+        encoder = self.__encoder__(**kwargs)
+        return encoder(as_dict(self))
+
+    to_json = json
+
+    def is_valid(self) -> bool:
+        """is_valid.
+
+        returns True when current Model is valid under datatype validations.
+        Returns:
+            bool: True if current model is valid.
+        """
+        return bool(self.__valid__)
+
+class Model(ModelMixin, metaclass=ModelMeta):
+    """Model.
+
+    Basic dataclass-based Model.
+    """
+    Meta = Meta
+
+    def __post_init__(self) -> None:
+        """
+        Post init method.
+        Useful for making Post-validations of Model.
+        """
+        self.__initialised__ = True

datamodel/parsers/encoders.py

@@ -0,0 +1,15 @@
+"""
+JSON Encoders.
+"""
+from .json import JSONContent, json_encoder
+
+DefaultEncoder = JSONContent
+
+class BaseEncoder:
+    """
+    Encoder replacement for json.dumps using orjson
+    """
+
+    def __init__(self, *args, **kwargs):
+        encoder = DefaultEncoder(*args, **kwargs)
+        self.encode = encoder.__call__