starmallow 0.1.0__tar.gz → 0.2.1__tar.gz

{starmallow-0.1.0 → starmallow-0.2.1}/PKG-INFO

@@ -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 → starmallow-0.2.1}/README.md

@@ -12,6 +12,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
 
@@ -32,7 +33,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
@@ -42,6 +43,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.2.1/examples/sample_server.py

@@ -0,0 +1,215 @@
+from dataclasses import asdict
+from typing import Annotated, Optional, Iterable
+
+import aiofiles.tempfile
+import marshmallow.fields as mf
+import orjson
+from marshmallow.validate import Range
+from marshmallow_dataclass import dataclass as ma_dataclass
+from starlette.middleware import Middleware
+from starlette.middleware.gzip import GZipMiddleware
+from starlette_context import middleware, plugins
+
+from starmallow.applications import StarMallow
+from starmallow.params import Body, Cookie, Header, Path, Query, Security, ResolvedParam
+from starmallow.security.http import HTTPBearer, HTTPAuthorizationCredentials
+from starmallow.security.oauth2 import OAuth2PasswordBearer
+
+from starlette.requests import Request, HTTPException
+from starmallow.security.http import HTTPBearer, HTTPAuthorizationCredentials
+from typing import Mapping
+
+from techlock.common.api.auth.claim import ClaimSpec
+from techlock.common.api.auth.jwt import JWTDecoder
+from techlock.common.api.auth.user_loader import JWTUserLoader, AuthInfo
+from techlock.common.api.auth.utils import SYSTEM_TENANT_ID
+from techlock.common.orm.sqlalchemy.base import BaseModel
+
+
+app = StarMallow(
+    title="My API",
+    version="1.0.0",
+    middleware=[
+        # Order matters!
+        Middleware(GZipMiddleware, minimum_size=500),
+        Middleware(
+            middleware.ContextMiddleware,
+            plugins=(
+                plugins.RequestIdPlugin(),
+                plugins.CorrelationIdPlugin(),
+            ),
+        ),
+    ],
+)
+
+jwks_urls = ['http://172.16.40.238:6081/.well-known/jwks.json']
+app.ndr_audience = None
+app.ndr_jwt_decoder = JWTDecoder(
+    jwks_urls,
+    # audience='https://ndr.techlockinc.com/',
+    # issuer='https://techlock.auth0.com/',
+)
+
+
+class NDR_JWTBearer(HTTPBearer):
+
+    def __init__(
+        self,
+        access_models: Mapping[ClaimSpec | BaseModel, str | Iterable[str]],
+        default_tenants: str | list[str] = SYSTEM_TENANT_ID,
+        replace_wildcard_tenants: bool = True,
+        # Bool if exact match for all access models. otherwise flag per access model
+        exact_match_only: bool | Mapping[ClaimSpec | BaseModel, bool] = False,
+        # All flags are required! (AND operation)
+        required_flags: str | list[str] = None,
+        auto_error: bool = True,
+    ):
+        super().__init__(auto_error=auto_error)
+
+        self.jwt_extractor = JWTUserLoader(
+            access_models=access_models,
+            default_tenants=default_tenants,
+            replace_wildcard_tenants=replace_wildcard_tenants,
+            exact_match_only=exact_match_only,
+            required_flags=required_flags,
+        )
+
+    async def __call__(self, request: Request) -> AuthInfo:
+        credentials: HTTPAuthorizationCredentials = await super().__call__(request)
+        if credentials:
+            if not credentials.scheme == "Bearer":
+                raise HTTPException(status_code=403, detail="Invalid authentication scheme.")
+
+            jwt_decoder: JWTDecoder = request.app.ndr_jwt_decoder
+            jwt_data = await jwt_decoder.decode(credentials.credentials)
+            return self.jwt_extractor.get_user_from_jwt(jwt_data, request.headers, getattr(request.app, 'ndr_audience'))
+
+        else:
+            raise HTTPException(status_code=403, detail="Invalid authorization code.")
+
+
+jwt_scheme = HTTPBearer()
+ndr_schema = NDR_JWTBearer(
+    {ClaimSpec(actions=['read'], resource_name='foo'): 'read'}
+)
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="v1/auth/login")
+
+
+@ma_dataclass
+class CreateRequest:
+    my_string: str
+    my_int: int = 5
+
+
+@ma_dataclass
+class CreateResponse:
+    my_string: str
+
+
+@app.get('/oauth_test')
+def oauth_test(
+    token: str = ResolvedParam(oauth2_scheme),
+):
+    print(token)
+
+
+@app.get('/auth_test')
+def auth_test(
+    token: HTTPAuthorizationCredentials = ResolvedParam(jwt_scheme),
+):
+    print(token)
+
+
+@app.get('/ndr_auth_test')
+def auth_test(
+    auth_info: AuthInfo = ResolvedParam(ndr_schema),
+):
+    print(auth_info)
+
+
+def myapi(
+    auth_info: AuthInfo = RequiredAccess(
+        {ClaimSpec(actions=['read'], resource_name='foo'): 'read'}
+    )
+):
+    print(auth_info)
+
+
+@app.post('/test')
+async def test(
+    create_request: CreateRequest,
+    limit: Annotated[int, Query()],
+    offset: int = 0,
+    offset2: int = Query(0, model=mf.Integer(validate=[Range(min=0, max=50)])),
+    my_string: str = Body('foobar'),
+    email: str = Body(..., model=mf.Email()),
+    foobar: str = Header(...),
+    preference: Optional[str] = Cookie(...),
+) -> CreateResponse:
+    print(create_request)
+    print(limit)
+    print(offset)
+    print(offset2)
+    print(foobar)
+    print(my_string)
+    print(email)
+    print(preference)
+
+    return create_request
+
+
+# Test path parameters
+@app.get('/test/{id}')
+def test_id(
+    id: int = Path(...),
+) -> CreateResponse:
+    print(id)
+
+    return None
+
+
+# Test basic JSON request body and JSON response body
+@app.put('/test2')
+def test2(create_request: CreateRequest) -> CreateResponse:
+    print(create_request)
+
+    return asdict(create_request)
+
+
+# Test basic JSON request body and JSON response body with request defaults
+@app.patch('/test3')
+def test3(
+    create_request: CreateRequest = CreateRequest(my_string='foobar', my_int=10),
+) -> CreateResponse:
+    print(create_request)
+
+    return asdict(create_request)
+
+
+# Test request query from schema where the entire schema is required
+@app.get('/test4')
+def test4(
+    create_request: CreateRequest = Query(...),
+) -> CreateResponse:
+    print(create_request)
+
+    return asdict(create_request)
+
+
+# Test request query from schema where the entire schema has a default
+@app.get('/test5')
+def test5(
+    create_request: CreateRequest = Query(CreateRequest(my_string='default_string', my_int=101)),
+) -> CreateResponse:
+    print(create_request)
+
+    return asdict(create_request)
+
+
+# Test basic JSON request body and JSON response body
+@app.put('/tmp_file')
+async def put_tmp_file(create_request: CreateRequest) -> CreateResponse:
+    async with aiofiles.tempfile.TemporaryFile('wb') as f:
+        await f.write(orjson.dumps(create_request))
+
+    return asdict(create_request)

{starmallow-0.1.0 → starmallow-0.2.1}/starmallow/__init__.py

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

{starmallow-0.1.0 → starmallow-0.2.1}/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-0.1.0 → starmallow-0.2.1}/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-0.1.0 → starmallow-0.2.1}/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-0.1.0 → starmallow-0.2.1}/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-0.1.0 → starmallow-0.2.1}/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-0.1.0 → starmallow-0.2.1}/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-0.1.0 → starmallow-0.2.1}/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)