wellapi 0.2.1__py3-none-any.whl

wellapi/__init__.py

@@ -0,0 +1,5 @@
+import typing
+
+from wellapi.applications import WellApi as WellApi
+
+Scope = typing.MutableMapping[str, typing.Any]

wellapi/__main__.py

@@ -0,0 +1,3 @@
+from .cli.main import cli
+
+cli()

wellapi/applications.py

@@ -0,0 +1,389 @@
+import inspect
+from collections.abc import Callable, Sequence
+from enum import Enum
+from typing import Any, Literal
+
+from pydantic._internal._utils import lenient_issubclass
+from pydantic.main import IncEx
+
+from wellapi import params
+from wellapi.datastructures import Default, DefaultPlaceholder
+from wellapi.dependencies.models import ModelField
+from wellapi.dependencies.utils import (
+    _should_embed_body_fields,
+    create_model_field,
+    get_body_field,
+    get_dependant,
+    get_flat_dependant,
+    get_parameterless_sub_dependant,
+    get_typed_return_annotation,
+)
+from wellapi.middleware.base import BaseMiddleware
+from wellapi.middleware.error import ServerErrorMiddleware
+from wellapi.middleware.exceptions import ExceptionMiddleware
+from wellapi.middleware.main import Middleware
+from wellapi.models import RequestAPIGateway, ResponseAPIGateway
+from wellapi.routing import (
+    compile_path,
+    get_request_handler,
+    is_body_allowed_for_status_code,
+    request_response,
+)
+
+
+def to_camel_case(snake_str):
+    return "".join(x.capitalize() for x in snake_str.lower().split("_"))
+
+
+def get_arn(endpoint: Callable[..., Any]) -> str:
+    name = f"{endpoint.__module__}.{endpoint.__name__}"
+    name = name.replace(".", "_")
+    return to_camel_case(name)
+
+
+class Lambda:
+    def __init__(
+        self,
+        path: str,
+        endpoint: Callable[..., Any],
+        *,
+        method: str = None,
+        type_: Literal["endpoint", "queue", "job"] = "endpoint",
+        name: str | None = None,
+        memory_size: int = 128,
+        timeout: int = 30,
+        response_model: Any = Default(None),
+        status_code: int | None = None,
+        description: str | None = None,
+        response_description: str = "Successful Response",
+        responses: dict[int | str, dict[str, Any]] | None = None,
+        response_class: type[ResponseAPIGateway] | DefaultPlaceholder = Default(
+            ResponseAPIGateway
+        ),
+        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,
+        dependencies: Sequence[params.Depends] | None = None,
+        tags: list[str | Enum] | None = None,
+        deprecated: bool | None = None,
+        operation_id: str | None = None,
+        summary: str | None = None,
+    ):
+        self.path = path
+        self.type_ = type_
+        self.name = endpoint.__name__ if name is None else name
+        self.memory_size = memory_size
+        self.timeout = timeout
+        self.method = method
+        self.endpoint = endpoint
+        self.path_regex, self.path_format, self.param_convertors = compile_path(path)
+        self.dependencies = list(dependencies or [])
+        self.operation_id = operation_id
+        self.unique_id = (
+            self.operation_id or f"{self.endpoint.__module__}.{self.endpoint.__name__}"
+        )
+        self.status_code = status_code
+        self.response_description = response_description
+        self.response_class = response_class
+        self.response_model_include = response_model_include
+        self.response_model_exclude = response_model_exclude
+        self.response_model_by_alias = response_model_by_alias
+        self.response_model_exclude_unset = response_model_exclude_unset
+        self.response_model_exclude_defaults = response_model_exclude_defaults
+        self.response_model_exclude_none = response_model_exclude_none
+        self.tags = tags or []
+        self.deprecated = deprecated
+        self.summary = summary
+        self.arn = get_arn(self.endpoint)
+
+        if isinstance(response_model, DefaultPlaceholder):
+            return_annotation = get_typed_return_annotation(endpoint)
+            if lenient_issubclass(return_annotation, ResponseAPIGateway):
+                response_model = None
+            else:
+                response_model = return_annotation
+        self.response_model = response_model
+        if self.response_model:
+            assert is_body_allowed_for_status_code(status_code), (
+                f"Status code {status_code} must not have a response body"
+            )
+            response_name = "Response_" + self.unique_id
+            self.response_field = create_model_field(
+                name=response_name,
+                type_=self.response_model,
+                mode="serialization",
+            )
+        else:
+            self.response_field = None  # type: ignore
+            self.secure_cloned_response_field = None
+
+        self.description = description or inspect.cleandoc(self.endpoint.__doc__ or "")
+        # if a "form feed" character (page break) is found in the description text,
+        # truncate description text to the content preceding the first "form feed"
+        self.description = self.description.split("\f")[0].strip()
+        response_fields = {}
+        self.responses = responses or {}
+        for additional_status_code, response in self.responses.items():
+            assert isinstance(response, dict), "An additional response must be a dict"
+            model = response.get("model")
+            if model:
+                assert is_body_allowed_for_status_code(additional_status_code), (
+                    f"Status code {additional_status_code} must not have a response body"
+                )
+                response_name = f"Response_{additional_status_code}_{self.unique_id}"
+                response_field = create_model_field(
+                    name=response_name, type_=model, mode="serialization"
+                )
+                response_fields[additional_status_code] = response_field
+        if response_fields:
+            self.response_fields: dict[int | str, ModelField] = response_fields
+        else:
+            self.response_fields = {}
+
+        assert callable(endpoint), "An endpoint must be a callable"
+        self.dependant = get_dependant(
+            path=self.path_format, call=self.endpoint, type_=self.type_
+        )
+        for depends in self.dependencies[::-1]:
+            self.dependant.dependencies.insert(
+                0,
+                get_parameterless_sub_dependant(
+                    depends=depends, path=self.path_format, type_=self.type_
+                ),
+            )
+        self._flat_dependant = get_flat_dependant(self.dependant)
+        self._embed_body_fields = _should_embed_body_fields(
+            self._flat_dependant.body_params
+        )
+        self.body_field = get_body_field(
+            flat_dependant=self._flat_dependant,
+            name=self.unique_id,
+            embed_body_fields=self._embed_body_fields,
+        )
+        self.app = self.get_route_handler()
+
+    def get_route_handler(self):
+        return get_request_handler(
+            dependant=self.dependant,
+            status_code=self.status_code,
+            response_class=self.response_class,
+            response_field=self.response_field,
+            response_model_include=self.response_model_include,
+            response_model_exclude=self.response_model_exclude,
+            response_model_by_alias=self.response_model_by_alias,
+            response_model_exclude_unset=self.response_model_exclude_unset,
+            response_model_exclude_defaults=self.response_model_exclude_defaults,
+            response_model_exclude_none=self.response_model_exclude_none,
+            embed_body_fields=self._embed_body_fields,
+        )
+
+
+class WellApi:
+    def __init__(
+        self,
+        title: str = "WellApi",
+        version: str = "0.1.0",
+        description: str = "",
+        openapi_tags: list[dict[str, Any]] | None = None,
+        servers: list[dict[str, str | Any]] | None = None,
+        queues: list[dict[str, Any]] | None = None,
+        debug: bool = False,
+    ):
+        self.lambdas = []
+        self.exception_handlers = {}
+        self.user_middleware = []
+        self.debug = debug
+        self.title = title
+        self.version = version
+        self.description = description
+        self.openapi_tags = openapi_tags
+        self.servers = servers
+        self.queues = queues or []
+
+    def build_middleware_stack(self, app: Callable) -> Callable:
+        debug = self.debug
+        error_handler = None
+        exception_handlers: dict[
+            Any, Callable[[RequestAPIGateway, Exception], ResponseAPIGateway]
+        ] = {}
+
+        for key, value in self.exception_handlers.items():
+            if key in (500, Exception):
+                error_handler = value
+            else:
+                exception_handlers[key] = value
+
+        middleware = (
+            [Middleware(ServerErrorMiddleware, handler=error_handler, debug=debug)]
+            + self.user_middleware
+            + [
+                Middleware(
+                    ExceptionMiddleware, handlers=exception_handlers, debug=debug
+                )
+            ]
+        )
+
+        for cls, args, kwargs in reversed(middleware):
+            app = cls(app, *args, **kwargs)
+        return request_response(app)
+
+    def add_endpoint(self, *args, **kwargs):
+        lambda_ = Lambda(*args, **kwargs)
+        self.lambdas.append(lambda_)
+
+        def endpoint(event, context):
+            return self.build_middleware_stack(lambda_.app)(event, context)
+
+        return endpoint
+
+    def add_exception_handler(
+        self,
+        exc_class_or_status_code: int | type[Exception],
+        handler: Callable[[RequestAPIGateway, Exception], ResponseAPIGateway],
+    ) -> None:  # pragma: no cover
+        self.exception_handlers[exc_class_or_status_code] = handler
+
+    def exception_handler(
+        self, exc_class_or_status_code: int | type[Exception]
+    ) -> Callable:
+        def decorator(func):
+            self.add_exception_handler(exc_class_or_status_code, func)
+            return func
+
+        return decorator
+
+    def add_middleware(self, middleware_class, dispatch) -> None:
+        self.user_middleware.insert(0, Middleware(middleware_class, dispatch))
+
+    def middleware(self) -> Callable:
+        def decorator(func):
+            self.add_middleware(BaseMiddleware, dispatch=func)
+            return func
+
+        return decorator
+
+    def get(
+        self,
+        path: str,
+        *,
+        response_model: Any = Default(None),
+        status_code: int | None = None,
+        response_class: type[ResponseAPIGateway] | DefaultPlaceholder = Default(
+            ResponseAPIGateway
+        ),
+        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,
+        dependencies: Sequence[params.Depends] | None = None,
+        tags: list[str | Enum] | None = None,
+    ):
+        def decorator(func):
+            lambda_ = self.add_endpoint(
+                path,
+                func,
+                type_="endpoint",
+                response_model=response_model,
+                status_code=status_code,
+                method="GET",
+                response_class=response_class,
+                response_model_include=response_model_include,
+                response_model_exclude=response_model_exclude,
+                response_model_by_alias=response_model_by_alias,
+                response_model_exclude_unset=response_model_exclude_unset,
+                response_model_exclude_defaults=response_model_exclude_defaults,
+                response_model_exclude_none=response_model_exclude_none,
+                dependencies=dependencies,
+                tags=tags,
+            )
+            return lambda_
+
+        return decorator
+
+    def post(
+        self,
+        path: str,
+        *,
+        response_model: Any = Default(None),
+        status_code: int | None = None,
+        response_class: type[ResponseAPIGateway] | DefaultPlaceholder = Default(
+            ResponseAPIGateway
+        ),
+        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,
+        dependencies: Sequence[params.Depends] | None = None,
+        tags: list[str | Enum] | None = None,
+    ):
+        def decorator(func):
+            lambda_ = self.add_endpoint(
+                path,
+                func,
+                type_="endpoint",
+                response_model=response_model,
+                status_code=status_code,
+                method="POST",
+                response_class=response_class,
+                response_model_include=response_model_include,
+                response_model_exclude=response_model_exclude,
+                response_model_by_alias=response_model_by_alias,
+                response_model_exclude_unset=response_model_exclude_unset,
+                response_model_exclude_defaults=response_model_exclude_defaults,
+                response_model_exclude_none=response_model_exclude_none,
+                dependencies=dependencies,
+                tags=tags,
+            )
+            return lambda_
+
+        return decorator
+
+    def sqs(
+        self,
+        queue_name: str,
+        memory_size: int = 128,
+        timeout: int = 30,
+        dependencies: Sequence[params.Depends] | None = None,
+    ):
+        def decorator(func):
+            lambda_ = self.add_endpoint(
+                queue_name,
+                func,
+                type_="queue",
+                memory_size=memory_size,
+                timeout=timeout,
+                dependencies=dependencies,
+            )
+            return lambda_
+
+        return decorator
+
+    def job(
+        self,
+        expression: str,
+        name: str | None = None,
+        memory_size: int = 128,
+        timeout: int = 30,
+        *,
+        dependencies: Sequence[params.Depends] | None = None,
+    ):
+        def decorator(func):
+            lambda_ = self.add_endpoint(
+                expression,
+                func,
+                type_="job",
+                name=name,
+                memory_size=memory_size,
+                timeout=timeout,
+                dependencies=dependencies,
+            )
+            return lambda_
+
+        return decorator

wellapi/awsmodel.py

@@ -0,0 +1,17 @@
+from pydantic import BaseModel
+
+
+class Message(BaseModel):
+    messageId: str
+    receiptHandle: str
+    body: str
+    attributes: dict
+    messageAttributes: dict
+    md5OfBody: str
+    eventSource: str
+    eventSourceARN: str
+    awsRegion: str
+
+
+class SQSEvent(BaseModel):
+    Records: list[Message]

wellapi/build/cdk.py

@@ -0,0 +1,141 @@
+import json
+import os
+
+# ruff: noqa: I001
+from aws_cdk import (
+    Fn,
+    Duration,
+    aws_apigateway as apigw,
+    aws_events as events,
+    aws_events_targets as targets,
+    aws_iam as iam,
+    aws_lambda as _lambda,
+    aws_lambda_event_sources as lambda_event_source,
+    aws_sqs as sqs,
+    aws_s3_assets as s3_assets,
+)
+from aws_cdk.aws_lambda import CfnFunction
+from constructs import Construct
+
+from wellapi.applications import Lambda, WellApi
+from wellapi.build.packager import package
+from wellapi.openapi.utils import get_openapi
+from wellapi.utils import import_app, load_handlers
+
+OPENAPI_FILE = "openapi-spec.json"
+APP_LAYOUT_FILE = "app_content.zip"
+DEP_LAYOUT_FILE = "layer_content.zip"
+
+
+class WellApiCDK(Construct):
+    """
+    This class is used to create a Well API using AWS CDK.
+    """
+
+    def __init__(
+        self,
+        scope: Construct,
+        id_: str,
+        *,
+        app_srt: str,
+        handlers_dir: str,
+    ) -> None:
+        super().__init__(scope, id_)
+
+        self.app_srt = app_srt
+        self.handlers_dir = os.path.abspath(handlers_dir)
+
+        wellapi_app: WellApi = self._package_app()
+
+        # defining a Cfn Asset from the openAPI file
+        open_api_asset = s3_assets.Asset(self, "OpenApiAsset", path=OPENAPI_FILE)
+        transform_map = {"Location": open_api_asset.s3_object_url}
+        data = Fn.transform("AWS::Include", transform_map)
+
+        self.api = apigw.SpecRestApi(
+            self,
+            f"{wellapi_app.title}Api",
+            api_definition=apigw.ApiDefinition.from_inline(data),
+        )
+
+        for q in wellapi_app.queues:
+            queue = sqs.Queue(self, f"{q.queue_name}Queue", queue_name=q.queue_name)
+
+        shared_layer = [
+            _lambda.LayerVersion(
+                self,
+                "SharedLayer",
+                code=_lambda.Code.from_asset(DEP_LAYOUT_FILE),
+                compatible_runtimes=[_lambda.Runtime.PYTHON_3_12],  # type: ignore
+                layer_version_name="shared_layer",
+            )
+        ]
+        code_layer = _lambda.Code.from_asset(APP_LAYOUT_FILE)
+
+        lmbd: Lambda
+        for lmbd in wellapi_app.lambdas:
+            lambda_function = _lambda.Function(
+                self,
+                f"{lmbd.arn}Function",
+                function_name=f"{lmbd.arn}Function",
+                runtime=_lambda.Runtime.PYTHON_3_12,  # type: ignore
+                handler=lmbd.unique_id,
+                memory_size=lmbd.memory_size,
+                timeout=Duration.seconds(lmbd.timeout),
+                code=code_layer,
+                layers=shared_layer,  # type: ignore
+            )
+
+            if lmbd.type_ == "endpoint":
+                lambda_function.add_permission(
+                    f"{lmbd.arn}Permission",
+                    principal=iam.ServicePrincipal("apigateway.amazonaws.com"),
+                    action="lambda:InvokeFunction",
+                    source_arn=self.api.arn_for_execute_api(lmbd.method.upper()),
+                )
+
+                cfn_lambda: CfnFunction = lambda_function.node.default_child  # type: ignore
+                cfn_lambda.override_logical_id(f"{lmbd.arn}Function")
+                # self.api.node.add_dependency(lambda_function)
+
+            if lmbd.type_ == "queue":
+                queue = sqs.Queue(
+                    self,
+                    f"{lmbd.name}Queue",
+                    queue_name=lmbd.path,
+                    visibility_timeout=Duration.seconds(lmbd.timeout),
+                )
+
+                sqs_event_source = lambda_event_source.SqsEventSource(queue)  # type: ignore
+
+                # Add SQS event source to the Lambda function
+                lambda_function.add_event_source(sqs_event_source)
+
+            if lmbd.type_ == "job":
+                rule = events.Rule(
+                    self,
+                    f"{lmbd.name}Rule",
+                    schedule=events.Schedule.expression(lmbd.path),
+                )
+
+                rule.add_target(targets.LambdaFunction(lambda_function))  # type: ignore
+
+    def _package_app(self) -> WellApi:
+        wellapi_app = import_app(self.app_srt)
+        load_handlers(self.handlers_dir)
+
+        resp = get_openapi(
+            title=wellapi_app.title,
+            version=wellapi_app.version,
+            openapi_version="3.0.1",
+            description=wellapi_app.description,
+            lambdas=wellapi_app.lambdas,
+            tags=wellapi_app.openapi_tags,
+            servers=wellapi_app.servers,
+        )
+        with open(OPENAPI_FILE, "w") as f:
+            json.dump(resp, f)
+
+        package(DEP_LAYOUT_FILE, APP_LAYOUT_FILE)
+
+        return wellapi_app

wellapi/build/packager.py

@@ -0,0 +1,82 @@
+import shutil
+import subprocess
+import zipfile
+from pathlib import Path
+
+"""
+https://docs.astral.sh/uv/guides/integration/aws-lambda/#deploying-a-zip-archive
+"""
+
+EXPERT_DEP_FILE = [
+    "uv",
+    "export",
+    "--frozen",
+    "--no-dev",
+    "--no-editable",
+    "-orequirements.txt",
+]
+INSTALL_DEP = [
+    "uv",
+    "pip",
+    "install",
+    "--no-installer-metadata",
+    "--no-compile-bytecode",
+    "--python-platform",
+    "x86_64-manylinux2014",
+    "--python",
+    "3.12",
+    "--prefix",
+    "packages",
+    "-r",
+    "requirements.txt",
+]
+
+
+def install_dependencies():
+    # Експорт файлу requirements.txt
+    subprocess.run(EXPERT_DEP_FILE, check=True)
+
+    # Створення директорії для інсталяції
+    packages_path = Path("packages")
+    packages_path.mkdir(parents=True, exist_ok=True)
+
+    subprocess.run(INSTALL_DEP, check=True)
+
+
+def copy_to_python_folder():
+    src = Path("packages/lib")
+    dst = Path("python/lib")
+    dst.parent.mkdir(exist_ok=True)
+    shutil.copytree(src, dst, dirs_exist_ok=True)
+
+
+def create_zip(file_name: str, dir_name: str):
+    zip_path = Path(file_name)
+    with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as z:
+        for path in Path(dir_name).rglob("*"):
+            # TODO: remove this check
+            if str(path).startswith(".venv/"):
+                continue
+            z.write(path, path.relative_to(Path(dir_name).parent))
+
+
+def package_dependencies(layer_name):
+    install_dependencies()
+    copy_to_python_folder()
+    create_zip(layer_name, "python")
+    # clean up
+    shutil.rmtree("packages")
+    shutil.rmtree("python")
+
+
+def package_app(app_name):
+    create_zip(app_name, ".")
+
+
+def package(layer_name: str, app_name: str):
+    """
+    Package the application into a zip file.
+    :return:
+    """
+    package_app(app_name)
+    package_dependencies(layer_name)

wellapi/build/sam_openapi.py

@@ -0,0 +1,10 @@
+"""
+https://medium.com/@usamadar4777/aws-sam-template-open-api-3-0-1-integration-26e67375c4a0
+
+https://aws.amazon.com/blogs/opensource/create-restful-apis-on-aws-with-openapi-specification-with-no-coding/
+
+https://github.com/aws/aws-sam-cli/blob/develop/tests/integration/testdata/start_api/swagger-template.yaml
+
+samcli.commands.build.command.do_cli
+
+"""