starmallow 0.7.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

starmallow/utils.py

@@ -3,8 +3,10 @@ import datetime as dt
 import inspect
 import logging
 import re
+import sys
 import uuid
 import warnings
+from collections.abc import Callable, Mapping, Sequence
 from contextlib import AsyncExitStack, asynccontextmanager, contextmanager
 from dataclasses import is_dataclass
 from decimal import Decimal
@@ -13,42 +15,42 @@ from types import NoneType, UnionType
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
-    Dict,
     ForwardRef,
-    FrozenSet,
-    List,
-    Mapping,
-    Sequence,
-    Set,
-    Tuple,
-    Type,
+    Protocol,
+    TypeGuard,
+    TypeVar,
     Union,
-    _eval_type,
-    _GenericAlias,
+    _eval_type,  # type: ignore
     get_args,
     get_origin,
 )
 
-import dpath.util
+import dpath
 import marshmallow as ma
 import marshmallow.fields as mf
-import marshmallow_dataclass.collection_field as collection_field
+import marshmallow_dataclass2.collection_field as collection_field
 import typing_inspect
 from marshmallow.validate import Equal, OneOf
+from marshmallow_dataclass2 import class_schema, is_generic_alias_of_dataclass
+from marshmallow_dataclass2.union_field import Union as UnionField
 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 sys.version_info >= (3, 11):
+    from typing import NotRequired
+else:
+    # Python 3.10 and below
+    from typing_extensions import NotRequired
 
 if TYPE_CHECKING:  # pragma: nocover
     from starmallow.routing import APIRoute
 
 logger = logging.getLogger(__name__)
 
-status_code_ranges: Dict[str, str] = {
+status_code_ranges: dict[str, str] = {
     "1XX": "Information",
     "2XX": "Success",
     "3XX": "Redirection",
@@ -57,7 +59,7 @@ status_code_ranges: Dict[str, str] = {
     "DEFAULT": "Default Response",
 }
 
-MARSHMALLOW_ITERABLES: Tuple[mf.Field] = (
+MARSHMALLOW_ITERABLES: tuple[type[mf.Field], ...] = (
     mf.Dict,
     mf.List,
     mf.Mapping,
@@ -82,33 +84,38 @@ PY_TO_MF_MAPPING = {
 
 PY_ITERABLES = [
     list,
-    List,
+    list,
     collections.abc.Sequence,
     Sequence,
     tuple,
-    Tuple,
+    tuple,
+    set,
     set,
-    Set,
     frozenset,
-    FrozenSet,
+    frozenset,
+    dict,
     dict,
-    Dict,
     collections.abc.Mapping,
     Mapping,
 ]
 
+T = TypeVar("T")
+
 
-def get_model_field(model: Any, **kwargs) -> mf.Field:
+def get_model_field(model: Any, **kwargs) -> mf.Field | None:
     if model == inspect._empty:
         return None
 
     if is_marshmallow_dataclass(model):
         model = model.Schema
 
+    if is_generic_alias_of_dataclass(model):
+        model = class_schema(model)
+
     if is_marshmallow_schema(model):
         return mf.Nested(model if isinstance(model, ma.Schema) else model())
 
-    if is_marshmallow_field(model):
+    if is_marshmallow_field_or_generic(model):
         return model if isinstance(model, mf.Field) else model()
 
     # Native Python handling
@@ -128,10 +135,7 @@ def get_model_field(model: Any, **kwargs) -> mf.Field:
 
     if is_final_type(model):
         arguments = get_args(model)
-        if arguments:
-            subtyp = arguments[0]
-        else:
-            subtyp = Any
+        subtyp = arguments[0] if arguments else Any
         return get_model_field(subtyp, **kwargs)
 
     # enumerations
@@ -142,9 +146,9 @@ def get_model_field(model: Any, **kwargs) -> mf.Field:
     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)
+            kwargs["dump_default"] = kwargs.get("dump_default")
             if not kwargs.get("required"):
-                kwargs["load_default"] = kwargs.get("load_default", None)
+                kwargs["load_default"] = kwargs.get("load_default")
             kwargs.setdefault("required", False)
 
         arguments = get_args(model)
@@ -152,44 +156,47 @@ def get_model_field(model: Any, **kwargs) -> mf.Field:
         if len(subtypes) == 1:
             return get_model_field(model, **kwargs)
 
-        return UnionField(
-            [(subtyp, get_model_field(subtyp, required=True)) for subtyp in subtypes],
-            **kwargs
-        )
+        union_types = []
+        for subtyp in subtypes:
+            field = get_model_field(subtyp, required=True)
+            if field is not None:
+                union_types.append((subtyp, field))
+
+        return UnionField(union_types, **kwargs)
 
     origin = get_origin(model)
     if origin not in PY_ITERABLES:
         raise Exception(f'Unknown model type, model is {model}')
 
     arguments = get_args(model)
-    if origin in (list, List):
+    if origin in (list, list):
         child_type = get_model_field(arguments[0])
-        return mf.List(child_type, **kwargs)
+        return mf.List(child_type, **kwargs) # type: ignore
 
     if origin in (collections.abc.Sequence, Sequence) or (
-        origin in (tuple, Tuple)
+        origin in (tuple, tuple)
         and len(arguments) == 2
         and arguments[1] is Ellipsis
     ):
         child_type = get_model_field(arguments[0])
-        return collection_field.Sequence(child_type, **kwargs)
+        return collection_field.Sequence(child_type, **kwargs) # type: ignore
 
-    if origin in (set, Set):
+    if origin in (set, set):
         child_type = get_model_field(arguments[0])
-        return collection_field.Set(child_type, frozen=False, **kwargs)
+        return collection_field.Set(child_type, frozen=False, **kwargs) # type: ignore
 
-    if origin in (frozenset, FrozenSet):
+    if origin in (frozenset, frozenset):
         child_type = get_model_field(arguments[0])
-        return collection_field.Set(child_type, frozen=True, **kwargs)
+        return collection_field.Set(child_type, frozen=True, **kwargs) # type: ignore
 
-    if origin in (tuple, Tuple):
-        child_types = (
+    if origin in (tuple, tuple):
+        child_types = tuple(
             get_model_field(arg)
             for arg in arguments
         )
-        return mf.Tuple(child_types, **kwargs)
+        return mf.Tuple(child_types, **kwargs) # type: ignore
 
-    if origin in (dict, Dict, collections.abc.Mapping, Mapping):
+    if origin in (dict, dict, collections.abc.Mapping, Mapping):
         key_type = get_model_field(arguments[0])
         value_type = get_model_field(arguments[1])
         return mf.Dict(keys=key_type, values=value_type, **kwargs)
@@ -216,7 +223,7 @@ def is_optional(field):
     return get_origin(field) in (Union, UnionType) and type(None) in get_args(field)
 
 
-def get_path_param_names(path: str) -> Set[str]:
+def get_path_param_names(path: str) -> set[str]:
     return set(re.findall("{(.*?)}", path))
 
 
@@ -229,16 +236,47 @@ def generate_unique_id(route: "APIRoute") -> str:
     return operation_id
 
 
-def is_marshmallow_schema(obj):
-    return (inspect.isclass(obj) and issubclass(obj, ma.Schema)) or isinstance(obj, ma.Schema)
+class MaDataclassProtocol(Protocol):
+    Schema: NotRequired[type[ma.Schema]]
+
+
+def is_marshmallow_schema(obj: Any) -> TypeGuard[ma.Schema | type[ma.Schema]]:
+    try:
+        return (inspect.isclass(obj) and issubclass(obj, ma.Schema)) or isinstance(obj, ma.Schema)
+    except TypeError:
+        # This is a workaround for the case where obj is a generic type
+        # and issubclass raises a TypeError.
+        return False
+
+
+def is_marshmallow_field(obj: Any) -> TypeGuard[mf.Field | type[mf.Field]]:
+    try:
+        return (inspect.isclass(obj) and issubclass(obj, mf.Field)) or isinstance(obj, mf.Field)
+    except TypeError:
+        # This is a workaround for the case where obj is a generic type
+        # and issubclass raises a TypeError.
+        return False
 
 
-def is_marshmallow_field(obj):
-    return (inspect.isclass(obj) and issubclass(obj, mf.Field)) or isinstance(obj, mf.Field)
+def is_marshmallow_field_or_generic(obj: Any) -> TypeGuard[mf.Field | type[mf.Field]]:
+    try:
+        return (
+            (inspect.isclass(obj) and issubclass(obj, mf.Field))
+            or isinstance(obj, mf.Field)
+            or (
+                isinstance(obj, typing_inspect.typingGenericAlias)
+                and lenient_issubclass(get_origin(obj), mf.Field)
+            )
+        )
+    except TypeError:
+        # This is a workaround for the case where obj is a generic type
+        # and issubclass raises a TypeError.
+        return False
 
+def is_marshmallow_dataclass(obj: MaDataclassProtocol | Any) -> TypeGuard[MaDataclassProtocol]:
+    schema = getattr(obj, 'Schema', None)
 
-def is_marshmallow_dataclass(obj):
-    return is_dataclass(obj) and hasattr(obj, 'Schema') and is_marshmallow_schema(obj.Schema)
+    return is_dataclass(obj) and schema is not None and is_marshmallow_schema(schema)
 
 
 def is_async_gen_callable(call: Callable[..., Any]) -> bool:
@@ -259,29 +297,32 @@ async def solve_generator(
     *,
     call: Callable[..., Any],
     stack: AsyncExitStack,
-    gen_kwargs: Dict[str, Any],
+    gen_kwargs: dict[str, Any],
 ) -> Any:
     if is_gen_callable(call):
         cm = contextmanager_in_threadpool(contextmanager(call)(**gen_kwargs))
     elif is_async_gen_callable(call):
         cm = asynccontextmanager(call)(**gen_kwargs)
+    else:
+        raise ValueError(f"Cannot solve generator for {call}")
     return await stack.enter_async_context(cm)
 
 
-def lenient_issubclass(cls: Any, class_or_tuple: Union[Type[Any], Tuple[Type[Any], ...], None]) -> bool:
+def lenient_issubclass(cls: Any, class_or_tuple: type[Any] | tuple[type[Any | UnionType], ...] | UnionType) -> bool:
     try:
-        return isinstance(cls, type) and issubclass(cls, class_or_tuple)  # type: ignore[arg-type]
+        return isinstance(cls, type) and issubclass(cls, class_or_tuple)
     except TypeError:
-        if isinstance(cls, _GenericAlias):
-            return False
-        raise  # pragma: no cover
+        return False
 
 
-def eq_marshmallow_fields(left: mf.Field, right: mf.Field) -> bool:
+def eq_marshmallow_fields(left: mf.Field | Any, right: mf.Field | Any) -> bool:
     '''
         Marshmallow Fields don't have an __eq__ functions.
         This compares them instead.
     '''
+    if not (isinstance(left, mf.Field) and isinstance(right, mf.Field)):
+        return False
+
     left_dict = left.__dict__.copy()
     left_dict.pop('_creation_index', None)
     right_dict = right.__dict__.copy()
@@ -290,7 +331,7 @@ def eq_marshmallow_fields(left: mf.Field, right: mf.Field) -> bool:
     return left_dict == right_dict
 
 
-def __dict_creator__(current, segments, i, hints=()):
+def _dict_creator(current, segments, i, hints: Sequence | None = None):
     '''
         Create missing path components. Always create a dictionary.
 
@@ -299,17 +340,17 @@ def __dict_creator__(current, segments, i, hints=()):
     segment = segments[i]
 
     # Infer the type from the hints provided.
-    if i < len(hints):
+    if hints and i < len(hints):
         current[segment] = hints[i][1]()
     else:
         current[segment] = {}
 
 
-def dict_safe_add(d: Dict, path: str, value: Any):
-    dpath.new(d, path, value, separator='.', creator=__dict_creator__)
+def dict_safe_add(d: dict, path: str, value: Any):
+    dpath.new(d, path, value, separator='.', creator=_dict_creator)
 
 
-def deep_dict_update(main_dict: Dict[Any, Any], update_dict: Dict[Any, Any]) -> None:
+def deep_dict_update(main_dict: dict[Any, Any], update_dict: dict[Any, Any]) -> None:
     for key, value in update_dict.items():
         if (
             key in main_dict
@@ -327,7 +368,7 @@ def deep_dict_update(main_dict: Dict[Any, Any], update_dict: Dict[Any, Any]) ->
             main_dict[key] = value
 
 
-def create_response_model(type_: Type[Any]) -> ma.Schema | mf.Field | None:
+def create_response_model(type_: type[Any] | Any | ma.Schema | mf.Field) -> mf.Field | None:
     if type_ in [inspect._empty, None] or (inspect.isclass(type_) and issubclass(type_, Response)):
         return None
 
@@ -343,7 +384,7 @@ def create_response_model(type_: Type[Any]) -> ma.Schema | mf.Field | None:
 def get_value_or_default(
     first_item: DefaultPlaceholder | DefaultType,
     *extra_items: DefaultPlaceholder | DefaultType,
-) -> DefaultPlaceholder | DefaultType:
+) -> Any:
     """
     Pass items or `DefaultPlaceholder`s by descending priority.
 
@@ -351,12 +392,15 @@ def get_value_or_default(
 
     Otherwise, the first item (a `DefaultPlaceholder`) will be returned.
     """
-    items = (first_item,) + extra_items
+    items = (first_item, *extra_items)
     for item in items:
         if not isinstance(item, DefaultPlaceholder):
             return item
-    return first_item
 
+    if isinstance(first_item, DefaultPlaceholder):
+        return first_item.value
+    else:
+        return first_item
 
 def get_name(endpoint: Callable) -> str:
     if inspect.isroutine(endpoint) or inspect.isclass(endpoint):
@@ -383,14 +427,14 @@ def get_typed_signature(call: Callable[..., Any]) -> inspect.Signature:
     return typed_signature
 
 
-def get_typed_annotation(annotation: Any, globalns: Dict[str, Any]) -> Any:
+def get_typed_annotation(annotation: Any, globalns: dict[str, Any]) -> Any:
     if isinstance(annotation, str):
         annotation = ForwardRef(annotation)
         annotation = evaluate_forwardref(annotation, globalns, globalns)
     return annotation
 
 
-def get_typed_return_annotation(call: Callable[..., Any]) -> Any:
+def get_typed_return_annotation(call: Callable[..., T]) -> T | None:
     signature = inspect.signature(call)
     annotation = signature.return_annotation
 

starmallow/websockets.py

@@ -13,7 +13,7 @@ class APIWebSocket(WebSocket):
     async def receive_json(
         self,
         mode: str = "text",
-        model: ma.Schema = None,
+        model: ma.Schema | type[ma.Schema] | None = None,
     ) -> Any:
         if mode not in {"text", "binary"}:
             raise RuntimeError('The "mode" argument should be "text" or "binary".')
@@ -24,10 +24,7 @@ class APIWebSocket(WebSocket):
         message = await self.receive()
         self._raise_on_disconnect(message)
 
-        if mode == "text":
-            text = message["text"]
-        else:
-            text = message["bytes"].decode("utf-8")
+        text = message["text"] if mode == "text" else message["bytes"].decode("utf-8")
 
         if model:
             if isinstance(model, ma.Schema):
@@ -44,7 +41,7 @@ class APIWebSocket(WebSocket):
         self,
         data: Any,
         mode: str = "text",
-        model: ma.Schema = None,
+        model: ma.Schema | type[ma.Schema] | None = None,
     ) -> None:
         if mode not in {"text", "binary"}:
             raise RuntimeError('The "mode" argument should be "text" or "binary".')

{starmallow-0.7.0.dist-info → starmallow-0.9.0.dist-info}/METADATA

@@ -1,10 +1,11 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: starmallow
-Version: 0.7.0
+Version: 0.9.0
 Summary: StarMallow framework
 Project-URL: Homepage, https://github.com/mvanderlee/starmallow
 Author-email: Michiel Vanderlee <jmt.vanderlee@gmail.com>
-License: MIT
+License-Expression: MIT
+License-File: LICENSE.md
 Classifier: Development Status :: 3 - Alpha
 Classifier: Environment :: Web Environment
 Classifier: Framework :: AsyncIO
@@ -17,6 +18,8 @@ Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3 :: Only
 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: Topic :: Internet
 Classifier: Topic :: Internet :: WWW/HTTP
 Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
@@ -28,29 +31,27 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Requires-Dist: apispec[marshmallow]<7,>=6
 Requires-Dist: dpath<3,>=2.1.0
-Requires-Dist: marshmallow-dataclass<9,>=8.5.1
-Requires-Dist: marshmallow<4,>=3.18.0
-Requires-Dist: python-multipart<0.0.7,>=0.0.5
+Requires-Dist: marshmallow-dataclass2<9,>=8.8.1
+Requires-Dist: marshmallow>=3.18.0
+Requires-Dist: python-multipart>=0.0.20
 Requires-Dist: pyyaml>=5.4.1
-Requires-Dist: starlette<1,>=0.35
+Requires-Dist: starlette>=0.46
 Provides-Extra: all
 Requires-Dist: orjson; extra == 'all'
 Requires-Dist: ujson>=3.2.1; extra == 'all'
 Requires-Dist: uvicorn[standard]>=0.12.0; extra == 'all'
 Provides-Extra: dev
-Requires-Dist: isort<6.0.0,>=5.0.6; extra == 'dev'
-Requires-Dist: pre-commit<4,>=3.2.0; extra == 'dev'
-Requires-Dist: ruff==0.0.260; extra == 'dev'
-Requires-Dist: uvicorn[standard]<0.22.0,>=0.17.0; extra == 'dev'
+Requires-Dist: pre-commit>=4; extra == 'dev'
+Requires-Dist: ruff==0.11.6; extra == 'dev'
+Requires-Dist: uvicorn[standard]>=0.34; extra == 'dev'
 Provides-Extra: publish
 Requires-Dist: hatch>=1.7.0; extra == 'publish'
 Provides-Extra: test
 Requires-Dist: coverage[toml]<8.0,>=6.5.0; extra == 'test'
 Requires-Dist: httpx>=0.22.0; extra == 'test'
-Requires-Dist: isort<6.0.0,>=5.0.6; extra == 'test'
 Requires-Dist: mypy<2,>=1.1.1; extra == 'test'
-Requires-Dist: pytest<8.0.0,>=7.1.3; extra == 'test'
-Requires-Dist: ruff==0.0.260; extra == 'test'
+Requires-Dist: pytest>=8; extra == 'test'
+Requires-Dist: ruff==0.11.6; extra == 'test'
 Description-Content-Type: text/markdown
 
 # StarMallow
@@ -68,7 +69,7 @@ Create a file `main.py` with:
 
 ```python
 from typing import Annotated
-from marshmallow_dataclass import dataclass
+from marshmallow_dataclass2 import dataclass
 from starmallow import Body, Path, StarMallow
 
 app = StarMallow()
@@ -131,7 +132,7 @@ INFO:     Application startup complete.
 You can also use class-based views. This can make it easier to organize your code and gives you an easy migration path if you use [flask-smorest](https://flask-smorest.readthedocs.io/)
 
 ```python
-from marshmallow_dataclass import dataclass
+from marshmallow_dataclass2 import dataclass
 from starmallow import StarMallow
 from starmallow.decorators import route
 from starmallow.endpoints import APIHTTPEndpoint

starmallow-0.9.0.dist-info/RECORD

@@ -0,0 +1,43 @@
+starmallow/__init__.py,sha256=tGlfbHYbodKJlydvWAPia0GpXyB1nRcjV5Quz2iZeUw,322
+starmallow/applications.py,sha256=wI3mViPAgMAGDUy0PzDLyd6GFQaFY_d1-85LBASATNY,30396
+starmallow/background.py,sha256=asjTMgO25zqZiKsxcEVBGPKd_Nb7RVZDEmzR4PNy6-k,996
+starmallow/concurrency.py,sha256=YNIFo8jmHZYXfFkqzL1xFiE5QFwWYnGUsYgAROv041Q,1404
+starmallow/constants.py,sha256=u0h8cJKhJY0oIZqzr7wpEZG2bPLrw5FroMnn3d8KBNQ,129
+starmallow/dataclasses.py,sha256=P8Eft25Q5UBhDp-3b0T-n2IOtjrQpxmRUxs3WAwlRFQ,2787
+starmallow/datastructures.py,sha256=oq2Dz6zcoQx9ctMSSviZMAX_wvNTT9ytkSBtZjcg7bY,853
+starmallow/decorators.py,sha256=VGzfFYualOcplRK6L3Tu2GrCl3a5yrOgADqWMokqzcQ,4036
+starmallow/delimited_field.py,sha256=MKQnCp-B8q1R69G6aCgthtWVCISqkKBFpTSnwcfC_8A,4429
+starmallow/docs.py,sha256=tc077aDFAzHTjpnEpqS8BVMhVolaYFmrqQ2obd1Jsbg,6229
+starmallow/endpoint.py,sha256=JVJTglAkAydVKIsgKr4dR_X9gzso6OHr_d6xUhq1MNU,17794
+starmallow/endpoints.py,sha256=2RuKhEX0EpEyWUdlKVfD0WXz_8zNQEduCoZ4UJkybZc,953
+starmallow/exception_handlers.py,sha256=gr2qLYWEtsIEH28n7OreEiiLVz6Y7b6osRyS9esJbBk,891
+starmallow/exceptions.py,sha256=arXkENa6dV626t_IDWZKqrh6laeV54PWbVIW0dafT2o,843
+starmallow/fields.py,sha256=5zXP2JLyTpVnVhl23GYHY9W3Sc5Oc_kRvOWmI7WWNRM,1283
+starmallow/generics.py,sha256=CE_Wf0vIqkup0mirGa-PL5511DT-avaCkC1Jx4sMe_U,1102
+starmallow/params.py,sha256=EDnUNVNfRY7uv5D1rzfmIrWKJ85R2ku4l13w1QKG4E8,8720
+starmallow/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+starmallow/request_resolver.py,sha256=o9OID0wOUCG1iUuvJVT6-ghzG61Pv08QiznFjzZZ8RE,11689
+starmallow/requests.py,sha256=o_yNhH9WJ35uAGuoXa5_gihevHeaveOvkP525dbwQSU,843
+starmallow/responses.py,sha256=H6Ze0R5JG9O8eaS4dffiAn3lI6Y9-hz3aDHdWKGk_nw,2023
+starmallow/routing.py,sha256=dK6ayN_Ruqz3ZGNQ3pFwqnguF7Vl0oIfD7e8OnnED_Y,45364
+starmallow/schema_generator.py,sha256=Y4o8v5OUgTZA2byTOcUKONimdF8JjiwD8FZLxCVOF0I,19210
+starmallow/serializers.py,sha256=Z-42L6is9klknpJ3r1DcGjB7t_txPfRvp-Rvj87_n70,12622
+starmallow/types.py,sha256=uPjoKwKF06n7b2yTtm0WAO1a_SOwRYJG1xzDy_GKAUg,879
+starmallow/utils.py,sha256=CudZ2x7iWHr6xi7RT848aSIZuAfDUFzWVCxHuyKvk-E,14146
+starmallow/websockets.py,sha256=54ctFGgA4A3VFwpUFmlu8aVmHOo4R6x3O_-z5r2BsdI,2232
+starmallow/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+starmallow/ext/marshmallow/__init__.py,sha256=33jENGdfPq4-CDG0LOmN3KOGW1pXTy7a2oMwy4hrYzM,208
+starmallow/ext/marshmallow/openapi.py,sha256=SkaGp80qvQxDSatxygN3IIKXQ7GTa01rioY_uddTxEs,10164
+starmallow/middleware/__init__.py,sha256=vtNm85Z9pUPjJd-9giJGg3YL1wO7Jm5ooXBm31pDOK8,53
+starmallow/middleware/asyncexitstack.py,sha256=wxugZgPg5yxuXxZjPm-_PMG7hAfOeo2lRLR07eaSWS8,1160
+starmallow/security/__init__.py,sha256=1rQFBIGnEbE51XDZSSi9NgPjXLScFq3RoLu4vk0KVYw,191
+starmallow/security/api_key.py,sha256=8WH52R4OjLKYSkXj35AgayFsXM7JQVp1Pf0DzpMl4ms,3108
+starmallow/security/base.py,sha256=d2bMKCbPB8wh4Ce0b5xSYS9ZHeeyVLnyjpwK_NE505M,1404
+starmallow/security/http.py,sha256=oOG436aohU9uNM40B0LP0Vg8Pcroj5pjzE1NRGiqOOs,6683
+starmallow/security/oauth2.py,sha256=G72-wJyvrGyHUbg9hbzf44RBN8zFalZYnHKpRC2I1po,10108
+starmallow/security/open_id_connect_url.py,sha256=9E-Zwnt-IR3jimOMkvIwnGHTuJMlGmjs7LCf1SGtKT8,1415
+starmallow/security/utils.py,sha256=7tziAa2Cwa7xhwM_NF4DSY3BHoqVaWgJ21VuV8LvhrY,253
+starmallow-0.9.0.dist-info/METADATA,sha256=ZQ_7tnMWg4IhxxCo3FhmBwa8OGc42qBRdOwBnBeK9y8,5611
+starmallow-0.9.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+starmallow-0.9.0.dist-info/licenses/LICENSE.md,sha256=QelyGgOzch8CXzy6HrYwHh7nmj0rlWkDA0YzmZ3CPaY,1084
+starmallow-0.9.0.dist-info/RECORD,,

{starmallow-0.7.0.dist-info → starmallow-0.9.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.26.3
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any

starmallow/union_field.py

@@ -1,86 +0,0 @@
-'''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)