Experiment/recursive controller

.gitignore

@@ -1,4 +1,5 @@
 /target
+.idea
 
 # Byte-compiled / optimized / DLL files
 __pycache__/

python/.gitignore

@@ -1,2 +1 @@
 ./venv
-tierkreis/core/protos/

python/examples/launchers/numerical-worker

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+printf "\n\n------ NUMERICAL WORKER ------"
+
+LAUNCHER_DIR=$(dirname "$0")
+uv run "$LAUNCHER_DIR/../numerical-worker" $1

python/examples/numerical-worker/__main__.py

@@ -0,0 +1,96 @@
+import json
+from logging import getLogger
+from pathlib import Path
+from sys import argv
+
+from pydantic import BaseModel
+
+logger = getLogger(__name__)
+
+
+class NodeDefinition(BaseModel):
+    function_name: str
+    inputs: dict[str, Path]
+    outputs: dict[str, Path]
+    done_path: Path
+
+
+def iadd(a: int, b: int) -> int:
+    logger.debug(f"iadd {a} {b}")
+    return a + b
+
+
+def itimes(a: int, b: int) -> int:
+    logger.debug(f"itimes {a} {b}")
+    return a * b
+
+
+def igt(a: int, b: int) -> bool:
+    logger.debug(f"igt {a} {b}")
+    return a > b
+
+
+def run(node_definition: NodeDefinition):
+    logger.debug(node_definition)
+    if node_definition.function_name == "iadd":
+        with open(node_definition.inputs["a"], "rb") as fh:
+            a: int = json.loads(fh.read())
+        with open(node_definition.inputs["b"], "rb") as fh:
+            b: int = json.loads(fh.read())
+
+        c = iadd(a, b)
+
+        with open(node_definition.outputs["value"], "w+") as fh:
+            fh.write(json.dumps(c))
+
+    elif node_definition.function_name == "itimes":
+        with open(node_definition.inputs["a"], "rb") as fh:
+            a: int = json.loads(fh.read())
+        with open(node_definition.inputs["b"], "rb") as fh:
+            b: int = json.loads(fh.read())
+
+        c = itimes(a, b)
+
+        with open(node_definition.outputs["value"], "w+") as fh:
+            fh.write(json.dumps(c))
+
+    elif node_definition.function_name == "igt":
+        with open(node_definition.inputs["a"], "rb") as fh:
+            a: int = json.loads(fh.read())
+        with open(node_definition.inputs["b"], "rb") as fh:
+            b: int = json.loads(fh.read())
+
+        c = igt(a, b)
+
+        with open(node_definition.outputs["value"], "w+") as fh:
+            fh.write(json.dumps(c))
+
+    elif node_definition.function_name == "and":
+        with open(node_definition.inputs["a"], "rb") as fh:
+            a = json.loads(fh.read())
+        with open(node_definition.inputs["b"], "rb") as fh:
+            b = json.loads(fh.read())
+
+        c = a and b
+
+        with open(node_definition.outputs["value"], "w+") as fh:
+            fh.write(json.dumps(c))
+
+    elif node_definition.function_name == "id":
+        with open(node_definition.inputs["value"], "rb") as fh:
+            value = json.loads(fh.read())
+
+        with open(node_definition.outputs["value"], "w+") as fh:
+            fh.write(json.dumps(value))
+
+    else:
+        raise ValueError(f"function name {node_definition.function_name} not found")
+    node_definition.done_path.touch()
+
+
+if __name__ == "__main__":
+    worker_definition_path = argv[1]
+    with open(worker_definition_path, "r") as fh:
+        node_definition = NodeDefinition(**json.loads(fh.read()))
+
+    run(node_definition)

python/examples/numerical-worker/pyproject.toml

@@ -0,0 +1,7 @@
+[project]
+name = "numerical-worker"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.10, <3.13"
+dependencies = []

python/examples/sc22_example.py

@@ -30,14 +30,14 @@
 
 def runtime_client_from_args(args: list[str]) -> Optional[RuntimeClient]:
     if len(args) == 0:
-        import sc22_worker.main
+        import examples.sc22_worker.main
 
         import pytket_worker.main  # type: ignore
         from tierkreis.pyruntime import PyRuntime
 
         return PyRuntime(
             [
-                sc22_worker.main.root,
+                examples.sc22_worker.main.root,
                 pytket_worker.main.root,
             ]
         )

python/pyproject.toml

@@ -2,7 +2,7 @@
 name = "tierkreis"
 description = "Python client and utilities for tierkreis."
 readme = "README.md"
-dynamic = ["version"]
+version = "0.7.8"
 authors = [
     { name = "Seyon Sivarajah", email = "[email protected]" },
     { name = "Lukas Heidemann", email = "[email protected]" },
@@ -42,17 +42,9 @@ build = ["build[uv]"]
 [tool.pytest.ini_options]
 markers = ["pytket"]
 
-
 [build-system]
-requires = ["setuptools>=65.5.0", "betterproto[compiler]==2.0.0b6"]
-build-backend = "generate_protos"
-backend-path = ["tierkreis/_build"]
-
-[tool.setuptools.dynamic]
-version = { attr = "tierkreis._version.__version__" }
-
-[tool.setuptools.packages.find]
-include = ["tierkreis*", "tierkreis/py.typed"]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
 
 
 [tool.ruff]

python/tests/conftest.py

@@ -4,8 +4,8 @@
 
 import pytest
 from grpclib.client import Channel
-from test_worker import main
 
+from tests.test_worker import main
 from tierkreis.builder import Namespace
 from tierkreis.client.runtime_client import RuntimeClient
 from tierkreis.client.server_client import ServerRuntime

python/tests/controller/test_models.py

@@ -0,0 +1,42 @@
+import pytest
+
+from tierkreis.controller.models import NodeLocation
+
+node_location_1 = NodeLocation(location=[])
+node_location_1 = node_location_1.append_node(0)
+node_location_1 = node_location_1.append_loop(0)
+node_location_1 = node_location_1.append_node(3)
+node_location_1 = node_location_1.append_loop(2)
+node_location_1 = node_location_1.append_node(0)
+node_location_1 = node_location_1.append_map(8)
+node_location_1 = node_location_1.append_node(0)
+
+
+node_location_2 = NodeLocation(location=[])
+node_location_2 = node_location_2.append_node(0)
+node_location_2 = node_location_2.append_loop(0)
+node_location_2 = node_location_2.append_node(3)
+node_location_2 = node_location_2.append_node(8)
+node_location_2 = node_location_2.append_node(0)
+
+node_location_3 = NodeLocation(location=[])
+node_location_3 = node_location_3.append_node(0)
+
+node_location_4 = NodeLocation(location=[])
+
+
+@pytest.mark.parametrize(
+    ["node_location", "loc_str"],
+    [
+        (node_location_1, "N0.L0.N3.L2.N0.M8.N0"),
+        (node_location_2, "N0.L0.N3.N8.N0"),
+        (node_location_3, "N0"),
+        (node_location_4, ""),
+    ],
+)
+def test_to_from_str(node_location: NodeLocation, loc_str: str):
+    node_location_str = str(node_location)
+    assert node_location_str == loc_str
+
+    new_loc = NodeLocation.from_str(node_location_str)
+    assert new_loc == node_location

python/tests/controller/test_resume.py

@@ -0,0 +1,29 @@
+import json
+from pathlib import Path
+from uuid import UUID
+
+from tests.sample_graph import sample_graph_without_match
+from tierkreis.controller import run_graph
+from tierkreis.controller.executor.shell_executor import ShellExecutor
+from tierkreis.controller.models import NodeLocation
+from tierkreis.controller.storage.filestorage import ControllerFileStorage
+from tierkreis.core import Labels
+
+
+def test_resume_sample_graph():
+    g = sample_graph_without_match()
+    storage = ControllerFileStorage(UUID(int=0))
+    executor = ShellExecutor(
+        Path("./python/examples/launchers"), logs_path=storage.logs_path
+    )
+    inputs = {
+        "inp": json.dumps(4).encode(),
+        Labels.VALUE: json.dumps(2).encode(),
+        Labels.THUNK: g.to_proto().SerializeToString(),
+    }
+
+    storage.clean_graph_files()
+    run_graph(storage, executor, g, inputs)
+
+    c = storage.read_output(NodeLocation(location=[]), "loop_out")
+    assert c == b"6"

python/tests/sample_graph.py

@@ -66,3 +66,68 @@ def sample_graph() -> TierkreisGraph:
         )["value"],
     )
     return tg
+
+
+def sample_graph_without_match() -> TierkreisGraph:
+    def loop_graph() -> TierkreisGraph:
+        ifg = TierkreisGraph()
+        ifg.set_outputs(value=ifg.add_tag(Labels.BREAK, value=ifg.input["x"]))
+
+        elg = TierkreisGraph()
+        elg.set_outputs(
+            value=elg.add_tag(
+                Labels.CONTINUE,
+                value=elg.add_func(
+                    "numerical-worker.iadd", a=elg.input["x"], b=elg.add_const(1)
+                ),
+            )
+        )
+
+        tg = TierkreisGraph()
+        v1, v2 = tg.copy_value(tg.input["value"])
+        tg.set_outputs(
+            value=tg.add_func(
+                "eval",
+                thunk=tg.add_func(
+                    "switch",
+                    pred=tg.add_func("numerical-worker.igt", a=v1, b=tg.add_const(5)),
+                    if_true=tg.add_const(ifg),
+                    if_false=tg.add_const(elg),
+                ),
+                x=v2,
+            )["value"]
+        )
+        return tg
+
+    one_graph = TierkreisGraph()
+    one_graph.set_outputs(
+        value=one_graph.add_func(
+            "numerical-worker.iadd",
+            a=one_graph.input["value"],
+            b=one_graph.input["other"],
+        )
+    )
+    many_graph = TierkreisGraph()
+    many_graph.discard(many_graph.input["other"])
+    many_graph.set_outputs(
+        value=many_graph.add_func(
+            "numerical-worker.id", value=many_graph.input["value"]
+        )
+    )
+
+    tg = TierkreisGraph()
+    tg.set_outputs(
+        out=tg.input["inp"],
+        b=tg.add_func("numerical-worker.iadd", a=tg.add_const(1), b=tg.add_const(3)),
+        tag=tg.add_tag("boo", value=tg.add_const("world")),
+        add=tg.add_func(
+            "numerical-worker.iadd", a=tg.add_const(23), b=tg.add_const(123)
+        ),
+        _and=tg.add_func(
+            "numerical-worker.and", a=tg.add_const(True), b=tg.add_const(False)
+        ),
+        loop_out=tg.add_func(
+            "loop", body=tg.add_const(loop_graph()), value=tg.add_const(2)
+        )["value"],
+    )
+    return tg

python/tests/test_frontend.py

@@ -3,8 +3,8 @@
 from typing import Any, Dict, List, Optional, Tuple, Type
 
 import pytest
-from utils import nint_adder
 
+from tests.utils import nint_adder
 from tierkreis import TierkreisGraph
 from tierkreis.client import RuntimeClient
 from tierkreis.core.graphviz import _merge_copies

python/tests/test_generics.py

@@ -3,11 +3,11 @@
 
 import pydantic as pyd
 import pytest
-from test_worker.main import (
+
+from tests.test_worker.main import (
     MyGeneric,
     MyGenericList,
 )
-
 from tierkreis.builder import Const, Output, graph
 from tierkreis.client.runtime_client import RuntimeClient
 from tierkreis.core._internal import generic_origin

python/tests/test_pyruntime.py

@@ -1,6 +1,6 @@
 import pytest
-from sample_graph import sample_graph as sample_g
 
+from tests.sample_graph import sample_graph as sample_g
 from tierkreis.core.tierkreis_graph import TierkreisEdge, TierkreisGraph
 from tierkreis.core.values import TierkreisValue, VariantValue
 from tierkreis.pyruntime import PyRuntime

python/tests/test_variants.py

@@ -7,8 +7,8 @@
 
 import pydantic as pyd
 import pytest
-from test_worker.main import EmptyStruct, IntStruct, MyGeneric
 
+from tests.test_worker.main import EmptyStruct, IntStruct, MyGeneric
 from tierkreis.builder import Const, Output, UnionConst, graph
 from tierkreis.client.runtime_client import RuntimeClient
 from tierkreis.core.opaque_model import OpaqueModel

python/tierkreis/_build/generate_protos.py

@@ -1,13 +1,14 @@
 import glob
 import os
+from pathlib import Path
 import subprocess
 
 from setuptools import build_meta as default_backend  # type : ignore
 
 # PEP 517 / 518 local (aka in-tree) backend for pip/build/etc.
-# We expect to be run from the project root, i.e. python/
-PROTO_INPUT_DIR = "./protos"
-PROTO_OUTPUT_DIR = "./tierkreis/core/protos"
+tierkreis_python_dir = Path(__file__).parent.parent.parent
+PROTO_INPUT_DIR = str(tierkreis_python_dir / "protos")
+PROTO_OUTPUT_DIR = str(tierkreis_python_dir / "tierkreis/core/protos")
 
 
 def generate_proto_code():
@@ -55,6 +56,7 @@ def build_wheel(*args, **kwargs):
 
 prepare_metadata_for_build_wheel = default_backend.prepare_metadata_for_build_wheel
 
+
 # PEP 660 defines additional hooks to support "pip install --editable":
 def build_editable(*args, **kwargs):
     generate_proto_code()