py-serverless-kit 0.1.0__py3-none-any.whl

py_serverless_kit/runtime/adapters/aws.py

@@ -0,0 +1,201 @@
+"""AWS Lambda adapter.
+
+Handles API Gateway HTTP API (payload v2), REST API / ALB (payload v1),
+Lambda Function URLs, SQS, SNS, S3, EventBridge, Step Functions and direct
+invocation.
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Any, Dict, List, Optional
+from urllib.parse import unquote_plus
+
+from ..batch import BatchResult
+from ..context import Context
+from ..dispatch import execute
+from ..event import Event, EventType, Headers, HttpRequest, Record, parse_time
+from ..response import Response
+from .base import action_from, function_name, maybe_json, unwrap_envelope
+
+PROVIDER = "aws"
+
+
+def _http_v2(evt: Dict[str, Any]) -> HttpRequest:
+    rc = evt.get("requestContext") or {}
+    http = rc.get("http") or {}
+    headers = dict(evt.get("headers") or {})
+    if evt.get("cookies"):
+        headers["cookie"] = "; ".join(evt["cookies"])
+    query = dict(evt.get("queryStringParameters") or {})
+    multi = {k: v.split(",") for k, v in query.items()}
+    return HttpRequest(
+        method=http.get("method", "GET"),
+        path=evt.get("rawPath") or http.get("path") or "/",
+        headers=Headers(headers),
+        query=query,
+        multi_query=multi,
+        path_params=dict(evt.get("pathParameters") or {}),
+        body=HttpRequest.decode_body(evt.get("body"), bool(evt.get("isBase64Encoded"))),
+        source_ip=http.get("sourceIp"),
+        route=(evt.get("routeKey") or "").split(" ", 1)[-1] or None,
+    )
+
+
+def _http_v1(evt: Dict[str, Any]) -> HttpRequest:
+    rc = evt.get("requestContext") or {}
+    multi_headers = evt.get("multiValueHeaders") or {}
+    headers: Dict[str, Any] = dict(multi_headers) if multi_headers else dict(evt.get("headers") or {})
+    multi_query = {k: list(v) for k, v in (evt.get("multiValueQueryStringParameters") or {}).items()}
+    query = dict(evt.get("queryStringParameters") or {})
+    if not query and multi_query:
+        query = {k: v[-1] for k, v in multi_query.items()}
+    return HttpRequest(
+        method=evt.get("httpMethod", "GET"),
+        path=evt.get("path") or "/",
+        headers=Headers(headers),
+        query=query,
+        multi_query=multi_query or {k: [v] for k, v in query.items()},
+        path_params=dict(evt.get("pathParameters") or {}),
+        body=HttpRequest.decode_body(evt.get("body"), bool(evt.get("isBase64Encoded"))),
+        source_ip=(rc.get("identity") or {}).get("sourceIp"),
+        route=evt.get("resource"),
+    )
+
+
+def _records(evt: Dict[str, Any]) -> Optional[Event]:
+    records = evt.get("Records")
+    if not isinstance(records, list) or not records:
+        return None
+    first = records[0]
+    source = first.get("eventSource") or first.get("EventSource") or ""
+    out: List[Record] = []
+    if source == "aws:sqs":
+        for r in records:
+            out.append(
+                Record(
+                    id=r.get("messageId"),
+                    body=r.get("body"),
+                    attributes={
+                        **(r.get("attributes") or {}),
+                        **{k: v.get("stringValue") for k, v in (r.get("messageAttributes") or {}).items()},
+                    },
+                    source=r.get("eventSourceARN"),
+                    raw=r,
+                )
+            )
+        return Event(type=EventType.QUEUE, provider=PROVIDER, records=out, source=first.get("eventSourceARN"), raw=evt)
+    if source == "aws:sns":
+        for r in records:
+            sns = r.get("Sns") or {}
+            out.append(
+                Record(
+                    id=sns.get("MessageId"),
+                    body=sns.get("Message"),
+                    attributes={k: v.get("Value") for k, v in (sns.get("MessageAttributes") or {}).items()},
+                    source=sns.get("TopicArn"),
+                    raw=r,
+                )
+            )
+        return Event(
+            type=EventType.TOPIC,
+            provider=PROVIDER,
+            records=out,
+            source=(first.get("Sns") or {}).get("TopicArn"),
+            time=parse_time((first.get("Sns") or {}).get("Timestamp")),
+            raw=evt,
+        )
+    if source == "aws:s3":
+        for r in records:
+            s3 = r.get("s3") or {}
+            obj = s3.get("object") or {}
+            out.append(
+                Record(
+                    id=obj.get("sequencer"),
+                    bucket=(s3.get("bucket") or {}).get("name"),
+                    key=unquote_plus(obj.get("key", "")),
+                    size=obj.get("size"),
+                    action=action_from(r.get("eventName", "")),
+                    attributes={"etag": obj.get("eTag"), "event_name": r.get("eventName")},
+                    source="aws:s3",
+                    raw=r,
+                )
+            )
+        return Event(
+            type=EventType.STORAGE,
+            provider=PROVIDER,
+            records=out,
+            source="aws:s3",
+            time=parse_time(first.get("eventTime")),
+            raw=evt,
+        )
+    return None
+
+
+def to_event(evt: Any, ctx: Any = None) -> Event:
+    fn = function_name(getattr(ctx, "function_name", "") or "")
+    wrapped = unwrap_envelope(evt)
+    if wrapped is not None:
+        kind, data, meta = wrapped
+        return Event(type=kind, provider=PROVIDER, function=fn, data=data, source=meta.get("source"), raw=evt)
+    if isinstance(evt, dict):
+        rc = evt.get("requestContext")
+        if isinstance(rc, dict) and isinstance(rc.get("http"), dict):
+            return Event(type=EventType.HTTP, provider=PROVIDER, function=fn, http=_http_v2(evt), raw=evt)
+        if "httpMethod" in evt:
+            return Event(type=EventType.HTTP, provider=PROVIDER, function=fn, http=_http_v1(evt), raw=evt)
+        batch = _records(evt)
+        if batch is not None:
+            batch.function = fn
+            return batch
+        if evt.get("source") == "aws.events" or evt.get("detail-type") == "Scheduled Event":
+            return Event(
+                type=EventType.SCHEDULE,
+                provider=PROVIDER,
+                function=fn,
+                data=evt.get("detail"),
+                time=parse_time(evt.get("time")),
+                source=evt.get("source"),
+                raw=evt,
+            )
+    return Event(type=EventType.INVOKE, provider=PROVIDER, function=fn, data=maybe_json(evt), raw=evt)
+
+
+def to_context(ctx: Any, fn: str) -> Context:
+    if ctx is None:
+        return Context(function=fn, provider=PROVIDER)
+    remaining = getattr(ctx, "get_remaining_time_in_millis", None)
+    memory = getattr(ctx, "memory_limit_in_mb", None)
+    return Context(
+        request_id=getattr(ctx, "aws_request_id", "") or "",
+        function=fn,
+        provider=PROVIDER,
+        memory_mb=int(memory) if memory else None,
+        deadline=(time.time() + remaining() / 1000.0) if callable(remaining) else None,
+        raw=ctx,
+        _remaining=remaining if callable(remaining) else None,
+    )
+
+
+def to_native(result: Any, event: Event) -> Any:
+    if event.http is not None:
+        resp: Response = result
+        status, headers, body, is_b64 = resp.render_for_gateway()
+        out: Dict[str, Any] = {"statusCode": status, "headers": headers, "body": body, "isBase64Encoded": is_b64}
+        if resp.cookies:
+            if (event.raw or {}).get("version") == "2.0":
+                out["cookies"] = list(resp.cookies)
+            else:
+                out["multiValueHeaders"] = {"set-cookie": list(resp.cookies)}
+        return out
+    if isinstance(result, BatchResult):
+        return {"batchItemFailures": [{"itemIdentifier": rid} for rid in result.failed]}
+    return result
+
+
+def handler(evt: Any, ctx: Any = None) -> Any:
+    """Lambda entrypoint - the generated ``pskit_entry.handler`` points here."""
+    event = to_event(evt, ctx)
+    context = to_context(ctx, event.function)
+    result = execute(event, context)
+    return to_native(result, event)

py_serverless_kit/runtime/adapters/azure.py

@@ -0,0 +1,185 @@
+"""Azure Functions (Python v2 programming model) adapter.
+
+The generated ``function_app.py`` registers one decorated wrapper per trigger
+and calls these helpers with the *logical* function name, because one Function
+App hosts every function of the service (app settings are shared, so
+``PSKIT_FUNCTION`` cannot be used).
+
+``azure.functions`` is imported lazily so the module can be unit-tested
+without the Azure SDK installed.
+"""
+
+from __future__ import annotations
+
+import uuid
+from typing import Any, Dict, Optional
+from urllib.parse import urlparse
+
+from ..context import Context
+from ..dispatch import execute
+from ..event import Event, EventType, Headers, HttpRequest, Record, parse_time
+from ..response import Response, dumps
+from .base import unwrap_envelope
+
+PROVIDER = "azure"
+_JSON = "application/json"
+
+
+def _func() -> Any:
+    import azure.functions as func  # type: ignore[import-not-found]
+
+    return func
+
+
+def _context(fn: str, request_id: Optional[str] = None, raw: Any = None) -> Context:
+    return Context(request_id=request_id or str(uuid.uuid4()), function=fn, provider=PROVIDER, raw=raw)
+
+
+def _text(value: Any) -> Any:
+    if isinstance(value, bytes):
+        try:
+            return value.decode("utf-8")
+        except UnicodeDecodeError:
+            return value
+    return value
+
+
+# ------------------------------------------------------------------ HTTP
+
+
+def to_http_event(req: Any, function: str) -> Event:
+    headers = dict(req.headers.items()) if hasattr(req.headers, "items") else dict(req.headers or {})
+    params = dict(req.params or {})
+    path = urlparse(req.url).path if getattr(req, "url", None) else "/"
+    request = HttpRequest(
+        method=req.method,
+        path=path or "/",
+        headers=Headers(headers),
+        query=params,
+        path_params={k: v for k, v in dict(getattr(req, "route_params", None) or {}).items()},
+        body=req.get_body() or b"",
+        source_ip=(headers.get("x-forwarded-for") or headers.get("X-Forwarded-For") or "").split(",")[0].split(":")[0]
+        or None,
+    )
+    return Event(type=EventType.HTTP, provider=PROVIDER, function=function, http=request, raw=req)
+
+
+def _http_response(body: bytes, status: int, headers: Dict[str, str]) -> Any:
+    func = _func()
+    return func.HttpResponse(body=body, status_code=status, headers=headers)
+
+
+def http(req: Any, function: str) -> Any:
+    body = req.get_body() or b""
+    headers = req.headers if req.headers is not None else {}
+    req_id = headers.get("x-ms-request-id") or headers.get("x-request-id")
+    wrapped = unwrap_envelope(body) if body[:1] == b"{" else None
+    if wrapped is not None:
+        kind, data, meta = wrapped
+        event = Event(type=kind, provider=PROVIDER, function=function, data=data, source=meta.get("source"), raw=req)
+        try:
+            result = execute(event, _context(function, req_id, req), function)
+        except Exception as exc:  # noqa: BLE001 - reported to the caller
+            payload = {"errorType": type(exc).__name__, "cause": str(exc)}
+            return _http_response(dumps(payload).encode("utf-8"), 500, {"content-type": _JSON})
+        return _http_response(dumps(result).encode("utf-8"), 200, {"content-type": _JSON})
+    event = to_http_event(req, function)
+    resp: Response = execute(event, _context(function, req_id, req), function)
+    status, out_headers, raw = resp.render()
+    if resp.cookies:
+        # Azure's HttpResponse headers are a plain mapping: only one Set-Cookie survives.
+        out_headers["set-cookie"] = resp.cookies[-1]
+    return _http_response(raw, status, out_headers)
+
+
+# ------------------------------------------------------------------ other triggers
+
+
+def timer(timer_request: Any, function: str, data: Any = None) -> Any:
+    event = Event(
+        type=EventType.SCHEDULE,
+        provider=PROVIDER,
+        function=function,
+        data=data,
+        source="azure.timer",
+        raw=timer_request,
+    )
+    return execute(event, _context(function, raw=timer_request), function)
+
+
+def to_queue_event(msg: Any, function: str) -> Event:
+    record = Record(
+        id=getattr(msg, "id", None),
+        body=_text(msg.get_body()),
+        attributes={
+            "dequeue_count": getattr(msg, "dequeue_count", None),
+            "insertion_time": str(getattr(msg, "insertion_time", "") or ""),
+        },
+        source="azure.storage.queue",
+        raw=msg,
+    )
+    return Event(
+        type=EventType.QUEUE,
+        provider=PROVIDER,
+        function=function,
+        records=[record],
+        time=parse_time(getattr(msg, "insertion_time", None)),
+        source="azure.storage.queue",
+        raw=msg,
+    )
+
+
+def queue(msg: Any, function: str) -> Any:
+    return execute(to_queue_event(msg, function), _context(function, getattr(msg, "id", None), msg), function)
+
+
+def to_blob_event(blob: Any, function: str, bucket: str) -> Event:
+    name = getattr(blob, "name", "") or ""
+    key = name[len(bucket) + 1 :] if name.startswith(bucket + "/") else name
+    record = Record(
+        id=getattr(blob, "uri", None) or name,
+        bucket=bucket,
+        key=key,
+        size=getattr(blob, "length", None),
+        action="created",
+        attributes={"uri": getattr(blob, "uri", None)},
+        source="azure.storage.blob",
+        raw=blob,
+    )
+    return Event(
+        type=EventType.STORAGE,
+        provider=PROVIDER,
+        function=function,
+        records=[record],
+        source="azure.storage.blob",
+        raw=blob,
+    )
+
+
+def blob(blob_stream: Any, function: str, bucket: str) -> Any:
+    return execute(to_blob_event(blob_stream, function, bucket), _context(function, raw=blob_stream), function)
+
+
+def to_service_bus_event(msg: Any, function: str) -> Event:
+    props = getattr(msg, "user_properties", None) or getattr(msg, "application_properties", None) or {}
+    record = Record(
+        id=getattr(msg, "message_id", None),
+        body=_text(msg.get_body()),
+        attributes={str(k): v for k, v in dict(props).items()},
+        source="azure.servicebus",
+        raw=msg,
+    )
+    return Event(
+        type=EventType.TOPIC,
+        provider=PROVIDER,
+        function=function,
+        records=[record],
+        time=parse_time(getattr(msg, "enqueued_time_utc", None)),
+        source="azure.servicebus",
+        raw=msg,
+    )
+
+
+def service_bus(msg: Any, function: str) -> Any:
+    event = to_service_bus_event(msg, function)
+    return execute(event, _context(function, getattr(msg, "message_id", None), msg), function)

py_serverless_kit/runtime/adapters/base.py

@@ -0,0 +1,86 @@
+"""Helpers shared by all adapters."""
+
+from __future__ import annotations
+
+import base64
+import json
+import os
+from typing import Any, Dict, Optional, Tuple
+
+from ..event import EventType
+
+ENVELOPE_KEY = "__pskit"
+
+
+def envelope(kind: str, data: Any = None, **meta: Any) -> Dict[str, Any]:
+    """Wrap a payload so any adapter can recognise its event type.
+
+    The CLI uses this for schedule inputs, workflow task payloads and
+    function-to-function ``invoke`` calls, because those arrive on most clouds
+    as an opaque JSON object.
+    """
+    body: Dict[str, Any] = {ENVELOPE_KEY: kind, "data": data}
+    body.update(meta)
+    return body
+
+
+def unwrap_envelope(obj: Any) -> Optional[Tuple[str, Any, Dict[str, Any]]]:
+    if isinstance(obj, (bytes, str)):
+        obj = maybe_json(obj)
+    if isinstance(obj, dict) and ENVELOPE_KEY in obj:
+        kind = obj[ENVELOPE_KEY]
+        if kind not in EventType.ALL:
+            kind = EventType.INVOKE
+        meta = {k: v for k, v in obj.items() if k not in (ENVELOPE_KEY, "data")}
+        return kind, obj.get("data"), meta
+    return None
+
+
+def maybe_json(value: Any) -> Any:
+    """Decode bytes/str holding JSON; return the input unchanged otherwise."""
+    if isinstance(value, bytes):
+        try:
+            value = value.decode("utf-8")
+        except UnicodeDecodeError:
+            return value
+    if isinstance(value, str):
+        text = value.strip()
+        if text[:1] in ("{", "[") or text in ("null", "true", "false"):
+            try:
+                return json.loads(text)
+            except ValueError:
+                return value
+    return value
+
+
+def b64_text(value: Optional[str]) -> Any:
+    """Decode a base64 field to text (or JSON) - used by Pub/Sub style payloads."""
+    if not value:
+        return None
+    try:
+        raw = base64.b64decode(value)
+    except (ValueError, TypeError):
+        return value
+    try:
+        return raw.decode("utf-8")
+    except UnicodeDecodeError:
+        return raw
+
+
+def function_name(default: str = "") -> str:
+    return os.environ.get("PSKIT_FUNCTION", default)
+
+
+def action_from(name: str) -> str:
+    """Map provider-specific object event names to ``created`` / ``deleted``."""
+    lowered = (name or "").lower()
+    if any(word in lowered for word in ("delete", "remove", "archive")):
+        return "deleted"
+    return "created"
+
+
+def first(mapping: Dict[str, Any], *keys: str, default: Any = None) -> Any:
+    for key in keys:
+        if key in mapping and mapping[key] is not None:
+            return mapping[key]
+    return default

py_serverless_kit/runtime/adapters/cloudflare.py

@@ -0,0 +1,126 @@
+"""Cloudflare Python Workers adapter (Pyodide).
+
+The generated worker module defines ``class Default(WorkerEntrypoint)`` whose
+``fetch`` / ``scheduled`` methods call :func:`fetch` / :func:`scheduled` here.
+Everything is async because the Workers runtime already owns the event loop.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any, Dict, Iterable, List, Optional, Tuple
+from urllib.parse import parse_qs, urlsplit
+
+from ..context import Context
+from ..dispatch import execute_async
+from ..event import Event, EventType, Headers, HttpRequest, parse_time
+from ._httpfn import event_from_request, run_async
+from .base import function_name
+
+PROVIDER = "cloudflare"
+
+# Filled by the generated worker module: {cron expression: schedule input}.
+SCHEDULE_INPUTS: Dict[str, Any] = {}
+
+
+def _header_items(headers: Any) -> Iterable[Tuple[str, str]]:
+    if headers is None:
+        return []
+    items = getattr(headers, "items", None)
+    if callable(items):
+        try:
+            return [(str(k), str(v)) for k, v in items()]
+        except TypeError:
+            pass
+    try:
+        return [(str(k), str(v)) for k, v in headers]
+    except (TypeError, ValueError):
+        return []
+
+
+async def _read_body(request: Any) -> bytes:
+    for name in ("bytes", "text"):
+        reader = getattr(request, name, None)
+        if not callable(reader):
+            continue
+        value = await reader()
+        if isinstance(value, (bytes, bytearray)):
+            return bytes(value)
+        if hasattr(value, "to_bytes"):  # JsProxy of an ArrayBuffer / Uint8Array
+            return bytes(value.to_bytes())
+        if value is None:
+            return b""
+        return str(value).encode("utf-8")
+    return b""
+
+
+async def to_request(request: Any) -> HttpRequest:
+    method = str(getattr(request, "method", "GET"))
+    parts = urlsplit(str(getattr(request, "url", "/")))
+    headers: List[Tuple[str, str]] = list(_header_items(getattr(request, "headers", None)))
+    body = await _read_body(request) if method not in ("GET", "HEAD") else b""
+    multi = parse_qs(parts.query, keep_blank_values=True)
+    lookup = {k.lower(): v for k, v in headers}
+    return HttpRequest(
+        method=method,
+        path=parts.path or "/",
+        headers=Headers(headers),
+        query={k: v[-1] for k, v in multi.items()},
+        multi_query=multi,
+        body=body,
+        source_ip=lookup.get("cf-connecting-ip"),
+    )
+
+
+def _response(status: int, headers: Dict[str, str], body: str, is_b64: bool) -> Any:
+    payload: Any = body
+    if is_b64:
+        import base64
+
+        payload = base64.b64decode(body)
+    try:
+        from workers import Response as WorkerResponse  # type: ignore[import-not-found]
+    except ImportError:  # local tests
+        return {"status": status, "headers": headers, "body": payload}
+    return WorkerResponse(payload, status=status, headers=headers)
+
+
+async def fetch(request: Any, env: Any = None) -> Any:
+    fn = function_name()
+    req = await to_request(request)
+    event = event_from_request(req, PROVIDER, fn, raw=request)
+    context = Context(
+        request_id=req.headers.get("cf-ray", "") or Context().request_id,
+        function=fn,
+        provider=PROVIDER,
+        raw=env,
+    )
+    status, headers, body, is_b64 = await run_async(event, context)
+    return _response(status, headers, body, is_b64)
+
+
+async def scheduled(controller: Any, env: Any = None) -> Any:
+    fn = function_name()
+    cron = str(getattr(controller, "cron", "") or "")
+    event = Event(
+        type=EventType.SCHEDULE,
+        provider=PROVIDER,
+        function=fn,
+        data=SCHEDULE_INPUTS.get(cron),
+        time=parse_time(getattr(controller, "scheduledTime", None)),
+        source=cron or None,
+        raw=controller,
+    )
+    return await execute_async(event, Context(function=fn, provider=PROVIDER, raw=env))
+
+
+def configure(
+    function: str,
+    environment: Optional[Dict[str, str]] = None,
+    schedules: Optional[Dict[str, Any]] = None,
+) -> None:
+    """Called once by the generated worker module at import time."""
+    os.environ.update(environment or {})
+    os.environ["PSKIT_FUNCTION"] = function
+    SCHEDULE_INPUTS.clear()
+    SCHEDULE_INPUTS.update(schedules or {})

py_serverless_kit/runtime/adapters/digitalocean.py

@@ -0,0 +1,74 @@
+"""DigitalOcean Functions adapter (``main(event, context)``).
+
+Web functions deployed with ``web: raw`` receive ``event["http"]`` with
+``method``, ``path``, ``headers``, ``queryString``, ``body`` and
+``isBase64Encoded``. Scheduled triggers deliver their ``withBody`` payload,
+which the CLI fills with the ``__pskit`` envelope.
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Any, Dict, Optional
+from urllib.parse import parse_qs
+
+from ..context import Context
+from ..event import Event, EventType, Headers, HttpRequest
+from ..response import dumps
+from ._httpfn import decode_body, event_from_request, run
+from .base import function_name, unwrap_envelope
+
+PROVIDER = "digitalocean"
+
+
+def to_request(event: Dict[str, Any]) -> Optional[HttpRequest]:
+    http = event.get("http")
+    if not isinstance(http, dict) or not http.get("method"):
+        return None
+    headers = dict(http.get("headers") or {})
+    body: Any = http.get("body")
+    if body is None:
+        # `web: true` (non-raw) merges body params into the event.
+        plain = {k: v for k, v in event.items() if k != "http" and not k.startswith("__ow_")}
+        body = dumps(plain) if plain else None
+    is_b64 = http.get("isBase64Encoded")
+    multi = parse_qs(str(http.get("queryString") or ""), keep_blank_values=True)
+    return HttpRequest(
+        method=str(http["method"]),
+        path=http.get("path") or "/",
+        headers=Headers(headers),
+        query={k: v[-1] for k, v in multi.items()},
+        multi_query=multi,
+        body=decode_body(body, headers, bool(is_b64) if is_b64 is not None else False),
+        source_ip=str(headers.get("x-forwarded-for", "")).split(",")[0].strip() or None,
+    )
+
+
+def to_event(event: Dict[str, Any], fn: str) -> Event:
+    req = to_request(event)
+    if req is not None:
+        return event_from_request(req, PROVIDER, fn, raw=event)
+    wrapped = unwrap_envelope(event)
+    if wrapped is not None:
+        kind, data, meta = wrapped
+        return Event(type=kind, provider=PROVIDER, function=fn, data=data, source=meta.get("source"), raw=event)
+    return Event(type=EventType.INVOKE, provider=PROVIDER, function=fn, data=event, raw=event)
+
+
+def to_context(ctx: Any, fn: str) -> Context:
+    remaining = getattr(ctx, "get_remaining_time_in_millis", None)
+    return Context(
+        request_id=str(getattr(ctx, "activation_id", "") or getattr(ctx, "request_id", "") or ""),
+        function=fn,
+        provider=PROVIDER,
+        deadline=(time.time() + remaining() / 1000.0) if callable(remaining) else None,
+        raw=ctx,
+        _remaining=remaining if callable(remaining) else None,
+    )
+
+
+def main(event: Optional[Dict[str, Any]] = None, context: Any = None) -> Dict[str, Any]:
+    event = event or {}
+    fn = function_name()
+    status, headers, body, _ = run(to_event(event, fn), to_context(context, fn))
+    return {"statusCode": status, "headers": headers, "body": body}