Python scalability banks

RELEASES.md

@@ -47,3 +47,34 @@ The `lfc` command line application is suitable for:
 - [C++](https://github.com/icyphy/lingua-franca/wiki/Writing-Reactors-in-Cpp)
 - [Python](https://github.com/icyphy/lingua-franca/wiki/Writing-Reactors-in-Python)
 - [TypeScript](https://github.com/icyphy/lingua-franca/wiki/Writing-Reactors-in-TypeScript)
+
+### Bug Fixes
+- fixed an issue where top-level custom Python classes were being serialized
+  incorrectly
+
+### New Features
+- [Python] `bank_index` (useful for banks of reactors) is now a proper parameter
+  that can be passed down the reactor hierarchy via parameter assignment. For
+  example, the following code snippet now works as expected:
+  ```Python
+  target Python;
+  reactor Bar (bank_index(0), parent_bank_index(0)) {
+    reaction(startup) {= 
+      print(f"My parent bank index is {self.parent_bank_index}.") 
+    =}
+  }
+  reactor Foo (bank_index(0)) {
+    bar = new[2] Bar(parent_bank_index = bank_index)
+  }
+  main reactor {
+    f = new[2] Foo()
+  }
+  ```
+  The output will be:
+
+  ```bash
+  My parent bank index is 0.
+  My parent bank index is 1.
+  My parent bank index is 1.
+  My parent bank index is 0.
+  ```

org.lflang.tests/src/org/lflang/tests/lsp/ErrorInserter.java

@@ -177,11 +177,13 @@ private void alter(BiFunction<ListIterator<String>, String, Boolean> alterer) {
             int lineNumber = 0;
             while (it.hasNext()) {
                 String current = it.next();
-                if (current.contains("=}")) inCodeBlock = false;
+                String uncommented = current.contains("//") ?
+                    current.substring(0, current.indexOf("//")) : current;
+                if (uncommented.contains("=}")) inCodeBlock = false;
                 if (inCodeBlock && alterer.apply(it, current)) badLines.add(lineNumber);
-                if (current.contains("{=")) inCodeBlock = true;
-                if (current.contains("{=") && current.contains("=}")) {
-                    inCodeBlock = current.lastIndexOf("{=") > current.lastIndexOf("=}");
+                if (uncommented.contains("{=")) inCodeBlock = true;
+                if (uncommented.contains("{=") && uncommented.contains("=}")) {
+                    inCodeBlock = uncommented.lastIndexOf("{=") > uncommented.lastIndexOf("=}");
                 }
                 lineNumber++;
             }

org.lflang/src/org/lflang/federated/FedASTUtils.java

@@ -619,10 +619,12 @@ private static void addNetworkOutputControlReaction(
                 Input newTriggerForControlReactionVariable = factory.createInput();
                 newTriggerForControlReactionVariable.setName(triggerName);
 
-                // The input needs a type. All targets have a Time type, so we use that.
-                Type portType = factory.createType();
-                portType.setId(generator.getTargetTypes().getTargetTimeType());
-                newTriggerForControlReactionVariable.setType(portType);
+                if (generator.getTarget().requiresTypes) {
+                    // The input needs a type. All targets have a Time type, so we use that.
+                    Type portType = factory.createType();
+                    portType.setId(generator.getTargetTypes().getTargetTimeType());
+                    newTriggerForControlReactionVariable.setType(portType);
+                }
 
                 top.getInputs().add(newTriggerForControlReactionVariable);
 

org.lflang/src/org/lflang/generator/c/CGenerator.xtend

@@ -886,7 +886,7 @@ class CGenerator extends GeneratorBase {
 
         if (targetConfig.dockerOptions !== null) {
             if (isFederated) {
-                appendRtiToDockerComposeServices(dockerComposeServices, rtiName, "rti:rti", federates.size);
+                appendRtiToDockerComposeServices(dockerComposeServices, rtiName, "lflang/rti:rti", federates.size);
             }
             writeFederatesDockerComposeFile(dockerComposeDir, dockerComposeServices, dockerComposeNetworkName);
         }

org.lflang/src/org/lflang/generator/python/PyUtil.java

@@ -0,0 +1,88 @@
+/* Utilities for Python code generation. */
+
+/*************
+Copyright (c) 2019-2021, The University of California at Berkeley.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice,
+   this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+***************/
+
+package org.lflang.generator.python;
+
+import org.lflang.generator.ReactorInstance;
+import org.lflang.generator.c.CUtil;
+
+
+/**
+ * A collection of utilities for Python code generation.
+ * This class inherits from CUtil but overrides a few methods to 
+ * codify the coding conventions for the Python target code generator.
+ * I.e., it defines how some variables are named and referenced.
+ * @author{Edward A. Lee <[email protected]>}
+ * @author{Soroush Bateni <[email protected]>}
+ */
+public class PyUtil extends CUtil {
+
+    /**
+     * Return the name of the list of Python class instances that contains the
+     * specified reactor instance. This is similar to
+     * {@link #reactorRef(ReactorInstance)} except that it does not index into
+     * the list.
+     * 
+     * @param instance The reactor instance.
+     */
+    static public String reactorRefName(ReactorInstance instance) {
+        return instance.uniqueID() + "_lf";
+    }
+
+    /**
+     * Return a reference to the list of Python class instances that contains
+     * the specified reactor instance. The returned string has the form
+     * list_name[runtimeIndex], where list_name is the name of the list of
+     * Python class instances that contains this reactor instance. If
+     * runtimeIndex is null, then it is replaced by the expression returned by
+     * {@link runtimeIndex(ReactorInstance)} or 0 if there are no banks.
+     * 
+     * @param instance     The reactor instance.
+     * @param runtimeIndex An optional expression to use to address bank
+     *                     members. If this is null, the expression used will be
+     *                     that returned by
+     *                     {@link #runtimeIndex(ReactorInstance)}.
+     */
+    static public String reactorRef(ReactorInstance instance, String runtimeIndex) {
+        if (runtimeIndex == null) runtimeIndex = runtimeIndex(instance);
+        return PyUtil.reactorRefName(instance) + "[" + runtimeIndex + "]";
+    }
+
+    /**
+     * Return a reference to the list of Python class instances that contains
+     * the specified reactor instance. The returned string has the form
+     * list_name[j], where list_name is the name of the list of of Python class
+     * instances that contains this reactor instance and j is the expression
+     * returned by {@link #runtimeIndex(ReactorInstance)} or 0 if there are no
+     * banks.
+     * 
+     * @param instance The reactor instance.
+     */
+    static public String reactorRef(ReactorInstance instance) {
+        return PyUtil.reactorRef(instance, null);
+    }
+
+}