starmallow 0.1.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

starmallow/__init__.py

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

starmallow/applications.py

@@ -35,7 +35,7 @@ from starmallow.exception_handlers import (
     http_exception_handler,
     request_validation_exception_handler,
 )
-from starmallow.exceptions import RequestValidationError
+from starmallow.exceptions import RequestValidationError, SchemaGenerationError
 from starmallow.middleware import AsyncExitStackMiddleware
 from starmallow.responses import JSONResponse
 from starmallow.routing import APIRoute, APIRouter
@@ -122,7 +122,7 @@ class StarMallow(Starlette):
         )
 
         self.user_middleware = [] if middleware is None else list(middleware)
-        self.middleware_stack = self.build_middleware_stack()
+        self.middleware_stack: Union[ASGIApp, None] = None
         self.init_openapi()
 
     def build_middleware_stack(self) -> ASGIApp:
@@ -168,7 +168,10 @@ class StarMallow(Starlette):
     def init_openapi(self):
         if self.openapi_url:
             async def openapi(req: Request) -> JSONResponse:
-                return JSONResponse(self.openapi())
+                try:
+                    return JSONResponse(self.openapi())
+                except Exception as e:
+                    raise SchemaGenerationError() from e
 
             self.add_route(self.openapi_url, openapi, include_in_schema=False)
 

starmallow/endpoint.py

@@ -13,6 +13,7 @@ from typing import (
     Optional,
     Type,
     Union,
+    get_origin,
 )
 
 import marshmallow as ma
@@ -22,6 +23,7 @@ from starlette.background import BackgroundTasks
 from starlette.requests import HTTPConnection, Request
 from starlette.responses import Response
 from starlette.websockets import WebSocket
+from typing_extensions import Annotated
 
 from starmallow.params import (
     Body,
@@ -37,6 +39,7 @@ from starmallow.params import (
     Security,
 )
 from starmallow.responses import JSONResponse
+from starmallow.security.base import SecurityBaseResolver
 from starmallow.utils import (
     create_response_model,
     get_args,
@@ -54,6 +57,13 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
+STARMALLOW_PARAM_TYPES = (
+    Param,
+    NoParam,
+    ResolvedParam,
+    mf.Field,
+)
+
 
 @dataclass
 class EndpointModel:
@@ -164,25 +174,31 @@ class SchemaModel(ma.Schema):
 
 class EndpointMixin:
 
-    def _get_param_model(self, parameter: inspect.Parameter) -> Union[ma.Schema, mf.Field]:
-        model = parameter.annotation
+    def _get_param_model(
+        self,
+        type_annotation: Any,
+        parameter: Param,
+        parameter_name: str,
+        default_value: Any,
+    ) -> Union[ma.Schema, mf.Field]:
+        model = type_annotation
 
         kwargs = {
             'required': True,
             'metadata': {
                 'title': (
-                    parameter.default.title
-                    if (isinstance(parameter.default, Param) and parameter.default.title)
-                    else parameter.name.title().replace('_', ' ')
+                    parameter.title
+                    if (isinstance(parameter, Param) and parameter.title)
+                    else parameter_name.title().replace('_', ' ')
                 ),
             },
         }
         # Ensure we pass parameter fields into the marshmallow field
-        if isinstance(parameter.default, Param):
-            if parameter.default.validators:
-                kwargs['validate'] = parameter.default.validators
-            if parameter.default.deprecated:
-                kwargs['metadata']['deprecated'] = parameter.default.deprecated
+        if isinstance(parameter, Param):
+            if parameter.validators:
+                kwargs['validate'] = parameter.validators
+            if parameter.deprecated:
+                kwargs['metadata']['deprecated'] = parameter.deprecated
 
         if is_optional(model):
             kwargs.update({
@@ -190,25 +206,25 @@ class EndpointMixin:
                 'required': False,
             })
             # This does not support Union[A,B,C,None]. Only Union[A,None] and Optional[A]
-            model = next((a for a in get_args(parameter.annotation) if a is not None), None)
+            model = next((a for a in get_args(type_annotation) if a is not None), None)
 
-        if isinstance(parameter.default, Param):
+        if isinstance(parameter, Param):
             # If default is not Ellipsis, then it's optional regardless of the typehint.
             # Although it's best practice to also mark the typehint as Optional
-            if parameter.default.default != Ellipsis:
+            if default_value != Ellipsis:
                 kwargs.update({
-                    'load_default': parameter.default.default,
+                    'load_default': default_value,
                     'required': False,
                 })
 
             # Ignore type hint. Use provided model instead.
-            if parameter.default.model is not None:
-                model = parameter.default.model
-        elif parameter.default != inspect._empty:
+            if parameter.model is not None:
+                model = parameter.model
+        elif default_value != inspect._empty:
             # If default is not a Param but is defined, then it's optional regardless of the typehint.
             # Although it's best practice to also mark the typehint as Optional
             kwargs.update({
-                'load_default': parameter.default,
+                'load_default': default_value,
                 'required': False,
             })
 
@@ -226,7 +242,7 @@ class EndpointMixin:
         elif is_marshmallow_field(model):
             if model.load_default is not None and model.load_default != kwargs.get('load_default', ma.missing):
                 logger.warning(
-                    f"'{parameter.name}' model and annotation have different 'load_default' values."
+                    f"'{parameter_name}' model and annotation have different 'load_default' values."
                     + f" {model.load_default} <> {kwargs.get('load_default', ma.missing)}",
                 )
 
@@ -239,15 +255,13 @@ class EndpointMixin:
             try:
                 return get_model_field(model, **kwargs)
             except Exception as e:
-                raise Exception(f'Unknown model type for parameter {parameter.name}, model is {model}') from e
-
-    def get_resolved_param(self, parameter: inspect.Parameter, path: str) -> ResolvedParam:
-        resolved_param: ResolvedParam = parameter.default
+                raise Exception(f'Unknown model type for parameter {parameter_name}, model is {model}') from e
 
+    def get_resolved_param(self, resolved_param: ResolvedParam, annotation: Any, path: str) -> ResolvedParam:
         # Supports `field = ResolvedParam(resolver_callable)
         # and field: resolver_callable = ResolvedParam()
         if resolved_param.resolver is None:
-            resolved_param.resolver = parameter.annotation
+            resolved_param.resolver = annotation
 
         resolved_param.resolver_params = self._get_params(resolved_param.resolver, path=path)
 
@@ -261,24 +275,60 @@ class EndpointMixin:
         path_param_names = get_path_param_names(path)
         params = {param_type: {} for param_type in ParamType}
         for name, parameter in inspect.signature(func).parameters.items():
+            default_value = parameter.default
+
+            # The type annotation. i.e.: 'str' in these `value: str`. Or `value: [str, Query(gt=3)]`
+            type_annotation: Any = inspect._empty
+            # The param to use when looking for Param details.
+            # i.e.: 'Query(gt=3)' in these `value: Query(gt=3)`. Or `value: [str, Query(gt=3)]`
+            starmallow_param: Any = inspect._empty
+            if parameter.annotation is not inspect.Signature.empty:
+                type_annotation = parameter.annotation
+            if isinstance(parameter.default, STARMALLOW_PARAM_TYPES):
+                starmallow_param = parameter.default
+                default_value = getattr(starmallow_param, 'default', None)
+
+            if get_origin(parameter.annotation) is Annotated:
+                annotated_args = get_args(parameter.annotation)
+                type_annotation = annotated_args[0]
+                starmallow_annotations = [
+                    arg
+                    for arg in annotated_args[1:]
+                    if isinstance(arg, STARMALLOW_PARAM_TYPES)
+                ]
+                if starmallow_annotations:
+                    assert starmallow_param is inspect._empty, (
+                        "Cannot specify `Param` in `Annotated` and default value"
+                    f" together for {name!r}"
+                    )
+
+                    starmallow_param = starmallow_annotations[-1]
+                    if (
+                        isinstance(starmallow_param, Param)
+                        and starmallow_param.default is not inspect.Signature.empty
+                        and default_value is inspect.Signature.empty
+                    ):
+                        default_value = starmallow_param.default
+
             if (
                 # Skip 'self' in APIHTTPEndpoint functions
                 (name == 'self' and '.' in func.__qualname__)
-                or isinstance(parameter.default, NoParam)
+                or isinstance(starmallow_param, NoParam)
             ):
                 continue
-            elif isinstance(parameter.default, Security):
-                security_param: Security = self.get_resolved_param(parameter, path=path)
-                params[ParamType.security][name] = security_param
-                # add to resolved so we can properly order them based which to execute first
-                params[ParamType.resolved][name] = security_param
-                continue
-            elif isinstance(parameter.default, ResolvedParam):
-                resolved_param: ResolvedParam = self.get_resolved_param(parameter, path=path)
+            elif isinstance(starmallow_param, ResolvedParam):
+                resolved_param: ResolvedParam = self.get_resolved_param(starmallow_param, type_annotation, path=path)
                 params[ParamType.resolved][name] = resolved_param
+
+                if isinstance(starmallow_param, Security):
+                    params[ParamType.security][name] = resolved_param
+                # Allow `ResolvedParam(HTTPBearer())`
+                elif isinstance(resolved_param.resolver, SecurityBaseResolver):
+                    params[ParamType.security][name] = resolved_param
+
                 continue
             elif lenient_issubclass(
-                parameter.annotation,
+                type_annotation,
                 (
                     Request,
                     WebSocket,
@@ -287,18 +337,18 @@ class EndpointMixin:
                     BackgroundTasks,
                 ),
             ):
-                params[ParamType.noparam][name] = parameter.annotation
+                params[ParamType.noparam][name] = type_annotation
                 continue
 
-            model = self._get_param_model(parameter)
+            model = self._get_param_model(type_annotation, starmallow_param, name, default_value)
             model.name = name
 
-            if isinstance(parameter.default, Param):
+            if isinstance(starmallow_param, Param):
                 # Create new field_info with processed model
-                field_info = parameter.default.__class__(
-                    parameter.default.default,
-                    deprecated=parameter.default.deprecated,
-                    include_in_schema=parameter.default.include_in_schema,
+                field_info = starmallow_param.__class__(
+                    starmallow_param.default,
+                    deprecated=starmallow_param.deprecated,
+                    include_in_schema=starmallow_param.include_in_schema,
                     model=model,
                 )
             elif isinstance(model, mf.Field):
@@ -308,7 +358,7 @@ class EndpointMixin:
                 if name in path_param_names:
                     field_info = Path(
                         # If a default was provided, honor it.
-                        ... if parameter.default == inspect._empty else parameter.default,
+                        ... if default_value == inspect._empty else default_value,
                         deprecated=False,
                         include_in_schema=True,
                         model=model,
@@ -317,7 +367,7 @@ class EndpointMixin:
                     # Default it to QueryParameter
                     field_info = Query(
                         # If a default was provided, honor it.
-                        ... if parameter.default == inspect._empty else parameter.default,
+                        ... if default_value == inspect._empty else default_value,
                         deprecated=False,
                         include_in_schema=True,
                         model=model,

starmallow/exceptions.py

@@ -1,7 +1,7 @@
 from typing import Any, Dict, List, Union
 
 from starlette.exceptions import HTTPException
-from starlette.status import HTTP_422_UNPROCESSABLE_ENTITY
+from starlette.status import HTTP_422_UNPROCESSABLE_ENTITY, HTTP_500_INTERNAL_SERVER_ERROR
 
 
 class RequestValidationError(HTTPException):
@@ -20,3 +20,10 @@ class WebSocketRequestValidationError(HTTPException):
     ) -> None:
         super().__init__(status_code=HTTP_422_UNPROCESSABLE_ENTITY)
         self.errors = errors
+
+
+class SchemaGenerationError(HTTPException):
+    def __init__(
+        self,
+    ) -> None:
+        super().__init__(status_code=HTTP_500_INTERNAL_SERVER_ERROR, detail="Failed to generate schema")

starmallow/ext/marshmallow/openapi.py

@@ -240,7 +240,7 @@ class OpenAPIConverter(ApiSpecOpenAPIConverter):
                 ret["explode"] = True
                 ret["style"] = "form"
             if prop.get("description", None):
-                ret["description"] = prop.pop("description")
+                ret["description"] = prop.pop("description", None)
             ret["schema"] = prop
 
             if 'deprecated' in field.metadata:

starmallow/routing.py

@@ -584,7 +584,7 @@ class APIRouter(routing.Router):
                     method_tags.extend(endpoint_options.tags)
 
                 route = APIRoute(
-                    path,
+                    self.prefix + path,
                     endpoint_function,
                     methods=[method],
                     name=endpoint_options.name or name,

starmallow/schema_generator.py

@@ -4,6 +4,7 @@ import itertools
 import re
 import warnings
 from collections import defaultdict
+from logging import getLogger
 from typing import Any, Dict, List, Optional, Sequence, Set, Tuple, Type
 
 import marshmallow as ma
@@ -29,6 +30,7 @@ from starmallow.utils import (
     status_code_ranges,
 )
 
+logger = getLogger(__name__)
 
 class SchemaRegistry(dict):
     '''
@@ -410,10 +412,8 @@ class SchemaGenerator(BaseSchemaGenerator):
 
         # Add default error response
         if (any_params or endpoint.body_params or endpoint.form_params) and not any(
-            [
-                status in schema['responses']
+            status in schema['responses']
                 for status in ["422", "4XX", "default"]
-            ],
         ):
             self._add_default_error_response(schema)
 
@@ -449,9 +449,13 @@ class SchemaGenerator(BaseSchemaGenerator):
         endpoints_info = self.get_endpoints(routes)
 
         for path, endpoints in endpoints_info.items():
-            self.spec.path(
-                path=path,
-                operations=self.get_operations(endpoints),
-            )
+            try:
+                self.spec.path(
+                    path=path,
+                    operations=self.get_operations(endpoints),
+                )
+            except Exception:
+                logger.error(f'Failed to generate schema for path {path}')
+                raise
 
         return self.spec.to_dict()

starmallow/security/oauth2.py

@@ -84,7 +84,7 @@ class OAuth2PasswordRequestForm:
     This is a dependency class, use it like:
 
         @app.post("/login")
-        def login(form_data: OAuth2PasswordRequestForm = Depends()):
+        def login(form_data: OAuth2PasswordRequestForm = ResolvedParam()):
             data = form_data.parse()
             print(data.username)
             print(data.password)
@@ -134,7 +134,7 @@ class OAuth2PasswordRequestFormStrict(OAuth2PasswordRequestForm):
     This is a dependency class, use it like:
 
         @app.post("/login")
-        def login(form_data: OAuth2PasswordRequestFormStrict = Depends()):
+        def login(form_data: OAuth2PasswordRequestFormStrict = ResolvedParam()):
             data = form_data.parse()
             print(data.username)
             print(data.password)

starmallow/utils.py

@@ -32,6 +32,7 @@ import marshmallow as ma
 import marshmallow.fields as mf
 import marshmallow_dataclass.collection_field as collection_field
 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
@@ -257,9 +258,9 @@ def eq_marshmallow_fields(left: mf.Field, right: mf.Field) -> bool:
         This compares them instead.
     '''
     left_dict = left.__dict__.copy()
-    left_dict.pop('_creation_index')
+    left_dict.pop('_creation_index', None)
     right_dict = right.__dict__.copy()
-    right_dict.pop('_creation_index')
+    right_dict.pop('_creation_index', None)
 
     return left_dict == right_dict
 
@@ -302,7 +303,7 @@ def deep_dict_update(main_dict: Dict[Any, Any], update_dict: Dict[Any, Any]) ->
 
 
 def create_response_model(type_: Type[Any]) -> ma.Schema | mf.Field | None:
-    if type_ == inspect._empty:
+    if type_ in [inspect._empty, None] or issubclass(type_, Response):
         return None
 
     field = get_model_field(type_)

{starmallow-0.1.0.dist-info → starmallow-0.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: starmallow
-Version: 0.1.0
+Version: 0.2.1
 Summary: StarMallow framework
 Project-URL: Homepage, https://github.com/mvanderlee/starmallow
 Author-email: Michiel Vanderlee <jmt.vanderlee@gmail.com>
@@ -68,6 +68,7 @@ An example of Pydantic's limitations can be found in [Issue 2277](https://github
 Create a file `main.py` with:
 
 ```python
+from typing import Annotated
 from marshmallow_dataclass import dataclass
 from starmallow import Body, Path, StarMallow
 
@@ -88,7 +89,7 @@ class MyBody:
 
 @app.get("/body")
 async def get_body(body: MyBody = Body()) -> int:
-    return MyBody.item_id
+    return body.item_id
 
 
 # Example with explicit marshmallow schema
@@ -98,6 +99,13 @@ class MyBodySchema(ma.Schema):
 @app.get("/path/body_schema")
 def get_body_from_schema(body: Dict[str, int] = Body(model=MyBodySchema)) -> int:
     return body['item_id']
+
+
+# Example with Annotated
+
+@app.get("/body_annotated")
+async def get_body_annotated(body: Annotated[MyBody, Body()]) -> int:
+    return body.item_id
 ```
 
 ### Run it

{starmallow-0.1.0.dist-info → starmallow-0.2.1.dist-info}/RECORD

@@ -1,5 +1,5 @@
-starmallow/__init__.py,sha256=ZV96O-3SQhCjRVTbSI_SesM-Kk6hN6isx3x0kPd49b4,312
-starmallow/applications.py,sha256=6AEKK3Gih1PrxWLD7k0Sm13snzGE_40kzoi0igJ0ie4,29170
+starmallow/__init__.py,sha256=Z9SbracH7YsHAB1n1L9nHMbxRCARFs22aHL9Nq8F9oU,312
+starmallow/applications.py,sha256=2lgblSsk9vbVI9t-r0RcvfFuvLB_vFw2OebSDiVO_TM,29311
 starmallow/concurrency.py,sha256=MVRjo4Vqss_yqhaoeVt3xb7rLaSuAq_q9uYgTwbsojE,1375
 starmallow/constants.py,sha256=u0h8cJKhJY0oIZqzr7wpEZG2bPLrw5FroMnn3d8KBNQ,129
 starmallow/dataclasses.py,sha256=ap9DInvQjH2AyI4MAAnbDEuNnbPb94PigaNmEb7AQU8,2658
@@ -7,32 +7,32 @@ starmallow/datastructures.py,sha256=iH_KJuJ6kBCWEsnHFLdA3iyb6ZxhfdMHYrJlhiEZtDU,
 starmallow/decorators.py,sha256=SBrzmKxzF2q7hNCW_V7j0UV461QERSh9OTtTdTFi6Kg,3597
 starmallow/delimited_field.py,sha256=gonWgYg6G5xH2yXAyfDgkePmQ8dUaRSp2hdJ3mCfOBw,3466
 starmallow/docs.py,sha256=eA39LunVMEoPU5ge4qxm2eiJbrFTUSUu5EhG1L_LKxk,6268
-starmallow/endpoint.py,sha256=MPWF3v-WXL44J3Q7InpPX_5fam251T-7ImdirwojASI,13743
+starmallow/endpoint.py,sha256=5oHoWu2dSG_nnctRM60ZPkB1R9Mh4cJv5yxRbYEZHec,15593
 starmallow/endpoints.py,sha256=UrwVZCxbmWI20iNtJ0oXxo4d3-y12TjsOGs_jnStTiU,939
 starmallow/exception_handlers.py,sha256=gr2qLYWEtsIEH28n7OreEiiLVz6Y7b6osRyS9esJbBk,891
-starmallow/exceptions.py,sha256=AWIsbrqYXnPBQUGtUT0BPDqqljl53UdnIFTKw7BcraQ,642
+starmallow/exceptions.py,sha256=vabtPJkTmtCdC8_2OPBE8Osz0v0KxaSOX6IWf1jgNkc,872
 starmallow/fields.py,sha256=arrTabCYoJFZcoY69EZTBH3YUg7CUSr3-zYLiAjYLTM,1238
 starmallow/params.py,sha256=XRWIFLm2H5jQUIo4gm5Oi4xVqGNosaQSSi7QYqjJyxQ,7000
 starmallow/responses.py,sha256=k2pf_m21ykf_FECdODUz400pMucMJJf_Zm8TXFujvaU,2012
-starmallow/routing.py,sha256=jfEaP7bZm_744w1Q83BfeUHjRb0Jtd2umLc91J3awyA,47243
-starmallow/schema_generator.py,sha256=Tn9loWgvORScxt2UjcYW7KUt9zTk00gQwqkA1TOfGdw,16629
+starmallow/routing.py,sha256=UaqP4NLw7g3-gBFO85x83NDpsbFCZJMIjxQPT31BCS4,47257
+starmallow/schema_generator.py,sha256=6cMXlovR9xiA3g3Aryt6XFlzC74VVE-s_Ltsfl0nm-M,16815
 starmallow/serializers.py,sha256=rBEKMNgONgz_bai12uDvAEMCI_aEFGsqMSeIoWtlrOI,12514
 starmallow/types.py,sha256=8GXWjvzXQhF5NMHf14fbid6uErxVd1Xk_w2I4FoUgZ4,717
-starmallow/utils.py,sha256=PmOdXLVCC82Kqq4x_EYSLGVRuoc1WR6NCaMsHddTakg,9392
+starmallow/utils.py,sha256=MS44NCYDpKA3JRCvJ7lRhrBK57wT5T8QlylZxlcZLEU,9484
 starmallow/websockets.py,sha256=yIz3LzTBMNclpEoG7oTMbQwxbcdKNU6M8XcqZMyBTuA,2223
 starmallow/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 starmallow/ext/marshmallow/__init__.py,sha256=33jENGdfPq4-CDG0LOmN3KOGW1pXTy7a2oMwy4hrYzM,208
-starmallow/ext/marshmallow/openapi.py,sha256=6C-4n8sLPAmVutGVPkgpRJR-gJjJMXgsz0HicpDNcXw,9011
+starmallow/ext/marshmallow/openapi.py,sha256=5aGvbwLGVucsVhXExpYeyt8n5dQTzazrf-nuh6mVhmA,9017
 starmallow/middleware/__init__.py,sha256=vtNm85Z9pUPjJd-9giJGg3YL1wO7Jm5ooXBm31pDOK8,53
 starmallow/middleware/asyncexitstack.py,sha256=0GPhQSxqSVmAiVIqBIN5slueWYZ8bwh9f2bBPy7AbP0,1191
 starmallow/security/__init__.py,sha256=1rQFBIGnEbE51XDZSSi9NgPjXLScFq3RoLu4vk0KVYw,191
 starmallow/security/api_key.py,sha256=v2a3FHv1c--F2guiJ3wxKQi5k0nIcl40d4tqMPFyb44,3131
 starmallow/security/base.py,sha256=6ybCCf22t8GNR4RZXIzOfFEGws28S-KVqri-gHHXVCU,1131
 starmallow/security/http.py,sha256=rMwBYQQRil5iVjM87b0gsCENSFQXiqsdAfy0g6Qmvt8,6597
-starmallow/security/oauth2.py,sha256=Sb90Y8ADFceqJImXZyAAiXQp-AOwXmAeP30-xdKoV14,9902
+starmallow/security/oauth2.py,sha256=PWdrgqUeijxzRAQilXMXRb9DnA-U2-xMQ5LKL4S66t8,9914
 starmallow/security/open_id_connect_url.py,sha256=ykokB7mJYu4pFsHW4Ro1y71h-5H11mt90jyv64EIQBM,1386
 starmallow/security/utils.py,sha256=bd8T0YM7UQD5ATKucr1bNtAvz_Y3__dVNAv5UebiPvc,293
-starmallow-0.1.0.dist-info/METADATA,sha256=1cmZHt1fQG2mGO0L9O6w9X-hiZh6e0MUzFZVUb8g3KE,5474
-starmallow-0.1.0.dist-info/WHEEL,sha256=y1bSCq4r5i4nMmpXeUJMqs3ipKvkZObrIXSvJHm1qCI,87
-starmallow-0.1.0.dist-info/licenses/LICENSE.md,sha256=QelyGgOzch8CXzy6HrYwHh7nmj0rlWkDA0YzmZ3CPaY,1084
-starmallow-0.1.0.dist-info/RECORD,,
+starmallow-0.2.1.dist-info/METADATA,sha256=a-W6lFF1CHbt1bMQxz-VBT-flN3cZh_5FHB-WF0MBDA,5651
+starmallow-0.2.1.dist-info/WHEEL,sha256=y1bSCq4r5i4nMmpXeUJMqs3ipKvkZObrIXSvJHm1qCI,87
+starmallow-0.2.1.dist-info/licenses/LICENSE.md,sha256=QelyGgOzch8CXzy6HrYwHh7nmj0rlWkDA0YzmZ3CPaY,1084
+starmallow-0.2.1.dist-info/RECORD,,