expose more to in unit test, prepare for other models

Author: jcschaff

src/simple_process_bigraph_runtime/generation/composite_generator.py

@@ -1,6 +1,6 @@
 from typing import Any, cast
 
-from process_bigraph_lang.dsl.model import Model, StoreDef, ProcessDef, Reference, Store
+from process_bigraph_lang.dsl.model import Model, StoreDef, ProcessDef, Store, Type
 from vivarium import Vivarium
 
 
@@ -17,7 +17,11 @@ def process_composite(model: Model, assembler: Vivarium):
 
             process_config = {}
             for param in process_def.params:
-                process_config[param.name] = param.default.val if param.default is not None else determine_builtin_default(param.type.ref_text)
+                param_type = cast(Type, param.type.ref_object)
+                assert isinstance(param_type, Type)
+                process_config[param.name] = param.default.val \
+                    if param.default is not None \
+                    else _determine_builtin_default(param_type)
 
             for store_ref in process.stores:
                 store = cast(Store, store_ref.ref_object)
@@ -29,7 +33,11 @@ def process_composite(model: Model, assembler: Vivarium):
                 store_path = [composite_def.name, store.name]
 
                 for state_def in store_def.states:
-                    store_path_to_value_map[store_path_str] = state_def.default.val if state_def.default is not None else determine_builtin_default(state_def.type.ref_text)
+                    state_type = cast(Type, state_def.type.ref_object)
+                    assert isinstance(state_type, Type)
+                    store_path_to_value_map[store_path_str] = state_def.default.val \
+                        if state_def.default is not None \
+                        else _determine_builtin_default(state_type)
 
                 for state_def in store_def.states:
                     if state_def.name in input_bindings:
@@ -51,10 +59,11 @@ def process_composite(model: Model, assembler: Vivarium):
 
     assembler.add_emitter()
 
-def determine_builtin_default(type_to_infer: str):
-    if type_to_infer == "float":
+
+def _determine_builtin_default(type_to_infer: Type):
+    if type_to_infer.name == "float":
         return 0.0
-    elif type_to_infer == "int":
+    elif type_to_infer.name == "int":
         return 0
     else:
         raise ValueError(f"Unknown built-in default for type `{type_to_infer}`")

src/simple_process_bigraph_runtime/generation/process_generator.py

@@ -1,17 +1,12 @@
-import warnings
+from process_bigraph_lang.dsl.model import ProcessDef
 from vivarium import Vivarium
-from process_bigraph_lang.dsl.model import Model
-with warnings.catch_warnings(): # Temporary minimal_impact bug in process_bigraphs
-    warnings.simplefilter("ignore", SyntaxWarning)
-    #warnings.filterwarnings("error", category=SyntaxWarning)
-    from process_bigraph import ProcessTypes, Process
 
 
-def register_process_defs(assembler: Vivarium, model: Model) -> None:
+def register_process_defs(assembler: Vivarium, process_defs: list[ProcessDef]) -> None:
     # note: does not actually dynamically build processes...yet
     registry = assembler.core
-    for process_def in model.processDefs:
-        if registry.process_registry.find(process_def.name) is not None:
-            continue
-        raise ValueError(f"Unknown process definition {process_def.name}")
+    for process_def in process_defs:
+        python_path = ".".join(process_def.python_path.path)
+        if not registry.process_registry.find(python_path):
+            raise ValueError(f"Unknown process definition {process_def.name}")
 

src/simple_process_bigraph_runtime/generation/store_generator.py

@@ -1,20 +1,6 @@
-import warnings
-
-from process_bigraph_lang.dsl.model import Model, Type
+from process_bigraph_lang.dsl.model import Type
 from vivarium import Vivarium
 
-with warnings.catch_warnings(): # Temporary minimal_impact bug in process_bigraphs
-    warnings.simplefilter("ignore", SyntaxWarning)
-    #warnings.filterwarnings("error", category=SyntaxWarning)
-    from process_bigraph import ProcessTypes
-
-def collect_types(model: Model) -> list[Type]:
-    types_to_process: list[Type] = []
-    for type_to_add in model.types:
-        # Insert some parsing code here
-        types_to_process.append(type_to_add)
-    return types_to_process
-
 
 def register_types(assembler: Vivarium, types_to_register: list[Type]):
     for type_to_register in types_to_register:

src/simple_process_bigraph_runtime/generation/type_generator.py

@@ -1,19 +1,10 @@
-import warnings
-
-from process_bigraph_lang.dsl.model import Model, Unit
+from process_bigraph_lang.dsl.model import Unit
 from vivarium import Vivarium
-with warnings.catch_warnings(): # Temporary minimal_impact bug in process_bigraphs
-    warnings.simplefilter("ignore", SyntaxWarning)
-    #warnings.filterwarnings("error", category=SyntaxWarning)
-    from process_bigraph import ProcessTypes
-
-
-def collect_units(model: Model) -> list[Unit]:
-    units_to_process: list[Unit] = []
-    for unit in model.units:
-        # Insert some parsing code here
-        units_to_process.append(unit)
-    return units_to_process
 
 def register_units(assembler: Vivarium, units_to_register: list[Unit]) -> None:
-    pass
+    for unit_to_register in units_to_register:
+        pass
+        # if 0 == assembler.get_type(unit_to_register.name).size:
+        #     raise ValueError(f"Type {unit_to_register.name} is an unknown type")
+        # in the future, we'd attempt to generate a new type
+

src/simple_process_bigraph_runtime/generation/unit_generator.py

@@ -5,6 +5,9 @@
 import typer
 from process_bigraph_lang.dsl.model import Model
 from typing_extensions import Annotated
+
+from simple_process_bigraph_runtime.generation.process_generator import register_process_defs
+
 with warnings.catch_warnings(): # Temporary minimal_impact bug in process_bigraphs
     warnings.simplefilter("ignore", SyntaxWarning)
     #warnings.filterwarnings("error", category=SyntaxWarning)
@@ -13,8 +16,8 @@
 from vivarium import Vivarium
 from process_bigraph import Composite
 
-from simple_process_bigraph_runtime.generation.type_generator import register_types, collect_types
-from simple_process_bigraph_runtime.generation.unit_generator import register_units, collect_units
+from simple_process_bigraph_runtime.generation.type_generator import register_types
+from simple_process_bigraph_runtime.generation.unit_generator import register_units
 from simple_process_bigraph_runtime.generation.composite_generator import process_composite
 import simple_process_bigraph_runtime.registry.spatio_flux_library as spatioflux
 import simple_process_bigraph_runtime.registry.toy_library as toy
@@ -76,8 +79,9 @@ def performConversion(ast_model: Model) -> tuple[Composite, dict, ProcessTypes]:
     assembler = Vivarium()
     spatioflux.apply_to_vivarium(assembler)
     toy.apply_to_vivarium(assembler)
-    register_types(assembler, collect_types(ast_model))
-    register_units(assembler, collect_units(ast_model))
+    register_types(assembler, ast_model.types)
+    register_units(assembler, ast_model.units)
+    register_process_defs(assembler, ast_model.processDefs)
     process_composite(ast_model, assembler)
 
     return assembler.composite, assembler.make_document(), assembler.core

src/simple_process_bigraph_runtime/main.py

@@ -1,6 +1,6 @@
 import os.path
-from typing import Any
-from process_bigraph import Process, Step, Composite, ProcessTypes, pp
+
+from process_bigraph import Process, Step
 from vivarium import Vivarium
 
 complex_number = {

src/simple_process_bigraph_runtime/registry/toy_library.py

@@ -1,13 +1,41 @@
 from pathlib import Path
 
-from process_bigraph_lang.dsl.model import Model
+from process_bigraph_lang.dsl.model import Model, ProcessDef
+from vivarium import Vivarium
 
+import simple_process_bigraph_runtime.registry.toy_library as toy
+from simple_process_bigraph_runtime.generation.composite_generator import process_composite
+from simple_process_bigraph_runtime.generation.process_generator import register_process_defs
+from simple_process_bigraph_runtime.generation.type_generator import register_types
+from simple_process_bigraph_runtime.generation.unit_generator import register_units
 from simple_process_bigraph_runtime.main import generatePythonModel, performConversion
 
 
 def test_add(model_path_abc: Path) -> None:
     ast_model: Model = generatePythonModel(model_path_abc)
-    pb_composite, _0, _1 = performConversion(ast_model)
+
+    assembler = Vivarium()
+    for type_name, type_schema in toy.TYPES_DICT.items():
+        assembler.core.register("toy.type." + type_name, type_schema)
+    for process_name, process in toy.PROCESS_DICT.items():
+        assembler.core.register_process("toy." + process_name, process)
+    register_process_defs(assembler, ast_model.processDefs)
+    register_types(assembler, ast_model.types)
+    register_units(assembler, ast_model.units)
+    process_composite(ast_model, assembler)
+    composite = assembler.composite
 
     duration = 10.0
-    pb_composite.run(duration)
+    composite.run(duration)
+    core = composite.core
+    print(core)
+
+    add_num: ProcessDef = ast_model.processDefs[0]
+    assert ".".join(add_num.python_path.path) == 'toy.AddFloatsRepeatedly'
+    assert ".".join(add_num.python_path.path) in core.process_registry.registry
+
+    print(core.process_registry.registry)
+
+    print_results: ProcessDef = ast_model.processDefs[1]
+    assert ".".join(print_results.python_path.path) == 'toy.SaveFloatToFile'
+    assert ".".join(print_results.python_path.path) in core.process_registry.registry