starmallow 0.6.5__tar.gz → 0.7.0__tar.gz

{starmallow-0.6.5 → starmallow-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: starmallow
-Version: 0.6.5
+Version: 0.7.0
 Summary: StarMallow framework
 Project-URL: Homepage, https://github.com/mvanderlee/starmallow
 Author-email: Michiel Vanderlee <jmt.vanderlee@gmail.com>

{starmallow-0.6.5 → starmallow-0.7.0}/starmallow/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.6.5"
+__version__ = "0.7.0"
 
 from .applications import StarMallow
 from .exceptions import RequestValidationError

{starmallow-0.6.5 → starmallow-0.7.0}/starmallow/ext/marshmallow/openapi.py

@@ -14,6 +14,7 @@ from apispec.ext.marshmallow.openapi import OpenAPIConverter as ApiSpecOpenAPICo
 from marshmallow.utils import is_collection
 from packaging.version import Version
 
+from starmallow.union_field import Union as UnionField
 from starmallow.utils import MARSHMALLOW_ITERABLES
 
 # marshmallow field => (JSON Schema type, format)
@@ -98,6 +99,7 @@ class OpenAPIConverter(ApiSpecOpenAPIConverter):
         self.add_attribute_function(self.field2title)
         self.add_attribute_function(self.field2uniqueItems)
         self.add_attribute_function(self.field2enum)
+        self.add_attribute_function(self.field2union)
 
     # Overriding to add exclusiveMinimum and exclusiveMaximum support
     def field2range(self: FieldConverterMixin, field: mf.Field, ret) -> dict:
@@ -211,6 +213,35 @@ class OpenAPIConverter(ApiSpecOpenAPIConverter):
 
         return ret
 
+    def field2union(self: FieldConverterMixin, field: mf.Field, **kwargs: Any) -> dict:
+        ret = {}
+
+        if isinstance(field, UnionField):
+            union_types = []
+            untyped = False
+            for _, subfield in field.union_fields:
+                for field_class in type(subfield).__mro__:
+                    if field_class in self.field_mapping:
+                        type_, fmt = self.field_mapping[field_class]
+
+                        union_type = {}
+                        if type_:
+                            union_type['type'] = type_
+                        if fmt:
+                            union_type['fmt'] = fmt
+
+                        if union_type:
+                            union_types.append(union_type)
+                        else:
+                            # at least one untyped, so can't reliably create a schema
+                            untyped = True
+                        break
+
+            if union_types and not untyped:
+                ret['type'] = {'oneOf': union_types}
+
+        return ret
+
     # Overrice to add 'deprecated' support
     def _field2parameter(
         self, field: mf.Field, *, name: str, location: str,

starmallow-0.7.0/starmallow/union_field.py

@@ -0,0 +1,86 @@
+'''Copied from marshmallow_dataclass, https://github.com/lovasoa/marshmallow_dataclass/blob/master/marshmallow_dataclass/union_field.py
+    Didn't want to add the dependency to this project1
+'''
+
+import copy
+import inspect
+from typing import Any, List, Optional, Tuple
+
+import typeguard
+from marshmallow import Schema, ValidationError, fields
+
+try:
+    from typeguard import TypeCheckError  # type: ignore[attr-defined]
+except ImportError:
+    # typeguard < 3
+    TypeCheckError = TypeError  # type: ignore[misc, assignment]
+
+if "argname" not in inspect.signature(typeguard.check_type).parameters:
+
+    def _check_type(value, expected_type, argname: str):
+        return typeguard.check_type(value=value, expected_type=expected_type)
+
+else:
+    # typeguard < 3.0.0rc2
+    def _check_type(value, expected_type, argname: str):
+        return typeguard.check_type(  # type: ignore[call-overload]
+            value=value, expected_type=expected_type, argname=argname,
+        )
+
+
+class Union(fields.Field):
+    """A union field, composed other `Field` classes or instances.
+    This field serializes elements based on their type, with one of its child fields.
+
+    Example: ::
+
+        number_or_string = UnionField([
+                    (float, fields.Float()),
+                    (str, fields.Str())
+                ])
+
+    :param union_fields: A list of types and their associated field instance.
+    :param kwargs: The same keyword arguments that :class:`Field` receives.
+    """
+
+    def __init__(self, union_fields: List[Tuple[type, fields.Field]], **kwargs):
+        super().__init__(**kwargs)
+        self.union_fields = union_fields
+
+    def _bind_to_schema(self, field_name: str, schema: Schema) -> None:
+        super()._bind_to_schema(field_name, schema)
+        new_union_fields = []
+        for typ, field in self.union_fields:
+            field = copy.deepcopy(field)
+            field._bind_to_schema(field_name, self)
+            new_union_fields.append((typ, field))
+
+        self.union_fields = new_union_fields
+
+    def _serialize(self, value: Any, attr: Optional[str], obj, **kwargs) -> Any:
+        errors = []
+        if value is None:
+            return value
+        for typ, field in self.union_fields:
+            try:
+                _check_type(value=value, expected_type=typ, argname=attr or "anonymous")
+                return field._serialize(value, attr, obj, **kwargs)
+            except TypeCheckError as e:
+                errors.append(e)
+        raise TypeError(
+            f"Unable to serialize value with any of the fields in the union: {errors}",
+        )
+
+    def _deserialize(self, value: Any, attr: Optional[str], data, **kwargs) -> Any:
+        errors = []
+        for typ, field in self.union_fields:
+            try:
+                result = field.deserialize(value, **kwargs)
+                _check_type(
+                    value=result, expected_type=typ, argname=attr or "anonymous",
+                )
+                return result
+            except (TypeCheckError, ValidationError) as e:
+                errors.append(e)
+
+        raise ValidationError(errors)

{starmallow-0.6.5 → starmallow-0.7.0}/starmallow/utils.py

@@ -34,12 +34,14 @@ import dpath.util
 import marshmallow as ma
 import marshmallow.fields as mf
 import marshmallow_dataclass.collection_field as collection_field
+import typing_inspect
 from marshmallow.validate import Equal, OneOf
 from starlette.responses import Response
 from typing_inspect import is_final_type, is_generic_type, is_literal_type
 
 from starmallow.concurrency import contextmanager_in_threadpool
 from starmallow.datastructures import DefaultPlaceholder, DefaultType
+from starmallow.union_field import Union as UnionField
 
 if TYPE_CHECKING:  # pragma: nocover
     from starmallow.routing import APIRoute
@@ -136,6 +138,25 @@ def get_model_field(model: Any, **kwargs) -> mf.Field:
     if not is_generic_type(model) and lenient_issubclass(model, Enum):
         return mf.Enum(model, **kwargs)
 
+    # Union
+    if typing_inspect.is_union_type(model):
+        if typing_inspect.is_optional_type(model):
+            kwargs["allow_none"] = kwargs.get("allow_none", True)
+            kwargs["dump_default"] = kwargs.get("dump_default", None)
+            if not kwargs.get("required"):
+                kwargs["load_default"] = kwargs.get("load_default", None)
+            kwargs.setdefault("required", False)
+
+        arguments = get_args(model)
+        subtypes = [t for t in arguments if t is not NoneType]  # type: ignore
+        if len(subtypes) == 1:
+            return get_model_field(model, **kwargs)
+
+        return UnionField(
+            [(subtyp, get_model_field(subtyp, required=True)) for subtyp in subtypes],
+            **kwargs
+        )
+
     origin = get_origin(model)
     if origin not in PY_ITERABLES:
         raise Exception(f'Unknown model type, model is {model}')

{starmallow-0.6.5 → starmallow-0.7.0}/tests/basic_api.py

@@ -116,6 +116,11 @@ def get_final_id(item_id: FinalItem = Path()):
     return item_id
 
 
+@app.get("/path/union/{item_id}")
+def get_union_id(item_id: int | float | bool):
+    return item_id
+
+
 #########################################################
 # Test Path parameters
 #########################################################

{starmallow-0.6.5 → starmallow-0.7.0}/tests/test_basic_api.py

@@ -470,6 +470,51 @@ openapi_schema = {
                 ],
             },
         },
+        "/path/union/{item_id}": {
+            "get": {
+                "responses": {
+                    "200": {
+                        "description": "Successful Response",
+                        "content": {"application/json": {"schema": {}}},
+                    },
+                    "422": {
+                        "description": "Validation Error",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "$ref": "#/components/schemas/HTTPValidationError",
+                                },
+                            },
+                        },
+                    },
+                },
+                "summary": "Get Union Id",
+                "operationId": "get_union_id_path_union__item_id__get",
+                "parameters": [
+                    {
+                        'in': 'path',
+                        'name': 'item_id',
+                        'required': True,
+                        'schema': {
+                            'title': 'Item Id',
+                            "type": {
+                                "oneOf": [
+                                    {
+                                        "type": "integer",
+                                    },
+                                    {
+                                        "type": "number",
+                                    },
+                                    {
+                                        "type": "boolean",
+                                    },
+                                ],
+                            },
+                        },
+                    },
+                ],
+            },
+        },
         "/path/param/{item_id}": {
             "get": {
                 "responses": {
@@ -2259,7 +2304,10 @@ openapi_schema = {
     "path,expected_status,expected_response",
     [
         ("/api_route", 200, {"message": "Hello World"}),
-        ("/non_decorated_route", 200, {"message": "Hello World"}),
+        ("/path/union/500.0", 200, 500.0),
+        ("/path/union/200", 200, 200),
+        ("/path/union/true", 200, True),
+        ("/api_route", 200, {"message": "Hello World"}),
         ("/nonexistent", 404, {"detail": "Not Found"}),
         ("/openapi.json", 200, openapi_schema),
     ],

{starmallow-0.6.5 → starmallow-0.7.0}/tests/test_delimited_params.py

@@ -235,6 +235,7 @@ openapi_schema = {
     [
         ("/path/1,2,3,4", {}, 200, [1, 2, 3, 4]),
         ("/query?item_ids=5,4,3,2", {}, 200, [5, 4, 3, 2]),
+        ("/query?item_ids=", {}, 200, []),
         ("/header", {'item_ids': '6,8,7'}, 200, [6, 8, 7]),
         ("/openapi.json", {}, 200, openapi_schema),
     ],