wip

Author: GeigerJ2

constructed-while-output.json

@@ -0,0 +1,106 @@
+{
+  "version": "1.0",
+  "nodes": [
+    {
+      "id": 1,
+      "type": "input",
+      "name": "initial_x",
+      "value": 1
+    },
+    {
+      "id": 2,
+      "type": "input",
+      "name": "initial_y",
+      "value": 1
+    },
+    {
+      "id": 3,
+      "type": "function",
+      "value": "mymodule.add"
+    },
+    {
+      "id": 4,
+      "type": "while",
+      "conditionFunction": null,
+      "conditionExpression": "ctx.n < 8",
+      "conditionWorkflow": null,
+      "bodyFunction": null,
+      "bodyWorkflow": {
+        "version": "1.0",
+        "nodes": [
+          {
+            "id": 1,
+            "type": "function",
+            "value": "mymodule.add"
+          },
+          {
+            "id": 2,
+            "type": "function",
+            "value": "mymodule.multiply"
+          }
+        ],
+        "edges": [
+          {
+            "target": 2,
+            "targetPort": "x",
+            "source": 1,
+            "sourcePort": null
+          }
+        ]
+      },
+      "contextVars": [
+        "n"
+      ],
+      "inputPorts": {
+        "n": null
+      },
+      "outputPorts": {
+        "n": "final_n"
+      },
+      "maxIterations": 10,
+      "stateMapping": null
+    },
+    {
+      "id": 5,
+      "type": "function",
+      "value": "mymodule.add"
+    },
+    {
+      "id": 6,
+      "type": "output",
+      "name": "result"
+    }
+  ],
+  "edges": [
+    {
+      "target": 3,
+      "targetPort": "x",
+      "source": 1,
+      "sourcePort": null
+    },
+    {
+      "target": 3,
+      "targetPort": "y",
+      "source": 2,
+      "sourcePort": null
+    },
+    {
+      "target": 4,
+      "targetPort": "n",
+      "source": 3,
+      "sourcePort": null
+    },
+    {
+      "target": 5,
+      "targetPort": "x",
+      "source": 4,
+      "sourcePort": "final_n"
+    },
+    {
+      "target": 6,
+      "targetPort": null,
+      "source": 5,
+      "sourcePort": null
+    }
+  ]
+}

example_workflows/while_loop/test_aiida_example.py

@@ -22,31 +22,101 @@
 sys.path.insert(0, str(while_loop_path))
 
 
-load_profile()
+from typing import Callable, Any
 
+def my_while(
+    input_ports: dict, 
+    condition_f: Callable[[dict, dict], bool], 
+    body_f: Callable[[dict, dict], dict], 
+    finalizer: Callable[[dict, dict], Any]
+) -> Any:
+    ctx = {}
+    while condition_f(input_ports, ctx):
+        ctx = body_f(input_ports, ctx)
+    return finalizer(input_ports, ctx)
 
-@task
-def add(x, y):
-    return x + y
 
-@task
-def compare(x, y):
-    return x < y
+# Example: Sum numbers from 0 to limit
+def condition_f(input_ports: dict, ctx: dict) -> bool:
+    limit = input_ports.get('limit', 0)
+    current = ctx.get('current', 0)
+    return current < limit
 
-@task
-def multiply(x, y):
-    return x * y
+def body_f(input_ports: dict, ctx: dict) -> dict:
+    current = ctx.get('current', 0)
+    total = ctx.get('total', 0)
+    return {
+        'current': current + 1,
+        'total': total + current
+    }
 
-@task.graph
-def WhileLoop(n, m):
-    if m >= n:
-        return m
-    m = add(x=m, y=1).result
-    return WhileLoop(n=n, m=m)
+def finalizer(input_ports: dict, ctx: dict) -> dict:
+    return {
+        'result': ctx.get('total', 0),
+        'iterations': ctx.get('current', 0)
+    }
 
 
-wg = WhileLoop.build(n=4, m=0)
+# Run it
+result = my_while(
+    input_ports={'limit': 10},
+    condition_f=condition_f,
+    body_f=body_f,
+    finalizer=finalizer
+)
 
-wg.to_html()
+print(result)  # {'result': 45, 'iterations': 10}
 
-write_workflow_json(wg=wg, file_name='write_while_loop.json')
+raise SystemExit()
+
+# from typing import Callable
+#
+# def condition_f(x, limit):
+#     return limit > x
+#
+# def body_f(x):
+#     return x + 1
+#
+# # def abstract_while(x, limit):
+# #     if not condition(x=x, limit=limit):
+# #         return x
+# #     x = function_body(x=x)
+# #     return abstract_while(x=x, limit=limit)
+#
+#
+# def my_while(input_ports: dict, condition_f=Callable, body_f=Callable, finalizer=Callable):
+#     ctx = {}
+#     while condition_f(input_ports, ctx):
+#         ctx = body_f(input_ports, ctx)
+#     return finalizer(input_ports, ctx) # these become output ports
+#
+# my_while()
+
+# load_profile()
+#
+#
+# @task
+# def add(x, y):
+#     return x + y
+#
+# @task
+# def compare(x, y):
+#     return x < y
+#
+# @task
+# def multiply(x, y):
+#     return x * y
+#
+# @task.graph
+# def WhileLoop(n, m):
+#     if m >= n:
+#         return m
+#     m = add(x=m, y=1).result
+#     return WhileLoop(n=n, m=m)
+#
+#
+# wg = WhileLoop.build(n=4, m=0)
+#
+# wg.to_html()
+#
+# write_workflow_json(wg=wg, file_name='write_while_loop.json')

example_workflows/while_loop/while-construct-pwd.py

@@ -0,0 +1,51 @@
+from python_workflow_definition.models import *
+
+workflow = PythonWorkflowDefinitionWorkflow(
+    version="1.0",
+    nodes=[
+        # Input node for initial value
+        PythonWorkflowDefinitionInputNode(id=1, type="input", name="initial_x", value=1),
+        PythonWorkflowDefinitionInputNode(id=2, type="input", name="initial_y", value=1),
+        
+        # Initial add to set up context
+        PythonWorkflowDefinitionFunctionNode(id=3, type="function", value="mymodule.add"),
+        
+        # While loop node
+        PythonWorkflowDefinitionWhileNode(
+            id=4,
+            type="while",
+            conditionExpression="ctx.n < 8",
+            bodyWorkflow=PythonWorkflowDefinitionWorkflow(
+                version="1.0",
+                nodes=[
+                    PythonWorkflowDefinitionFunctionNode(id=1, type="function", value="mymodule.add"),
+                    PythonWorkflowDefinitionFunctionNode(id=2, type="function", value="mymodule.multiply"),
+                ],
+                edges=[
+                    PythonWorkflowDefinitionEdge(source=1, target=2, targetPort="x"),
+                ]
+            ),
+            contextVars=["n"],
+            inputPorts={"n": None},  # Will be connected via edge
+            outputPorts={"n": "final_n"},
+            maxIterations=10
+        ),
+        
+        # Final add after loop
+        PythonWorkflowDefinitionFunctionNode(id=5, type="function", value="mymodule.add"),
+        
+        # Output node
+        PythonWorkflowDefinitionOutputNode(id=6, type="output", name="result"),
+    ],
+    edges=[
+        PythonWorkflowDefinitionEdge(source=1, target=3, targetPort="x"),
+        PythonWorkflowDefinitionEdge(source=2, target=3, targetPort="y"),
+        PythonWorkflowDefinitionEdge(source=3, target=4, targetPort="n"),
+        PythonWorkflowDefinitionEdge(source=4, sourcePort="final_n", target=5, targetPort="x"),
+        PythonWorkflowDefinitionEdge(source=5, target=6),
+    ]
+)
+
+breakpoint()
+
+pass