linkinpy 0.0.1__py3-none-any.whl

linkinpy/__init__.py

@@ -0,0 +1,63 @@
+from .colab import (
+    choose_colab_spec,
+    install_colab_spec,
+    installed_colab_specs,
+    launch_colab,
+    mount_google_drive,
+    run_installed_colab_method,
+)
+from .environment import EnvironmentManager, ensure_uv, find_uv
+from .images import (
+    SharedArray,
+    attach_shared_array,
+    create_shared_array,
+    read_image,
+    write_image,
+)
+from .linkinpy import LinkinPy
+from .runner import (
+    get_callable,
+    resolve_callable,
+    run_callable_in_process,
+    run_spec_callable,
+    run_spec_callable_in_environment,
+)
+from .spec import (
+    CallableSpec,
+    InputSpec,
+    LinkinPySpec,
+    PackageSpec,
+    SpecError,
+    load_spec,
+    parse_spec,
+)
+
+__all__ = [
+    "CallableSpec",
+    "EnvironmentManager",
+    "InputSpec",
+    "LinkinPy",
+    "LinkinPySpec",
+    "PackageSpec",
+    "SharedArray",
+    "SpecError",
+    "attach_shared_array",
+    "choose_colab_spec",
+    "create_shared_array",
+    "ensure_uv",
+    "find_uv",
+    "get_callable",
+    "install_colab_spec",
+    "installed_colab_specs",
+    "launch_colab",
+    "load_spec",
+    "mount_google_drive",
+    "parse_spec",
+    "read_image",
+    "resolve_callable",
+    "run_callable_in_process",
+    "run_installed_colab_method",
+    "run_spec_callable",
+    "run_spec_callable_in_environment",
+    "write_image",
+]

linkinpy/_shm.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+import argparse
+import json
+from typing import Optional
+
+from .images import create_empty_untracked_shared_array
+
+
+def main(argv: Optional[list[str]] = None) -> int:
+    parser = argparse.ArgumentParser(description="Internal LinkinPy shared-memory helper.")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    allocate = subparsers.add_parser("allocate", help="Allocate an untracked shared-memory array.")
+    allocate.add_argument("--shape", required=True, help="JSON list of dimensions.")
+    allocate.add_argument("--dtype", required=True)
+    allocate.add_argument("--axes")
+
+    args = parser.parse_args(argv)
+    if args.command == "allocate":
+        shape = json.loads(args.shape)
+        descriptor, block = create_empty_untracked_shared_array(shape, args.dtype, axes=args.axes)
+        block.close()
+        print(json.dumps(descriptor.to_descriptor()), flush=True)
+        return 0
+    return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

linkinpy/_testing.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+import numpy as np
+
+
+def add_one(x: float) -> float:
+    return x + 1
+
+
+def image_plus_one(image: np.ndarray) -> np.ndarray:
+    return image + 1
+
+
+def make_image() -> np.ndarray:
+    return np.arange(4, dtype=np.float32).reshape(2, 2)

linkinpy/_worker.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Optional
+
+import numpy as np
+
+from .images import create_untracked_shared_array, write_image
+from .runner import parse_cli_values, run_spec_callable
+from .spec import load_spec
+
+
+def main(argv: Optional[list[str]] = None) -> int:
+    parser = argparse.ArgumentParser(description="Internal LinkinPy worker.")
+    parser.add_argument("spec")
+    parser.add_argument("callable_name")
+    parser.add_argument("--output")
+    parser.add_argument("--transport", choices=("shared_memory", "disk"), default="shared_memory")
+    parser.add_argument("--wait-for-shm-release", action="store_true")
+    parser.add_argument("values", nargs="*")
+    args = parser.parse_args(argv)
+
+    spec = load_spec(args.spec)
+    values = parse_cli_values(args.values)
+    result = run_spec_callable(
+        spec,
+        args.callable_name,
+        values,
+        interface="cli",
+        output_path=args.output if args.transport == "disk" else None,
+        ensure_environment=False,
+    )
+    if args.transport == "shared_memory" and _is_image_like(result):
+        try:
+            shared, _block = create_untracked_shared_array(result)
+            print(json.dumps(shared.to_descriptor()))
+            sys.stdout.flush()
+            if args.wait_for_shm_release:
+                sys.stdin.readline()
+        except Exception as exc:
+            print(f"linkinpy: shared-memory output failed, falling back to disk: {exc}", file=sys.stderr)
+            if args.output is None:
+                raise
+            print(str(write_image(args.output, result)))
+    elif args.output is None:
+        print(json.dumps(_jsonable(result)))
+    else:
+        print(str(Path(args.output).expanduser().resolve()))
+    return 0
+
+
+def _jsonable(value: object) -> object:
+    if hasattr(value, "tolist"):
+        return value.tolist()
+    if isinstance(value, Path):
+        return str(value)
+    return value
+
+
+def _is_image_like(value: object) -> bool:
+    return isinstance(value, np.ndarray) or (hasattr(value, "shape") and hasattr(value, "dtype"))
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

linkinpy/cli.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+import argparse
+import subprocess
+import sys
+from typing import Optional
+
+from .environment import EnvironmentError, EnvironmentManager, format_requirements
+from .runner import RunnerError
+from .spec import SpecError, load_spec
+
+
+def main(argv: Optional[list[str]] = None) -> int:
+    parser = argparse.ArgumentParser(prog="linkinpy")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    install = subparsers.add_parser("install", help="Create/update the uv environment for a spec.")
+    install.add_argument("spec")
+    install.add_argument("--interface", default="cli")
+
+    list_cmd = subparsers.add_parser("list", help="List callable workflows declared by a spec.")
+    list_cmd.add_argument("spec")
+
+    run = subparsers.add_parser("run", help="Run a callable workflow inside its spec-owned environment.")
+    run.add_argument("spec")
+    run.add_argument("callable_name")
+    run.add_argument("--interface", default="cli")
+    run.add_argument("--output")
+    run.add_argument("--transport", choices=("shared_memory", "disk"), default="shared_memory")
+    run.add_argument("--wait-for-shm-release", action="store_true")
+    run.add_argument("values", nargs="*", help="Callable arguments as name=value.")
+
+    gui = subparsers.add_parser("gui", help="Launch a generated magicgui interface.")
+    gui.add_argument("spec")
+    gui.add_argument("callable_name")
+
+    args = parser.parse_args(argv)
+    try:
+        if args.command == "install":
+            return _install(args.spec, args.interface)
+        if args.command == "list":
+            return _list(args.spec)
+        if args.command == "run":
+            return _run(
+                args.spec,
+                args.callable_name,
+                args.interface,
+                args.output,
+                args.transport,
+                args.wait_for_shm_release,
+                args.values,
+            )
+        if args.command == "gui":
+            return _gui(args.spec, args.callable_name)
+    except (EnvironmentError, RunnerError, RuntimeError, SpecError) as exc:
+        print(f"linkinpy: {exc}", file=sys.stderr)
+        return 2
+    return 0
+
+
+def _install(spec_source: str, interface: str) -> int:
+    spec = load_spec(spec_source)
+    manager = EnvironmentManager(spec)
+    env_path = manager.ensure(interface, force=True)
+    requirements = format_requirements(spec.python_packages())
+    print(f"Environment: {env_path}")
+    print(f"Installed for {interface}: {', '.join(requirements) if requirements else '(LinkinPy core only)'}")
+    return 0
+
+
+def _list(spec_source: str) -> int:
+    spec = load_spec(spec_source)
+    print(spec.display_name)
+    for callable_spec in spec.callables.values():
+        display = callable_spec.display_name or callable_spec.name
+        print(f"- {callable_spec.name}: {display} ({callable_spec.callable})")
+    return 0
+
+
+def _run(
+    spec_source: str,
+    callable_name: str,
+    interface: str,
+    output: Optional[str],
+    transport: str,
+    wait_for_shm_release: bool,
+    values: list[str],
+) -> int:
+    spec = load_spec(spec_source)
+    manager = EnvironmentManager(spec)
+    manager.ensure(interface)
+    worker_args = ["-m", "linkinpy._worker", spec_source, callable_name, "--transport", transport, *values]
+    if output is not None:
+        worker_args[4:4] = ["--output", output]
+    if wait_for_shm_release:
+        worker_args[4:4] = ["--wait-for-shm-release"]
+        return _run_worker_with_release_handshake(manager, worker_args)
+    completed = manager.run_python(worker_args)
+    print(completed.stdout, end="")
+    if completed.stderr:
+        print(completed.stderr, file=sys.stderr, end="")
+    return completed.returncode
+
+
+def _run_worker_with_release_handshake(manager: EnvironmentManager, worker_args: list[str]) -> int:
+    command = [str(manager.python_executable), *worker_args]
+    process = subprocess.Popen(
+        command,
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+    )
+    assert process.stdout is not None
+    for line in process.stdout:
+        print(line, end="", flush=True)
+        if '"transport"' in line and '"shared_memory"' in line and process.stdin is not None:
+            sys.stdin.readline()
+            process.stdin.write("\n")
+            process.stdin.flush()
+    return process.wait()
+
+
+def _gui(spec_source: str, callable_name: str) -> int:
+    from .gui import launch_magicgui
+
+    spec = load_spec(spec_source)
+    launch_magicgui(spec, callable_name)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())