python-datamodel 0.6.18__tar.gz → 0.10.1__tar.gz

python_datamodel-0.10.1/CHANGELOG.md

@@ -0,0 +1,17 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this
+project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+## [0.0.15] - 2022-09-15
+* fixing building wheel for x86_64
+* fixing behaviors over Meta class in Models with missing attributes
+
+## [0.0.7] - 2022-09-14
+* Added "from_dict" and "from_json" methods to create datamodels from json strings and dictionaries
+* added a new json encoder, based on orjson
+* "model()" method export a json version of Model (serialization).
+
+## [0.0.1] - 2022-09-12
+* First version

python_datamodel-0.10.1/CONTRIBUTING.md

@@ -0,0 +1,60 @@
+# Contributing to DataModel
+
+## Preparation
+
+DataModel is designed to use last syntax of asyncio-tools, for that reason, you'll need to have at least Python 3.8 available for testing.
+
+You can do this with [pyenv][]:
+
+
+    $ pyenv install 3.8.1
+    $ pyenv local 3.8.1
+
+Or using virtualenv:
+
+    $ python3.8 -m venv .venv
+
+Also, we can use the command "make venv" inside of Makefile.
+
+    $ make venv
+
+## Setup
+
+Once cloned, create a clean virtual environment and
+install the appropriate tools and dependencies:
+
+    $ cd <path/to/DataModel>
+    $ make venv
+    $ source .venv/bin/activate
+    $ make setup
+
+
+## Formatting
+
+DataModel start using *[black][]* for formating code.
+
+    $ make format
+
+
+## Testing
+
+Once you've made changes, you should run unit tests,
+validate your type annotations, and ensure your code
+meets the appropriate style and linting rules:
+
+    $ make test lint
+
+
+## Submitting
+
+Before submitting a pull request, please ensure
+that you have done the following:
+
+* Documented changes or features in README.md
+* Added appropriate license headers to new files
+* Written or modified tests for new functionality
+* Formatted code following project standards
+* Validated code and formatting with `make test lint`
+
+[black]: https://github.com/psf/black
+[pyenv]: https://github.com/pyenv/pyenv

python_datamodel-0.10.1/MANIFEST.in

@@ -0,0 +1,22 @@
+include LICENSE
+include CHANGELOG.md
+include CONTRIBUTING.md
+include SECURITY.md
+include README.md
+include Makefile
+
+graft datamodel
+graft tests
+
+recursive-include datamodel *.pxd *.pyx
+recursive-include datamodel/rs_parsers *
+
+# Exclude tests, settings, env, examples, and bin folders
+global-exclude *.pyc
+prune docs
+prune settings
+prune env
+prune examples
+prune bin
+recursive-exclude */__pycache__
+prune */__pycache__

python_datamodel-0.10.1/Makefile

@@ -0,0 +1,37 @@
+venv:
+	python3.11 -m venv .venv
+	echo 'run `source .venv/bin/activate` to start develop DataModel'
+
+venv12:
+	python3.12 -m venv .venv11
+	echo 'run `source .venv/bin/activate` to start develop DataModel'
+
+install:
+	pip install -e .
+
+develop:
+	pip install -e .
+	pip install -Ur docs/requirements-dev.txt
+
+compile:
+	python setup.py build_ext --inplace
+
+release:
+	lint test clean
+	flit publish
+
+format:
+	python -m black datamodel
+
+lint:
+	python -m pylint --rcfile .pylintrc datamodels/*.py
+	python -m pylint --rcfile .pylintrc datamodels/models/*.py
+	python -m black --check datamodels
+
+test:
+	python -m coverage run -m datamodels.tests
+	python -m coverage report
+	python -m mypy datamodels/*.py
+
+distclean:
+	rm -rf .venv

{python-datamodel-0.6.18 → python_datamodel-0.10.1}/PKG-INFO

@@ -1,13 +1,16 @@
 Metadata-Version: 2.1
 Name: python-datamodel
-Version: 0.6.18
+Version: 0.10.1
 Summary: simple library based on python +3.8 to use Dataclass-syntaxfor interacting with Data
 Home-page: https://github.com/phenobarbital/python-datamodel
 Author: Jesus Lara
 Author-email: jesuslarag@gmail.com
 License: BSD
-Project-URL: Source, https://github.com/phenobarbital/datamodels
+Project-URL: Source, https://github.com/phenobarbital/datamodel
 Project-URL: Funding, https://paypal.me/phenobarbital
+Project-URL: Tracker, https://github.com/phenobarbital/datamodel/issues
+Project-URL: Documentation, https://datamodel.readthedocs.io/en/latest/
+Project-URL: Buy Me A Coffee!, https://www.buymeacoffee.com/phenobarbital
 Project-URL: Say Thanks!, https://saythanks.io/to/phenobarbital
 Keywords: asyncio,dataclass,dataclasses,data models
 Platform: any
@@ -18,30 +21,32 @@ Classifier: Topic :: Software Development :: Build Tools
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Framework :: AsyncIO
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: System :: Systems Administration
 Classifier: Topic :: Utilities
 Classifier: Environment :: Web Environment
-Requires-Python: >=3.9.14
+Requires-Python: >=3.10.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy==1.24.2
-Requires-Dist: uvloop==0.19.0
+Requires-Dist: numpy>=1.26.4
+Requires-Dist: uvloop>=0.21.0
 Requires-Dist: asyncio==3.4.3
 Requires-Dist: faust-cchardet==2.1.19
-Requires-Dist: ciso8601==2.3.1
+Requires-Dist: ciso8601==2.3.2
 Requires-Dist: objectpath==0.6.1
-Requires-Dist: orjson==3.9.10
-Requires-Dist: typing_extensions==4.8.0
-Requires-Dist: asyncpg==0.29.0
-Requires-Dist: python-dateutil==2.8.2
-Requires-Dist: pendulum==2.1.2
+Requires-Dist: orjson>=3.10.11
+Requires-Dist: typing_extensions>=4.9.0
+Requires-Dist: asyncpg>=0.29.0
+Requires-Dist: python-dateutil>=2.8.2
 Requires-Dist: python-slugify==8.0.1
+Requires-Dist: psycopg2-binary==2.9.10
+Requires-Dist: msgspec==0.19.0
 
 # DataModel
 DataModel is a simple library based on python +3.8 to use Dataclass-syntax for interacting with

python_datamodel-0.10.1/SECURITY.md

@@ -0,0 +1,18 @@
+# Security Policy
+
+## Supported Versions
+
+We release patches for security vulnerabilities. Which versions are eligible
+receiving such patches depend on the CVSS v3.0 Rating:
+
+| CVSS v3.0 | Supported Versions                        |
+| --------- | ----------------------------------------- |
+| 9.0-10.0  | Releases within the previous three months |
+| 4.0-8.9   | Most recent release                       |
+
+## Reporting a Vulnerability
+
+Please report (suspected) security vulnerabilities to
+**[jesularag@gmail.com](mailto:jesularag@gmail.com)**. You will receive a response from
+us within 48 hours. If the issue is confirmed, we will release a patch as soon
+as possible depending on complexity but historically within a few days.

python_datamodel-0.10.1/datamodel/abstract.py

@@ -0,0 +1,383 @@
+import contextlib
+import logging
+from typing import Optional, Any, List, Dict, get_args, get_origin, ClassVar
+from types import GenericAlias
+from collections import OrderedDict
+from collections.abc import Callable
+import types
+from inspect import isclass
+from dataclasses import dataclass, InitVar
+from .parsers.json import JSONContent
+from .converters import encoders, parse_basic
+from .validation import validators
+from .fields import Field
+from .functions import (
+    is_dataclass,
+    is_primitive
+)
+
+class Meta:
+    """
+    Metadata information about Model.
+
+    Attributes:
+    name: str = "" name of the model
+    description: str = "" description of the model
+    schema: str = "" schema of the model (optional)
+    frozen: bool = False if the model (dataclass) is read-only (frozen state)
+    strict: bool = True if the model (dataclass) should raise an error on invalid data.
+    remove_null: bool = True if the model should remove null values from the data.
+    validate_assignment: bool = True if the model should validate during assignment.
+    """
+    name: str = ""
+    description: str = ""
+    schema: str = ""
+    frozen: bool = False
+    strict: bool = True
+    driver: str = None
+    credentials: dict = Optional[dict]
+    dsn: Optional[str] = None
+    datasource: Optional[str] = None
+    connection: Optional[Callable] = None
+    remove_nulls: bool = False
+    endpoint: str
+    extra: str = 'forbid'  # could be 'allow', 'ignore', or 'forbid'
+    validate_assignment: bool = False
+    as_objects: bool = False
+    no_nesting: bool = False
+    alias_function: Optional[Callable] = None
+
+
+def set_connection(cls, conn: Callable):
+    cls.connection = conn
+
+
+def _dc_method_setattr_(self, name: str, value: Any) -> None:
+    """
+    Simplified __setattr__ for dataclass-like objects.
+
+    This version separates the known-field assignment (with optional validation)
+    from the “extra field” assignment and uses a helper to perform conversion/validation.
+    """
+    # Ensure that the __values__ dict is present.
+    if not hasattr(self, '__values__'):
+        object.__setattr__(self, '__values__', {})
+
+    # Check whether we are assigning to a known field.
+    if name in self.__fields__:
+        # Save the initial value (only once).
+        self.__values__.setdefault(name, value)
+
+        # If assignment validation is active, convert the value.
+        if self.Meta.validate_assignment:
+            value = _validate_field_assignment(self, name, value)
+        object.__setattr__(self, name, value)
+        return
+
+    # If the class is frozen, do not allow new attributes.
+    if self.Meta.frozen:
+        raise TypeError(
+            f"Cannot add new attribute {name!r} on {self.modelName} "
+            "(the class is frozen)"
+        )
+
+    # For extra attributes, store them as usual.
+    # (Note: here we “neutralize” any callable value to None if needed.)
+    object.__setattr__(self, name, None if callable(value) else value)
+    if name == '__values__':
+        return
+
+    # If the field isn’t known yet:
+    if name not in self.__fields__:
+        # In strict mode, we don’t allow unknown fields.
+        if self.Meta.strict:
+            return False
+
+        # Otherwise, check the "extra" policy.
+        extra_policy = self.Meta.extra
+        if extra_policy == 'forbid':
+            raise TypeError(f"Field {name!r} is not allowed on {self.modelName}")
+        elif extra_policy == 'ignore':
+            return
+
+        # Dynamically create a new Field for the unknown attribute.
+        try:
+            new_field = Field(required=False, default=value)
+            new_field.name = name
+            new_field.type = type(value)
+            # (Optionally, you might attach a parser here if validation is on.)
+            self.__columns__[name] = new_field
+            self.__fields__.append(name)
+            object.__setattr__(self, name, value)
+        except Exception as err:
+            logging.exception(err, stack_info=True)
+            raise
+
+
+def _validate_field_assignment(self, name: str, value: Any) -> Any:
+    """
+    Helper that applies field conversion/validation based on cached field info.
+
+    If you cache the parser (or the type-category) on the Field during model creation,
+    this helper could simply call that parser.
+    """
+    field_obj = self.__columns__[name]
+    # _type = field_obj.type
+    # _encoder = field_obj.metadata.get('encoder')
+    # Retrieve the field category (pre‐computed at class creation)
+    # field_category = self.__field_types__.get(name, 'complex')
+    try:
+        return field_obj.parser(value) if field_obj.parser else value
+    except Exception as e:
+        raise TypeError(
+            f"Cannot assign {value!r} to field {name!r}: {e}"
+        ) from e
+
+
+class ModelMeta(type):
+    """ModelMeta.
+
+    Metaclass for DataModels, convert any Model into a dataclass-compatible object.
+    """
+    __columns__: Dict
+    __fields__: List
+    __field_types__: List
+    __aliases__: Dict
+
+    def __new__(cls, name, bases, attrs, **kwargs):  # noqa
+        cols = OrderedDict()
+        strict = False
+        cls.__field_types__ = {}
+        cls.__typing_args__ = {}
+        cls.__aliases__ = {}
+        _types = {}
+        _typing_args = {}
+        aliases = {}
+
+        if "__annotations__" in attrs:
+            annotations = attrs.get('__annotations__', {})
+            with contextlib.suppress(TypeError, AttributeError, KeyError):
+                strict = attrs['Meta'].strict
+
+            @staticmethod
+            def _initialize_fields(attrs, annotations, strict):
+                cols = OrderedDict()
+                _types_local = {}
+                _typing_args = {}
+                aliases = {}
+                for field, _type in annotations.items():
+                    if isinstance(_type, InitVar) or _type == InitVar:
+                        # Skip InitVar fields;
+                        # they should not be part of the dataclass instance
+                        continue
+                    origin = get_origin(_type)
+                    if origin is ClassVar:
+                        continue
+
+                    # Check if the field's default value is a descriptor
+                    default_value = attrs.get(field, None)
+                    is_descriptor = any(
+                        hasattr(default_value, method)
+                        for method in ("__get__", "__set__", "__delete__")
+                    )
+                    # Handle the descriptor field
+                    if is_descriptor:
+                        default_value._type_category = 'descriptor'
+                        cols[field] = default_value
+                        _types_local[field] = 'descriptor'
+                        continue
+
+                    if isinstance(_type, Field):
+                        _type = _type.type
+                    df = attrs.get(
+                        field,
+                        Field(type=_type, required=False, default=None)
+                    )
+                    if df is not None and isinstance(df, Field):
+                        alias = df.metadata.get("alias", None)
+                        if alias:
+                            aliases[alias] = field
+                    if not isinstance(df, Field):
+                        df = Field(required=False, type=_type, default=df)
+                    df.name = field
+                    df.type = _type
+
+                    # Cache reflection info so we DON’T need to call
+                    # get_origin/get_args repeatedly:
+                    args = get_args(_type)
+                    _default = df.default
+                    _is_dc = is_dataclass(_type)
+                    _is_prim = is_primitive(_type)
+                    _is_alias = isinstance(_type, GenericAlias)
+                    _is_typing = hasattr(_type, '__module__') and _type.__module__ == 'typing'  # noqa
+
+                    # Store the type info in the field object:
+                    df.is_dc = _is_dc
+                    df.is_primitive = _is_prim
+                    df.is_typing = _is_typing
+                    df.origin = origin
+                    df.args = args
+                    df.type_args = getattr(_type, '__args__', None)
+
+                    df._typeinfo_ = {
+                        "default_callable": callable(_default)
+                    }
+                    # Current Field have an Encoder Function.
+                    custom_encoder = df.metadata.get("encoder")
+                    try:
+                        df.parser = encoders[_type]
+                    except (TypeError, KeyError):
+                        df.parser = None
+                    if custom_encoder:
+                        df.parser = lambda value, _type=_type, encoder=custom_encoder: parse_basic(_type, value, encoder)  # noqa
+                    # Caching Validator:
+                    try:
+                        df.validator = validators[_type]
+                    except (KeyError, TypeError):
+                        df.validator = None
+
+                    # check type of field:
+                    if _is_prim:
+                        _type_category = 'primitive'
+                    elif origin == type:
+                        _type_category = 'type'
+                    elif _is_dc:
+                        _type_category = 'dataclass'
+                    elif _is_typing or _is_alias:  # noqa
+                        if df.origin is not None and (df.origin is list and df.args):
+                            df._inner_type = args[0]
+                            df._inner_origin = get_origin(df._inner_type)
+                            df._typing_args = get_args(df._inner_type)
+                            df._inner_is_dc = is_dataclass(df._inner_type)
+                            try:
+                                df._encoder_fn = encoders[df._inner_type]
+                            except (TypeError, KeyError):
+                                df._encoder_fn = None
+                        if origin is list:
+                            inner_type = args[0]
+                            try:
+                                df._encoder_fn = encoders[inner_type]
+                            except (TypeError, KeyError):
+                                df._encoder_fn = None
+                        _type_category = 'typing'
+                    elif isclass(_type):
+                        _type_category = 'class'
+                    # elif _is_alias:
+                    #    _type_category = 'typing'
+                    else:
+                        # TODO: making parser for complex types
+                        _type_category = 'complex'
+                    _types_local[field] = _type_category
+                    df._type_category = _type_category
+
+                    # Store them in a dict keyed by field name:
+                    _typing_args[field] = (origin, args)
+                    # Assign the field object to the attrs so dataclass can pick it up
+                    attrs[field] = df
+                    cols[field] = df
+                return cols, _types_local, _typing_args, aliases
+
+            # Initialize the fields
+            cols, _types, _typing_args, aliases = _initialize_fields(
+                attrs, annotations, strict
+            )
+        else:
+            # if no __annotations__, cols is empty:
+            cols = OrderedDict()
+
+        _columns = cols.keys()
+        cls.__slots__ = tuple(_columns)
+
+        # Pop Meta before creating the class so we can assign it after
+        attr_meta = attrs.pop("Meta", None)
+        # Create the class
+        new_cls = super().__new__(cls, name, bases, attrs, **kwargs)
+
+        # Attach Meta class
+        new_cls.Meta = attr_meta or getattr(new_cls, "Meta", Meta)
+        new_cls.__dataclass_fields__ = cols
+        new_cls.__typing_args__ = _typing_args
+        if not new_cls.Meta:
+            new_cls.Meta = Meta
+        new_cls.Meta.set_connection = types.MethodType(
+            set_connection, new_cls.Meta
+        )
+        try:
+            frozen = new_cls.Meta.frozen
+        except AttributeError:
+            new_cls.Meta.frozen = False
+            frozen = False
+
+        # mix values from Meta to an existing Meta Class
+        new_cls.Meta.__annotations__ = Meta.__annotations__
+        for key, _ in Meta.__annotations__.items():
+            if not hasattr(new_cls.Meta, key):
+                try:
+                    setattr(new_cls.Meta, key, None)
+                except AttributeError as e:
+                    logging.warning(
+                        f'Missing Meta Key: {key}, {e}'
+                    )
+
+        # If there's a __model_init__ method, call it
+        try:
+            new_cls.__model_init__(
+                new_cls,
+                name,
+                attrs
+            )
+        except AttributeError:
+            pass
+
+        # Now that fields are in attrs, decorate the class as a dataclass
+        dc = dataclass(
+            unsafe_hash=strict,
+            repr=False,
+            init=True,
+            order=False,
+            eq=True,
+            frozen=frozen
+        )(new_cls)
+        # Set additional attributes:
+        dc.__columns__ = cols
+        dc.__fields__ = list(_columns)
+        dc.__values__ = {}
+        dc.__encoder__ = JSONContent
+        dc.__valid__ = False
+        dc.__errors__ = None
+        dc.__frozen__ = strict
+        dc.__initialised__ = False
+        dc.__field_types__ = _types
+        dc.__aliases__ = aliases
+        dc.__typing_args__ = _typing_args
+        dc.modelName = dc.__name__
+
+        # Override __setattr__ method
+        setattr(dc, "__setattr__", _dc_method_setattr_)
+        return dc
+
+    def __init__(cls, *args, **kwargs) -> None:
+        # Initialized Data Model = True
+        cls.__initialised__ = True
+        cls.__errors__ = None
+        super().__init__(*args, **kwargs)
+
+    def __call__(cls, *args, **kwargs):
+        #    rename any kwargs that match an alias ONLY if there are aliases defined.
+        alias_func = getattr(cls.Meta, "alias_function", None)
+        if callable(alias_func):
+            new_kwargs = {}
+            for k, v in kwargs.items():
+                new_k = alias_func(k)
+                new_kwargs[new_k] = v
+            kwargs = new_kwargs
+        if cls.__aliases__:
+            new_kwargs = {}
+            for k, v in kwargs.items():
+                if k in cls.__aliases__:
+                    real_field = cls.__aliases__[k]
+                    new_kwargs[real_field] = v
+                else:
+                    new_kwargs[k] = v
+            kwargs = new_kwargs
+        return super().__call__(*args, **kwargs)