python-datamodel 0.10.10__tar.gz → 0.10.13__tar.gz

{python_datamodel-0.10.10 → python_datamodel-0.10.13}/MANIFEST.in

@@ -13,6 +13,8 @@ recursive-include datamodel/rs_parsers *
 
 # Exclude tests, settings, env, examples, and bin folders
 global-exclude *.pyc
+recursive-exclude datamodel/rs_parsers/target *
+
 prune docs
 prune settings
 prune env

{python_datamodel-0.10.10 → python_datamodel-0.10.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-datamodel
-Version: 0.10.10
+Version: 0.10.13
 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

{python_datamodel-0.10.10 → python_datamodel-0.10.13}/datamodel/abstract.py

@@ -16,6 +16,7 @@ from collections import OrderedDict
 from collections.abc import Callable
 import types
 from inspect import isclass
+from functools import lru_cache
 from dataclasses import dataclass, InitVar
 from .parsers.json import JSONContent
 from .converters import encoders, parse_basic
@@ -153,8 +154,27 @@ class ModelMeta(type):
     __fields__: List
     __field_types__: List
     __aliases__: Dict
+    __primary_keys__: List
     # Class-level cache
-    _base_class_cache = {}
+    _base_class_cache = OrderedDict()
+    _MAX_CACHE_SIZE = 512  # size limit
+
+    @classmethod
+    def _cache_get(cls, key):
+        """Get item from cache with LRU behavior."""
+        if key not in cls._base_class_cache:
+            return None
+        value = cls._base_class_cache.pop(key)
+        cls._base_class_cache[key] = value
+        return value
+
+    @classmethod
+    def _cache_set(cls, key, value):
+        """Set item in cache with LRU eviction."""
+        # If cache is full, remove oldest item (first in OrderedDict)
+        if len(cls._base_class_cache) >= cls._MAX_CACHE_SIZE:
+            cls._base_class_cache.popitem(last=False)
+        cls._base_class_cache[key] = value
 
     @staticmethod
     def _initialize_fields(attrs, annotations, strict):
@@ -162,6 +182,8 @@ class ModelMeta(type):
         _types_local = {}
         _typing_args = {}
         aliases = {}
+        primary_keys = []  # New list to collect primary key fields
+
         for field, _type in annotations.items():
             if isinstance(_type, InitVar) or _type == InitVar:
                 # Skip InitVar fields;
@@ -202,6 +224,10 @@ class ModelMeta(type):
             df.name = field
             df.type = _type
 
+            # Check for primary_key in field metadata
+            if df.metadata.get("primary", False) or df.primary_key is True:
+                primary_keys.append(field)
+
             # Cache reflection info so we DON’T need to call
             # get_origin/get_args repeatedly:
             args = get_args(_type)
@@ -281,26 +307,35 @@ class ModelMeta(type):
             # 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
+        return cols, _types_local, _typing_args, aliases, primary_keys
 
     def __new__(cls, name, bases, attrs, **kwargs):  # noqa
         annotations = attrs.get('__annotations__', {})
-        base_key = (tuple(bases), tuple(sorted(annotations.items())))
-        strict = getattr(attrs.get('Meta', Meta), 'strict', False)
+        _strict_ = False
+        cols = OrderedDict()
 
-        if base_key in cls._base_class_cache:
+        # Base class constructor
+        base_key = (name, tuple(bases), tuple(sorted(annotations.items())))
+        with contextlib.suppress(TypeError, AttributeError, KeyError):
+            _strict_ = attrs['Meta'].strict
+
+        # Use LRU get method
+        cached = cls._cache_get(base_key)
+        if cached:
+            # if base_key in cls._base_class_cache:
             # Check the Cache First:
-            cached = cls._base_class_cache[base_key]
+            # cached = cls._base_class_cache[base_key]
             cols = cached['cols'].copy()
             _types = cached['types'].copy()
             _typing_args = cached['_typing_args'].copy()
             aliases = cached['aliases'].copy()
+            primary_keys = cached['primary_keys'].copy()
         else:
             # Compute field from Bases:
-            cols = OrderedDict()
             _types = {}
             _typing_args = {}
             aliases = {}
+            primary_keys = []
 
             # Step 1: Collect fields from parent classes
             for base in bases:
@@ -311,10 +346,12 @@ class ModelMeta(type):
                     _typing_args |= base.__typing_args__
                 if hasattr(base, '__aliases__'):
                     aliases |= base.__aliases__
+                if hasattr(base, '__primary_keys__'):
+                    primary_keys += base.__primary_keys__
 
             # Now initialize subclass-specific fields
-            new_cols, new_types, new_typing_args, new_aliases = cls._initialize_fields(
-                attrs, annotations, strict
+            new_cols, new_types, new_typing_args, new_aliases, nw_primary_keys = cls._initialize_fields(  # noqa
+                attrs, annotations, _strict_
             )
 
             # Merge new fields with inherited fields
@@ -322,14 +359,24 @@ class ModelMeta(type):
             _types.update(new_types)
             _typing_args.update(new_typing_args)
             aliases.update(new_aliases)
+            primary_keys.extend(nw_primary_keys)
 
             # Store computed results in cache
-            cls._base_class_cache[base_key] = {
+            # cls._base_class_cache[base_key] = {
+            #     'cols': cols.copy(),
+            #     'types': _types.copy(),
+            #     '_typing_args': _typing_args.copy(),
+            #     'aliases': aliases.copy(),
+            #     'primary_keys': primary_keys.copy(),
+            # }
+            cache_entry = {
                 'cols': cols.copy(),
                 'types': _types.copy(),
                 '_typing_args': _typing_args.copy(),
                 'aliases': aliases.copy(),
+                'primary_keys': primary_keys.copy(),
             }
+            cls._cache_set(base_key, cache_entry)
 
         _columns = cols.keys()
         cls.__slots__ = tuple(_columns)
@@ -375,7 +422,7 @@ class ModelMeta(type):
 
         # Now that fields are in attrs, decorate the class as a dataclass
         dc = dataclass(
-            unsafe_hash=strict,
+            unsafe_hash=_strict_,
             repr=False,
             init=True,
             order=False,
@@ -389,15 +436,37 @@ class ModelMeta(type):
         dc.__valid__ = False
         dc.__errors__ = {}
         dc.__values__ = {}
-        dc.__frozen__ = strict
+        dc.__frozen__ = _strict_
         dc.__initialised__ = False
         dc.__field_types__ = _types
         dc.__aliases__ = aliases
+        # Set the primary_keys on the dataclass
+        dc.__primary_keys__ = primary_keys
         dc.__typing_args__ = _typing_args
         dc.modelName = dc.__name__
 
         # Override __setattr__ method
         setattr(dc, "__setattr__", _dc_method_setattr_)
+
+        # Method to get primary keys without further introspection
+        def get_primary_keys(cls):
+            return cls.__primary_keys__
+
+        # Add the method to the class
+        dc.get_primary_keys = classmethod(get_primary_keys)
+
+        def get_primary_key_fields(cls):
+            """Return a dictionary of primary key fields with their types."""
+            return {name: cls.__columns__[name] for name in cls.__primary_keys__}
+
+        dc.get_primary_key_fields = classmethod(get_primary_key_fields)
+
+        def get_primary_key_values(self):
+            """Get primary key values for this instance as a dictionary."""
+            return {key: getattr(self, key) for key in self.__primary_keys__}
+
+        dc.get_primary_key_values = get_primary_key_values
+
         return dc
 
     def __init__(cls, *args, **kwargs) -> None:

{python_datamodel-0.10.10 → python_datamodel-0.10.13}/datamodel/models.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 import contextlib
-from typing import Any, Dict
+from typing import Any, Dict, get_args
 from enum import Enum, EnumMeta
 # Dataclass
 import inspect
@@ -250,13 +250,22 @@ class ModelMixin:
                     )
             # if it's a list, might contain submodels or scalars
             elif isinstance(value, list):
-                if field.origin is list and field.args:
-                    submodel_class = field.args[0]  # The type inside the list
-                    if issubclass(
-                        submodel_class, ModelMixin
-                    ) and not hasattr(submodel_class, name):
-                        out[name] = json_encoder(value)
-                        continue
+                targs = field.args
+                if len(targs) == 2 and targs[1] is type(None):
+                    # Checking if it's Optional[T]
+                    submodel_class = get_args(targs[0])
+                elif field.origin is list and field.args:
+                    submodel_class = field.args[0]
+                else:
+                    submodel_class = None
+                if field.origin is list and submodel_class and (
+                    issubclass(
+                        submodel_class,
+                        ModelMixin
+                    ) and not hasattr(submodel_class, name)
+                ):
+                    out[name] = json_encoder(value)
+                    continue
                 items_out = []
                 for item in value:
                     if isinstance(item, ModelMixin):

{python_datamodel-0.10.10 → python_datamodel-0.10.13}/datamodel/rs_parsers/src/lib.rs

@@ -5,12 +5,10 @@ use pyo3::wrap_pyfunction;
 use pyo3::types::{PyDate, PyDateTime, PyAny, PyString, PyBool, PyBytes, PyInt, PyFloat, PyList};
 use chrono::{Datelike, Timelike, NaiveDate, NaiveDateTime, DateTime, Utc};
 use speedate::Date as SpeeDate;
-use std::sync::Mutex;
 use speedate::DateTime as SpeeDateTime;
 use uuid::Uuid;
 use rust_decimal::Decimal; // Rust Decimal crate
 use rust_decimal::prelude::FromStr;
-use rayon::prelude::*;
 // use speedate::{Date, DateTime, ParseError};
 // use std::collections::HashMap;
 // NaiveTime

{python_datamodel-0.10.10 → python_datamodel-0.10.13}/datamodel/version.py

@@ -6,7 +6,7 @@ __description__ = (
     'simple library based on python +3.8 to use Dataclass-syntax'
     'for interacting with Data'
 )
-__version__ = '0.10.10'
+__version__ = '0.10.13'
 __copyright__ = 'Copyright (c) 2020-2024 Jesus Lara'
 __author__ = 'Jesus Lara'
 __author_email__ = 'jesuslarag@gmail.com'

{python_datamodel-0.10.10 → python_datamodel-0.10.13}/python_datamodel.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-datamodel
-Version: 0.10.10
+Version: 0.10.13
 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