workpeg-sdk 0.1.0__py3-none-any.whl

workpeg_sdk/__init__.py

@@ -0,0 +1,5 @@
+# src/workpeg_sdk/__init__.py
+
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"

workpeg_sdk/create_new.py

@@ -0,0 +1,86 @@
+# src/workpeg_sdk/create_new.py
+import argparse
+import os
+import shutil
+from pathlib import Path
+import importlib.resources as pkg_resources
+
+
+class TemplateError(Exception):
+    pass
+
+
+def _copy_tree(src_root: Path, dst_root: Path, *, force: bool) -> None:
+    """
+    Recursively copy src_root directory contents into dst_root.
+    """
+    if not src_root.exists():
+        raise TemplateError(f"Template root not found: {src_root}")
+
+    dst_root.mkdir(parents=True, exist_ok=True)
+
+    for item in src_root.rglob("*"):
+        rel = item.relative_to(src_root)
+        dst = dst_root / rel
+
+        if item.is_dir():
+            dst.mkdir(parents=True, exist_ok=True)
+            continue
+
+        if dst.exists() and not force:
+            raise TemplateError(f"Target file exists: {dst} (use --force)")
+
+        dst.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(item, dst)
+
+
+def create_new_project(target_dir: str, *, force: bool = False) -> Path:
+    """
+    Copy the function template from workpeg_sdk/templates/functions/*
+    into target_dir.
+    """
+    target = Path(target_dir).expanduser().resolve()
+
+    # Get a Traversable pointing at .../workpeg_sdk/templates/functions
+    traversable = (
+        pkg_resources.files("workpeg_sdk") / "templates" / "functions"
+    )
+
+    # as_file() gives us a real filesystem path even if the package
+    # is loaded from a wheel/zip. This completely avoids the old
+    # "not available as a filesystem path" issue.
+    with pkg_resources.as_file(traversable) as src_path:
+        src_root = Path(src_path)
+        _copy_tree(src_root, target, force=force)
+
+    return target
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="workpeg-new-function",
+        description="Create a new Workpeg function"
+        " project from the built-in template.",
+    )
+    p.add_argument(
+        "path",
+        help="Target directory to create/populate (e.g. ./my-function).",
+    )
+    p.add_argument(
+        "--force",
+        action="store_true",
+        help="Overwrite existing files in the target directory.",
+    )
+    return p
+
+
+def main() -> None:
+    parser = build_parser()
+    args = parser.parse_args()
+
+    try:
+        out = create_new_project(args.path, force=args.force)
+        print(str(out))
+    except TemplateError as e:
+        print(f"ERROR: {e}", file=os.sys.stderr)
+        raise SystemExit(2)

workpeg_sdk/runtime.py

@@ -0,0 +1,164 @@
+# src/workpeg_sdk/runtime.py
+
+import importlib
+import json
+import os
+import sys
+import traceback
+from typing import Any, Callable, Dict, Tuple
+
+
+DEFAULT_ENTRYPOINT = "app.main:main"
+
+
+class FunctionRuntimeError(Exception):
+    """Custom exception for runtime-level errors."""
+    pass
+
+
+def parse_entrypoint(entry: str) -> Tuple[str, str]:
+    """
+    Parse 'module.path:func_name' into (module, func).
+    """
+    try:
+        module_name, func_name = entry.split(":", 1)
+        module_name = module_name.strip()
+        func_name = func_name.strip()
+        if not module_name or not func_name:
+            raise ValueError
+        return module_name, func_name
+    except ValueError:
+        raise FunctionRuntimeError(
+            f"Invalid FUNCTION_ENTRYPOINT format: '{entry}'. "
+            "Expected 'module.path:func_name'."
+        )
+
+
+def _ensure_cwd_on_syspath() -> None:
+    """
+    Ensure current working directory is at the front of sys.path.
+
+    This is critical when running via a console script installed by pip,
+    because sys.path[0] is the script's directory (e.g. venv/bin),
+    NOT the current working directory.
+    """
+    cwd = os.getcwd()
+    if cwd not in sys.path:
+        sys.path.insert(0, cwd)
+
+
+def load_function() -> Callable[[Dict[str, Any], Dict[str, Any]], Any]:
+    """
+    Load the user function based on env FUNCTION_ENTRYPOINT or default.
+    """
+    _ensure_cwd_on_syspath()
+
+    entry = os.getenv("FUNCTION_ENTRYPOINT", DEFAULT_ENTRYPOINT)
+    module_name, func_name = parse_entrypoint(entry)
+
+    try:
+        module = importlib.import_module(module_name)
+    except Exception as exc:
+        raise FunctionRuntimeError(
+            f"Failed to import module '{module_name}' from '{entry}': {exc}"
+        ) from exc
+
+    try:
+        fn = getattr(module, func_name)
+    except AttributeError as exc:
+        raise FunctionRuntimeError(
+            f"Module '{module_name}'"
+            f" does not define '{func_name}' from '{entry}'."
+        ) from exc
+
+    if not callable(fn):
+        raise FunctionRuntimeError(
+            f"'{entry}' is not callable. Expected a function."
+        )
+
+    return fn
+
+
+def read_request() -> Dict[str, Any]:
+    """
+    Read a single JSON object from stdin.
+    Expected format: {"context": {...}, "payload": {...}}
+    """
+    try:
+        raw = sys.stdin.read()
+        if not raw.strip():
+            raise FunctionRuntimeError("No input received on stdin.")
+        data = json.loads(raw)
+        if not isinstance(data, dict):
+            raise FunctionRuntimeError("Input JSON must be a JSON object.")
+        return data
+    except json.JSONDecodeError as exc:
+        raise FunctionRuntimeError(f"Invalid JSON input: {exc}") from exc
+
+
+def run_once() -> int:
+    """
+    Run a single invocation:
+      - load function
+      - read request
+      - call function
+      - emit JSON result
+
+    Returns exit code (0 on success, 1 on error).
+    """
+    try:
+        fn = load_function()
+        request = read_request()
+
+        context = request.get("context", {})
+        payload = request.get("payload", {})
+
+        if not isinstance(context, dict):
+            raise FunctionRuntimeError(
+                "Field 'context' must be a JSON object.")
+        if not isinstance(payload, dict):
+            raise FunctionRuntimeError(
+                "Field 'payload' must be a JSON object.")
+
+        result = fn(context, payload)
+
+        output = {
+            "status": "success",
+            "result": result,
+        }
+        print(json.dumps(output))
+        return 0
+
+    except FunctionRuntimeError as e:
+        # Runtime / wiring error
+        err_output = {
+            "status": "error",
+            "error_type": "runtime_error",
+            "error": str(e),
+        }
+        # Send JSON to stdout (for the host)
+        # and more detail to stderr (for logs)
+        print(json.dumps(err_output))
+        print(f"[workpeg-runtime] runtime_error: {e}", file=sys.stderr)
+        return 1
+
+    except Exception as e:
+        # User code error
+        trace = traceback.format_exc()
+        err_output = {
+            "status": "error",
+            "error_type": "user_error",
+            "error": str(e),
+            "trace": trace,
+        }
+        print(json.dumps(err_output))
+        print(f"[workpeg-runtime] user_error: {e}\n{trace}", file=sys.stderr)
+        return 1
+
+
+def main() -> None:
+    """
+    Console script entrypoint for 'workpeg-runtime'.
+    """
+    exit_code = run_once()
+    sys.exit(exit_code)

workpeg_sdk/templates/functions/Dockerfile

@@ -0,0 +1,17 @@
+FROM python:3.12-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+
+RUN useradd -m -u 10001 appuser
+
+WORKDIR /app
+
+COPY requirements.txt /app/requirements.txt
+RUN pip install --no-cache-dir -r /app/requirements.txt
+
+COPY app /app/app
+
+USER appuser
+
+ENTRYPOINT ["workpeg-runtime"]

workpeg_sdk/templates/functions/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2011-2025 The Bootstrap Authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

workpeg_sdk/templates/functions/README.md

@@ -0,0 +1,81 @@
+# Workpeg Function Project
+
+This directory was created using **Workpeg SDK**.
+
+It contains everything you need to build and run a single **Workpeg Function**, which can later be attached to a Peg inside Workpeg.
+
+---
+
+## Project Structure
+
+```text
+app/
+  __init__.py
+  main.py        # Your function: def main(context, payload) -> dict
+requirements.txt # Python dependencies (must include workpeg-sdk)
+Dockerfile       # Example container runtime using workpeg-runtime
+```
+
+---
+
+## Function Contract
+
+Your function **must** define:
+
+```python
+def main(context: dict, payload: dict) -> dict:
+    ...
+```
+
+- `context` – execution metadata injected by Workpeg (user, peg, execution id, etc.)
+- `payload` – input data sent by the caller
+- return value – must be JSON serializable
+
+By default, the runtime looks for `app.main:main`.
+You can change this using the `FUNCTION_ENTRYPOINT` environment variable:
+
+```bash
+export FUNCTION_ENTRYPOINT="module.path:function_name"
+```
+
+---
+
+## Running Locally
+
+Make sure `workpeg-sdk` is installed (or use the generated `requirements.txt`):
+
+```bash
+pip install -r requirements.txt
+```
+
+Then run the function:
+
+```bash
+echo '{"context": {}, "payload": {"hello": "world"}}' | workpeg-runtime
+```
+
+Expected output:
+
+```json
+{ "status": "success", "result": { "hello": "world" } }
+```
+
+---
+
+## Docker (Optional)
+
+You can build and run the container using the included `Dockerfile`:
+
+```bash
+docker build -t my-workpeg-function .
+echo '{"context": {}, "payload": {"hello": "world"}}' | docker run --rm -i my-workpeg-function
+```
+
+---
+
+## More
+
+This template is part of the official Workpeg SDK.
+
+Repo: [https://gitlab.com/workpeg/workpeg-sdk](https://gitlab.com/workpeg/workpeg-sdk)
+Full documentation and Peg integration guides are coming soon.

workpeg_sdk/templates/functions/app/main.py

@@ -0,0 +1,2 @@
+def main(context, payload):
+    return payload

workpeg_sdk-0.1.0.dist-info/METADATA

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: workpeg-sdk
+Version: 0.1.0
+Summary: Workpeg function runtime and SDK
+Author-email: Workpeg <support@workpeg.com>
+License: MIT
+Project-URL: Homepage, https://gitlab.com/workpeg/workpeg-sdk
+Project-URL: Repository, https://gitlab.com/workpeg/workpeg-sdk
+Keywords: workpeg,serverless,functions,runtime
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Workpeg SDK
+
+SDK for building **Workpeg Pegs and Functions**.
+
+Currently focused on:
+
+* `workpeg-runtime` – function execution runtime
+* `workpeg-new-function` – project scaffolding
+
+Frontend features, Peg integrations, push & deployment tooling are coming soon.
+
+---
+
+## Installation
+
+```bash
+pip install workpeg-sdk
+```
+
+---
+
+## Getting Started
+
+### 1. Create a New Function
+
+```bash
+workpeg-new-function my-peg
+cd my-peg
+```
+
+This generates:
+
+```
+my-peg/
+  app/
+    __init__.py
+    main.py
+  requirements.txt
+  Dockerfile
+```
+
+---
+
+### 2. Implement Your Function
+
+Edit `app/main.py`:
+
+```python
+def main(context, payload):
+    return payload
+```
+
+Every Workpeg Function must define:
+
+```python
+def main(context: dict, payload: dict) -> dict
+```
+
+* `context` → execution metadata (provided by Workpeg)
+* `payload` → input data
+* return value → must be JSON serializable
+
+---
+
+### 3. Run Locally
+
+```bash
+echo '{"context": {}, "payload": {"hello": "world"}}' | workpeg-runtime
+```
+
+Example output:
+
+```json
+{"status":"success","result":{"hello":"world"}}
+```
+
+---
+
+## Runtime
+
+`workpeg-runtime`:
+
+1. Reads JSON from STDIN
+2. Loads `app.main:main`
+3. Executes the function
+4. Writes structured JSON to STDOUT
+
+Override entrypoint:
+
+```bash
+FUNCTION_ENTRYPOINT="module.path:function_name" workpeg-runtime
+```
+
+---
+
+## Roadmap
+
+* Peg-level integrations
+* Frontend features (Streamlit/Reflex style)
+* Push & deployment tooling
+* Hosted execution
+
+---
+
+📘 Documentation coming soon.
+
+MIT License

workpeg_sdk-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+workpeg_sdk/__init__.py,sha256=y5VvJPaDTdeEX8SbdZRLHxuZyx1Sr1Xbh-fMuKrXJHI,80
+workpeg_sdk/create_new.py,sha256=JIRc7cNVuxr3cm1AG8gZMakFf4a-Q9wQ6WVHkd8nR0k,2423
+workpeg_sdk/runtime.py,sha256=4ksjupPKYv3jQg6KTDrwS3x1LKqNJKb18xIE33V4RMs,4520
+workpeg_sdk/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+workpeg_sdk/templates/functions/Dockerfile,sha256=JJqkAZIpfMp_j_dBi5QCnqWcYResMo1o-2zj4iZhuJw,288
+workpeg_sdk/templates/functions/LICENSE,sha256=aBE_D2wOlXFk9dvBsu-Wt1xgJkzHXk_7wYR9O7PNb58,1092
+workpeg_sdk/templates/functions/README.md,sha256=B5HmxUflOKsr3-cS1EwarieBZSD34Zd-Nge0THQfK0M,1783
+workpeg_sdk/templates/functions/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+workpeg_sdk/templates/functions/app/main.py,sha256=pgI-9eriwIbGqRjG2gjM2ldKeX5FMltJpeN5Bz5-wlQ,47
+workpeg_sdk-0.1.0.dist-info/licenses/LICENSE,sha256=aBE_D2wOlXFk9dvBsu-Wt1xgJkzHXk_7wYR9O7PNb58,1092
+workpeg_sdk-0.1.0.dist-info/METADATA,sha256=Cs2dU8BcSLoRk82cffjQnj0DJ5vK938yDTr5GQ64joY,2144
+workpeg_sdk-0.1.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+workpeg_sdk-0.1.0.dist-info/entry_points.txt,sha256=Zwt02joUSB4wpQ-zxRzplT7AjmDZ5aU5_PfxoChmoNs,112
+workpeg_sdk-0.1.0.dist-info/top_level.txt,sha256=0BobHoWoeCtlHrk9c0oIrS8FDOet9WJRVlSz6e8glGM,12
+workpeg_sdk-0.1.0.dist-info/RECORD,,

workpeg_sdk-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

workpeg_sdk-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+workpeg-new-function = workpeg_sdk.create_new:main
+workpeg-runtime = workpeg_sdk.runtime:main

workpeg_sdk-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2011-2025 The Bootstrap Authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

workpeg_sdk-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+workpeg_sdk