python-datamodel 0.10.9__tar.gz → 0.10.11__tar.gz

{python_datamodel-0.10.9 → python_datamodel-0.10.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-datamodel
-Version: 0.10.9
+Version: 0.10.11
 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.9 → python_datamodel-0.10.11}/datamodel/abstract.py

@@ -153,6 +153,7 @@ class ModelMeta(type):
     __fields__: List
     __field_types__: List
     __aliases__: Dict
+    __primary_keys__: List
     # Class-level cache
     _base_class_cache = {}
 
@@ -162,6 +163,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 +205,10 @@ class ModelMeta(type):
             df.name = field
             df.type = _type
 
+            # Check for primary_key in field metadata
+            if df.metadata.get("primary_key", False):
+                primary_keys.append(field)
+
             # Cache reflection info so we DON’T need to call
             # get_origin/get_args repeatedly:
             args = get_args(_type)
@@ -281,7 +288,7 @@ 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__', {})
@@ -295,12 +302,14 @@ class ModelMeta(type):
             _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,9 +320,11 @@ 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(
+            new_cols, new_types, new_typing_args, new_aliases, nw_primary_keys = cls._initialize_fields(  # noqa
                 attrs, annotations, strict
             )
 
@@ -322,6 +333,7 @@ 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] = {
@@ -329,6 +341,7 @@ class ModelMeta(type):
                 'types': _types.copy(),
                 '_typing_args': _typing_args.copy(),
                 'aliases': aliases.copy(),
+                'primary_keys': primary_keys.copy(),
             }
 
         _columns = cols.keys()
@@ -393,11 +406,33 @@ class ModelMeta(type):
         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.9 → python_datamodel-0.10.11}/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
@@ -230,15 +230,18 @@ class ModelMixin:
     ) -> dict[str, Any]:
         """Recursively converts any BaseModel instances to their primary key value."""
         out = {}
-        fields = self.columns()
-        for name, field in fields.items():
+        _fields = self.columns()
+        for name, field in _fields.items():
             # datatype = field.type
             value = getattr(self, name)
             if value is None and remove_nulls:
                 continue
             if isinstance(value, ModelMixin):
                 if as_values:
-                    out[name] = getattr(value, name)
+                    try:
+                        out[name] = getattr(value, name)
+                    except AttributeError:
+                        out[name] = value.to_json()
                 else:
                     out[name] = value.__collapse_as_values__(
                         remove_nulls=remove_nulls,
@@ -247,11 +250,30 @@ class ModelMixin:
                     )
             # if it's a list, might contain submodels or scalars
             elif isinstance(value, list):
+                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):
                         if as_values:
-                            items_out.append(getattr(item, name))
+                            try:
+                                items_out.append(getattr(item, name))
+                            except AttributeError:
+                                items_out.append(item.to_json())
                         else:
                             items_out.append(item.__collapse_as_values__(
                                 remove_nulls=remove_nulls,
@@ -391,7 +413,7 @@ class ModelMixin:
     @classmethod
     def _build_fields(cls, title: str, locale: Any = None) -> dict:
         """Build the fields part of the schema."""
-        fields = {}
+        _fields = {}
         required = []
         defs = {}
 
@@ -400,12 +422,12 @@ class ModelMixin:
             field_schema, field_defs, field_required = cls._process_field_schema(
                 name, field, locale, title
             )
-            fields[name] = field_schema
+            _fields[name] = field_schema
             if field_required:
                 required.append(name)
             if field_defs:
                 defs[name] = field_defs.get('schema')
-        return fields, required, defs
+        return _fields, required, defs
 
     @classmethod
     def _extract_field_basics(cls, name: str, field: Field, title: str):
@@ -623,7 +645,7 @@ class ModelMixin:
         endpoint_kwargs = {"endpoint": endpoint} if endpoint else {}
 
         # Build the fields part of the schema.
-        fields, required, defs = cls._build_fields(title, locale)
+        _fields, required, defs = cls._build_fields(title, locale)
 
         base_schema = {
             "$schema": "https://json-schema.org/draft/2020-12/schema",
@@ -636,7 +658,7 @@ class ModelMixin:
             "type": "object",
             "table": table,
             "schema": schema,
-            "properties": fields,
+            "properties": _fields,
             "required": required,
             "display_name": display_name,
         }

{python_datamodel-0.10.9 → python_datamodel-0.10.11}/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.9'
+__version__ = '0.10.11'
 __copyright__ = 'Copyright (c) 2020-2024 Jesus Lara'
 __author__ = 'Jesus Lara'
 __author_email__ = 'jesuslarag@gmail.com'

{python_datamodel-0.10.9 → python_datamodel-0.10.11}/python_datamodel.egg-info/PKG-INFO

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