workpeg 0.4.2__tar.gz → 0.5.0__tar.gz

{workpeg-0.4.2/src/workpeg.egg-info → workpeg-0.5.0}/PKG-INFO

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

{workpeg-0.4.2 → workpeg-0.5.0}/pyproject.toml

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

workpeg-0.5.0/src/workpeg/cli.py

@@ -0,0 +1,373 @@
+import argparse
+import sys
+
+from workpeg import build, create_new, run, runtime, submit
+
+try:
+    from importlib.metadata import version
+    __version__ = version("workpeg")
+except Exception:
+    __version__ = "unknown"
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="workpeg",
+        description=(
+            "Workpeg CLI\n\n"
+            "Build, run, and deploy Workpeg workloads."
+        ),
+        formatter_class=argparse.RawTextHelpFormatter,
+        epilog=(
+            "Examples:\n"
+            "  workpeg function new hello\n"
+            "  workpeg function build\n"
+            "  workpeg function run --with docker\n"
+            "\n"
+            "Use 'workpeg <namespace> --help' for more information.\n"
+        ),
+    )
+
+    p.add_argument(
+        "-v",
+        "--version",
+        action="version",
+        version=f"workpeg {__version__}",
+    )
+
+    root_sub = p.add_subparsers(
+        dest="namespace",
+        metavar="{function}",
+    )
+
+    #
+    # FUNCTION NAMESPACE
+    #
+    function_p = root_sub.add_parser(
+        "function",
+        help="Manage Workpeg Functions",
+        description=(
+            "Manage Workpeg Functions.\n\n"
+            "Functions are portable execution units that run\n"
+            "inside isolated runtimes such as Docker and\n"
+            "future Firecracker microVM runtimes."
+        ),
+        formatter_class=argparse.RawTextHelpFormatter,
+        epilog=(
+            "Examples:\n"
+            "  workpeg function new hello\n"
+            "  workpeg function build\n"
+            "  workpeg function run --with docker\n"
+            "  workpeg function runtime --server\n"
+            "  workpeg function submit hello:1.0.0\n"
+        ),
+    )
+
+    function_p.set_defaults(_namespace_parser=function_p)
+
+    function_sub = function_p.add_subparsers(
+        dest="command",
+        metavar="{new,build,run,runtime,submit}",
+    )
+
+    #
+    # FUNCTION NEW
+    #
+    new_p = function_sub.add_parser(
+        "new",
+        help="Create a new function project",
+        description=(
+            "Create a new Workpeg Function project scaffold.\n\n"
+            "Generated structure includes:\n"
+            "  - app/main.py\n"
+            "  - workpeg.json\n"
+            "  - Dockerfile\n"
+            "  - tests/\n"
+        ),
+        formatter_class=argparse.RawTextHelpFormatter,
+        epilog=(
+            "Examples:\n"
+            "  workpeg function new hello\n"
+            "  workpeg function new hello --force\n"
+        ),
+    )
+
+    new_p.add_argument(
+        "path",
+        help="Directory path for the new function project",
+    )
+
+    new_p.add_argument(
+        "--force",
+        action="store_true",
+        help="Overwrite existing files if the directory already exists",
+    )
+
+    new_p.set_defaults(_handler="function.new")
+
+    #
+    # FUNCTION RUNTIME
+    #
+    runtime_p = function_sub.add_parser(
+        "runtime",
+        help="Run the raw function runtime",
+        description=(
+            "Run the low-level Workpeg runtime.\n\n"
+            "Default mode:\n"
+            "  Reads a single invocation from stdin.\n\n"
+            "Server mode:\n"
+            "  Starts a persistent HTTP runtime."
+        ),
+        formatter_class=argparse.RawTextHelpFormatter,
+        epilog=(
+            "Examples:\n"
+            "  echo '{\"context\": {}, \"payload\": {}}' | \\\n"
+            "    workpeg function runtime\n\n"
+            "  workpeg function runtime --server\n"
+        ),
+    )
+
+    runtime_p.add_argument(
+        "--server",
+        action="store_true",
+        help="Run as a persistent HTTP server",
+    )
+
+    runtime_p.set_defaults(_handler="function.runtime")
+
+    #
+    # FUNCTION BUILD
+    #
+    build_p = function_sub.add_parser(
+        "build",
+        help="Build the function Docker image",
+        description=(
+            "Build a Docker image for the current function project."
+        ),
+        formatter_class=argparse.RawTextHelpFormatter,
+        epilog=(
+            "Examples:\n"
+            "  workpeg function build\n"
+            "  workpeg function build --tag my-image\n"
+        ),
+    )
+
+    build_p.add_argument(
+        "--path",
+        default=".",
+        help="Path to the function project (default: current directory)",
+    )
+
+    build_p.add_argument(
+        "--tag",
+        default=None,
+        help="Custom Docker image tag",
+    )
+
+    build_p.set_defaults(_handler="function.build")
+
+    #
+    # FUNCTION RUN
+    #
+    run_p = function_sub.add_parser(
+        "run",
+        help="Run the function using a configured runtime",
+        description=(
+            "Run a Workpeg Function locally.\n\n"
+            "Docker runtime:\n"
+            "  Starts a warm containerized runtime.\n\n"
+            "Cracker runtime:\n"
+            "  Reserved for future Firecracker microVM support."
+        ),
+        formatter_class=argparse.RawTextHelpFormatter,
+        epilog=(
+            "Examples:\n"
+            "  workpeg function run --with docker\n"
+            "  workpeg function run --network workpeg_net\n"
+            "  workpeg function run --name fn-hello\n"
+            "  workpeg function run --no-expose\n"
+        ),
+    )
+
+    run_p.add_argument(
+        "--with",
+        dest="with_runtime",
+        choices=["docker", "cracker"],
+        help="Runtime backend to use",
+    )
+
+    run_p.add_argument(
+        "--path",
+        default=".",
+        help="Path to the function project",
+    )
+
+    run_p.add_argument(
+        "--no-build",
+        action="store_true",
+        help="Skip Docker image build step",
+    )
+
+    run_p.add_argument(
+        "--network",
+        default=None,
+        help="Docker network to attach the container to",
+    )
+
+    run_p.add_argument(
+        "--name",
+        default=None,
+        help="Container name",
+    )
+
+    run_p.add_argument(
+        "--no-expose",
+        action="store_true",
+        help="Do not expose the runtime port to the host",
+    )
+
+    run_p.set_defaults(_handler="function.run")
+
+    #
+    # FUNCTION SUBMIT
+    #
+    submit_p = function_sub.add_parser(
+        "submit",
+        help="Submit a function bundle",
+        description=(
+            "Package and upload a Workpeg Function to the registry."
+        ),
+        formatter_class=argparse.RawTextHelpFormatter,
+        epilog=(
+            "Examples:\n"
+            "  workpeg function submit hello:1.0.0\n"
+            "  workpeg function submit hello:1.0.0 --timeout 30\n"
+        ),
+    )
+
+    submit_p.add_argument(
+        "ref",
+        help="Function reference in format <name>:<version>",
+    )
+
+    submit_p.add_argument(
+        "--api",
+        default=None,
+        help="Override Workpeg registry API base URL",
+    )
+
+    submit_p.add_argument(
+        "--path",
+        default=None,
+        help="Path to the function project",
+    )
+
+    submit_p.add_argument(
+        "--timeout",
+        type=int,
+        default=None,
+        help="HTTP request timeout in seconds",
+    )
+
+    submit_p.set_defaults(_handler="function.submit")
+
+    return p
+
+
+def main(argv=None) -> None:
+    argv = argv if argv is not None else sys.argv[1:]
+    parser = build_parser()
+
+    if not argv:
+        parser.print_help()
+        return
+
+    args = parser.parse_args(argv)
+
+    if not hasattr(args, "_handler"):
+        parser.print_help()
+        return
+
+    #
+    # function new
+    #
+    if args._handler == "function.new":
+        try:
+            out = create_new.create_new_project(
+                args.path,
+                force=args.force,
+            )
+            print(str(out))
+        except create_new.TemplateError as e:
+            print(f"ERROR: {e}", file=sys.stderr)
+            raise SystemExit(2)
+        return
+
+    #
+    # function runtime
+    #
+    if args._handler == "function.runtime":
+        runtime_argv = []
+
+        if args.server:
+            runtime_argv.append("--server")
+
+        runtime.main(runtime_argv)
+        return
+
+    #
+    # function submit
+    #
+    if args._handler == "function.submit":
+        submit_argv = [args.ref]
+
+        if args.api:
+            submit_argv += ["--api", args.api]
+
+        if args.path:
+            submit_argv += ["--path", args.path]
+
+        if args.timeout is not None:
+            submit_argv += ["--timeout", str(args.timeout)]
+
+        submit.main(submit_argv)
+        return
+
+    #
+    # function build
+    #
+    if args._handler == "function.build":
+        image = build.build_image(
+            path=args.path,
+            tag=args.tag,
+        )
+
+        print(image)
+        return
+
+    #
+    # function run
+    #
+    if args._handler == "function.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")
+
+        if args.network:
+            run_argv += ["--network", args.network]
+
+        if args.name:
+            run_argv += ["--name", args.name]
+
+        if args.no_expose:
+            run_argv.append("--no-expose")
+
+        run.main(run_argv)
+        return

{workpeg-0.4.2 → workpeg-0.5.0}/src/workpeg/run.py

@@ -27,7 +27,7 @@ def run_with_docker(
         cfg.get("build", {}).get("image") or project_path.name
     )
 
-    cmd = ["docker", "run", "--rm"]
+    cmd = ["docker", "run", "-d"]
 
     if name:
         cmd += ["--name", name]
@@ -38,6 +38,8 @@ def run_with_docker(
     if network:
         cmd += ["--network", network]
 
+    cmd += ["--restart", "unless-stopped"]
+
     cmd.append(image)
 
     subprocess.run(cmd, check=True)

workpeg-0.5.0/src/workpeg/utils.py

@@ -0,0 +1,10 @@
+def get_hook_urn(hook_name: str) -> str:
+    # move to workpeg SDK
+    """Convert a hook name to a valid Python method name."""
+    # remove "custom." prefix if it exists
+    urn = hook_name[len("custom."):] if str(
+        hook_name).startswith("custom.") else str(hook_name)
+
+    urn = urn.replace(":", "_").lower()
+
+    return f"http://{urn}:8000"

{workpeg-0.4.2 → workpeg-0.5.0/src/workpeg.egg-info}/PKG-INFO

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

{workpeg-0.4.2 → workpeg-0.5.0}/src/workpeg.egg-info/SOURCES.txt

@@ -11,6 +11,7 @@ src/workpeg/create_new.py
 src/workpeg/run.py
 src/workpeg/runtime.py
 src/workpeg/submit.py
+src/workpeg/utils.py
 src/workpeg.egg-info/PKG-INFO
 src/workpeg.egg-info/SOURCES.txt
 src/workpeg.egg-info/dependency_links.txt
@@ -30,4 +31,5 @@ tests/test_context.py
 tests/test_create_new.py
 tests/test_run.py
 tests/test_runtime.py
-tests/test_submit.py
+tests/test_submit.py
+tests/test_utils.py

{workpeg-0.4.2 → workpeg-0.5.0}/tests/test_cli.py

@@ -3,11 +3,20 @@ import pytest
 from workpeg import cli
 
 
-def test_cli_no_args_prints_help(monkeypatch, capsys):
+def test_cli_no_args_prints_help(capsys):
     cli.main([])
 
     captured = capsys.readouterr()
     assert "usage: workpeg" in captured.out
+    assert "function" in captured.out
+
+
+def test_cli_function_no_args_prints_help(capsys):
+    cli.main(["function"])
+
+    captured = capsys.readouterr()
+    assert "usage: workpeg" in captured.out
+    assert "function" in captured.out
 
 
 def test_cli_version_long(capsys):
@@ -28,34 +37,34 @@ def test_cli_version_short(capsys):
     assert captured.out.strip().startswith("workpeg ")
 
 
-def test_cli_new_function_success(monkeypatch, capsys):
+def test_cli_function_new_success(monkeypatch, capsys):
     monkeypatch.setattr(
         cli.create_new,
         "create_new_project",
         lambda path, force=False: "/tmp/output",
     )
 
-    cli.main(["new-function", "foo"])
+    cli.main(["function", "new", "foo"])
 
     out = capsys.readouterr().out.strip()
     assert out == "/tmp/output"
 
 
-def test_cli_new_function_template_error(monkeypatch, capsys):
+def test_cli_function_new_template_error(monkeypatch, capsys):
     def fake_create(path, force=False):
         raise cli.create_new.TemplateError("boom")
 
     monkeypatch.setattr(cli.create_new, "create_new_project", fake_create)
 
     with pytest.raises(SystemExit) as exc:
-        cli.main(["new-function", "foo"])
+        cli.main(["function", "new", "foo"])
 
     assert exc.value.code == 2
     err = capsys.readouterr().err
     assert "ERROR: boom" in err
 
 
-def test_cli_runtime_default(monkeypatch):
+def test_cli_function_runtime_default(monkeypatch):
     called = {}
 
     def fake_runtime_main(argv):
@@ -63,11 +72,11 @@ def test_cli_runtime_default(monkeypatch):
 
     monkeypatch.setattr(cli.runtime, "main", fake_runtime_main)
 
-    cli.main(["runtime"])
+    cli.main(["function", "runtime"])
     assert called["argv"] == []
 
 
-def test_cli_runtime_server(monkeypatch):
+def test_cli_function_runtime_server(monkeypatch):
     called = {}
 
     def fake_runtime_main(argv):
@@ -75,11 +84,11 @@ def test_cli_runtime_server(monkeypatch):
 
     monkeypatch.setattr(cli.runtime, "main", fake_runtime_main)
 
-    cli.main(["runtime", "--server"])
+    cli.main(["function", "runtime", "--server"])
     assert called["argv"] == ["--server"]
 
 
-def test_cli_submit(monkeypatch):
+def test_cli_function_submit(monkeypatch):
     called = {}
 
     def fake_submit_main(argv):
@@ -88,6 +97,7 @@ def test_cli_submit(monkeypatch):
     monkeypatch.setattr(cli.submit, "main", fake_submit_main)
 
     cli.main([
+        "function",
         "submit",
         "fn_echo:1.0.0",
         "--api", "https://repo.workpeg.com",
@@ -103,20 +113,20 @@ def test_cli_submit(monkeypatch):
     ]
 
 
-def test_cli_build(monkeypatch, capsys):
+def test_cli_function_build(monkeypatch, capsys):
     monkeypatch.setattr(
         cli.build,
         "build_image",
         lambda path=".", tag=None: "built-image",
     )
 
-    cli.main(["build"])
+    cli.main(["function", "build"])
 
     out = capsys.readouterr().out.strip()
     assert out == "built-image"
 
 
-def test_cli_build_with_args(monkeypatch, capsys):
+def test_cli_function_build_with_args(monkeypatch, capsys):
     called = {}
 
     def fake_build_image(path=".", tag=None):
@@ -126,14 +136,19 @@ def test_cli_build_with_args(monkeypatch, capsys):
 
     monkeypatch.setattr(cli.build, "build_image", fake_build_image)
 
-    cli.main(["build", "--path", "/tmp/demo", "--tag", "custom-image"])
+    cli.main([
+        "function",
+        "build",
+        "--path", "/tmp/demo",
+        "--tag", "custom-image",
+    ])
 
     assert called == {"path": "/tmp/demo", "tag": "custom-image"}
     out = capsys.readouterr().out.strip()
     assert out == "custom-image"
 
 
-def test_cli_run(monkeypatch):
+def test_cli_function_run(monkeypatch):
     called = {}
 
     def fake_run_main(argv):
@@ -142,11 +157,14 @@ def test_cli_run(monkeypatch):
     monkeypatch.setattr(cli.run, "main", fake_run_main)
 
     cli.main([
+        "function",
         "run",
         "--with", "docker",
         "--path", "/tmp/demo",
         "--no-build",
         "--network", "workpeg_net",
+        "--name", "foo",
+        "--no-expose",
     ])
 
     assert called["argv"] == [
@@ -154,4 +172,6 @@ def test_cli_run(monkeypatch):
         "--path", "/tmp/demo",
         "--no-build",
         "--network", "workpeg_net",
+        "--name", "foo",
+        "--no-expose",
     ]

{workpeg-0.4.2 → workpeg-0.5.0}/tests/test_create_new.py

@@ -6,7 +6,7 @@ def test_create_new_copies_template(tmp_path):
     project_dir = tmp_path / "my-func"
 
     result = subprocess.run(
-        ["workpeg", "new-function", str(project_dir)],
+        ["workpeg", "function", "new", str(project_dir)],
         text=True,
         capture_output=True,
         cwd=tmp_path,
@@ -19,8 +19,7 @@ def test_create_new_copies_template(tmp_path):
     assert (project_dir / "app" / "main.py").exists()
 
     template_pkg = "workpeg.templates.functions.app"
-    template_main = pkg_resources.files(
-        template_pkg).joinpath("main.py").read_text()
+    template_main = pkg_resources.files(template_pkg).joinpath("main.py").read_text()
 
     created_main = (project_dir / "app" / "main.py").read_text()
     assert created_main == template_main
@@ -33,7 +32,7 @@ def test_create_new_refuses_overwrite_without_force(tmp_path):
     (project_dir / "app" / "main.py").write_text("existing")
 
     result = subprocess.run(
-        ["workpeg", "new-function", str(project_dir)],
+        ["workpeg", "function", "new", str(project_dir)],
         text=True,
         capture_output=True,
         cwd=tmp_path,
@@ -50,7 +49,7 @@ def test_create_new_overwrites_with_force(tmp_path):
     (project_dir / "app" / "main.py").write_text("existing")
 
     result = subprocess.run(
-        ["workpeg", "new-function", str(project_dir), "--force"],
+        ["workpeg", "function", "new", str(project_dir), "--force"],
         text=True,
         capture_output=True,
         cwd=tmp_path,

{workpeg-0.4.2 → workpeg-0.5.0}/tests/test_run.py

@@ -38,14 +38,19 @@ def test_run_with_docker_builds_first(monkeypatch, tmp_path):
 
     monkeypatch.setattr(run.subprocess, "run", fake_run)
 
-    run.run_with_docker(path=str(project), build_first=True, network="workpeg_net")
+    run.run_with_docker(
+        path=str(project),
+        build_first=True,
+        network="workpeg_net",
+    )
 
     assert len(calls) == 1
     cmd, check = calls[0]
     assert cmd == [
-        "docker", "run", "--rm",
+        "docker", "run", "-d",
         "-p", "9000:9000",
         "--network", "workpeg_net",
+        "--restart", "unless-stopped",
         "built-image",
     ]
     assert check is True
@@ -55,7 +60,8 @@ def test_run_with_docker_no_build(monkeypatch, tmp_path):
     project = tmp_path / "demo"
     project.mkdir()
     (project / "workpeg.json").write_text(
-        '{"build": {"image": "configured-image"}, "runtime": {"docker": {"port": 8000}}}'
+        '{"build": {"image": "configured-image"}, '
+        '"runtime": {"docker": {"port": 8000}}}'
     )
 
     calls = []
@@ -65,13 +71,18 @@ def test_run_with_docker_no_build(monkeypatch, tmp_path):
 
     monkeypatch.setattr(run.subprocess, "run", fake_run)
 
-    run.run_with_docker(path=str(project), build_first=False, network="bridge")
+    run.run_with_docker(
+        path=str(project),
+        build_first=False,
+        network="bridge",
+    )
 
     cmd, check = calls[0]
     assert cmd == [
-        "docker", "run", "--rm",
+        "docker", "run", "-d",
         "-p", "8000:8000",
         "--network", "bridge",
+        "--restart", "unless-stopped",
         "configured-image",
     ]
     assert check is True
@@ -80,10 +91,18 @@ def test_run_with_docker_no_build(monkeypatch, tmp_path):
 def test_run_main_with_docker(monkeypatch):
     called = {}
 
-    def fake_run_with_docker(path=".", build_first=True, network=None):
+    def fake_run_with_docker(
+        path=".",
+        build_first=True,
+        network=None,
+        expose=True,
+        name=None,
+    ):
         called["path"] = path
         called["build_first"] = build_first
         called["network"] = network
+        called["expose"] = expose
+        called["name"] = name
 
     monkeypatch.setattr(run, "run_with_docker", fake_run_with_docker)
 
@@ -93,6 +112,8 @@ def test_run_main_with_docker(monkeypatch):
         "path": "/tmp/demo",
         "build_first": False,
         "network": None,
+        "expose": True,
+        "name": None,
     }
 
 
@@ -118,10 +139,18 @@ def test_run_main_uses_config_default(monkeypatch, tmp_path):
 
     called = {}
 
-    def fake_run_with_docker(path=".", build_first=True, network=None):
+    def fake_run_with_docker(
+        path=".",
+        build_first=True,
+        network=None,
+        expose=True,
+        name=None,
+    ):
         called["path"] = path
         called["build_first"] = build_first
         called["network"] = network
+        called["expose"] = expose
+        called["name"] = name
 
     monkeypatch.setattr(run, "run_with_docker", fake_run_with_docker)
 
@@ -131,16 +160,26 @@ def test_run_main_uses_config_default(monkeypatch, tmp_path):
         "path": str(project),
         "build_first": True,
         "network": None,
+        "expose": True,
+        "name": None,
     }
 
 
 def test_run_main_with_docker_and_network(monkeypatch):
     called = {}
 
-    def fake_run_with_docker(path=".", build_first=True, network=None):
+    def fake_run_with_docker(
+        path=".",
+        build_first=True,
+        network=None,
+        expose=True,
+        name=None,
+    ):
         called["path"] = path
         called["build_first"] = build_first
         called["network"] = network
+        called["expose"] = expose
+        called["name"] = name
 
     monkeypatch.setattr(run, "run_with_docker", fake_run_with_docker)
 
@@ -154,6 +193,8 @@ def test_run_main_with_docker_and_network(monkeypatch):
         "path": "/tmp/demo",
         "build_first": True,
         "network": "workpeg_net",
+        "expose": True,
+        "name": None,
     }
 
 
@@ -171,12 +212,17 @@ def test_run_with_docker_no_expose(monkeypatch, tmp_path):
 
     monkeypatch.setattr(run.subprocess, "run", fake_run)
 
-    run.run_with_docker(path=str(project), build_first=False, expose=False)
+    run.run_with_docker(
+        path=str(project),
+        build_first=False,
+        expose=False,
+    )
 
     assert len(calls) == 1
     cmd, check = calls[0]
     assert cmd == [
-        "docker", "run", "--rm",
+        "docker", "run", "-d",
+        "--restart", "unless-stopped",
         "demo",
     ]
     assert check is True
@@ -196,12 +242,17 @@ def test_run_with_docker_expose(monkeypatch, tmp_path):
 
     monkeypatch.setattr(run.subprocess, "run", fake_run)
 
-    run.run_with_docker(path=str(project), build_first=False, expose=True)
+    run.run_with_docker(
+        path=str(project),
+        build_first=False,
+        expose=True,
+    )
 
     cmd, check = calls[0]
     assert cmd == [
-        "docker", "run", "--rm",
+        "docker", "run", "-d",
         "-p", "9000:9000",
+        "--restart", "unless-stopped",
         "demo",
     ]
     assert check is True
@@ -232,8 +283,9 @@ def test_run_with_docker_with_name(monkeypatch, tmp_path):
     cmd, check = calls[0]
 
     assert cmd == [
-        "docker", "run", "--rm",
+        "docker", "run", "-d",
         "--name", "foo",
+        "--restart", "unless-stopped",
         "demo",
     ]
     assert check is True
@@ -264,9 +316,10 @@ def test_run_with_docker_name_and_network(monkeypatch, tmp_path):
     cmd, check = calls[0]
 
     assert cmd == [
-        "docker", "run", "--rm",
+        "docker", "run", "-d",
         "--name", "foo",
         "--network", "workpeg_net",
+        "--restart", "unless-stopped",
         "demo",
     ]
     assert check is True

workpeg-0.5.0/tests/test_utils.py

@@ -0,0 +1,46 @@
+from unittest import TestCase
+
+from workpeg.utils import get_hook_urn
+
+
+class TestGetHookUrn(TestCase):
+
+    def test_returns_hook_urn(self):
+        result = get_hook_urn("mail_sanitizer:v1")
+
+        self.assertEqual(
+            result,
+            "http://mail_sanitizer_v1:8000",
+        )
+
+    def test_removes_custom_prefix(self):
+        result = get_hook_urn("custom.mail_sanitizer:v1")
+
+        self.assertEqual(
+            result,
+            "http://mail_sanitizer_v1:8000",
+        )
+
+    def test_lowercases_hook_name(self):
+        result = get_hook_urn("Mail_Sanitizer:V1")
+
+        self.assertEqual(
+            result,
+            "http://mail_sanitizer_v1:8000",
+        )
+
+    def test_replaces_colon_with_underscore(self):
+        result = get_hook_urn("calendar:1.1")
+
+        self.assertEqual(
+            result,
+            "http://calendar_1.1:8000",
+        )
+
+    def test_handles_hook_without_version(self):
+        result = get_hook_urn("mailer")
+
+        self.assertEqual(
+            result,
+            "http://mailer:8000",
+        )

workpeg-0.4.2/src/workpeg/cli.py

@@ -1,118 +0,0 @@
-import argparse
-import sys
-
-from workpeg import create_new, runtime, submit, build, run
-
-try:
-    from importlib.metadata import version
-    __version__ = version("workpeg")
-except Exception:
-    __version__ = "unknown"
-
-
-def build_parser() -> argparse.ArgumentParser:
-    p = argparse.ArgumentParser(
-        prog="workpeg",
-        description="Workpeg CLI",
-    )
-
-    # version flag
-    p.add_argument(
-        "-v", "--version",
-        action="version",
-        version=f"workpeg {__version__}",
-    )
-
-    # IMPORTANT: no required=True
-    sub = p.add_subparsers(dest="command")
-
-    # submit
-    submit_p = sub.add_parser("submit", help="Submit a function bundle")
-    submit_p.add_argument("ref")
-    submit_p.add_argument("--api", default=None)
-    submit_p.add_argument("--path", default=None)
-    submit_p.add_argument("--timeout", type=int, default=None)
-    submit_p.set_defaults(_handler="submit")
-
-    # new-function
-    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")
-
-    # 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
-    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
-    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.add_argument("--network", default=None)
-    run_p.set_defaults(_handler="run")
-
-    return p
-
-
-def main(argv=None) -> None:
-    argv = argv if argv is not None else sys.argv[1:]
-    parser = build_parser()
-
-    if not argv:
-        parser.print_help()
-        return
-
-    args = parser.parse_args(argv)
-
-    if args._handler == "new-function":
-        try:
-            out = create_new.create_new_project(args.path, force=args.force)
-            print(str(out))
-        except create_new.TemplateError as e:
-            print(f"ERROR: {e}", file=sys.stderr)
-            raise SystemExit(2)
-        return
-
-    if args._handler == "runtime":
-        runtime_argv = []
-        if args.server:
-            runtime_argv.append("--server")
-        runtime.main(runtime_argv)
-        return
-
-    if args._handler == "submit":
-        submit_argv = [args.ref]
-        if args.api:
-            submit_argv += ["--api", args.api]
-        if args.path:
-            submit_argv += ["--path", args.path]
-        if args.timeout is not 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")
-        if args.network:
-            run_argv += ["--network", args.network]
-        run.main(run_argv)
-        return