Gromet Import PR (#324)

* Starting import implementation

* In progress changes for GroMEt Imports

* More updates for importing

* Fixed import * bug so now that it can properly read modules

* Updated CAST nodes for model import

* Pushing current additional changes for Vincent

* Adding required modules list file for generating gromet.

* Adding Gromet Import Reference to importer

* updating files needed to generate GroMEt for Bucky simplified

* Fixing issue with unescaped characters

Co-authored-by: Vincent Raymond <vraymond6@arizona.edu>

Author: titomeister

automates/gromet/metadata/gromet_creation.py

@@ -42,7 +42,7 @@ class GrometCreation(Metadata):
     if hasattr(Metadata, "attribute_map"):
         attribute_map.update(Metadata.attribute_map)
 
-    def __init__(self, metadata_type='gromet_creation', gromet_version='0.1.2', *args, **kwargs):  # noqa: E501
+    def __init__(self, metadata_type='gromet_creation', gromet_version='0.1.4', *args, **kwargs):  # noqa: E501
         """GrometCreation - a model defined in Swagger"""  # noqa: E501
         self._metadata_type = None
         self._gromet_version = None

automates/program_analysis/CAST2GrFN/ann_cast/ann_cast_helpers.py

@@ -369,7 +369,7 @@ def func_container_name_from_name_node(node) -> str:
     if isinstance(node, AnnCastAttribute):
         return f"{node.attr.name}_id{node.attr.id}"
     else:
-        return f"{node.name}_id{node.id}"    
+        return f"{node.name}_id{node.id}"
 
 def func_def_argument_name(node, arg_index: int) -> str:
     """

automates/program_analysis/CAST2GrFN/ann_cast/annotated_cast.py

@@ -33,6 +33,7 @@
 )    
 
 from automates.model_assembly.networks import GroundedFunctionNetwork, VariableNode
+from automates.program_analysis.CAST2GrFN.model.cast.model_import import ModelImport
 
 class PipelineState:
     def __init__(self, ann_nodes: typing.List, grfn2_2: bool):
@@ -659,6 +660,27 @@ def equiv(self, other):
     def __str__(self):
         return ModelContinue.__str__(self)
 
+class AnnCastModelImport(AnnCastNode):
+    def __init__(self, node: ModelImport):
+        super().__init__(self)
+        self.name = node.name
+        self.alias = node.alias
+        self.symbol = node.symbol
+        self.all = node.all
+        self.source_refs = node.source_refs
+
+    def to_dict(self):
+        result = super().to_dict()
+        return result
+
+    def equiv(self, other):
+        if not isinstance(other, AnnCastModelImport):
+            return False
+        return self.to_dict() == other.to_dict()
+
+    def __str__(self):
+        return ModelImport.__str__(self)
+
 class AnnCastModelIf(AnnCastNode):
     def __init__(self, expr, body, orelse, source_refs):
         super().__init__(self)

automates/program_analysis/CAST2GrFN/ann_cast/cast_to_annotated_cast.py

@@ -166,6 +166,10 @@ def visit_model_break(self, node: ModelBreak):
     def visit_model_continue(self, node: ModelContinue):
         return AnnCastModelContinue(node.source_refs)
 
+    @_visit.register
+    def visit_model_import(self, node: ModelImport):
+        return AnnCastModelImport(node)
+
     @_visit.register
     def visit_model_if(self, node: ModelIf):
         expr = self.visit(node.expr)

automates/program_analysis/CAST2GrFN/ann_cast/container_scope_pass.py

@@ -234,7 +234,7 @@ def visit_assignment(
         right_src_ref = self.visit(node.right, base_func_scopestr, enclosing_con_scope, AssignSide.RIGHT)
         # The AnnCastTuple is added to handle scenarios where an assignment
         # is made by assigning to a tuple of values, as opposed to one singular value
-        assert isinstance(node.left, AnnCastVar) or isinstance(node.left, AnnCastTuple) or isinstance(node.left, AnnCastAttribute), f"container_scope: visit_assigment: node.left is not AnnCastVar or AnnCastTuple it is {type(node.left)}"
+        assert isinstance(node.left, AnnCastVar) or isinstance(node.left, AnnCastTuple) or isinstance(node.left, AnnCastAttribute), f"container_scope: visit_assigment: node.left is {type(node.left)}"
         left_src_ref = self.visit(node.left, base_func_scopestr, enclosing_con_scope, AssignSide.LEFT)
 
         return combine_grfn_con_src_refs([right_src_ref, left_src_ref])
@@ -312,7 +312,7 @@ def visit_record_def(self, node: AnnCastRecordDef, base_func_scopestr, enclosing
         assert(assign_side == AssignSide.NEITHER)
         # we do not visit the name because it is a string
         assert isinstance(node.name, str)
-        classscope = enclosing_con_scope + [node.name]
+        classscope = enclosing_con_scope # + [node.name]
         # NOTE:
         # node.bases is a list of strings
         # node.funcs is a list of Vars
@@ -395,7 +395,8 @@ def visit_literal_value(self, node: AnnCastLiteralValue, base_func_scopestr, enc
     @_visit.register
     def visit_loop(self, node: AnnCastLoop, base_func_scopestr, enclosing_con_scope, assign_side):
         # we believe the start of the container should not be on either side of an assignment
-        assert(assign_side == AssignSide.NEITHER)
+        # (NOTE: In the case of list/dict comprehensions, they could be on the right hand side)
+        assert(assign_side == AssignSide.NEITHER or assign_side == AssignSide.RIGHT)
         # store the base_func_scopestr for this container
         node.base_func_scopestr = base_func_scopestr
 
@@ -435,10 +436,15 @@ def visit_model_break(self, node: AnnCastModelBreak, assign_side):
     def visit_model_continue(self, node: AnnCastModelContinue, assign_side):
         pass
 
+    @_visit.register
+    def visit_model_import(self, node: AnnCastModelImport, base_func_scopestr, enclosing_con_scope, assign_side):
+        pass
+
     @_visit.register
     def visit_model_if(self, node: AnnCastModelIf, base_func_scopestr, enclosing_con_scope, assign_side):
         # we believe the start of the container should not be on either side of an assignment
-        assert(assign_side == AssignSide.NEITHER)
+        # (NOTE: In the case of list/dict comprehensions, they could be on the right hand side)
+        assert(assign_side == AssignSide.NEITHER or assign_side == AssignSide.RIGHT)
         # store the base_func_scopestr for this container
         node.base_func_scopestr = base_func_scopestr
         # want orig enclosing
@@ -540,7 +546,7 @@ def visit_string(self, node: AnnCastString, base_func_scopestr, enclosing_con_sc
         pass
 
     @_visit.register
-    def visit_subscript(self, node: AnnCastSubscript, assign_side):
+    def visit_subscript(self, node: AnnCastSubscript, base_func_scoptr, enclosing_con_scope, assign_side):
         pass
 
     @_visit.register

automates/program_analysis/CAST2GrFN/ann_cast/grfn_assignment_pass.py

@@ -224,6 +224,10 @@ def visit_model_break(self, node: AnnCastModelBreak, add_to: typing.Dict):
     def visit_model_continue(self, node: AnnCastModelContinue, add_to: typing.Dict):
         pass
 
+    @_visit.register
+    def visit_model_import(self, node: AnnCastModelImport, add_to: typing.Dict):
+        pass
+
     @_visit.register
     def visit_model_if(self, node: AnnCastModelIf, add_to: typing.Dict):
         self.visit(node.expr, add_to)

automates/program_analysis/CAST2GrFN/ann_cast/grfn_var_creation_pass.py

@@ -425,7 +425,7 @@ def visit_assignment(self, node: AnnCastAssignment):
         self.visit(node.right)
         # The AnnCastTuple is added to handle scenarios where an assignment
         # is made by assigning to a tuple of values, as opposed to one singular value
-        assert isinstance(node.left, AnnCastVar) or isinstance(node.left, AnnCastTuple), f"container_scope: visit_assigment: node.left is not AnnCastVar or AnnCastTuple it is {type(node.left)}"
+        assert isinstance(node.left, AnnCastVar) or isinstance(node.left, AnnCastTuple) or isinstance(node.left, AnnCastAttribute), f"container_scope: visit_assigment: node.left is not AnnCastVar or AnnCastTuple it is {type(node.left)}"
         self.visit(node.left)
 
     @_visit.register
@@ -529,6 +529,10 @@ def visit_model_break(self, node: AnnCastModelBreak):
     def visit_model_continue(self, node: AnnCastModelContinue):
         pass
 
+    @_visit.register
+    def visit_model_import(self, node: AnnCastModelImport):
+        pass
+
     @_visit.register
     def visit_model_if(self, node: AnnCastModelIf):
         self.create_grfn_vars_model_if(node)

automates/program_analysis/CAST2GrFN/ann_cast/id_collapse_pass.py

@@ -1,3 +1,4 @@
+from re import A
 import typing
 from collections import defaultdict
 from functools import singledispatchmethod
@@ -90,7 +91,7 @@ def visit_assignment(self, node: AnnCastAssignment, at_module_scope):
         self.visit(node.right, at_module_scope)
         # The AnnCastTuple is added to handle scenarios where an assignment
         # is made by assigning to a tuple of values, as opposed to one singular value
-        assert isinstance(node.left, AnnCastVar) or isinstance(node.left, AnnCastTuple) or isinstance(node.left, AnnCastAttribute), f"id_collapse: visit_assigment: node.left is not AnnCastVar it is {type(node.left)}"
+        assert isinstance(node.left, AnnCastVar) or isinstance(node.left, AnnCastTuple) or isinstance(node.left, AnnCastAttribute), f"id_collapse: visit_assigment: node.left is {type(node.left)}"
         self.visit(node.left, at_module_scope)
 
     @_visit.register
@@ -108,16 +109,27 @@ def visit_binary_op(self, node: AnnCastBinaryOp, at_module_scope):
 
     @_visit.register
     def visit_call(self, node: AnnCastCall, at_module_scope):
-        assert isinstance(node.func, AnnCastName) or isinstance(node.func, AnnCastAttribute)
+        if isinstance(node.func, AnnCastLiteralValue):
+            return
+
+        assert isinstance(node.func, AnnCastName) or isinstance(node.func, AnnCastAttribute), f"node.func is type f{type(node.func)}"
         if isinstance(node.func, AnnCastName):
             node.func.id = self.collapse_id(node.func.id)
             node.invocation_index = self.next_function_invocation(node.func.id)
         else:
+            if isinstance(node.func.value, AnnCastCall):
+                self.visit(node.func.value, at_module_scope)
+            elif isinstance(node.func.value, AnnCastAttribute):
+                self.visit(node.func.value, at_module_scope)
+            elif isinstance(node.func.value, AnnCastSubscript):
+                self.visit(node.func.value, at_module_scope)
+            elif isinstance(node.func.value, AnnCastBinaryOp):
+                self.visit(node.func.value, at_module_scope)
+            else:
+                node.func.value.id = self.collapse_id(node.func.value.id)
             node.func.attr.id = self.collapse_id(node.func.attr.id)
-            node.func.value.id = self.collapse_id(node.func.value.id)
             node.invocation_index = self.next_function_invocation(node.func.attr.id)
 
-            
         # cache Call node to later determine if this Call has a FunctionDef
         call_name = call_container_name(node)
         self.cached_call_nodes[call_name] = node
@@ -193,6 +205,10 @@ def visit_model_if(self, node: AnnCastModelIf, at_module_scope):
     def visit_return(self, node: AnnCastModelReturn, at_module_scope):
         self.visit(node.value, at_module_scope)
 
+    @_visit.register
+    def visit_model_import(self, node: AnnCastModelImport, at_module_scope):
+        pass
+
     @_visit.register
     def visit_module(self, node: AnnCastModule, at_module_scope):
         # we cache the module node in the AnnCast object

automates/program_analysis/CAST2GrFN/ann_cast/lambda_expression_pass.py

@@ -394,6 +394,10 @@ def visit_model_break(self, node: AnnCastModelBreak) -> str:
     def visit_model_continue(self, node: AnnCastModelContinue) -> str:
         return node.expr_str
 
+    @_visit.register
+    def visit_model_import(self, node: AnnCastModelImport) -> str:
+        pass
+
     @_visit.register
     def visit_model_if(self, node: AnnCastModelIf) -> str:
         # top interface lambda