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

starmallow/background.py

@@ -23,7 +23,7 @@ class BackgroundTask(StarletteBackgroundTask):
 
 class BackgroundTasks(StarletteBackgroundTasks):
     def add_task(
-        self, func: typing.Callable[P, typing.Any], *args: P.args, **kwargs: P.kwargs
+        self, func: typing.Callable[P, typing.Any], *args: P.args, **kwargs: P.kwargs,
     ) -> None:
         task = BackgroundTask(func, *args, **kwargs)
         self.tasks.append(task)

starmallow/concurrency.py

@@ -1,18 +1,19 @@
-from contextlib import asynccontextmanager
-from typing import AsyncGenerator, ContextManager, TypeVar
+from collections.abc import AsyncGenerator
+from contextlib import AbstractContextManager, asynccontextmanager
+from typing import TypeVar
 
-import anyio
+import anyio.to_thread
 from anyio import CapacityLimiter
-from starlette.concurrency import iterate_in_threadpool as iterate_in_threadpool  # noqa
-from starlette.concurrency import run_in_threadpool as run_in_threadpool  # noqa
-from starlette.concurrency import run_until_first_complete as run_until_first_complete  # noqa
+from starlette.concurrency import iterate_in_threadpool as iterate_in_threadpool
+from starlette.concurrency import run_in_threadpool as run_in_threadpool
+from starlette.concurrency import run_until_first_complete as run_until_first_complete
 
 _T = TypeVar("_T")
 
 
 @asynccontextmanager
 async def contextmanager_in_threadpool(
-    cm: ContextManager[_T],
+    cm: AbstractContextManager[_T],
 ) -> AsyncGenerator[_T, None]:
     # blocking __exit__ from running waiting on a free thread
     # can create race conditions/deadlocks if the context manager itself

starmallow/dataclasses.py

@@ -1,5 +1,6 @@
+from collections.abc import Callable
 from dataclasses import MISSING, field
-from typing import Any, Callable, Dict
+from typing import Any, Literal
 
 
 ##############################################################
@@ -15,12 +16,12 @@ from typing import Any, Callable, Dict
 ##############################################################
 def required_field(
     default: Any = None,
-    default_factory: Callable = MISSING,
+    default_factory: Callable | Literal[MISSING] = MISSING,
     dump_only: bool = False,
     load_only: bool = False,
-    description: str = None,
+    description: str | None = None,
     # Marshmallow Schema metadata
-    metadata: Dict[str, Any] = None,
+    metadata: dict[str, Any] | None = None,
     # Marshmallow Schema kwargs
     **schema_kwargs,
 ):
@@ -46,12 +47,12 @@ def required_field(
 
 def optional_field(
     default: Any = None,
-    default_factory: Callable = MISSING,
+    default_factory: Callable | Literal[MISSING] = MISSING,
     dump_only: bool = False,
     load_only: bool = False,
-    description: str = None,
+    description: str | None = None,
     # Marshmallow Schema metadata
-    metadata: Dict[str, Any] = None,
+    metadata: dict[str, Any] | None = None,
     # Marshmallow Schema kwargs
     **schema_kwargs,
 ):
@@ -77,10 +78,10 @@ def optional_field(
 
 def dump_only_field(
     default: Any = None,
-    default_factory: Callable = MISSING,
-    description: str = None,
+    default_factory: Callable | Literal[MISSING] = MISSING,
+    description: str | None = None,
     # Marshmallow Schema metadata
-    metadata: Dict[str, Any] = None,
+    metadata: dict[str, Any] | None = None,
     # Marshmallow Schema kwargs
     **schema_kwargs,
 ):

starmallow/datastructures.py

@@ -22,7 +22,7 @@ class DefaultPlaceholder:
 DefaultType = TypeVar("DefaultType")
 
 
-def Default(value: DefaultType) -> DefaultType:
+def Default(value: DefaultType) -> DefaultType:  # noqa: N802
     """
     You shouldn't use this function directly.
 

starmallow/decorators.py

@@ -1,6 +1,7 @@
+from collections.abc import Callable, Sequence
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Sequence, Type, Union
+from typing import TYPE_CHECKING, Any
 
 from starlette.middleware import Middleware
 from starlette.requests import Request
@@ -18,65 +19,65 @@ if TYPE_CHECKING:  # pragma: nocover
 
 @dataclass
 class EndpointOptions:
-    name: str = None
+    name: str | None = None
     include_in_schema: bool = True
-    status_code: Optional[int] = None
+    status_code: int | None = None
     middleware: Sequence[Middleware] | None = None
-    deprecated: Optional[bool] = None
-    request_class: Type[Request] = Request
-    response_model: Optional[Type[Any]] = None
-    response_class: Type[Response] = JSONResponse
+    deprecated: bool | None = None
+    request_class: type[Request] = Request
+    response_model: type[Any] | None = None
+    response_class: type[Response] = JSONResponse
     # OpenAPI summary
-    summary: Optional[str] = None
-    description: Optional[str] = None
+    summary: str | None = None
+    description: str | None = None
     response_description: str = "Successful Response"
-    responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None
-    callbacks: Optional[List[BaseRoute]] = None
+    responses: dict[int | str, dict[str, Any]] | None = None
+    callbacks: list[BaseRoute] | None = None
     # Sets the OpenAPI operationId to be used in your path operation
-    operation_id: Optional[str] = None
+    operation_id: str | None = None
     # If operation_id is None, this function will be used to create one.
     generate_unique_id_function: Callable[["APIRoute"], str] = field(
         default_factory=lambda: Default(generate_unique_id),
     )
     # OpenAPI tags
-    tags: Optional[List[Union[str, Enum]]] = None
+    tags: list[str | Enum] | None = None
     # Will be deeply merged with the automatically generated OpenAPI schema for the path operation.
-    openapi_extra: Optional[Dict[str, Any]] = None
-    route_class: Optional[Type["APIRoute"]] = None
+    openapi_extra: dict[str, Any] | None = None
+    route_class: type["APIRoute"] | None = None
 
 
 def route(
     *,
-    name: str = None,
+    name: str | None = None,
     include_in_schema: bool = True,
-    status_code: Optional[int] = None,
+    status_code: int | None = None,
     middleware: Sequence[Middleware] | None = None,
-    deprecated: Optional[bool] = None,
-    request_class: Type[Request] = Default(Request),
-    response_model: Optional[Type[Any]] = None,
-    response_class: Type[Response] = JSONResponse,
+    deprecated: bool | None = None,
+    request_class: type[Request] = Default(Request),
+    response_model: type[Any] | None = None,
+    response_class: type[Response] = JSONResponse,
     # OpenAPI summary
-    summary: Optional[str] = None,
-    description: Optional[str] = None,
+    summary: str | None = None,
+    description: str | None = None,
     response_description: str = "Successful Response",
-    responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
-    callbacks: Optional[List[BaseRoute]] = None,
+    responses: dict[int | str, dict[str, Any]] | None = None,
+    callbacks: list[BaseRoute] | None = None,
     # Sets the OpenAPI operationId to be used in your path operation
-    operation_id: Optional[str] = None,
+    operation_id: str | None = None,
     # If operation_id is None, this function will be used to create one.
     generate_unique_id_function: Callable[["APIRoute"], str] = Default(generate_unique_id),
     # OpenAPI tags
-    tags: Optional[List[Union[str, Enum]]] = None,
+    tags: list[str | Enum] | None = None,
     # Will be deeply merged with the automatically generated OpenAPI schema for the path operation.
-    openapi_extra: Optional[Dict[str, Any]] = None,
-    route_class: Optional[Type["APIRoute"]] = None,
+    openapi_extra: dict[str, Any] | None = None,
+    route_class: type["APIRoute"] | None = None,
 ) -> Callable[[DecoratedCallable], DecoratedCallable]:
     '''
         Intended to be used with APIHTTPEndpoint to override options on a per method basis
     '''
     def decorator(func: DecoratedCallable) -> DecoratedCallable:
         # Attach options to the function so we can call upon them when we process the class
-        func.endpoint_options = EndpointOptions(
+        func.endpoint_options = EndpointOptions( # type: ignore
             name=name,
             include_in_schema=include_in_schema,
             status_code=status_code,

starmallow/delimited_field.py

@@ -1,4 +1,4 @@
-## Copied from webargs, but allows for None values.
+# Copied from webargs, but allows for None values.
 
 """Field classes.
 
@@ -15,10 +15,30 @@ tells webargs where to parse the request argument from.
         "content_type": fields.Str(data_key="Content-Type", location="headers"),
     }
 """
-from typing import Union
+import sys
+from typing import Any, ClassVar, Generic, Protocol, TypeVar
 
 import marshmallow as ma
 
+if sys.version_info >= (3, 11):
+    from typing import TypeVarTuple
+else:
+    # Python 3.10 and below
+    from typing_extensions import TypeVarTuple
+
+from .generics import get_orig_class
+
+T = TypeVar('T', bound=ma.fields.Field | type[ma.fields.Field])
+Ts = TypeVarTuple('Ts')  # Bound is not supported, bound=ma.fields.Field | type[ma.fields.Field]
+
+
+class _SupportListOrTupleField(Protocol):
+    delimiter: str
+
+    def _serialize(self, value: Any, attr: str | None, obj: Any, **kwargs) -> list | tuple: ...
+    def _deserialize(self, value, attr: str | None, data, **kwargs): ...
+    def make_error(self, key: str, **kwargs) -> ma.ValidationError: ...
+
 
 class DelimitedFieldMixin:
     """
@@ -38,24 +58,26 @@ class DelimitedFieldMixin:
     # delimited fields set is_multiple=False for webargs.core.is_multiple
     is_multiple: bool = False
 
-    def _serialize(self, value, attr, obj, **kwargs):
+    def _serialize(self: _SupportListOrTupleField, value: Any, attr: str | None, obj: Any, **kwargs):
         # serializing will start with parent-class serialization, so that we correctly
         # output lists of non-primitive types, e.g. DelimitedList(DateTime)
         if value is not None:
             return self.delimiter.join(
-                format(each) for each in super()._serialize(value, attr, obj, **kwargs)
+                format(each) if each is not None else ''
+                for each in super()._serialize(value, attr, obj, **kwargs)
             )
 
-    def _deserialize(self, value, attr, data, **kwargs):
+    def _deserialize(self: _SupportListOrTupleField, value, attr: str | None, data, **kwargs):
         if value is not None:
             # attempting to deserialize from a non-string source is an error
-            if not isinstance(value, (str, bytes)):
+            if not isinstance(value, str):
                 raise self.make_error("invalid")
+
             values = value.split(self.delimiter) if value else []
             return super()._deserialize(values, attr, data, **kwargs)
 
 
-class DelimitedList(DelimitedFieldMixin, ma.fields.List):
+class DelimitedList(DelimitedFieldMixin, ma.fields.List, Generic[T]):  # type: ignore
     """A field which is similar to a List, but takes its input as a delimited
     string (e.g. "foo,bar,baz").
 
@@ -66,20 +88,20 @@ class DelimitedList(DelimitedFieldMixin, ma.fields.List):
     :param str delimiter: Delimiter between values.
     """
 
-    default_error_messages = {"invalid": "Not a valid delimited list."}
+    default_error_messages: ClassVar[dict[str, str]] = {"invalid": "Not a valid delimited list."}
 
     def __init__(
         self,
-        cls_or_instance: Union[ma.fields.Field, type],
         *,
-        delimiter: Union[str, None] = None,
+        delimiter: str | None = None,
         **kwargs,
     ):
+        cls_or_instance = get_orig_class(self).__args__[0]
         self.delimiter = delimiter or self.delimiter
         super().__init__(cls_or_instance, **kwargs)
 
 
-class DelimitedTuple(DelimitedFieldMixin, ma.fields.Tuple):
+class DelimitedTuple(DelimitedFieldMixin, ma.fields.Tuple, Generic[Ts]):  # type: ignore
     """A field which is similar to a Tuple, but takes its input as a delimited
     string (e.g. "foo,bar,baz").
 
@@ -90,14 +112,14 @@ class DelimitedTuple(DelimitedFieldMixin, ma.fields.Tuple):
     :param str delimiter: Delimiter between values.
     """
 
-    default_error_messages = {"invalid": "Not a valid delimited tuple."}
+    default_error_messages: ClassVar[dict[str, str]] = {"invalid": "Not a valid delimited tuple."}
 
     def __init__(
         self,
-        tuple_fields,
         *,
-        delimiter: Union[str, None] = None,
+        delimiter: str | None = None,
         **kwargs,
     ):
+        cls_or_instances = get_orig_class(self).__args__
         self.delimiter = delimiter or self.delimiter
-        super().__init__(tuple_fields, **kwargs)
+        super().__init__(cls_or_instances, **kwargs)

starmallow/docs.py

@@ -1,5 +1,5 @@
 import json
-from typing import Any, Dict, Optional
+from typing import Any
 
 from starlette.responses import HTMLResponse
 
@@ -20,9 +20,9 @@ def get_swagger_ui_html(
     title: str,
     swagger_js_url: str = "https://cdn.jsdelivr.net/npm/swagger-ui-dist@4/swagger-ui-bundle.js",
     swagger_css_url: str = "https://cdn.jsdelivr.net/npm/swagger-ui-dist@4/swagger-ui.css",
-    oauth2_redirect_url: Optional[str] = None,
-    init_oauth: Optional[Dict[str, Any]] = None,
-    swagger_ui_parameters: Optional[Dict[str, Any]] = None,
+    oauth2_redirect_url: str | None = None,
+    init_oauth: dict[str, Any] | None = None,
+    swagger_ui_parameters: dict[str, Any] | None = None,
 ) -> HTMLResponse:
     current_swagger_ui_parameters = swagger_ui_default_parameters.copy()
     if swagger_ui_parameters:
@@ -196,5 +196,5 @@ def get_swagger_ui_oauth2_redirect_html() -> HTMLResponse:
     </script>
     </body>
     </html>
-    """  # noqa: E501
+    """
     return HTMLResponse(content=html)