Added subcomponents

Author: willgebhardt

ngcsimlib/_src/compartment/compartment.py

@@ -45,7 +45,7 @@ def root(self):
 
     @property
     def targeted(self) -> bool:
-        return self._target != self._root_target
+        return not isinstance(self._target, str) or (self._target != self._root_target)
 
     @property
     def fixed(self) -> bool:
@@ -54,11 +54,12 @@ def fixed(self) -> bool:
         """
         return self._fixed
 
-    def _setup(self, objName, compName, path):
+    def _setup(self, compName, path):
         self.name = compName
-        self._root_target = path + ":" + objName + ":" + self.name
-        self._target = self._root_target
-        self.set(self._initial_value)
+        self._root_target = path + ":" + self.name
+        if self.target is None:
+            self._target = self._root_target
+            self.set(self._initial_value)
         gState.add_compartment(self)
 
     def set(self, value: T) -> None:
@@ -119,7 +120,8 @@ def _to_ast(self, node, ctx):
         return self.target._to_ast(node, ctx)
 
     def __rrshift__(self, other):
-        gcm.current_context.add_connection(other, self)
+        if gcm.current_context is not None:
+            gcm.current_context.add_connection(other, self)
         self.target = other
 
     def __rshift__(self, other):

ngcsimlib/_src/context/context.py

@@ -6,6 +6,8 @@
 from ngcsimlib._src.modules.modules_manager import modules_manager as modManager
 from ngcsimlib._src.operations.BaseOp import BaseOp
 
+from ngcsimlib._src.global_state.manager import global_state_manager
+
 from enum import Enum
 import os, shutil
 
@@ -84,6 +86,7 @@ def recompile(self):
         """
         priorities = {}
 
+
         for objectType in self.objects.keys():
             _objs = self.get_objects_by_type(objectType)
             for objName, obj in _objs.items():
@@ -93,6 +96,7 @@ def recompile(self):
 
                     if p not in priorities:
                         priorities[p] = []
+
                     priorities[p].append(obj)
 
 
@@ -255,10 +259,11 @@ def save_to_json(self, directory: str, model_name: Union[str, None] = None,
 
         path = make_unique_path(directory, model_name)
 
-        contextMeta = {"types": list(self.objects.keys())}
+        contextMeta = {"types": list(self.objects.keys()),
+                       "path": self.path}
 
         with open(f"{path}/contextData.json", "w") as f:
-            f.write(json.dumps(contextMeta))
+            f.write(json.dumps(contextMeta, indent=4))
 
         for _type in self.objects.keys():
             type_path = f"{path}/{make_safe_filename(_type)}"
@@ -307,11 +312,11 @@ def load(directory: str, module_name: str):
                  "existing context")
             return gcm.get_context(gcm.append_path(module_name))
 
-        with Context(module_name) as ctx:
-            path = directory + "/" + module_name
-            with open(f"{path}/contextData.json", "r") as f:
-                metaData = json.load(f)
+        path = directory + "/" + module_name
+        with open(f"{path}/contextData.json", "r") as f:
+            metaData = json.load(f)
 
+        with Context(metaData.get("path", module_name)) as ctx:
             delayed_load = []
 
             for _type in metaData["types"]:

ngcsimlib/_src/context/contextAwareObject.py

@@ -1,8 +1,10 @@
+import json
 from typing import Dict, Any
 
 from .context_manager import global_context_manager as gcm
 from .contextAwareObjectMeta import ContextAwareObjectMeta
 from ngcsimlib._src.parser.utils import compileObject
+from ngcsimlib._src.logger import warn
 
 class ContextAwareObject(object, metaclass=ContextAwareObjectMeta):
     """
@@ -22,8 +24,24 @@ def to_json(self) -> Dict[str, Any]:
 
         Returns: A dictionary of data that can be serialized by JSON.
         """
-        data = {"args": self._args,
-                "kwargs": self._kwargs}
+        safe_args = []
+        for a in self._args:
+            try:
+                json.dumps(a)
+                safe_args.append(a)
+            except:
+                warn(f"In {self.name}, unable to serialize positional argument {a}")
+
+        safe_kwargs = {}
+        for key, val in self._kwargs.items():
+            try:
+                json.dumps(val)
+                safe_kwargs[key] = val
+            except:
+                warn(f"In {self.name}, unable to serialize keyword argument {key}: {val}")
+
+        data = {"args": safe_args,
+                "kwargs": safe_kwargs}
         return data
 
     def compile(self):

ngcsimlib/_src/context/contextAwareObjectMeta.py

@@ -1,35 +1,68 @@
+import inspect
+
 from ngcsimlib.logger import error, warn
 from .context_manager import global_context_manager as gcm
 from collections.abc import Iterable
 
+def extract_name(cls, args, kwargs):
+    init = cls.__init__
+    sig = inspect.signature(init)
+    bound = sig.bind_partial(None, *args, **kwargs)
+    bound.apply_defaults()
+
+    if "name" in bound.arguments:
+        return bound.arguments["name"]
+    return None
+
 class ContextAwareObjectMeta(type):
+    def __new__(cls, name, bases, attrs):
+        if '__enter__' not in attrs:
+            def __enter__(self):
+                gcm.step(self._inferred_name, catch_empty=False)
+
+            attrs['__enter__'] = __enter__
+
+        if '__exit__' not in attrs:
+            def __exit__(self, type, value, traceback):
+                gcm.step_back()
+
+            attrs['__exit__'] = __exit__
+
+
+        return super().__new__(cls, name, bases, attrs)
+
     """
     This is the metaclass for objects that want to interact with the context
     they were created in. Generally use the base class "ContextAwareObject" over
     this metaclass.
     """
     def __call__(cls, *args, **kwargs):
-        obj = super().__call__(*args, **kwargs)
+        obj = cls.__new__(cls, *args, **kwargs)
+        obj._inferred_name = extract_name(cls, args, kwargs)
 
-        obj._args = args
-        obj._kwargs = kwargs
+        with obj:
+            cls.__init__(obj, *args, **kwargs)
 
-        if not hasattr(obj, 'name'):
-            error(f"Created context objects must have a name. "
-                  f"Error occurred when making an object of class {cls.__name__}")
+            obj._args = args
+            obj._kwargs = kwargs
 
-        contextRef = gcm.current_context
-        if contextRef is None:
-            warn(f"An instance of a context aware object was initialized while "
-                 f"the current context is None. Did you forget to place it in "
-                 f"a \"with\" block?")
-            return obj
+            if not hasattr(obj, 'name'):
+                error(f"Created context objects must have a name. "
+                      f"Error occurred when making an object of class {cls.__name__}")
+
+            # if contextRef is None:
+            #     warn(f"An instance of a context aware object was initialized while "
+            #          f"the current context is None. Did you forget to place it in "
+            #          f"a \"with\" block?")
+            #     return obj
 
-        contextRef.registerObj(obj)
 
-        if hasattr(obj, "compartments") and isinstance(obj.compartments, Iterable) and not isinstance(obj.compartments, (str, bytes)):
-            for (comp_name, comp) in obj.compartments:
-                if hasattr(comp, "_setup") and callable(comp._setup):
-                    comp._setup(obj.name, comp_name, gcm.current_path)
+            if hasattr(obj, "compartments") and isinstance(obj.compartments, Iterable) and not isinstance(obj.compartments, (str, bytes)):
+                for (comp_name, comp) in obj.compartments:
+                    if hasattr(comp, "_setup") and callable(comp._setup):
+                        comp._setup(comp_name, gcm.current_path)
 
+        contextRef = gcm.current_context
+        if contextRef is not None:
+            contextRef.registerObj(obj)
         return obj

ngcsimlib/_src/context/context_manager.py

@@ -44,18 +44,19 @@ def clear(self):
         """
         self.__contexts.clear()
 
-    def step(self, location: str) -> bool:
+    def step(self, location: str, catch_empty=True) -> bool:
         """
         Steps one step forward in the hierarchy of contexts
         Args:
             location: The path to step into
+            catch_empty: warn if stepping into a location that does not have a context
 
         Returns: if there is a registered context at the path stepped into (it will
         still step either way)
 
         """
         self.__current_path.append(location)
-        if self.exists():
+        if self.exists() or not catch_empty:
             return True
         warn(f"Stepping into a context path that does not have an associated "
              f"context ({self.join_path()}).")

ngcsimlib/_src/parser/contextTransformer.py

@@ -1,4 +1,6 @@
 import ast
+
+from ngcsimlib._src.context.contextAwareObjectMeta import ContextAwareObjectMeta
 from ngcsimlib._src.global_state.manager import global_state_manager
 from ngcsimlib._src.logger import warn, error
 from ngcsimlib._src.compartment.compartment import Compartment
@@ -14,9 +16,11 @@ def __init__(self, obj, method, subMethod=False):
         self.method = method
         self.current_args = set()
         self.needed_keys = set()
-        self.needed_methods = {}
         self.subMethod = subMethod
+
+        self.needed_methods = {}
         self.needed_globals = {}
+        self.auxiliary_ast = {}
 
     def visit_Return(self, node):
         if self.subMethod:
@@ -46,8 +50,7 @@ def visit_FunctionDef(self, node):
 
 
         node.decorator_list = new_decorators
-
-        node.name = self.obj.name + "_" + node.name
+        node.name = self.obj.context_path.replace(":", "_") + "_" + node.name
         self.generic_visit(node)
 
         if not self.subMethod:
@@ -74,21 +77,47 @@ def visit_Attribute(self, node):
 
                 return ast.fix_missing_locations(new_node)
 
+            if hasattr(stateVal, '_is_compilable') and isinstance(type(stateVal), ContextAwareObjectMeta):
+                return node
+
             if callable(stateVal):
-                method_name = f"{self.obj.name}_{node.attr}"
+                method_name = f"{self.obj.context_path.replace(':', '_')}_{node.attr}"
                 new_node = ast.copy_location(ast.Name(id=method_name, ctx=node.ctx), node)
                 self.needed_methods[method_name] = node.attr
                 return ast.fix_missing_locations(new_node)
 
-            attr_name = f"{self.obj.name}_{node.attr}"
+            attr_name = f"{self.obj.context_path.replace(':', '_')}_{node.attr}"
             new_node = ast.copy_location(ast.Name(id=attr_name, ctx=node.ctx), node)
             self.needed_globals[attr_name] = stateVal
             return ast.fix_missing_locations(new_node)
 
         return node
 
     def visit_Call(self, node):
+
         node = self.generic_visit(node)
+
+        if isinstance(node.func, ast.Attribute) and isinstance(node.func.value, ast.Attribute) \
+            and isinstance(node.func.value.value, ast.Name) and node.func.value.value.id == "self":
+            attr = getattr(self.obj, node.func.value.attr)
+            if not isinstance(type(attr), ContextAwareObjectMeta):
+                return node
+
+            subAttr = getattr(attr, node.func.attr)
+            if not hasattr(subAttr, "compiled"):
+                error("Attempting to use a method of a subcomponent that is not compiled/compilable")
+
+            method_id = f"{attr.context_path.replace(':', '_')}_{node.func.attr}"
+            subAst = subAttr.compiled.ast
+            subAst.body[0].body = subAst.body[0].body[:-1]
+
+            self.auxiliary_ast[method_id] = subAst
+            self.auxiliary_ast.update(subAttr.compiled.auxiliary_ast)
+            self.needed_globals.update(subAttr.compiled.extra_globals)
+
+            node.func = ast.Name(id=method_id, ctx=ast.Load())
+            node.args = [ast.Name(id='ctx', ctx=ast.Load())] + node.args
+
         if isinstance(node.func, ast.Attribute) and node.func.attr == "get":
             return node.func.value
 
@@ -97,19 +126,6 @@ def visit_Call(self, node):
 
         return node
 
-    # def visit_Assign(self, node):
-    #     for target in node.targets:
-    #         if isinstance(target, ast.Name):
-    #             target.id = f"{self.obj.name}_{target.id}"
-    #             self.local_vars.add(target.id)
-    #     return self.generic_visit(node)
-    #
-    #
-    # def visit_Name(self, node):
-    #     # if node.id in self.local_vars:
-    #     #     node.id = f"{self.obj.name}_{node.id}"
-    #     return node
-
     def visit_Expr(self, node):
         node = self.generic_visit(node)
         if isinstance(node.value, ast.Call):