Merge pull request #194 from cyrillemidingoyi/release

update py to Crop2ml

Author: cyrillemidingoyi

src/pycropml/transpiler/antlr_py/csharp/csharp_preprocessing.py

@@ -115,7 +115,7 @@ def action_assignment(self, tree):
                 self.env[-1][t_name] = type_
 
 
-        if tree.op != "=":
+        if "op" in dir(tree) and tree.op != "=":
             if t_name not in self.current_scope:
                 self.inputs.append(t_name)   
 
@@ -155,22 +155,18 @@ def action_if_statement(self, tree):
         self.transform(tree.test)
         self.transform(tree.block)
         m1 = self.env[-1]
-        print("pppppp", m1)
         self.env.pop()
         self.current_scope = self.current()
 
         if tree.otherwise:
             self.env.append({})
             self.transform(tree.otherwise)
             m2 = self.env[-1]
-            print("nnnnnnnn", m2)
             self.env.pop()
             common_keys = m1.keys( ) & m2.keys()
             common_dict = {k:m1[k] for k in common_keys}
             self.env[-1].update(common_dict)
-            self.current_scope = self.current()  
-        print("iiiii", self.inputs)
-        print("ifff", self.current_scope)   
+            self.current_scope = self.current()   
         return tree
 
     #def action_elseif_statement(self, tree):

src/pycropml/transpiler/antlr_py/dssat/run.py

@@ -76,9 +76,9 @@ def translate(node, asgt, imports, inout=[], index=[]):
     r = z.process(h)
 
 
-    return translate_simple(r, total_tree=asgt)
+    return r
 
-def translate_simple(r, total_tree=None):
+def translate_simple(r, total_tree=None, var = []):
     """ Transform the ASG of Fortran code in the Common Model Representation that is transformed into CyML
 
     Args:
@@ -87,7 +87,7 @@ def translate_simple(r, total_tree=None):
     Returns:
         str: The generated CyML code 
     """
-    cd = f90_cyml.F90_Cyml_ast(r, treeG=total_tree)
+    cd = f90_cyml.F90_Cyml_ast(r, treeG=total_tree, var = var)
     hh = cd.transform()
     nd = transform_to_syntax_tree(hh)
     codes = writeCyml(nd)
@@ -209,7 +209,7 @@ def run_dssat(component, package):
                 newinputs.append(d.decl[0])
 
             inout = modunit_asg[0].inputs_name + modunit_asg[0].outputs_name + attrname
-                
+            
             ass = Assignment()
             node2=ass.process(node_w_attrib)     
             l = Local()
@@ -225,7 +225,6 @@ def run_dssat(component, package):
                         if inp.name in input1 and inp.name not in modunit_asg[0].indexnames :
                             inputs1.append(inp)
 
-
             initialization =  extraction(res[0] , init_tags[0],init_tags[1])
             ratecalculation = extraction(res[0] , rates_tags[0],rates_tags[1])
             statecalculation = extraction(res[0] , states_tags[0],states_tags[1])
@@ -247,49 +246,72 @@ def run_dssat(component, package):
             algop = False
             ratep = False
             statep = False
+            init_outputs = []
+            v = []
 
-            if initialization:
-                initv = True
-                metainfo_init = {"name": f"init.{modunit_asg[0].name}", "language":"Cyml", "filename":f"algo/pyx/init.{modunit_asg[0].name}.pyx"}
-                initialization = initialization[0]  +endline + endconstruct
-                comments_init = fortrancomments(initialization)
-                initialization_dictasg = to_dictASG(initialization, language,comments_init, env = modunit_asg[0].env)
-                initialization_asg = to_CASG(initialization_dictasg)
-                codes_init = translate(decl+initialization_asg,asgt,imports, inout=inout, index = modunit_asg[0].indexnames)
-            
-
             if algoPart:
                 algop = True
                 algoPart = algoPart[0]  + endline + endconstruct 
                 comments_compute = fortrancomments(algoPart)
                 algoPart_dictasg = to_dictASG(algoPart, language,comments_compute, env = modunit_asg[0].env)
                 algoPart_asg = to_CASG(algoPart_dictasg)
-                codes_compute = translate(decl+algoPart_asg,asgt,imports,inout=inout, index = modunit_asg[0].indexnames)
-            
+                r = translate(decl+algoPart_asg,asgt,imports,inout=inout, index = modunit_asg[0].indexnames)
 
             if ratecalculation:
                 ratep = True
                 ratecalculation = ratecalculation[0]  + endline + endconstruct
                 comments_rate = fortrancomments(ratecalculation)
                 ratecalculation_dictasg = to_dictASG(ratecalculation, language,comments_rate, env = modunit_asg[0].env)
                 ratecalculation_asg = to_CASG(ratecalculation_dictasg)
-                codes_rates = translate(decl+ratecalculation_asg,asgt,imports,inout=inout, index = modunit_asg[0].indexnames)
+                g = Call_stmt(trees=asgt)
+                h = g.process(ratecalculation_asg)
+                from pycropml.transpiler.antlr_py.csharp.csharp_preprocessing import CheckingInOut
+                zz = CheckingInOut( {},isAlgo = True)
+                r_ch = zz.process(h)
+                index = list(set(modunit_asg[0].indexnames).intersection(set(zz.inputs) ))
+                r = translate(decl + ratecalculation_asg,asgt,imports,inout=inout, index = index)
+                var = list(set(zz.inputs) - set(index))
+                print(var)
+                x = list(set(var)-set([m.name for m in model_inputs]))
+                
+                for i in x:
+                    v.append(extr2.getDeclaration(asgt, i))
+                codes_rates = translate_simple(r, total_tree=asgt, var = var)         
 
             if statecalculation:
                 statep = True
                 statecalculation = statecalculation[0]  + endline + endconstruct
                 comments_state = fortrancomments(statecalculation)
                 statecalculation_dictasg = to_dictASG(statecalculation, language,comments_state, env = modunit_asg[0].env)
                 statecalculation_asg = to_CASG(statecalculation_dictasg)
-                codes_states = translate(decl+statecalculation_asg,asgt,imports,inout=inout, index = modunit_asg[0].indexnames)
-               
+                r, codes_states = translate(decl+statecalculation_asg,asgt,imports,inout=inout, index = modunit_asg[0].indexnames)
+                
+            if initialization:
+                initv = True
+                metainfo_init = {"name": f"init.{modunit_asg[0].name}", "language":"Cyml", "filename":f"algo/pyx/init.{modunit_asg[0].name}.pyx"}
+                initialization = initialization[0]  +endline + endconstruct
+                comments_init = fortrancomments(initialization)
+                initialization_dictasg = to_dictASG(initialization, language,comments_init, env = modunit_asg[0].env)
+                initialization_asg = to_CASG(initialization_dictasg)
+                
+                from pycropml.transpiler.antlr_py.csharp.csharp_preprocessing import CheckingInOut
+                zz = CheckingInOut( {},isAlgo = True)
+                r_ch = zz.process(initialization_asg)
+                index = list(set(modunit_asg[0].indexnames).intersection(set(zz.inputs) ))
+                init_outputs = zz.outputs
+                r = translate(decl + initialization_asg,asgt,imports,inout=inout, index = index)
+                #var = list(set(zz.inputs) - set(index))
+                var = [n.name for n in model_inputs+v]
+                codes_init = translate_simple(r, total_tree=asgt, var=var)  
+                
+                     
             metainfo = extractMetaInfo(mod, "!")
             inp_info = []
             out_info = []
 
             metainfo2 = copy.deepcopy(metainfo)
             mm = []
-            for inp in model_inputs:
+            for inp in model_inputs+v:
                 res = {}
                 if inp.name in metainfo.keys() and inp.name not in mm:
                     res["name"] = inp.name

src/pycropml/transpiler/antlr_py/fortran/fortranTransformer.py

@@ -1262,7 +1262,7 @@ def visit_assignmentstmt(self, node, label, NAME, sFExprListRef, substringRange,
                                     'elements': [res["value"]]},
                                     'right': self.type_env['arrays'][res["target"]["name"]],
                                     'pseudo_type': ['list', type_]},
-                                    'pseudo_type': type_}
+                                    'pseudo_type': ["array",type_]}
                 if self.recursive and str(NAME)==self.out:
                         return {"type":"implicit_return",
                                 "value": res["value"],

src/pycropml/transpiler/antlr_py/python/pythonExtraction.py

@@ -5,6 +5,7 @@
 from pycropml.transpiler.antlr_py.extract_metadata_from_comment import ExtractComments, extract_compo
 from pycropml.transpiler.antlr_py.extraction import ExtractComments
 from openalea.core.pkgmanager import PackageManager
+from pycropml.transpiler.antlr_py.codeExtraction import extraction
 import re
 
 
@@ -21,7 +22,51 @@ def retrievePackage(self, wralea_dir):
 
     def modelunit(self, file, tree):
         pass
+    
+    def getMethod(self, tree):
+        self.getTypeNode(tree, "function_definition") 
+        return self.getTree 
 
-    def modelcomposition(self, wf, mu_names):
-        pass
+    def modelcomposition(self, file, models, tree):
+        self.mc = extract_compo(file)
+        inputlink = []
+        outputlink = []
+        inp = {}
+        #name = re.findall(r'(def\s+.+\()', py_unit)[0].replace("def", "").replace("(", "").strip()
+        funcs = self.getMethod(tree)
+        algo = [f for f in funcs if f.name.startswith("model")]
+        self.getTypeNode(algo[0].block,"custom_call")
+        call = self.getTree
+        self.mc.model = [c.function.split("model_")[-1] for c in call]
+        inps, outs = [], []
+        md = [n for m in self.mc.model for n in models if m.lower() == n.name.split("model_")[-1].lower()]
+        self.mc.model = [n.name for n in md]
+        inps = [n.name for m in md for n in m.inputs ]
+        outs = [n.name for m in md for n in m.outputs ]
+        m_in = set(inps) - set(outs)
+        z = {}
+        internallink= []
+        for m in md:
+            vi = list(set([n.name for n in m.inputs ]).intersection(m_in))
+            vo = [n.name for n in m.outputs]
+            for v in vi:
+                inputlink.append({"target": m.name + "." + v, "source":v})
+            for v in vo: z.update({v:m.name})
+
+        for k, v in z.items():
+            outputlink.append({"source": v + "." + k, "target":k})
+
+        for i in range(0, len(md)-1):
+            mi = md[i]
+            for j in range(i+1, len(md)):
+                mj = md[j]
+                vi = list(set([n.name for n in mi.outputs ]).intersection(set([n.name for n in mj.inputs ])))
+                if vi: 
+                    for k in vi:
+                        internallink.append({"source": mi.name + "." + k, "target":mj.name + "." + k})
+
+        self.mc.inputlink = inputlink
+        self.mc.outputlink = outputlink
+        self.mc.internallink = internallink
+        return self.mc
 

src/pycropml/transpiler/antlr_py/python/pythonTransformer.py

@@ -1053,7 +1053,6 @@ def _translate_builtin_call(self, namespace, function, args, location, attrib):
                     prepare_table(TYPED_API[namespace], ORIGINAL_METHODS.get(namespace)).strip()))
 
             elif not isinstance(api, dict):
-                print(args)
                 z = api.expand(args)
                 if attrib == 1:
                     z["attrib"] = 1

src/pycropml/transpiler/antlr_py/python/run.py

@@ -61,6 +61,7 @@ def run_python(components, package):
     package_name = m[0] +"." + "".join(m[1:])
 
     mu_names = []
+    models = []
     for  k, v in files.items():
         if v not in [composite]:
             print(v)
@@ -88,11 +89,14 @@ def run_python(components, package):
 
             if py_units:
                 for py_unit in py_units:
+                    
                     # match def ...() # retrieve the name
                     name = re.findall(r'(def\s+.+\()', py_unit)[0].replace("def", "").replace("(", "").strip()
                     # extract algorithm of each py_unit using file_asg, the name of the unit
                     meth = z.getmethod(file_asg, name, True)
-
+                    
+                    
+                    
                     mdata = extract(meth.doc) # create a ModelUnit object (description, inputs and outputs). After we complete with other info
                     #print(mdata.description.ExtendedDescription, "babfsdvhsdbvjsbvbsjvjskdfbv")
 
@@ -150,4 +154,13 @@ def run_python(components, package):
                         break
                     else:
                         generate_unitfile(package, mdata, package_name)  
-    
+                    models.append(mdata)
+
+    with open(composite, "r") as f:
+        code = f.read()
+    res_compo = extraction(code, modeltag_begin,modeltag_end)
+    compo_dictasg = to_dictASG(res_compo[0] , "py")
+    compo_asg = to_CASG(compo_dictasg)
+    mc = op_extr.modelcomposition(res_compo[0], models, compo_asg) 
+    generate_compositefile(package, mc, package_name)
+    

src/pycropml/transpiler/antlr_py/simplace/simplaceExtraction.py

@@ -239,25 +239,26 @@ def modelcomposition(self, xfile, models):
         outputs = []
         for el in list(root):
             for l in list(el):
-                mu_name = l.attrib["id"]
-                mods.append(mu_name)
-                for j in list(l):
-                    attr = j.attrib
-                    if j.tag == "input" and "source" in attr:
-                        id = attr["id"]
-                        var = attr["source"].split(".")[-1]
-                        mod = attr["source"].split(".")[0]
-                        if mod == name or mod not in mods:
-                            self.mc.inputlink.append({"target": mu_name + "." + id, "source":var})
-                            inputs.append(var)
-                        elif mod in mods:
-                            self.mc.internallink.append({"source": mod + "." + var, "target":mu_name + "." + id})
-                    elif j.tag == "output":
-                        id = attr["id"]
-                        var = attr["destination"].split(".")[-1]
-                        mod = attr["destination"].split(".")[0]
-                        self.mc.outputlink.append({"source": mu_name + "." + id, "target":var})
-                        outputs.append(var)
+                if l.tag=="simcomponent":
+                    mu_name = l.attrib["id"]
+                    mods.append(mu_name)
+                    for j in list(l):
+                        attr = j.attrib
+                        if j.tag == "input" and "source" in attr:
+                            id = attr["id"]
+                            var = attr["source"].split(".")[-1]
+                            mod = attr["source"].split(".")[0]
+                            if mod == name or mod not in mods:
+                                self.mc.inputlink.append({"target": mu_name + "." + id, "source":var})
+                                inputs.append(var)
+                            elif mod in mods:
+                                self.mc.internallink.append({"source": mod + "." + var, "target":mu_name + "." + id})
+                        elif j.tag == "output":
+                            id = attr["id"]
+                            var = attr["destination"].split(".")[-1]
+                            mod = attr["destination"].split(".")[0]
+                            self.mc.outputlink.append({"source": mu_name + "." + id, "target":var})
+                            outputs.append(var)
         self.mc.model = mods
         for m in models:
             for n in m.inputs:

src/pycropml/transpiler/generators/biomaGenerator.py

@@ -289,6 +289,7 @@ def TestPostConditions(self, node):
         self.open(node)
         self.write("//Set current values of the outputs to the static VarInfo representing the output properties of the domain classes")	
         for out in self.model.outputs:
+            print(out.name)
             self.newline(node)
             self.write('%s%s.DomainClass.%s%sVarInfo.%s.CurrentValue=%s.%s;'%(self.customer,self.name, self.name, out.variablecategory.capitalize(),out.name,category[out.variablecategory], out.name))
         self.newline(node)