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

py_serverless_kit/runtime/adapters/gcp.py

@@ -0,0 +1,176 @@
+"""Google Cloud Functions (2nd gen) adapter.
+
+Two entrypoints are exposed through the generated ``main.py``:
+
+* :func:`http` - ``@functions_framework.http``; receives a Flask request. A body
+  carrying the ``__pskit`` envelope (Cloud Scheduler, Cloud Workflows,
+  ``invoke()``) is dispatched as a *non-HTTP* event and answered with the raw
+  JSON result, or a 500 ``{"errorType", "cause"}`` that the workflow compiler
+  understands.
+* :func:`cloud_event` - ``@functions_framework.cloud_event``; Pub/Sub
+  ``messagePublished`` (queue / topic) and Cloud Storage object events.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import uuid
+from typing import Any, Dict, List, Optional, Tuple
+
+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 action_from, b64_text, function_name, unwrap_envelope
+
+PROVIDER = "gcp"
+_JSON = "application/json"
+
+
+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 _request_id(headers: Any) -> Optional[str]:
+    for key in ("Function-Execution-Id", "X-Cloud-Trace-Context"):
+        value = headers.get(key) if headers is not None else None
+        if value:
+            return str(value).split("/")[0]
+    return None
+
+
+# ------------------------------------------------------------------ HTTP
+
+
+def to_http_event(request: Any, fn: str) -> Event:
+    headers = dict(request.headers.items()) if hasattr(request.headers, "items") else dict(request.headers or {})
+    args = getattr(request, "args", None) or {}
+    multi: Dict[str, List[str]] = {}
+    if hasattr(args, "getlist"):
+        multi = {k: list(args.getlist(k)) for k in args.keys()}
+    query = {k: (v[-1] if v else "") for k, v in multi.items()} if multi else dict(args)
+    req = HttpRequest(
+        method=request.method,
+        path=request.path or "/",
+        headers=Headers(headers),
+        query=query,
+        multi_query=multi or {k: [v] for k, v in query.items()},
+        body=request.get_data() or b"",
+        source_ip=headers.get("X-Forwarded-For", "").split(",")[0].strip() or getattr(request, "remote_addr", None),
+    )
+    return Event(type=EventType.HTTP, provider=PROVIDER, function=fn, http=req, raw=request)
+
+
+def _render(resp: Response) -> Tuple[bytes, int, List[Tuple[str, str]]]:
+    status, headers, body = resp.render()
+    items = list(headers.items()) + [("set-cookie", c) for c in resp.cookies]
+    return body, status, items
+
+
+def http(request: Any) -> Tuple[bytes, int, Any]:
+    fn = function_name()
+    body = request.get_data() or b""
+    req_id = _request_id(request.headers)
+    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=fn, data=data, source=meta.get("source"), raw=request)
+        try:
+            result = execute(event, _context(fn, req_id, request))
+        except Exception as exc:  # noqa: BLE001 - reported to the caller (workflow / scheduler)
+            payload = {"errorType": type(exc).__name__, "cause": str(exc)}
+            return dumps(payload).encode("utf-8"), 500, [("content-type", _JSON)]
+        return dumps(result).encode("utf-8"), 200, [("content-type", _JSON)]
+    event = to_http_event(request, fn)
+    return _render(execute(event, _context(fn, req_id, request)))
+
+
+# ------------------------------------------------------------------ CloudEvents
+
+
+def _ce_attr(ce: Any, key: str, default: Any = None) -> Any:
+    try:
+        value = ce[key]
+    except (KeyError, TypeError, IndexError):
+        value = None
+    if value is None:
+        value = getattr(ce, key, None)
+    return default if value is None else value
+
+
+def _ce_data(ce: Any) -> Any:
+    data = getattr(ce, "data", None)
+    if data is None and isinstance(ce, dict):
+        data = ce.get("data")
+    if isinstance(data, (bytes, str)):
+        try:
+            data = json.loads(data)
+        except ValueError:
+            pass
+    return data
+
+
+def _storage_wanted(key: str) -> bool:
+    prefix = os.environ.get("PSKIT_STORAGE_PREFIX", "")
+    suffix = os.environ.get("PSKIT_STORAGE_SUFFIX", "")
+    return key.startswith(prefix) and key.endswith(suffix)
+
+
+def to_cloud_event(ce: Any, fn: str = "") -> Optional[Event]:
+    """Translate a CloudEvent; returns ``None`` when filtered out (storage prefix/suffix)."""
+    ce_type = str(_ce_attr(ce, "type", ""))
+    source = _ce_attr(ce, "source")
+    when = parse_time(_ce_attr(ce, "time"))
+    data = _ce_data(ce) or {}
+    if ce_type.startswith("google.cloud.pubsub.topic"):
+        msg = data.get("message") or {}
+        body = b64_text(msg.get("data"))
+        wrapped = unwrap_envelope(body) if isinstance(body, str) else None
+        if wrapped is not None:  # Cloud Scheduler -> Pub/Sub target
+            kind, payload, meta = wrapped
+            return Event(
+                type=kind,
+                provider=PROVIDER,
+                function=fn,
+                data=payload,
+                time=when,
+                source=meta.get("source", source),
+                raw=ce,
+            )
+        kind = EventType.QUEUE if os.environ.get("PSKIT_TRIGGER_KIND") == "queue" else EventType.TOPIC
+        record = Record(
+            id=msg.get("messageId") or msg.get("message_id") or _ce_attr(ce, "id"),
+            body=body,
+            attributes=dict(msg.get("attributes") or {}),
+            source=data.get("subscription") or source,
+            raw=msg,
+        )
+        return Event(type=kind, provider=PROVIDER, function=fn, records=[record], time=when, source=source, raw=ce)
+    if ce_type.startswith("google.cloud.storage.object"):
+        key = data.get("name", "")
+        if not _storage_wanted(key):
+            return None
+        size = data.get("size")
+        record = Record(
+            id=str(data.get("generation") or _ce_attr(ce, "id") or ""),
+            bucket=data.get("bucket"),
+            key=key,
+            size=int(size) if size not in (None, "") else None,
+            action=action_from(ce_type.rsplit(".", 1)[-1]),
+            attributes={"content_type": data.get("contentType"), "event_type": ce_type},
+            source=source,
+            raw=data,
+        )
+        return Event(
+            type=EventType.STORAGE, provider=PROVIDER, function=fn, records=[record], time=when, source=source, raw=ce
+        )
+    return Event(type=EventType.INVOKE, provider=PROVIDER, function=fn, data=data, time=when, source=source, raw=ce)
+
+
+def cloud_event(ce: Any) -> Any:
+    fn = function_name()
+    event = to_cloud_event(ce, fn)
+    if event is None:
+        return None
+    return execute(event, _context(fn, str(_ce_attr(ce, "id", "")) or None, ce))

py_serverless_kit/runtime/adapters/huawei.py

@@ -0,0 +1,173 @@
+"""Huawei Cloud FunctionGraph adapter.
+
+Handles APIG (dedicated gateway) events, timer triggers, OBS triggers, SMN
+topic triggers and direct invocation.
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Any, Dict
+from urllib.parse import unquote_plus
+
+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 = "huawei"
+
+
+def _call(ctx: Any, method: str, default: Any = None) -> Any:
+    fn = getattr(ctx, method, None)
+    if callable(fn):
+        try:
+            return fn()
+        except Exception:  # noqa: BLE001 - context helpers are best effort
+            return default
+    return default
+
+
+def _http(evt: Dict[str, Any]) -> HttpRequest:
+    rc = evt.get("requestContext") or {}
+    query: Dict[str, str] = {}
+    multi = {}
+    for key, value in (evt.get("queryStringParameters") 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=evt.get("httpMethod", "GET"),
+        path=evt.get("path") or "/",
+        headers=Headers(evt.get("headers") or {}),
+        query=query,
+        multi_query=multi,
+        path_params={k: str(v) for k, v in (evt.get("pathParameters") or {}).items()},
+        body=HttpRequest.decode_body(evt.get("body"), bool(evt.get("isBase64Encoded"))),
+        source_ip=rc.get("sourceIp"),
+    )
+
+
+def _obs(evt: Dict[str, Any], fn: str) -> Event:
+    records = []
+    for r in evt.get("Records") or []:
+        obs = r.get("obs") or r.get("s3") or {}
+        obj = obs.get("object") or {}
+        records.append(
+            Record(
+                id=obj.get("sequencer"),
+                bucket=(obs.get("bucket") or {}).get("name"),
+                key=unquote_plus(obj.get("key", "")),
+                size=obj.get("size"),
+                action=action_from(r.get("eventName", "")),
+                attributes={"event_name": r.get("eventName"), "etag": obj.get("eTag")},
+                source="obs",
+                raw=r,
+            )
+        )
+    first = (evt.get("Records") or [{}])[0]
+    return Event(
+        type=EventType.STORAGE,
+        provider=PROVIDER,
+        function=fn,
+        records=records,
+        source="obs",
+        time=parse_time(first.get("eventTime")),
+        raw=evt,
+    )
+
+
+def _smn(evt: Dict[str, Any], fn: str) -> Event:
+    records = []
+    for r in evt.get("record") or []:
+        smn = r.get("smn") or {}
+        records.append(
+            Record(
+                id=smn.get("message_id"),
+                body=smn.get("message"),
+                attributes={"subject": smn.get("subject"), **(smn.get("message_attributes") or {})},
+                source=smn.get("topic_urn"),
+                raw=r,
+            )
+        )
+    first = ((evt.get("record") or [{}])[0].get("smn")) or {}
+    return Event(
+        type=EventType.TOPIC,
+        provider=PROVIDER,
+        function=fn,
+        records=records,
+        source=first.get("topic_urn"),
+        time=parse_time(first.get("timestamp")),
+        raw=evt,
+    )
+
+
+def to_event(native: Any, ctx: Any = None) -> Event:
+    fn = function_name(_call(ctx, "getFunctionName", "") 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):
+        if "httpMethod" in evt and ("requestContext" in evt or "path" in evt):
+            return Event(type=EventType.HTTP, provider=PROVIDER, function=fn, http=_http(evt), raw=evt)
+        if str(evt.get("trigger_type", "")).upper() == "TIMER":
+            user_event = evt.get("user_event")
+            inner = unwrap_envelope(user_event) if user_event else None
+            return Event(
+                type=EventType.SCHEDULE,
+                provider=PROVIDER,
+                function=fn,
+                data=inner[1] if inner else (maybe_json(user_event) if user_event else None),
+                time=parse_time(evt.get("time")),
+                source=evt.get("trigger_name"),
+                raw=evt,
+            )
+        records = evt.get("Records")
+        if (
+            isinstance(records, list)
+            and records
+            and isinstance(records[0], dict)
+            and ("obs" in records[0] or "s3" in records[0])
+        ):
+            return _obs(evt, fn)
+        smn = evt.get("record")
+        if isinstance(smn, list) and smn and isinstance(smn[0], dict) and "smn" in smn[0]:
+            return _smn(evt, fn)
+    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)
+    remaining = getattr(ctx, "getRemainingTimeInMilliSeconds", None)
+    memory = _call(ctx, "getMemorySize")
+    remaining_ms = _call(ctx, "getRemainingTimeInMilliSeconds")
+    return Context(
+        request_id=str(_call(ctx, "getRequestID", "") or ""),
+        function=fn,
+        provider=PROVIDER,
+        memory_mb=int(memory) if memory else None,
+        deadline=(time.time() + float(remaining_ms) / 1000.0) if remaining_ms 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()
+        if resp.cookies:
+            headers["set-cookie"] = resp.cookies[0] if len(resp.cookies) == 1 else ", ".join(resp.cookies)
+        return {"statusCode": status, "isBase64Encoded": is_b64, "headers": headers, "body": body}
+    return result
+
+
+def handler(native: Any, ctx: Any = None) -> Any:
+    """FunctionGraph 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)

py_serverless_kit/runtime/adapters/ibm.py

@@ -0,0 +1,91 @@
+"""IBM Cloud Code Engine functions adapter.
+
+Code Engine calls ``main(params)``; HTTP request data arrives in ``__ce_*`` keys
+(``__ow_*`` from the older Cloud Functions / OpenWhisk platform is accepted too)
+and the function returns ``{"statusCode", "headers", "body"}``.
+"""
+
+from __future__ import annotations
+
+import os
+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 = "ibm"
+_PREFIXES = ("__ce_", "__ow_")
+
+
+def _get(params: Dict[str, Any], key: str) -> Any:
+    for prefix in _PREFIXES:
+        if prefix + key in params:
+            return params[prefix + key]
+    return None
+
+
+def _query(raw: Any) -> Dict[str, Any]:
+    if isinstance(raw, dict):
+        return {str(k): v if isinstance(v, list) else [str(v)] for k, v in raw.items()}
+    if isinstance(raw, str) and raw:
+        return parse_qs(raw.lstrip("?"), keep_blank_values=True)
+    return {}
+
+
+def to_request(params: Dict[str, Any]) -> Optional[HttpRequest]:
+    method = _get(params, "method")
+    if not method:
+        return None
+    headers = dict(_get(params, "headers") or {})
+    body = _get(params, "body")
+    if body is None:
+        # Code Engine merges JSON bodies into params; rebuild it from the plain keys.
+        plain = {k: v for k, v in params.items() if not k.startswith(_PREFIXES)}
+        body = dumps(plain) if plain else None
+    multi = _query(_get(params, "query"))
+    return HttpRequest(
+        method=str(method),
+        path=_get(params, "path") or "/",
+        headers=Headers(headers),
+        query={k: v[-1] for k, v in multi.items() if v},
+        multi_query=multi,
+        body=decode_body(body, headers),
+        source_ip=headers.get("x-forwarded-for", "").split(",")[0].strip() or None,
+    )
+
+
+def main(params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+    params = params or {}
+    fn = function_name()
+    req = to_request(params)
+    if req is None:
+        # Direct invocation without HTTP metadata: params are the payload.
+        wrapped = unwrap_envelope(params)
+        if wrapped is not None:
+            event = Event(type=wrapped[0], provider=PROVIDER, function=fn, data=wrapped[1], raw=params)
+        else:
+            event = Event(type=EventType.INVOKE, provider=PROVIDER, function=fn, data=params, raw=params)
+    else:
+        event = event_from_request(req, PROVIDER, fn, raw=params)
+    context = Context(
+        request_id=os.environ.get("CE_REQUEST_ID", "") or headers_id(params),
+        function=fn,
+        provider=PROVIDER,
+        raw=params,
+    )
+    status, headers, body, _is_b64 = run(event, context)
+    return {"statusCode": status, "headers": headers, "body": body}
+
+
+def headers_id(params: Dict[str, Any]) -> str:
+    headers = _get(params, "headers") or {}
+    for key in ("x-request-id", "X-Request-Id", "x-ce-request-id"):
+        if key in headers:
+            return str(headers[key])
+    import uuid
+
+    return str(uuid.uuid4())

py_serverless_kit/runtime/adapters/oracle.py

@@ -0,0 +1,161 @@
+"""Oracle Cloud (OCI) Functions adapter, built on the Fn Project Python FDK.
+
+``func.py`` exposes ``handler(ctx, data)``. Invocations come from:
+
+* OCI API Gateway - the FDK context carries ``Fn-Http-Method``,
+  ``Fn-Http-Request-Url`` and ``Fn-Http-H-<name>`` headers;
+* OCI Events (object storage) - a CloudEvents JSON body;
+* direct invoke (``oci fn function invoke``) / the ``__pskit`` envelope.
+"""
+
+from __future__ import annotations
+
+import base64
+import io
+from typing import Any, Dict, Optional
+from urllib.parse import parse_qs, urlsplit
+
+from ..context import Context
+from ..event import Event, EventType, Headers, HttpRequest, Record, parse_time
+from ._httpfn import event_from_request, run
+from .base import action_from, function_name, maybe_json, unwrap_envelope
+
+PROVIDER = "oracle"
+_HEADER_PREFIX = "fn-http-h-"
+
+
+def _call(obj: Any, name: str, default: Any = None) -> Any:
+    fn = getattr(obj, name, None)
+    if callable(fn):
+        try:
+            return fn()
+        except Exception:  # noqa: BLE001 - FDK accessors are best effort
+            return default
+    return default
+
+
+def _ctx_headers(ctx: Any) -> Dict[str, Any]:
+    raw = _call(ctx, "Headers") or {}
+    return {str(k).lower(): v for k, v in dict(raw).items()}
+
+
+def _first(value: Any) -> Any:
+    if isinstance(value, (list, tuple)):
+        return value[0] if value else None
+    return value
+
+
+def _read(data: Any) -> bytes:
+    if data is None:
+        return b""
+    if isinstance(data, (bytes, bytearray)):
+        return bytes(data)
+    if isinstance(data, str):
+        return data.encode("utf-8")
+    if hasattr(data, "getvalue"):
+        return data.getvalue()
+    if hasattr(data, "read"):
+        return data.read()
+    return str(data).encode("utf-8")
+
+
+def to_request(ctx: Any, body: bytes) -> Optional[HttpRequest]:
+    headers = _ctx_headers(ctx)
+    method = _first(headers.get("fn-http-method"))
+    if not method:
+        http_headers = _call(ctx, "HttpHeaders")
+        if http_headers is None:
+            return None
+        method = _call(ctx, "Method")
+        if not method:
+            return None
+    url = _first(headers.get("fn-http-request-url")) or _call(ctx, "RequestURL") or "/"
+    http_headers = _call(ctx, "HttpHeaders")
+    if http_headers is None:
+        http_headers = {k[len(_HEADER_PREFIX) :]: v for k, v in headers.items() if k.startswith(_HEADER_PREFIX)}
+    parts = urlsplit(str(url))
+    multi = parse_qs(parts.query, keep_blank_values=True)
+    return HttpRequest(
+        method=str(method),
+        path=parts.path or "/",
+        headers=Headers(dict(http_headers)),
+        query={k: v[-1] for k, v in multi.items()},
+        multi_query=multi,
+        body=body,
+    )
+
+
+def _cloud_event(payload: Dict[str, Any], fn: str) -> Optional[Event]:
+    etype = str(payload.get("eventType") or payload.get("type") or "")
+    if "objectstorage" not in etype:
+        return None
+    data = payload.get("data") or {}
+    details = data.get("additionalDetails") or {}
+    record = Record(
+        id=str(payload.get("eventID") or payload.get("id") or ""),
+        bucket=details.get("bucketName"),
+        key=data.get("resourceName"),
+        action=action_from(etype),
+        attributes={"event_type": etype, "namespace": details.get("namespace")},
+        source=str(payload.get("source") or "objectstorage"),
+        raw=payload,
+    )
+    return Event(
+        type=EventType.STORAGE,
+        provider=PROVIDER,
+        function=fn,
+        records=[record],
+        source=record.source,
+        time=parse_time(payload.get("eventTime") or payload.get("time")),
+        raw=payload,
+    )
+
+
+def to_event(ctx: Any, data: Any, fn: str) -> Event:
+    body = _read(data)
+    req = to_request(ctx, body)
+    if req is not None:
+        return event_from_request(req, PROVIDER, fn, raw=ctx)
+    payload = maybe_json(body) if body else None
+    wrapped = unwrap_envelope(payload)
+    if wrapped is not None:
+        kind, value, meta = wrapped
+        return Event(type=kind, provider=PROVIDER, function=fn, data=value, source=meta.get("source"), raw=payload)
+    if isinstance(payload, dict):
+        storage = _cloud_event(payload, fn)
+        if storage is not None:
+            return storage
+    return Event(type=EventType.INVOKE, provider=PROVIDER, function=fn, data=payload, raw=payload)
+
+
+def _respond(ctx: Any, status: int, headers: Dict[str, str], body: Any, is_http: bool) -> Any:
+    try:
+        from fdk import response as fdk_response  # type: ignore[import-not-found]
+    except ImportError:  # local tests without the FDK
+        return {"status": status, "headers": headers, "body": body}
+    if is_http:
+        try:
+            from fdk import context as fdk_context  # type: ignore[import-not-found]
+
+            factory = getattr(fdk_context, "GetHTTPGatewayContext", None) or getattr(
+                fdk_context, "HTTPGatewayContext", None
+            )
+            if factory is not None:
+                gw = factory(ctx)
+                gw.SetStatusCode(status)
+                gw.SetResponseHeaders(headers, status)
+        except Exception:  # noqa: BLE001, S110 - fall back to protocol headers
+            pass
+        headers = dict(headers)
+        headers["Fn-Http-Status"] = str(status)
+    return fdk_response.Response(ctx, response_data=body, headers=headers, status_code=200 if is_http else status)
+
+
+def handler(ctx: Any, data: Any = None) -> Any:
+    """FDK entrypoint used by the generated ``func.py``."""
+    fn = function_name()
+    event = to_event(ctx, data if data is not None else io.BytesIO(b""), fn)
+    context = Context(request_id=str(_call(ctx, "CallID") or ""), function=fn, provider=PROVIDER, raw=ctx)
+    status, headers, body, is_b64 = run(event, context)
+    payload: Any = base64.b64decode(body) if is_b64 else body
+    return _respond(ctx, status, headers, payload, event.http is not None)