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

py_serverless_kit/providers/tencent.py

@@ -0,0 +1,275 @@
+"""Tencent Cloud: SCF + API Gateway + timer / COS triggers."""
+
+from __future__ import annotations
+
+import json
+import re
+import shutil
+from typing import Any, Dict, List, Optional
+
+from ..config.schema import FunctionConfig, ServiceConfig
+from ..runtime.adapters.base import envelope
+from . import schedule as sched
+from .base import HTTP, SCHEDULE, STORAGE, Issue, Provider, RenderContext
+from .terraform_doc import TerraformDoc, escape, ref, tf_id
+
+FUNCTION = "tencentcloud_scf_function"
+_BUCKET_RE = re.compile(r"^[a-z0-9][a-z0-9-]*-\d+$")
+
+
+def _gateway_path(path: str) -> str:
+    """API Gateway has no greedy params; ``/files/{p+}`` becomes prefix ``/files``."""
+    segments = [s for s in path.split("/") if s]
+    if segments and segments[-1].endswith("+}"):
+        segments = segments[:-1]
+    return "/" + "/".join(segments)
+
+
+class TencentProvider(Provider):
+    name = "tencent"
+    display_name = "Tencent Cloud SCF"
+    tier = "beta"
+    terraform_source = "tencentcloudstack/tencentcloud"
+    terraform_version = ">= 1.81.0"
+    terraform_local_name = "tencentcloud"
+    default_region = "ap-guangzhou"
+    capabilities = frozenset({HTTP, SCHEDULE, STORAGE})
+    max_name_length = 60
+    name_pattern = r"[^a-z0-9_-]"
+    runtimes = {"python3.9": "Python3.9", "python3.10": "Python3.10"}
+    vendor_dependencies = True
+    max_timeout = 900
+    notes = (
+        "HTTP via an API Gateway service (one API per route, released to `release`); "
+        "timer and COS triggers; COS bucket names must include the APPID suffix (name-1250000000)."
+    )
+
+    # ------------------------------------------------------------------ bundle
+    def shim_files(self, config: ServiceConfig) -> Dict[str, str]:
+        return {
+            "index.py": (
+                "# Generated by py-serverless-kit. SCF handler: index.main_handler\n"
+                "from py_serverless_kit.runtime.adapters.tencent import main_handler  # noqa: F401\n"
+            )
+        }
+
+    def provider_block(self, ctx: RenderContext) -> Dict[str, Any]:
+        block: Dict[str, Any] = {"region": ctx.region}
+        if ctx.opt("profile"):
+            block["profile"] = ctx.opt("profile")
+        return block
+
+    def physical_name(self, service: str, stage: str, logical: str) -> str:
+        name = super().physical_name(service, stage, logical)
+        # SCF names must start with a letter and must not end with '-' or '_'.
+        return name.rstrip("-_") or "fn"
+
+    def extra_validation(self, config: ServiceConfig) -> List[Issue]:
+        issues = []
+        if config.provider.iam.statements:
+            issues.append(
+                Issue(
+                    "warning",
+                    "iam.statements are not translated to CAM policies on Tencent; set iam.role to an existing "
+                    "CAM role name",
+                    "provider.iam",
+                )
+            )
+        for name, fn in config.functions.items():
+            where = f"functions.{name}"
+            for ev in fn.events_of("http"):
+                if ev.auth != "none":
+                    issues.append(
+                        Issue("error", f"http auth `{ev.auth}` is not supported on Tencent (use none)", where)
+                    )
+                if ev.method == "PATCH":
+                    issues.append(Issue("error", "Tencent API Gateway does not support PATCH; use ANY", where))
+            for ev in fn.events_of("storage"):
+                if not _BUCKET_RE.match(ev.bucket):
+                    issues.append(
+                        Issue(
+                            "error",
+                            f"COS bucket {ev.bucket!r} must be '<name>-<APPID>', e.g. uploads-1250000000",
+                            where,
+                        )
+                    )
+            memory = config.memory_of(fn)
+            if memory not in (64, 128) and memory % 128 != 0:
+                issues.append(
+                    Issue("error", f"SCF memory must be 64, 128 or a multiple of 128 MB (got {memory})", where)
+                )
+        return issues
+
+    # ------------------------------------------------------------------ render
+    def render_resources(self, doc: TerraformDoc, ctx: RenderContext) -> None:
+        cfg = ctx.config
+        zip_name = self._artifact_copy(ctx)
+        fn_out: Dict[str, Dict[str, Any]] = {}
+        service: Optional[str] = None
+        apis: List[str] = []
+        for name, fn in ctx.function_items():
+            res = self._function(doc, ctx, name, fn, zip_name)
+            namespace = ctx.opt("namespace", "default")
+            out: Dict[str, Any] = {
+                "id": ref(res, "name"),
+                "console": "https://console.cloud.tencent.com/scf/list-detail"
+                f"?ns={namespace}&id={ctx.physical_name(name)}",
+            }
+            http_events = fn.events_of("http")
+            if http_events:
+                service = service or self._service(doc, ctx)
+                apis.extend(self._apis(doc, ctx, service, name, res, fn, http_events))
+                out["base_url"] = "https://" + ref(service, "outer_sub_domain") + "/release"
+            fn_out[name] = out
+
+        endpoint = None
+        if service:
+            doc.resource(
+                "tencentcloud_api_gateway_service_release",
+                "release",
+                {
+                    "service_id": ref(service, "id"),
+                    "environment_name": "release",
+                    "release_desc": f"py-serverless-kit {ctx.artifact.sha256[:12]}",
+                    "depends_on": apis,
+                },
+            )
+            endpoint = "https://" + ref(service, "outer_sub_domain") + "/release"
+
+        wf_out = {n: {"id": ref(FUNCTION, tf_id(f"{n}-orchestrator"), "name")} for n in sorted(cfg.workflows)}
+        doc.output(
+            "pskit",
+            {"functions": fn_out, "workflows": wf_out, "endpoint": endpoint},
+            description="py-serverless-kit deployment summary",
+        )
+
+    # ------------------------------------------------------------------ pieces
+    @staticmethod
+    def _artifact_copy(ctx: RenderContext) -> str:
+        """SCF only re-uploads when ``zip_file`` *path* changes, so use a content-addressed copy."""
+        name = f"artifact-{ctx.artifact.sha256[:16]}.zip"
+        target = ctx.work_dir / name
+        for old in ctx.work_dir.glob("artifact-*.zip"):
+            if old.name != name:
+                old.unlink()
+        if not target.exists() and ctx.artifact.path.exists():
+            shutil.copyfile(ctx.artifact.path, target)
+        return name
+
+    def _function(self, doc: TerraformDoc, ctx: RenderContext, name: str, fn: FunctionConfig, zip_name: str) -> str:
+        cfg = ctx.config
+        triggers: List[Dict[str, Any]] = []
+        configs: List[Dict[str, Any]] = []
+        for i, ev in enumerate(fn.events_of("schedule")):
+            tname = re.sub(r"[^A-Za-z0-9_-]", "-", ev.name or f"timer-{i}")[:100]
+            desc = "0 " + sched.named_cron5(ev) + " *"
+            triggers.append({"name": tname, "type": "timer", "trigger_desc": desc})
+            if ev.input is not None or not ev.enabled:
+                configs.append(
+                    {
+                        "trigger_name": tname,
+                        "type": "timer",
+                        "trigger_desc": desc,
+                        "enable": "OPEN" if ev.enabled else "CLOSE",
+                        "custom_argument": escape(json.dumps(envelope("schedule", ev.input, source="tencent.timer"))),
+                    }
+                )
+        for ev in fn.events_of("storage"):
+            label = f"b-{ev.bucket}"
+            if not ev.existing and not doc.has_resource("tencentcloud_cos_bucket", label):
+                doc.resource(
+                    "tencentcloud_cos_bucket", label, {"bucket": ev.bucket, "acl": "private", "tags": ctx.tags()}
+                )
+            for action in ev.events:
+                desc_obj: Dict[str, Any] = {
+                    "event": {"created": "cos:ObjectCreated:*", "deleted": "cos:ObjectRemove:*"}[action]
+                }
+                if ev.prefix or ev.suffix:
+                    desc_obj["filter"] = {"Prefix": ev.prefix or "", "Suffix": ev.suffix or ""}
+                triggers.append(
+                    {
+                        "name": f"{ev.bucket}.cos.{ctx.region}.myqcloud.com",
+                        "type": "cos",
+                        "cos_region": ctx.region,
+                        "trigger_desc": json.dumps(desc_obj),
+                    }
+                )
+        body: Dict[str, Any] = {
+            "name": ctx.physical_name(name),
+            "description": re.sub(r"[^\w\s,.一-鿿]", " ", fn.description)[:1000],
+            "handler": "index.main_handler",
+            "runtime": self.runtime_id(cfg.runtime_of(fn)),
+            "mem_size": cfg.memory_of(fn),
+            "timeout": cfg.timeout_of(fn),
+            "namespace": ctx.opt("namespace", "default"),
+            "zip_file": "${path.module}/" + zip_name,
+            "enable_public_net": True,
+            "environment": {k: escape(v) for k, v in ctx.environment(name, fn).items()},
+            "tags": ctx.tags(fn),
+        }
+        if triggers:
+            body["triggers"] = triggers
+        role = fn.iam.role or cfg.provider.iam.role
+        if role:
+            body["role"] = role
+        body.update(fn.options)  # escape hatch: vpc_id, subnet_id, layers, cls_*...
+        res = doc.resource(FUNCTION, name, body)
+        for c in configs:
+            doc.resource(
+                "tencentcloud_scf_trigger_config",
+                f"{name}-{c['trigger_name']}",
+                {"function_name": ref(res, "name"), "namespace": ref(res, "namespace"), **c},
+            )
+        return res
+
+    def _service(self, doc: TerraformDoc, ctx: RenderContext) -> str:
+        return doc.resource(
+            "tencentcloud_api_gateway_service",
+            "http",
+            {
+                "service_name": re.sub(r"[^A-Za-z0-9_]", "_", ctx.prefix)[:50],
+                "protocol": "http&https",
+                "service_desc": f"py-serverless-kit {ctx.service} ({ctx.stage})",
+                "net_type": ["OUTER"],
+                "ip_version": "IPv4",
+                "tags": ctx.tags(),
+            },
+        )
+
+    def _apis(
+        self,
+        doc: TerraformDoc,
+        ctx: RenderContext,
+        service: str,
+        name: str,
+        fn_res: str,
+        fn: FunctionConfig,
+        events: List[Any],
+    ) -> List[str]:
+        refs = []
+        for i, ev in enumerate(events):
+            path = _gateway_path(ev.path)
+            params = re.findall(r"\{([A-Za-z_]\w*)\}", path)
+            body: Dict[str, Any] = {
+                "service_id": ref(service, "id"),
+                "api_name": re.sub(r"[^A-Za-z0-9_]", "_", f"{name}_{i}")[:60],
+                "api_desc": f"{ev.method} {ev.path} -> {name}",
+                "auth_type": "NONE",
+                "protocol": "HTTP",
+                "enable_cors": ev.cors_config is not None,
+                "request_config_path": path,
+                "request_config_method": ev.method,
+                "service_config_type": "SCF",
+                "service_config_scf_function_name": ref(fn_res, "name"),
+                "service_config_scf_function_namespace": ref(fn_res, "namespace"),
+                "service_config_scf_function_qualifier": "$LATEST",
+                "service_config_scf_is_integrated_response": True,
+                "service_config_timeout": min(ctx.config.timeout_of(fn), 1800),
+                "response_type": "JSON",
+            }
+            if params:
+                body["request_parameters"] = [
+                    {"name": p, "position": "PATH", "type": "string", "required": True, "desc": p} for p in params
+                ]
+            refs.append(doc.resource("tencentcloud_api_gateway_api", f"{name}-{i}", body))
+        return refs

py_serverless_kit/providers/terraform_doc.py

@@ -0,0 +1,125 @@
+"""Builder for Terraform JSON configuration (``main.tf.json``).
+
+Terraform reads ``*.tf.json`` natively. Generating JSON (instead of HCL text)
+removes a whole class of quoting / escaping bugs.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from typing import Any, Dict, List, Optional
+
+from ..config.loader import deep_merge
+
+_TF_REF = re.compile(r"\$\$\{\s*tf:([^}]+)\}")
+
+
+def tf_id(name: str) -> str:
+    """Make a valid Terraform block label from an arbitrary logical name."""
+    ident = re.sub(r"[^A-Za-z0-9_]", "_", name)
+    if not re.match(r"[A-Za-z_]", ident):
+        ident = "_" + ident
+    return ident
+
+
+def ref(*parts: str) -> str:
+    """``ref("aws_lambda_function", "hello", "arn")`` -> ``${aws_lambda_function.hello.arn}``."""
+    return "${" + ".".join(parts) + "}"
+
+
+def escape(value: str) -> str:
+    """Escape literal ``${`` / ``%{`` so Terraform does not treat them as templates.
+
+    The explicit ``${tf:<expression>}`` form is the one way to reference Terraform
+    from user values, e.g. ``${tf:aws_dynamodb_table.orders.arn}`` in an IAM
+    statement or environment variable.
+    """
+    escaped = value.replace("${", "$${").replace("%{", "%%{")
+    return _TF_REF.sub(lambda m: "${" + m.group(1).strip() + "}", escaped)
+
+
+class TerraformDoc:
+    def __init__(self) -> None:
+        self.terraform: Dict[str, Any] = {"required_providers": {}}
+        self.providers: Dict[str, Any] = {}
+        self.resources: Dict[str, Dict[str, Any]] = {}
+        self.data_sources: Dict[str, Dict[str, Any]] = {}
+        self.outputs: Dict[str, Any] = {}
+        self.locals: Dict[str, Any] = {}
+        self.variables: Dict[str, Any] = {}
+        self._extra: Dict[str, Any] = {}
+        self.warnings: List[str] = []
+
+    # ----------------------------------------------------------------- blocks
+    def required_provider(self, name: str, source: str, version: Optional[str] = None) -> None:
+        spec: Dict[str, Any] = {"source": source}
+        if version:
+            spec["version"] = version
+        self.terraform["required_providers"][name] = spec
+
+    def required_version(self, constraint: str) -> None:
+        self.terraform["required_version"] = constraint
+
+    def backend(self, kind: str, config: Dict[str, Any]) -> None:
+        self.terraform["backend"] = {kind: config}
+
+    def provider(self, name: str, body: Dict[str, Any]) -> None:
+        self.providers.setdefault(name, []).append(body)
+
+    def resource(self, rtype: str, name: str, body: Dict[str, Any]) -> str:
+        bucket = self.resources.setdefault(rtype, {})
+        label = tf_id(name)
+        if label in bucket:
+            raise ValueError(f"duplicate terraform resource {rtype}.{label}")
+        bucket[label] = body
+        return f"{rtype}.{label}"
+
+    def has_resource(self, rtype: str, name: str) -> bool:
+        return tf_id(name) in self.resources.get(rtype, {})
+
+    def data(self, dtype: str, name: str, body: Dict[str, Any]) -> str:
+        bucket = self.data_sources.setdefault(dtype, {})
+        label = tf_id(name)
+        bucket.setdefault(label, body)
+        return f"data.{dtype}.{label}"
+
+    def output(self, name: str, value: Any, *, sensitive: bool = False, description: str = "") -> None:
+        body: Dict[str, Any] = {"value": value}
+        if sensitive:
+            body["sensitive"] = True
+        if description:
+            body["description"] = description
+        self.outputs[tf_id(name)] = body
+
+    def local(self, name: str, value: Any) -> None:
+        self.locals[name] = value
+
+    def merge(self, extra: Dict[str, Any]) -> None:
+        """Deep-merge user supplied raw Terraform JSON (escape hatch)."""
+        self._extra = deep_merge(self._extra, extra)
+
+    # ----------------------------------------------------------------- output
+    def to_dict(self) -> Dict[str, Any]:
+        doc: Dict[str, Any] = {"terraform": self.terraform}
+        if self.providers:
+            doc["provider"] = self.providers
+        if self.variables:
+            doc["variable"] = self.variables
+        if self.locals:
+            doc["locals"] = self.locals
+        if self.data_sources:
+            doc["data"] = self.data_sources
+        if self.resources:
+            doc["resource"] = self.resources
+        if self.outputs:
+            doc["output"] = self.outputs
+        if self._extra:
+            doc = deep_merge(doc, self._extra)
+        return doc
+
+    def to_json(self) -> str:
+        return json.dumps(self.to_dict(), indent=2, sort_keys=False) + "\n"
+
+    def count(self) -> int:
+        return sum(len(v) for v in self.resources.values())

py_serverless_kit/runtime/__init__.py

@@ -0,0 +1,6 @@
+"""Portable function runtime.
+
+Everything in this package MUST stay standard-library only and compatible with
+Python 3.9+, because it is vendored into every deployment artifact and executed
+on runtimes we do not control (Tencent / Huawei still default to 3.9).
+"""

py_serverless_kit/runtime/adapters/__init__.py

@@ -0,0 +1,18 @@
+"""Per-provider translation between native payloads and the portable model.
+
+Each module exposes at least ``to_event(native, native_context)`` and a
+provider-specific entrypoint used by the generated shim in the bundle.
+"""
+
+ADAPTERS = (
+    "aws",
+    "azure",
+    "gcp",
+    "alibaba",
+    "oracle",
+    "ibm",
+    "digitalocean",
+    "tencent",
+    "huawei",
+    "cloudflare",
+)

py_serverless_kit/runtime/adapters/_httpfn.py

@@ -0,0 +1,91 @@
+"""Shared logic for providers where *every* invocation arrives as an HTTP-ish
+request (IBM Code Engine, DigitalOcean web functions, Cloudflare Workers,
+OCI behind API Gateway).
+
+A request whose JSON body carries the ``__pskit`` envelope is treated as a
+non-HTTP event (``invoke()``, workflow task, scheduler with input): the handler
+result is returned as JSON 200, and failures as JSON 500
+``{"errorType", "cause"}`` - the same contract the GCP adapter uses.
+"""
+
+from __future__ import annotations
+
+import base64
+from typing import Any, Dict, Optional, Tuple
+
+from ..context import Context
+from ..dispatch import execute, execute_async
+from ..event import Event, EventType, HttpRequest
+from ..response import Response, dumps
+from .base import maybe_json, unwrap_envelope
+
+NativeHttp = Tuple[int, Dict[str, str], str, bool]  # status, headers, body, is_base64
+
+
+def event_from_request(req: HttpRequest, provider: str, function: str, raw: Any = None) -> Event:
+    if req.method == "POST" and req.body[:1] == b"{":
+        wrapped = unwrap_envelope(req.body)
+        if wrapped is not None:
+            kind, data, meta = wrapped
+            return Event(type=kind, provider=provider, function=function, data=data, source=meta.get("source"), raw=raw)
+    return Event(type=EventType.HTTP, provider=provider, function=function, http=req, raw=raw)
+
+
+def error_body(exc: BaseException) -> Dict[str, Any]:
+    return {"errorType": getattr(exc, "error", None) or type(exc).__name__, "cause": str(exc)}
+
+
+def result_to_http(event: Event, result: Any) -> NativeHttp:
+    if isinstance(result, Response):
+        return result.render_for_gateway()
+    return 200, {"content-type": "application/json"}, dumps(result), False
+
+
+def run(event: Event, context: Context) -> NativeHttp:
+    """Execute and always return an HTTP-shaped result."""
+    if event.http is not None:
+        return execute(event, context).render_for_gateway()
+    try:
+        result = execute(event, context)
+    except Exception as exc:  # noqa: BLE001 - reported to the caller as JSON
+        return 500, {"content-type": "application/json"}, dumps(error_body(exc)), False
+    return result_to_http(event, result)
+
+
+async def run_async(event: Event, context: Context) -> NativeHttp:
+    if event.http is not None:
+        resp = await execute_async(event, context)
+        return resp.render_for_gateway()
+    try:
+        result = await execute_async(event, context)
+    except Exception as exc:  # noqa: BLE001
+        return 500, {"content-type": "application/json"}, dumps(error_body(exc)), False
+    return result_to_http(event, result)
+
+
+def decode_body(body: Any, headers: Dict[str, Any], is_base64: Optional[bool] = None) -> bytes:
+    """Decode a body that may be base64 when the content type is binary."""
+    if body is None:
+        return b""
+    if isinstance(body, (dict, list)):
+        return dumps(body).encode("utf-8")
+    if isinstance(body, bytes):
+        return body
+    text = str(body)
+    if is_base64 is None:
+        ctype = ""
+        for k, v in headers.items():
+            if str(k).lower() == "content-type":
+                ctype = str(v).lower()
+        textual = (not ctype) or ctype.startswith("text/") or "json" in ctype or "xml" in ctype or "form" in ctype
+        is_base64 = not textual
+    if is_base64:
+        try:
+            return base64.b64decode(text, validate=True)
+        except (ValueError, TypeError):
+            return text.encode("utf-8")
+    return text.encode("utf-8")
+
+
+def json_or_text(text: str) -> Any:
+    return maybe_json(text)

py_serverless_kit/runtime/adapters/alibaba.py

@@ -0,0 +1,147 @@
+"""Alibaba Cloud Function Compute 3.0 adapter.
+
+Handles HTTP triggers (event handler mode), timer triggers, OSS triggers,
+MNS topic triggers and direct invocation. FC passes the event as ``bytes``.
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Any, Dict, List
+
+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 = "alibaba"
+
+
+def _http(evt: Dict[str, Any]) -> HttpRequest:
+    rc = evt.get("requestContext") or {}
+    http = rc.get("http") or {}
+    query: Dict[str, Any] = {}
+    multi: Dict[str, List[str]] = {}
+    for key, value in (evt.get("queryParameters") or {}).items():
+        values = [str(v) for v in value] if isinstance(value, list) else [str(value)]
+        multi[key] = values
+        query[key] = values[-1] if values else ""
+    return HttpRequest(
+        method=http.get("method", "GET"),
+        path=evt.get("rawPath") or http.get("path") or "/",
+        headers=Headers(evt.get("headers") or {}),
+        query=query,
+        multi_query=multi,
+        body=HttpRequest.decode_body(evt.get("body"), bool(evt.get("isBase64Encoded"))),
+        source_ip=http.get("sourceIp"),
+    )
+
+
+def _oss(evt: Dict[str, Any], fn: str) -> Event:
+    records = []
+    for r in evt.get("events") or []:
+        oss = r.get("oss") or {}
+        obj = oss.get("object") or {}
+        records.append(
+            Record(
+                id=(r.get("responseElements") or {}).get("requestId"),
+                bucket=(oss.get("bucket") or {}).get("name"),
+                key=obj.get("key"),
+                size=obj.get("size"),
+                action=action_from(r.get("eventName", "")),
+                attributes={"event_name": r.get("eventName"), "etag": obj.get("eTag")},
+                source="acs:oss",
+                raw=r,
+            )
+        )
+    first = (evt.get("events") or [{}])[0]
+    return Event(
+        type=EventType.STORAGE,
+        provider=PROVIDER,
+        function=fn,
+        records=records,
+        source="acs:oss",
+        time=parse_time(first.get("eventTime")),
+        raw=evt,
+    )
+
+
+def to_event(native: Any, ctx: Any = None) -> Event:
+    fn = function_name(getattr(getattr(ctx, "function", None), "name", "") or "")
+    evt = maybe_json(native)
+    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(evt), raw=evt)
+        if "triggerTime" in evt and "triggerName" in evt:
+            payload = evt.get("payload")
+            inner = unwrap_envelope(payload) if payload else None
+            return Event(
+                type=EventType.SCHEDULE,
+                provider=PROVIDER,
+                function=fn,
+                data=inner[1] if inner else maybe_json(payload) if payload else None,
+                time=parse_time(evt.get("triggerTime")),
+                source=evt.get("triggerName"),
+                raw=evt,
+            )
+        events = evt.get("events")
+        if isinstance(events, list) and events and isinstance(events[0], dict) and "oss" in events[0]:
+            return _oss(evt, fn)
+        if "TopicName" in evt and "Message" in evt:  # MNS topic, JSON notify format
+            record = Record(
+                id=evt.get("MessageId"),
+                body=evt.get("Message"),
+                attributes={k: v for k, v in evt.items() if k not in ("Message",)},
+                source=evt.get("TopicOwner", "") + ":" + evt.get("TopicName", ""),
+                raw=evt,
+            )
+            return Event(
+                type=EventType.TOPIC,
+                provider=PROVIDER,
+                function=fn,
+                records=[record],
+                source=evt.get("TopicName"),
+                time=parse_time(evt.get("PublishTime")),
+                raw=evt,
+            )
+    return Event(type=EventType.INVOKE, provider=PROVIDER, function=fn, data=evt, raw=native)
+
+
+def to_context(ctx: Any, fn: str) -> Context:
+    if ctx is None:
+        return Context(function=fn, provider=PROVIDER)
+    func = getattr(ctx, "function", None)
+    memory = getattr(func, "memory", None)
+    timeout = getattr(func, "timeout", None)
+    return Context(
+        request_id=getattr(ctx, "request_id", "") or "",
+        function=fn,
+        provider=PROVIDER,
+        region=getattr(ctx, "region", "") or "",
+        memory_mb=int(memory) if memory else None,
+        deadline=(time.time() + float(timeout)) if timeout else None,
+        raw=ctx,
+    )
+
+
+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()
+        if resp.cookies:
+            headers["set-cookie"] = resp.cookies[0] if len(resp.cookies) == 1 else ", ".join(resp.cookies)
+        return {"statusCode": status, "headers": headers, "body": body, "isBase64Encoded": is_b64}
+    return result
+
+
+def handler(native: Any, ctx: Any = None) -> Any:
+    """FC 3.0 entrypoint - the generated ``index.handler`` points here."""
+    event = to_event(native, ctx)
+    context = to_context(ctx, event.function)
+    return to_native(execute(event, context), event)