workpeg 0.1.4__tar.gz → 0.2.0__tar.gz

{workpeg-0.1.4/src/workpeg.egg-info → workpeg-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: workpeg
-Version: 0.1.4
+Version: 0.2.0
 Summary: Workpeg function runtime and SDK
 Author-email: Workpeg <support@workpeg.com>
 License: MIT

{workpeg-0.1.4 → workpeg-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "workpeg"
-version = "0.1.4"
+version = "0.2.0"
 description = "Workpeg function runtime and SDK"
 readme = "README.md"
 requires-python = ">=3.10"

{workpeg-0.1.4 → workpeg-0.2.0/src/workpeg.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: workpeg
-Version: 0.1.4
+Version: 0.2.0
 Summary: Workpeg function runtime and SDK
 Author-email: Workpeg <support@workpeg.com>
 License: MIT

{workpeg-0.1.4 → workpeg-0.2.0}/src/workpeg.egg-info/SOURCES.txt

@@ -9,8 +9,11 @@ src/workpeg.egg-info/entry_points.txt
 src/workpeg.egg-info/requires.txt
 src/workpeg.egg-info/top_level.txt
 src/workpeg_sdk/__init__.py
+src/workpeg_sdk/build.py
 src/workpeg_sdk/cli.py
+src/workpeg_sdk/config.py
 src/workpeg_sdk/create_new.py
+src/workpeg_sdk/run.py
 src/workpeg_sdk/runtime.py
 src/workpeg_sdk/submit.py
 src/workpeg_sdk/templates/__init__.py
@@ -20,6 +23,9 @@ src/workpeg_sdk/templates/functions/README.md
 src/workpeg_sdk/templates/functions/requirements.txt
 src/workpeg_sdk/templates/functions/app/__init__.py
 src/workpeg_sdk/templates/functions/app/main.py
+tests/test_build.py
+tests/test_cli.py
 tests/test_create_new.py
-tests/test_run_time.py
+tests/test_run.py
+tests/test_runtime.py
 tests/test_submit.py

workpeg-0.2.0/src/workpeg_sdk/build.py

@@ -0,0 +1,34 @@
+# src/workpeg_sdk/build.py
+# import hashlib
+# import os
+import subprocess
+from pathlib import Path
+
+from workpeg_sdk.config import load_config
+
+
+def slugify(value: str) -> str:
+    return (
+        value.lower()
+        .replace("_", "-")
+        .replace(".", "-")
+        .replace(" ", "-")
+    )
+
+
+def default_image_name(project_path: Path) -> str:
+    project_name = slugify(project_path.resolve().name)
+    return f"workpeg-fn-{project_name}"
+
+
+def build_image(path: str = ".", tag: str | None = None) -> str:
+    project_path = Path(path).resolve()
+    cfg = load_config(project_path / "workpeg.json")
+
+    image = tag or cfg.get("build", {}).get("image") or default_image_name(project_path)
+
+    subprocess.run(
+        ["docker", "build", "-t", image, str(project_path)],
+        check=True,
+    )
+    return image

{workpeg-0.1.4 → workpeg-0.2.0}/src/workpeg_sdk/cli.py

@@ -1,15 +1,14 @@
+# src/workpeg_sdk/cli.py
 import argparse
 import sys
 
-from workpeg_sdk import create_new, runtime, submit
+from workpeg_sdk import build, create_new, run, runtime, submit
 
 
 def build_parser() -> argparse.ArgumentParser:
     p = argparse.ArgumentParser(prog="workpeg")
     sub = p.add_subparsers(dest="command", required=True)
 
-    # workpeg submit
-    # <function>:<version> [--api ...] [--path ...] [--timeout ...]
     submit_p = sub.add_parser("submit", help="Submit a function bundle")
     submit_p.add_argument("ref")
     submit_p.add_argument("--api", default=None)
@@ -17,17 +16,25 @@ def build_parser() -> argparse.ArgumentParser:
     submit_p.add_argument("--timeout", type=int, default=None)
     submit_p.set_defaults(_handler="submit")
 
-    # workpeg new-function <path> [--force]
-    new_p = sub.add_parser(
-        "new-function", help="Create a new function project from template")
+    new_p = sub.add_parser("new-function", help="Create a new function project from template")
     new_p.add_argument("path")
     new_p.add_argument("--force", action="store_true")
     new_p.set_defaults(_handler="new-function")
 
-    # workpeg runtime
-    run_p = sub.add_parser(
-        "runtime", help="Run a function locally (reads JSON from stdin)")
-    run_p.set_defaults(_handler="runtime")
+    runtime_p = sub.add_parser("runtime", help="Run the function runtime")
+    runtime_p.add_argument("--server", action="store_true")
+    runtime_p.set_defaults(_handler="runtime")
+
+    build_p = sub.add_parser("build", help="Build the function docker image")
+    build_p.add_argument("--path", default=".")
+    build_p.add_argument("--tag", default=None)
+    build_p.set_defaults(_handler="build")
+
+    run_p = sub.add_parser("run", help="Run the function using a configured runtime")
+    run_p.add_argument("--with", dest="with_runtime", choices=["docker", "cracker"])
+    run_p.add_argument("--path", default=".")
+    run_p.add_argument("--no-build", action="store_true")
+    run_p.set_defaults(_handler="run")
 
     return p
 
@@ -38,7 +45,6 @@ def main(argv=None) -> None:
     args = parser.parse_args(argv)
 
     if args._handler == "new-function":
-        # call the implementation directly (no double-argparse)
         try:
             out = create_new.create_new_project(args.path, force=args.force)
             print(str(out))
@@ -48,12 +54,13 @@ def main(argv=None) -> None:
         return
 
     if args._handler == "runtime":
-        # runtime may read stdin, so call directly
-        runtime.main([])
+        runtime_argv = []
+        if args.server:
+            runtime_argv.append("--server")
+        runtime.main(runtime_argv)
         return
 
     if args._handler == "submit":
-        # build argv for submit.main (it already supports argv)
         submit_argv = [args.ref]
         if args.api:
             submit_argv += ["--api", args.api]
@@ -63,3 +70,19 @@ def main(argv=None) -> None:
             submit_argv += ["--timeout", str(args.timeout)]
         submit.main(submit_argv)
         return
+
+    if args._handler == "build":
+        image = build.build_image(path=args.path, tag=args.tag)
+        print(image)
+        return
+
+    if args._handler == "run":
+        run_argv = []
+        if args.with_runtime:
+            run_argv += ["--with", args.with_runtime]
+        if args.path:
+            run_argv += ["--path", args.path]
+        if args.no_build:
+            run_argv.append("--no-build")
+        run.main(run_argv)
+        return

workpeg-0.2.0/src/workpeg_sdk/config.py

@@ -0,0 +1,39 @@
+# src/workpeg_sdk/config.py
+import json
+from pathlib import Path
+
+
+DEFAULT_CONFIG = {
+    "function": {
+        "entrypoint": "app.main:main",
+    },
+    "runtime": {
+        "default": "cracker",
+        "docker": {
+            "host": "127.0.0.1",
+            "port": 8000,
+        },
+    },
+    "build": {
+        "image": None,
+    },
+}
+
+
+def deep_merge(base: dict, override: dict) -> dict:
+    out = dict(base)
+    for key, value in override.items():
+        if isinstance(value, dict) and isinstance(out.get(key), dict):
+            out[key] = deep_merge(out[key], value)
+        else:
+            out[key] = value
+    return out
+
+
+def load_config(path: str = "workpeg.json") -> dict:
+    cfg_path = Path(path)
+    if not cfg_path.exists():
+        return DEFAULT_CONFIG.copy()
+
+    data = json.loads(cfg_path.read_text(encoding="utf-8"))
+    return deep_merge(DEFAULT_CONFIG, data)

workpeg-0.2.0/src/workpeg_sdk/run.py

@@ -0,0 +1,60 @@
+# src/workpeg_sdk/run.py
+# import json
+import subprocess
+from pathlib import Path
+
+from workpeg_sdk.build import build_image
+from workpeg_sdk.config import load_config
+
+
+def resolve_runtime(with_runtime: str | None, config: dict) -> str:
+    if with_runtime:
+        return with_runtime
+    return config.get("runtime", {}).get("default") or "cracker"
+
+
+def run_with_docker(path: str = ".", build_first: bool = True) -> None:
+    project_path = Path(path).resolve()
+    cfg = load_config(project_path / "workpeg.json")
+    port = cfg.get("runtime", {}).get("docker", {}).get("port", 8000)
+
+    image = build_image(path) if build_first else (
+        cfg.get("build", {}).get("image") or project_path.name
+    )
+
+    subprocess.run(
+        [
+            "docker", "run", "--rm",
+            "-p", f"{port}:{port}",
+            image,
+            "workpeg", "runtime", "--server",
+        ],
+        check=True,
+    )
+
+
+def run_with_cracker(path: str = ".") -> None:
+    raise NotImplementedError("Cracker runtime is not implemented yet.")
+
+
+def main(argv=None) -> None:
+    import argparse
+
+    parser = argparse.ArgumentParser(prog="workpeg run")
+    parser.add_argument("--with", dest="with_runtime", choices=["docker", "cracker"])
+    parser.add_argument("--path", default=".")
+    parser.add_argument("--no-build", action="store_true")
+    args = parser.parse_args(argv or [])
+
+    cfg = load_config(Path(args.path) / "workpeg.json")
+    runtime = resolve_runtime(args.with_runtime, cfg)
+
+    if runtime == "docker":
+        run_with_docker(path=args.path, build_first=not args.no_build)
+        return
+
+    if runtime == "cracker":
+        run_with_cracker(path=args.path)
+        return
+
+    raise ValueError(f"Unsupported runtime: {runtime}")

workpeg-0.2.0/src/workpeg_sdk/runtime.py

@@ -0,0 +1,236 @@
+# src/workpeg_sdk/runtime.py
+
+import importlib
+import json
+import os
+import sys
+import traceback
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from typing import Any, Callable, Dict, Tuple
+
+
+DEFAULT_ENTRYPOINT = "app.main:main"
+DEFAULT_HOST = "0.0.0.0"
+DEFAULT_PORT = 8000
+
+
+class FunctionRuntimeError(Exception):
+    pass
+
+
+def _json_dump(obj: Any) -> str:
+    try:
+        return json.dumps(obj)
+    except TypeError as exc:
+        raise FunctionRuntimeError(
+            f"Function returned a non-JSON-serializable value: {exc}"
+        ) from exc
+
+
+def parse_entrypoint(entry: str) -> Tuple[str, str]:
+    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:
+    cwd = os.getcwd()
+    if cwd not in sys.path:
+        sys.path.insert(0, cwd)
+
+
+def load_function(entry: str | None = None):
+    _ensure_cwd_on_syspath()
+
+    entry = entry or os.getenv("FUNCTION_ENTRYPOINT", DEFAULT_ENTRYPOINT)
+    module_name, func_name = parse_entrypoint(entry)
+
+    importlib.invalidate_caches()
+
+    # Clear module + parent packages from cache
+    parts = module_name.split(".")
+    for i in range(len(parts), 0, -1):
+        candidate = ".".join(parts[:i])
+        sys.modules.pop(candidate, None)
+
+    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}' 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]:
+    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 invoke_function(
+    fn: Callable[[Dict[str, Any], Dict[str, Any]], Any],
+    request: Dict[str, Any],
+) -> Tuple[Dict[str, Any], int]:
+    try:
+        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)
+        return {"status": "success", "result": result}, 0
+
+    except FunctionRuntimeError as e:
+        return {
+            "status": "error",
+            "error_type": "runtime_error",
+            "error": str(e),
+        }, 1
+
+    except Exception as e:
+        trace = traceback.format_exc()
+        return {
+            "status": "error",
+            "error_type": "user_error",
+            "error": str(e),
+            "trace": trace,
+        }, 1
+
+
+def run_once(entrypoint: str | None = None) -> int:
+    try:
+        fn = load_function(entrypoint)
+        request = read_request()
+
+        response, exit_code = invoke_function(fn, request)
+
+        print(_json_dump(response), flush=True)
+        return exit_code
+
+    except FunctionRuntimeError as e:
+        err_output = {
+            "status": "error",
+            "error_type": "runtime_error",
+            "error": str(e),
+        }
+        print(_json_dump(err_output), flush=True)
+        print(f"[workpeg runtime] runtime_error: {e}", file=sys.stderr)
+        return 1
+
+    except Exception as e:
+        trace = traceback.format_exc()
+        err_output = {
+            "status": "error",
+            "error_type": "user_error",
+            "error": str(e),
+            "trace": trace,
+        }
+        print(_json_dump(err_output), flush=True)
+        print(f"[workpeg runtime] user_error: {e}\n{trace}", file=sys.stderr)
+        return 1
+
+
+def serve(host: str = DEFAULT_HOST,
+          port: int = DEFAULT_PORT,
+          entrypoint: str | None = None) -> None:
+    fn = load_function(entrypoint)
+
+    class Handler(BaseHTTPRequestHandler):
+        def _send_json(self, status_code: int, payload: Dict[str, Any]) -> None:
+            body = _json_dump(payload).encode("utf-8")
+            self.send_response(status_code)
+            self.send_header("Content-Type", "application/json")
+            self.send_header("Content-Length", str(len(body)))
+            self.end_headers()
+            self.wfile.write(body)
+
+        def do_GET(self) -> None:
+            if self.path == "/healthz":
+                self._send_json(200, {"status": "ok"})
+                return
+            self._send_json(404, {"status": "error", "error": "Not found"})
+
+        def do_POST(self) -> None:
+            if self.path != "/invoke":
+                self._send_json(404, {"status": "error", "error": "Not found"})
+                return
+
+            try:
+                content_length = int(self.headers.get("Content-Length", "0"))
+                raw = self.rfile.read(content_length).decode("utf-8")
+                request = json.loads(raw)
+
+                if not isinstance(request, dict):
+                    raise FunctionRuntimeError("Input JSON must be a JSON object.")
+
+                response, exit_code = invoke_function(fn, request)
+                self._send_json(200 if exit_code == 0 else 400, response)
+
+            except json.JSONDecodeError as exc:
+                self._send_json(
+                    400,
+                    {
+                        "status": "error",
+                        "error_type": "runtime_error",
+                        "error": f"Invalid JSON input: {exc}",
+                    },
+                )
+            except Exception as exc:
+                self._send_json(
+                    500,
+                    {
+                        "status": "error",
+                        "error_type": "runtime_error",
+                        "error": str(exc),
+                        "trace": traceback.format_exc(),
+                    },
+                )
+
+        def log_message(self, fmt: str, *args: Any) -> None:
+            print(f"[workpeg runtime] {fmt % args}", file=sys.stderr)
+
+    server = ThreadingHTTPServer((host, port), Handler)
+    print(f"[workpeg runtime] listening on http://{host}:{port}", file=sys.stderr)
+    server.serve_forever()
+
+
+def main(argv=None) -> None:
+    argv = argv or []
+    if "--server" in argv:
+        serve()
+        return
+
+    sys.exit(run_once())

{workpeg-0.1.4 → workpeg-0.2.0}/src/workpeg_sdk/templates/functions/Dockerfile

@@ -15,4 +15,4 @@ COPY app /app/app
 
 USER appuser
 
-ENTRYPOINT ["workpeg", "runtime"]
+ENTRYPOINT ["workpeg", "runtime", "--server"]

workpeg-0.2.0/tests/test_build.py

@@ -0,0 +1,76 @@
+# from pathlib import Path
+
+from workpeg_sdk import build
+
+
+def test_slugify():
+    assert build.slugify("My_Function.1") == "my-function-1"
+
+
+def test_default_image_name(tmp_path):
+    project = tmp_path / "My Project"
+    project.mkdir()
+    assert build.default_image_name(project) == "workpeg-fn-my-project"
+
+
+def test_build_image_uses_default_name(monkeypatch, tmp_path):
+    project = tmp_path / "demo"
+    project.mkdir()
+    (project / "workpeg.json").write_text("{}")
+
+    calls = []
+
+    def fake_run(cmd, check):
+        calls.append((cmd, check))
+
+    monkeypatch.setattr(build.subprocess, "run", fake_run)
+
+    image = build.build_image(path=str(project))
+    assert image == "workpeg-fn-demo"
+
+    assert len(calls) == 1
+    cmd, check = calls[0]
+    assert cmd == ["docker", "build", "-t", "workpeg-fn-demo", str(project.resolve())]
+    assert check is True
+
+
+def test_build_image_uses_explicit_tag(monkeypatch, tmp_path):
+    project = tmp_path / "demo"
+    project.mkdir()
+    (project / "workpeg.json").write_text("{}")
+
+    calls = []
+
+    def fake_run(cmd, check):
+        calls.append((cmd, check))
+
+    monkeypatch.setattr(build.subprocess, "run", fake_run)
+
+    image = build.build_image(path=str(project), tag="custom-image")
+    assert image == "custom-image"
+
+    cmd, check = calls[0]
+    assert cmd == ["docker", "build", "-t", "custom-image", str(project.resolve())]
+    assert check is True
+
+
+def test_build_image_uses_config_image(monkeypatch, tmp_path):
+    project = tmp_path / "demo"
+    project.mkdir()
+    (project / "workpeg.json").write_text(
+        '{"build": {"image": "configured-image"}}'
+    )
+
+    calls = []
+
+    def fake_run(cmd, check):
+        calls.append((cmd, check))
+
+    monkeypatch.setattr(build.subprocess, "run", fake_run)
+
+    image = build.build_image(path=str(project))
+    assert image == "configured-image"
+
+    cmd, check = calls[0]
+    assert cmd == ["docker", "build", "-t", "configured-image", str(project.resolve())]
+    assert check is True