wellapi 0.2.1__py3-none-any.whl

wellapi/routing.py

@@ -0,0 +1,248 @@
+import json
+import re
+from collections.abc import Callable
+from typing import Any
+
+from pydantic.main import IncEx
+
+from wellapi.convertors import CONVERTOR_TYPES
+from wellapi.datastructures import Default, DefaultPlaceholder
+from wellapi.dependencies.models import Dependant, ModelField
+from wellapi.dependencies.utils import solve_dependencies
+from wellapi.exceptions import (
+    HTTPException,
+    RequestValidationError,
+    ResponseValidationError,
+    WellAPIError,
+)
+from wellapi.models import RequestAPIGateway, RequestJob, RequestSQS, ResponseAPIGateway
+
+# Match parameters in URL paths, eg. '{param}', and '{param:int}'
+PARAM_REGEX = re.compile("{([a-zA-Z_][a-zA-Z0-9_]*)(:[a-zA-Z_][a-zA-Z0-9_]*)?}")
+
+
+def compile_path(path: str) -> tuple:
+    """
+    Given a path string, like: "/{username:str}",
+    or a host string, like: "{subdomain}.mydomain.org", return a three-tuple
+    of (regex, format, {param_name:convertor}).
+
+    regex:      "/(?P<username>[^/]+)"
+    format:     "/{username}"
+    convertors: {"username": StringConvertor()}
+    """
+    is_host = not path.startswith("/")
+
+    path_regex = "^"
+    path_format = ""
+    duplicated_params = set()
+
+    idx = 0
+    param_convertors = {}
+    for match in PARAM_REGEX.finditer(path):
+        param_name, convertor_type = match.groups("str")
+        convertor_type = convertor_type.lstrip(":")
+        assert convertor_type in CONVERTOR_TYPES, (
+            f"Unknown path convertor '{convertor_type}'"
+        )
+        convertor = CONVERTOR_TYPES[convertor_type]
+
+        path_regex += re.escape(path[idx : match.start()])
+        path_regex += f"(?P<{param_name}>{convertor.regex})"
+
+        path_format += path[idx : match.start()]
+        path_format += "{%s}" % param_name  # noqa: UP031
+
+        if param_name in param_convertors:
+            duplicated_params.add(param_name)
+
+        param_convertors[param_name] = convertor
+
+        idx = match.end()
+
+    if duplicated_params:
+        names = ", ".join(sorted(duplicated_params))
+        ending = "s" if len(duplicated_params) > 1 else ""
+        raise ValueError(f"Duplicated param name{ending} {names} at path {path}")
+
+    if is_host:
+        # Align with `Host.matches()` behavior, which ignores port.
+        hostname = path[idx:].split(":")[0]
+        path_regex += re.escape(hostname) + "$"
+    else:
+        path_regex += re.escape(path[idx:]) + "$"
+
+    path_format += path[idx:]
+
+    return re.compile(path_regex), path_format, param_convertors
+
+
+def get_request_handler(
+    dependant: Dependant,
+    status_code: int | None = None,
+    response_class: type[ResponseAPIGateway] | DefaultPlaceholder = Default(
+        ResponseAPIGateway
+    ),
+    response_field: ModelField | None = None,
+    response_model_include: IncEx | None = None,
+    response_model_exclude: IncEx | None = None,
+    response_model_by_alias: bool = True,
+    response_model_exclude_unset: bool = False,
+    response_model_exclude_defaults: bool = False,
+    response_model_exclude_none: bool = False,
+    embed_body_fields: bool = False,
+) -> Callable[[RequestAPIGateway], ResponseAPIGateway]:
+    assert dependant.call is not None, "dependant.call must be a function"
+
+    if isinstance(response_class, DefaultPlaceholder):
+        actual_response_class: type[ResponseAPIGateway] = response_class.value
+    else:
+        actual_response_class = response_class
+
+    def app(request: RequestAPIGateway) -> ResponseAPIGateway:
+        response: ResponseAPIGateway | None = None
+        try:
+            body: Any = request.json()
+        except json.JSONDecodeError as e:
+            validation_error = RequestValidationError(
+                [
+                    {
+                        "type": "json_invalid",
+                        "loc": ("body", e.pos),
+                        "msg": "JSON decode error",
+                        "input": {},
+                        "ctx": {"error": e.msg},
+                    }
+                ],
+                body=e.doc,
+            )
+            raise validation_error from e
+        except HTTPException:
+            # If a middleware raises an HTTPException, it should be raised again
+            raise
+        except Exception as e:
+            http_error = HTTPException(
+                status_code=400, detail="There was an error parsing the body"
+            )
+            raise http_error from e
+        errors: list[Any] = []
+        solved_result = solve_dependencies(
+            request=request,
+            dependant=dependant,
+            body=body,
+            embed_body_fields=embed_body_fields,
+        )
+        errors = solved_result.errors
+        if not errors:
+            raw_response = dependant.call(**solved_result.values)
+            if isinstance(raw_response, ResponseAPIGateway):
+                response = raw_response
+            else:
+                response_args: dict[str, Any] = {}
+                # If status_code was set, use it, otherwise use the default from the
+                # response class, in the case of redirect it's 307
+                current_status_code = (
+                    status_code if status_code else solved_result.response.statusCode
+                )
+                if current_status_code is not None:
+                    response_args["status_code"] = current_status_code
+                if solved_result.response.statusCode:
+                    response_args["status_code"] = solved_result.response.statusCode
+                content = serialize_response(
+                    field=response_field,
+                    response_content=raw_response,
+                    include=response_model_include,
+                    exclude=response_model_exclude,
+                    by_alias=response_model_by_alias,
+                    exclude_unset=response_model_exclude_unset,
+                    exclude_defaults=response_model_exclude_defaults,
+                    exclude_none=response_model_exclude_none,
+                )
+                response = actual_response_class(content, **response_args)
+                if not is_body_allowed_for_status_code(response.statusCode):
+                    response.body = ""
+                response.headers.raw.extend(solved_result.response.headers.raw)
+        if errors:
+            validation_error = RequestValidationError(errors, body=body)
+            raise validation_error
+        if response is None:
+            raise WellAPIError(
+                "No response object was returned. There's a high chance that the "
+                "application code is raising an exception and a dependency with yield "
+                "has a block with a bare except, or a block with except Exception, "
+                "and is not raising the exception again. Read more about it in the "
+                "docs: https://fastapi.tiangolo.com/tutorial/dependencies/dependencies-with-yield/#dependencies-with-yield-and-except"
+            )
+        return response
+
+    return app
+
+
+def serialize_response(
+    *,
+    field: ModelField | None = None,
+    response_content: Any,
+    include: IncEx | None = None,
+    exclude: IncEx | None = None,
+    by_alias: bool = True,
+    exclude_unset: bool = False,
+    exclude_defaults: bool = False,
+    exclude_none: bool = False,
+) -> Any:
+    if field:
+        errors = []
+        value, errors_ = field.validate(response_content, {}, loc=("response",))
+
+        if isinstance(errors_, list):
+            errors.extend(errors_)
+        elif errors_:
+            errors.append(errors_)
+        if errors:
+            raise ResponseValidationError(errors=errors, body=response_content)
+
+        return field.serialize(
+            value,
+            include=include,
+            exclude=exclude,
+            by_alias=by_alias,
+            exclude_unset=exclude_unset,
+            exclude_defaults=exclude_defaults,
+            exclude_none=exclude_none,
+        )
+    else:
+        return json.dumps(response_content)
+
+
+def is_body_allowed_for_status_code(status_code: int | str | None) -> bool:
+    if status_code is None:
+        return True
+    # Ref: https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#patterned-fields-1
+    if status_code in {
+        "default",
+        "1XX",
+        "2XX",
+        "3XX",
+        "4XX",
+        "5XX",
+    }:
+        return True
+    current_status_code = int(status_code)
+    return not (current_status_code < 200 or current_status_code in {204, 205, 304})
+
+
+def request_response(
+    func: Callable[[RequestAPIGateway], ResponseAPIGateway],
+) -> Callable[[dict, dict], dict]:
+    def app(event: dict, context: dict) -> dict:
+        if "Records" in event:
+            request = RequestSQS.create_request_from_event(event)
+        elif "source" in event and event["source"] == "aws.events":
+            request = RequestJob.create_request_from_event(event)
+        else:
+            request = RequestAPIGateway.create_request_from_event(event)
+
+        resp = func(request)
+
+        return resp.to_aws_response()
+
+    return app

wellapi/security.py

@@ -0,0 +1,82 @@
+from typing import Any, cast
+
+from wellapi.exceptions import HTTPException
+from wellapi.models import RequestAPIGateway
+from wellapi.openapi.models import OAuth2 as OAuth2Model
+from wellapi.openapi.models import OAuthFlows as OAuthFlowsModel
+from wellapi.openapi.models import SecurityBase as SecurityBaseModel
+
+
+class SecurityBase:
+    model: SecurityBaseModel
+    scheme_name: str
+
+
+class OAuth2(SecurityBase):
+    def __init__(
+        self,
+        *,
+        flows: OAuthFlowsModel | dict[str, dict[str, Any]] = OAuthFlowsModel(),
+        scheme_name: str | None = None,
+        description: str | None = None,
+        auto_error: bool = True,
+    ):
+        self.model = OAuth2Model(
+            flows=cast(OAuthFlowsModel, flows), description=description
+        )
+        self.scheme_name = scheme_name or self.__class__.__name__
+        self.auto_error = auto_error
+
+    def __call__(self, request: RequestAPIGateway) -> str | None:
+        authorization = request.headers.get("Authorization")
+        if not authorization:
+            if self.auto_error:
+                raise HTTPException(status_code=403, detail="Not authenticated")
+            else:
+                return None
+        return authorization
+
+
+class OAuth2PasswordBearer(OAuth2):
+    def __init__(
+        self,
+        tokenUrl: str,
+        scheme_name: str | None = None,
+        scopes: dict[str, str] | None = None,
+        description: str | None = None,
+        auto_error: bool = True,
+    ):
+        if not scopes:
+            scopes = {}
+        flows = OAuthFlowsModel(
+            password=cast(Any, {"tokenUrl": tokenUrl, "scopes": scopes})
+        )
+        super().__init__(
+            flows=flows,
+            scheme_name=scheme_name,
+            description=description,
+            auto_error=auto_error,
+        )
+
+    def __call__(self, request: RequestAPIGateway) -> str | None:
+        authorization = request.headers.get("Authorization")
+        scheme, param = get_authorization_scheme_param(authorization)
+        if not authorization or scheme.lower() != "bearer":
+            if self.auto_error:
+                raise HTTPException(
+                    status_code=401,
+                    detail="Not authenticated",
+                    headers={"WWW-Authenticate": "Bearer"},
+                )
+            else:
+                return None
+        return param
+
+
+def get_authorization_scheme_param(
+    authorization_header_value: str | None,
+) -> tuple[str, str]:
+    if not authorization_header_value:
+        return "", ""
+    scheme, _, param = authorization_header_value.partition(" ")
+    return scheme, param

wellapi/utils.py

@@ -0,0 +1,37 @@
+import importlib
+import os
+import sys
+from pathlib import Path
+
+
+def import_app(app: str):
+    app_modal, app_name = app.split(":")
+    app_path = f"{os.path.abspath(Path(app_modal))}.py"
+
+    spec = importlib.util.spec_from_file_location(app_modal, app_path)
+    main = importlib.util.module_from_spec(spec)
+    sys.modules[app_modal] = main
+    spec.loader.exec_module(main)
+
+    return getattr(main, app_name)
+
+
+def load_handlers(handlers_dir: str):
+    handlers_path = Path(handlers_dir)
+    handlers_module = handlers_path.name
+    base_path = Path(os.path.dirname(handlers_path))
+
+    if not handlers_path.exists() or not handlers_path.is_dir():
+        print(f"Директорія {handlers_path} не існує")
+        return
+
+    # Додаємо шлях до директорії у sys.path для імпорту
+    sys.path.insert(0, str(base_path))
+
+    # Імпортуємо всі Python файли з директорії
+    for file_path in handlers_path.glob("*.py"):
+        module_name = f"{handlers_module}.{file_path.stem}"
+        try:
+            importlib.import_module(module_name)
+        except ImportError as e:
+            print(f"Помилка імпорту {module_name}: {e}")

wellapi-0.2.1.dist-info/METADATA

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: wellapi
+Version: 0.2.1
+Summary: Add your description here
+Author-email: ramses <romayuhym@gmail.com>
+Requires-Python: >=3.12
+Requires-Dist: aws-cdk-lib>=2.189.1
+Requires-Dist: email-validator>=2.0.0
+Requires-Dist: pydantic==2.11.3
+Requires-Dist: typing-extensions>=4.8.0
+Provides-Extra: standard
+Requires-Dist: click>=8.1.8; extra == 'standard'
+Requires-Dist: watchdog>=4.0.2; extra == 'standard'
+Description-Content-Type: text/markdown
+
+TODO
+
+- [ ] OpenAPI
+  - [X] Request validation
+  - [ ] CORS
+  - [ ] x-api-key
+  - [ ] cache
+  - [ ] access log
+- [ ] Build
+  - [ ] Clean up 
+- [x] Use multi Value Request Parameters (Headers, QueryString)
+- [ ] Check AWS warning 
+
+  The API with ID 6526xo4n92 doesn’t include a resource with path /* having an integration arn:aws:lambda:eu-central-1:985539757029:function:MainHelloFunction on the ANY method.
+
+  The API with ID doesn’t include a resource with path /* having an integration on the ANY method.
+- [ ] [Dependency groups](https://docs.astral.sh/uv/concepts/projects/dependencies/)

wellapi-0.2.1.dist-info/RECORD

@@ -0,0 +1,38 @@
+wellapi/__init__.py,sha256=N6ifyrbNKflKx8oJ7xYi3vV5SWLuiQMqJJtUxU5K3Ww,115
+wellapi/__main__.py,sha256=nEdSvtvjzSyjlucTTawydRW7_Yrn-8tIvpbn-k4s3pQ,33
+wellapi/applications.py,sha256=U6vThhLg3qQtC9rCa0PtEHK1DEtfqzeqaVX1cwlxJRU,14468
+wellapi/awsmodel.py,sha256=Vnx_HcQUAxH5EKhZRFwd7CsThZ2RPaO6asF3qX4EZZk,303
+wellapi/convertors.py,sha256=Z8alTWkTTahOYLw-O6oLpd7kvXT11qtF4lbRI_7yq_o,2317
+wellapi/datastructures.py,sha256=Wl6dMoD-E1F5ZozoYQecZZv-wNfIxCvCLTM9hE97FBM,12923
+wellapi/exceptions.py,sha256=FvcBiLayr27drUy8xVX5y3SCXlNrm8DAyZOvFjnk8VE,1495
+wellapi/models.py,sha256=dXhBcKsQuuQv4Ja7DTg2wOz9W5xxbM0qcc-57VE0MnY,4271
+wellapi/params.py,sha256=cwrXYmFarMP1r3OqgQ6aeLK4rleprcwn6Canwhz-c20,16190
+wellapi/routing.py,sha256=2n9K4KnlMhkCtiwn1aUHmwzcKZkKZbtmEAQQv9usXh8,8999
+wellapi/security.py,sha256=qdSETiJZXIrbbSJFN9Ilyk-U3nagzYpE1XZtA_IFtWE,2625
+wellapi/utils.py,sha256=AH45QMkL96FTizoIBGBIzSBelrMeWdr477rJRpw_bfo,1220
+wellapi/build/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wellapi/build/cdk.py,sha256=BLMRQ8cEHyj2q3jHEC7rduIyeHwebHokYRgxkdYb2v4,4648
+wellapi/build/packager.py,sha256=cmQaEAVT_F7X2tkFSZug9LZJpfpRO54ysoYtfde18w0,1883
+wellapi/build/sam_openapi.py,sha256=SAbgR5HnscCNEVXQBH7eMlJd9h0jeW17mbFTeJiwHiI,356
+wellapi/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wellapi/cli/main.py,sha256=75VhVYryXjadu3Tr_7CKCRbDMOiwLXGXxoA5oYRt7DA,1966
+wellapi/dependencies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wellapi/dependencies/models.py,sha256=GIagLUOKFp9FndQlSrmcRXcvlj2kaaSdXdFvB0aGHcU,4322
+wellapi/dependencies/utils.py,sha256=qcx38SjVtYlFIRKUhWbBwu0TmnS9KAK_VBF1ZqlIwGE,32581
+wellapi/local/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wellapi/local/reloader.py,sha256=BgF4zSipXhfX-Lk9NkKBaaTCtIz_gV9p1sSkeADP67c,3190
+wellapi/local/router.py,sha256=m_1LZ-DGL2TPJyq8Czrb-cc7HFMdKhqgfjyw9lFPeyQ,3294
+wellapi/local/server.py,sha256=wKS-jarw66wXhAGfTpYbZqtH1bmP4wY7rz5rNqhU9wA,5611
+wellapi/middleware/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wellapi/middleware/base.py,sha256=0zAN4ydARbVf-3_q_9KVEep4LBvUDklhl_zEWjnIlwM,647
+wellapi/middleware/error.py,sha256=ozpCk980nkpQa_jWLv0J4YxKvWUtnP8RJcv0HyvCGGI,7066
+wellapi/middleware/exceptions.py,sha256=pQGWR5lnJcSvkBDhPg54CKg4ximgaYWNJU3fJ5caRLI,2370
+wellapi/middleware/main.py,sha256=orMTtLPETezQOeFsrPju9p68v2Cdi3EZ2iHi9UzMV30,761
+wellapi/openapi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wellapi/openapi/docs.py,sha256=bCwrv9OlJNfh3WA5gKlsbMYM1irYkDi5fP9y8Y2WNMg,10323
+wellapi/openapi/models.py,sha256=9BD9G2FrstD4uuZZ2aHSrCBoWuU_jv2gQwo7LBWbf7c,13434
+wellapi/openapi/utils.py,sha256=ecPSmcS6FUzbU6-ATYwuEgLbXa8wj55jmbjHhT7xECg,20147
+wellapi-0.2.1.dist-info/METADATA,sha256=xkSpufFydjtrc5CLhrqSDoHriIeLG5YnqiCpL4iX4XM,1063
+wellapi-0.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+wellapi-0.2.1.dist-info/entry_points.txt,sha256=O4XF2o637XkqrRiaZjPXxU_P1y6-2sRaYaBw9Jc7IJM,49
+wellapi-0.2.1.dist-info/RECORD,,

wellapi-0.2.1.dist-info/WHEEL

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

wellapi-0.2.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+wellapi = wellapi.cli.main:cli