Add basic functionality for saving schedules

Closes #108 (closed)

b_asic/save_load_structure.py

@@ -30,7 +30,7 @@ def sfg_to_python(
     suffix : str, optional
         String to append at the end of the result.
     schedule : bool, default: False
-        True if printing a schedule
+        True if printing a schedule.
 
     """
     _type = "Schedule" if schedule else "SFG"
@@ -77,38 +77,41 @@ def sfg_to_python(
         return ", ".join([f"{param}={value}" for param, value in params.items()])
 
     # No need to redefined I/Os
-    io_ops = [*sfg._input_operations, *sfg._output_operations]
+    io_ops = [*sfg.input_operations, *sfg.output_operations]
 
     result += "\n# Inputs:\n"
-    for input_op in sfg._input_operations:
+    for input_op in sfg.input_operations:
         result += f"{input_op.graph_id} = Input({kwarg_unpacker(input_op)})\n"
 
     result += "\n# Outputs:\n"
-    for output_op in sfg._output_operations:
+    for output_op in sfg.output_operations:
         result += f"{output_op.graph_id} = Output({kwarg_unpacker(output_op)})\n"
 
     result += "\n# Operations:\n"
-    for op in sfg.split():
-        if op in io_ops:
+    for operation in sfg.split():
+        if operation in io_ops:
             continue
-        if isinstance(op, SFG):
+        if isinstance(operation, SFG):
             counter += 1
-            result = sfg_to_python(op, counter) + result
+            result = sfg_to_python(operation, counter) + result
             continue
 
-        result += f"{op.graph_id} = {op.__class__.__name__}({kwarg_unpacker(op)})\n"
+        result += (
+            f"{operation.graph_id} ="
+            f" {operation.__class__.__name__}({kwarg_unpacker(operation)})\n"
+        )
 
     result += "\n# Signals:\n"
     # Keep track of already existing connections to avoid adding duplicates
     connections = []
-    for op in sfg.split():
-        for out in op.outputs:
+    for operation in sfg.split():
+        for out in operation.outputs:
             for signal in out.signals:
                 destination = cast(InputPort, signal.destination)
                 dest_op = destination.operation
                 connection = (
-                    f"Signal(source={op.graph_id}."
-                    f"output({op.outputs.index(signal.source)}),"
+                    f"Signal(source={operation.graph_id}."
+                    f"output({operation.outputs.index(signal.source)}),"
                     f" destination={dest_op.graph_id}."
                     f"input({dest_op.inputs.index(destination)}))\n"
                 )
@@ -143,8 +146,8 @@ def python_to_sfg(path: str) -> Tuple[SFG, Dict[str, Tuple[int, int]]]:
     path : str
         Path to file to read and deserialize.
     """
-    with open(path) as f:
-        code = compile(f.read(), path, "exec")
+    with open(path) as file:
+        code = compile(file.read(), path, "exec")
         exec(code, globals(), locals())
 
     return (