feat: wip

Author: klen

.github/workflows/tests.yml

@@ -19,7 +19,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ['3.8', '3.9', '3.10', '3.11']
+        python-version: ['3.9', '3.10', '3.11', '3.12', '3.13']
 
     steps:
     - uses: actions/checkout@main

.pre-commit-config.yaml

@@ -4,7 +4,7 @@ fail_fast: true
 
 repos:
 -   repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.4.0
+    rev: v5.0.0
     hooks:
     - id: check-added-large-files
     - id: check-ast
@@ -19,12 +19,12 @@ repos:
     - id: trailing-whitespace
 
 - repo: https://github.com/psf/black
-  rev: 23.1.0
+  rev: 24.10.0
   hooks:
   - id: black
 
 - repo: https://github.com/python-poetry/poetry
-  rev: '1.5.1'
+  rev: '1.8.0'
   hooks:
     - id: poetry-check
     - id: poetry-lock

README.md

@@ -12,7 +12,7 @@ integration with the
 
 ## Requirements
 
-* python >= 3.7
+* python >= 3.9
 
 ## Installation
 

marshmallow_peewee/convert.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from collections import OrderedDict
-from typing import TYPE_CHECKING, List, Optional, Type, cast, overload
+from typing import TYPE_CHECKING, Optional, cast, overload
 
 import peewee as pw
 from marshmallow import ValidationError, fields
@@ -36,34 +36,35 @@ def __init__(self, opts: SchemaOpts):
     def get_fields(self, model: pw.Model) -> OrderedDict[str, fields.Field]:
         result = OrderedDict()
         meta = cast(pw.Metadata, model._meta)  # type: ignore[]
+        id_keys = self.opts.id_keys
         for field in meta.sorted_fields:
-            name = field.name
-            if self.opts.id_keys and isinstance(
+            data_key = field.name
+            if id_keys and isinstance(
                 field, (pw.ForeignKeyField, pw.DeferredForeignKey)
             ):
-                name = field.column_name
+                data_key = field.column_name
 
-            ma_field = self.convert(field)
-            if ma_field:
-                result[name] = ma_field
+            ma_field = self.convert(field, data_key)
+            if not ma_field:
+                continue
+
+            result[data_key] = ma_field
 
         return result
 
     @overload
     @classmethod
-    def register(cls, field: Type[pw.Field]) -> Callable[[Callable], Callable]:
-        ...
+    def register(cls, field: type[pw.Field]) -> Callable[[Callable], Callable]: ...
 
     @overload
     @classmethod
-    def register(cls, field: Type[pw.Field], ma_field: Type[fields.Field]) -> None:
-        ...
+    def register(cls, field: type[pw.Field], ma_field: type[fields.Field]) -> None: ...
 
     @classmethod
     def register(
         cls,
-        field: Type[pw.Field],
-        ma_field: Optional[Type[fields.Field]] = None,
+        field: type[pw.Field],
+        ma_field: Optional[type[fields.Field]] = None,
     ) -> Callable[[Callable], Callable] | None:
         if ma_field is None:
 
@@ -78,10 +79,10 @@ def wrapper(fn):
 
         return None
 
-    def convert(self, field: pw.Field) -> fields.Field:
+    def convert(self, field: pw.Field, data_key: Optional[str] = None) -> fields.Field:
         params = {
+            "data_key": data_key or field.name,
             "allow_none": field.null,
-            "attribute": field.name,
             "required": not field.null and field.default is None,
             "validate": [convert_value_validate(field.db_value)],
         }
@@ -100,8 +101,9 @@ def convert(self, field: pw.Field) -> fields.Field:
                 labels.append(c[1])
             params["validate"].append(ma_validate.OneOf(choices, labels))
 
+        params["metadata"] = {"name": field.name}
         if field.help_text:
-            params["metadata"] = {"description": field.help_text}
+            params["metadata"]["description"] = field.help_text
 
         # use first "known" field class from field class mro
         # so that extended field classes get converted correctly
@@ -113,7 +115,7 @@ def convert(self, field: pw.Field) -> fields.Field:
         return DEFAULT_BUILDER(field, self.opts, **params)
 
 
-def generate_builder(ma_field_cls: Type[fields.Field]) -> Callable:
+def generate_builder(ma_field_cls: type[fields.Field]) -> Callable:
     """Generate builder function for given marshmallow field."""
 
     def builder(_: pw.Field, __: SchemaOpts, **params) -> fields.Field:
@@ -153,7 +155,7 @@ def convert_charfield(
     field: pw.CharField,
     _: SchemaOpts,
     *,
-    validate: Optional[List] = None,
+    validate: Optional[list] = None,
     **params,
 ) -> fields.Field:
     if validate is None:

marshmallow_peewee/fields.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Dict, Optional, Type, Union
+from typing import Any, Optional, Union
 
 import peewee as pw
 from marshmallow import Schema, fields
@@ -9,8 +9,8 @@
 class Related(fields.Nested):
     def __init__(
         self,
-        nested: Optional[Type[Schema]] = None,
-        meta: Optional[Dict[str, Any]] = None,
+        nested: Optional[type[Schema]] = None,
+        meta: Optional[dict[str, Any]] = None,
         **kwargs,
     ):
         self.field = None
@@ -34,14 +34,14 @@ def init_model(self, model: pw.Model, name: str):
         meta = type("Meta", (), self.meta)
         self.nested = type("Schema", (ModelSchema,), {"Meta": meta})
 
-    def _deserialize(self, value, attr, data, **_):
+    def _deserialize(self, value, attr, data, partial=None, **_):
         if self.field is None:
             raise RuntimeError("Init model first.")
 
         if not isinstance(value, dict):
             return self.field.rel_field.python_value(value)
 
-        return super(Related, self)._deserialize(value, attr, data)
+        return super(Related, self)._deserialize(value, attr, data, partial=partial)
 
 
 class ForeignKey(fields.Raw):
@@ -53,8 +53,7 @@ def _bind_to_schema(self, field_name, schema):
 
     def get_value(self, obj: pw.Model, attr, **_) -> Any:  # type: ignore[override]
         """Return the value for a given key from an object."""
-        check_key = attr if self.attribute is None else self.attribute
-        value = obj.__data__.get(check_key)
+        value = obj.__data__.get(self.metadata["name"])
         if value is not None and self.string_keys:
             return str(value)
         return value
@@ -63,14 +62,14 @@ def get_value(self, obj: pw.Model, attr, **_) -> Any:  # type: ignore[override]
 class FKNested(fields.Nested):
     """Get an related instance from cache."""
 
-    def __init__(self, nested: Union[Type[Schema], Type[pw.Model]], **kwargs):
+    def __init__(self, nested: Union[type[Schema], type[pw.Model]], **kwargs):
         if issubclass(nested, pw.Model):
             nested = self.get_schema(nested, **kwargs)
 
         super(FKNested, self).__init__(nested, **kwargs)
 
     @staticmethod
-    def get_schema(model_cls: Type[pw.Model], **kwargs) -> Type[Schema]:
+    def get_schema(model_cls: type[pw.Model], **kwargs) -> type[Schema]:
         from .schema import ModelSchema
 
         class Schema(ModelSchema):

marshmallow_peewee/schema.py

@@ -3,14 +3,12 @@
 from typing import (
     TYPE_CHECKING,
     Any,
-    Dict,
+    ClassVar,
     Generic,
     Iterable,
-    List,
     Literal,
     Mapping,
     Optional,
-    Type,
     Union,
     overload,
 )
@@ -26,11 +24,11 @@
 
 
 class SchemaOpts(ma.SchemaOpts, Generic[TVModel]):
-    model: Optional[Type[TVModel]]
+    model: Optional[type[TVModel]]
     dump_only_pk: bool
     string_keys: bool
     id_keys: bool
-    model_converter: Type[DefaultConverter]
+    model_converter: type[DefaultConverter]
 
     def __init__(self, meta, **kwargs):
         super(SchemaOpts, self).__init__(meta, **kwargs)
@@ -73,7 +71,7 @@ def __new__(cls, name, bases, attrs):
         return super(SchemaMeta, cls).__new__(cls, name, bases, attrs)
 
     @classmethod
-    def get_declared_fields(cls, klass, cls_fields, inherited_fields, dict_cls):
+    def get_declared_fields(cls, klass, cls_fields, inherited_fields, dict_cls=dict):
         opts: SchemaOpts = klass.opts
         base_fields = super(SchemaMeta, cls).get_declared_fields(
             klass, cls_fields, inherited_fields, dict_cls
@@ -95,20 +93,21 @@ class ModelSchema(ma.Schema, Generic[TVModel], metaclass=SchemaMeta):
     OPTIONS_CLASS = SchemaOpts
 
     opts: SchemaOpts[TVModel]
+    Meta: ClassVar[type[Any]]
 
     def __init__(self, instance: Optional[TVModel] = None, **kwargs):
         self.instance = instance
         super(ModelSchema, self).__init__(**kwargs)
 
     @overload  # type: ignore[override]
-    def load(self, data, *, many: Optional[Literal[False]] = None, **kwargs) -> TVModel:
-        ...
+    def load(
+        self, data, *, many: Optional[Literal[False]] = None, **kwargs
+    ) -> TVModel: ...
 
     @overload
     def load(
         self, data, *, many: Optional[Literal[True]] = None, **kwargs
-    ) -> List[TVModel]:
-        ...
+    ) -> list[TVModel]: ...
 
     def load(
         self,
@@ -121,7 +120,7 @@ def load(
         return super().load(data, **kwargs)
 
     @ma.post_load
-    def make_instance(self, data: Dict[str, Any], **params) -> Union[Dict, TVModel]:
+    def make_instance(self, data: dict[str, Any], **params) -> Union[dict, TVModel]:
         """Build object from data."""
         if not self.opts.model:
             return data
@@ -137,18 +136,14 @@ def make_instance(self, data: Dict[str, Any], **params) -> Union[Dict, TVModel]:
     if TYPE_CHECKING:
 
         @overload  # type: ignore[override]
-        def dump(self, obj) -> Dict[str, Any]:
-            ...
+        def dump(self, obj) -> dict[str, Any]: ...
 
         @overload
-        def dump(self, obj, *, many: Literal[False]) -> Dict[str, Any]:
-            ...
+        def dump(self, obj, *, many: Literal[False]) -> dict[str, Any]: ...
 
         @overload
-        def dump(self, obj, *, many: Literal[True]) -> List[Dict[str, Any]]:
-            ...
+        def dump(self, obj, *, many: Literal[True]) -> list[dict[str, Any]]: ...
 
         def dump(
             self, obj: Union[TVModel, Iterable[TVModel]], *, many: Optional[bool] = None
-        ) -> Union[Dict[str, Any], List[Dict[str, Any]]]:
-            ...
+        ) -> Union[dict[str, Any], list[dict[str, Any]]]: ...