fmu-manipulation-toolbox 1.8__tar.gz → 1.8.2.dev2__tar.gz

{fmu_manipulation_toolbox-1.8 → fmu_manipulation_toolbox-1.8.2.dev2}/PKG-INFO

@@ -1,14 +1,19 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: fmu_manipulation_toolbox
-Version: 1.8
+Version: 1.8.2.dev2
 Summary: FMU Manipulation Toobox is a python application which help to modify a Functional Mock-up Units (FMUs) without recompilation or to group them into FMU Containers
 Home-page: https://github.com/grouperenault/fmu_manipulation_toolbox/
 Author: Nicolas.LAURENT@Renault.com
 License-File: LICENSE.txt
-Requires-Dist: PyQt5>=5.15.10
+Requires-Dist: PySide6>=6.8.0
 Requires-Dist: xmlschema>=3.3.1
 Requires-Dist: elementpath>=4.4.0
 Requires-Dist: colorama>=0.4.6
+Dynamic: author
+Dynamic: description
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: summary
 
 FMU Manipulation Toolbox is a python application which help to modify a Functional Mock-up Units (FMUs) 
 without recompilation. It mainly modifies the `modelDescription.xml` file. It is highly customizable.

{fmu_manipulation_toolbox-1.8 → fmu_manipulation_toolbox-1.8.2.dev2}/README.md

@@ -122,22 +122,25 @@ optional arguments:
 ### FMU Containers
 
 ```
-fmucontainer [-h] -fmu-directory FMU_DIRECTORY [-container filename.csv:step_size] [-debug] [-no-auto-input]
-             [-no-auto-output] [-no-auto-link] [-mt] [-profile]
+usage: fmucontainer [-h] [-fmu-directory FMU_DIRECTORY] -container filename.{csv|json|ssp},[:step_size] [-debug]
+                    [-no-auto-input] [-no-auto-output] [-auto-parameter] [-no-auto-link] [-mt] [-profile] [-dump-json]
 
 Generate FMU from FMU's
 
 optional arguments:
   -h, -help
-  -fmu-directory FMU_DIRECTORY      Directory containing initial FMU’s and used to generate containers. (default: None)
-  -container filename.csv:step_size
+  -fmu-directory FMU_DIRECTORY      Directory containing initial FMU’s and used to generate containers. If not defined,
+                                    current directory is used. (default: .)
+  -container filename.{csv|json|ssp},[:step_size]
                                     Description of the container to create. (default: [])
   -debug                            Add lot of useful log during the process. (default: False)
   -no-auto-input                    Create ONLY explicit input. (default: True)
   -no-auto-output                   Create ONLY explicit output. (default: True)
+  -auto-parameter                   Expose parameters of the embedded fmu's. (default: False)
   -no-auto-link                     Create ONLY explicit links. (default: True)
   -mt                               Enable Multi-Threaded mode for the generated container. (default: False)
   -profile                          Enable Profiling mode for the generated container. (default: False)
+  -dump-json                        Dump a JSON file for each container. (default: False)
 ```
 
 ## API

fmu_manipulation_toolbox-1.8.2.dev2/fmu_manipulation_toolbox/__version__.py

@@ -0,0 +1 @@
+'V1.8.2-dev2'

{fmu_manipulation_toolbox-1.8 → fmu_manipulation_toolbox-1.8.2.dev2}/fmu_manipulation_toolbox/assembly.py

@@ -7,7 +7,7 @@ import uuid
 import xml.parsers.expat
 import zipfile
 
-from .fmu_container import FMUContainer, FMUContainerError
+from .fmu_container import FMUContainer
 
 logger = logging.getLogger("fmu_manipulation_toolbox")
 
@@ -23,28 +23,43 @@ class Port:
     def __eq__(self, other):
         return str(self) == str(other)
 
+    def __str__(self):
+        return f"{self.fmu_name}/{self.port_name}"
+
 
 class Connection:
     def __init__(self, from_port: Port, to_port: Port):
         self.from_port = from_port
         self.to_port = to_port
 
+    def __str__(self):
+        return f"{self.from_port} -> {self.to_port}"
+
 
 class AssemblyNode:
-    def __init__(self, name: str, step_size: float = None, mt=False, profiling=False,
-                 auto_link=True, auto_input=True, auto_output=True):
+    def __init__(self, name: Optional[str], step_size: float = None, mt=False, profiling=False,
+                 auto_link=True, auto_input=True, auto_output=True, auto_parameter=False):
         self.name = name
-        self.step_size = step_size
+        if step_size:
+            try:
+                self.step_size = float(step_size)
+            except ValueError:
+                logger.warning(f"Step size '{step_size}' is incorrect format.")
+                self.step_size = None
+        else:
+            self.step_size = None
         self.mt = mt
         self.profiling = profiling
         self.auto_link = auto_link
         self.auto_input = auto_input
         self.auto_output = auto_output
-        self.children: List[AssemblyNode] = []
+        self.auto_parameter = auto_parameter
 
-        self.fmu_names_list: Set[str] = set()
-        self.input_ports: Dict[Port, str] = {}
-        self.output_ports: Dict[Port, str] = {}
+        self.parent: Optional[AssemblyNode] = None
+        self.children: Dict[str, AssemblyNode] = {}     # sub-containers
+        self.fmu_names_list: List[str] = []             # FMUs contained at this level (ordered list)
+        self.input_ports: Dict[Port, str] = {}          # value is input port name, key is the source
+        self.output_ports: Dict[Port, str] = {}         # value is output port name, key is the origin
         self.start_values: Dict[Port, str] = {}
         self.drop_ports: List[Port] = []
         self.links: List[Connection] = []
@@ -53,11 +68,20 @@ class AssemblyNode:
         if sub_node.name is None:
             sub_node.name = str(uuid.uuid4())+".fmu"
 
-        self.fmu_names_list.add(sub_node.name)
-        self.children.append(sub_node)
+        if sub_node.parent is not None:
+            raise AssemblyError(f"Internal Error: AssemblyNode {sub_node.name} is already parented.")
+
+        if sub_node.name in self.children:
+            raise AssemblyError(f"Internal Error: AssemblyNode {sub_node.name} is already child of {self.name}")
+
+        sub_node.parent = self
+        if sub_node.name not in self.fmu_names_list:
+            self.fmu_names_list.append(sub_node.name)
+        self.children[sub_node.name] = sub_node
 
     def add_fmu(self, fmu_name: str):
-        self.fmu_names_list.add(fmu_name)
+        if fmu_name not in self.fmu_names_list:
+            self.fmu_names_list.append(fmu_name)
 
     def add_input(self, from_port_name: str, to_fmu_filename: str, to_port_name: str):
         self.input_ports[Port(to_fmu_filename, to_port_name)] = from_port_name
@@ -76,12 +100,13 @@ class AssemblyNode:
         self.start_values[Port(fmu_filename, port_name)] = value
 
     def make_fmu(self, fmu_directory: Path, debug=False, description_pathname=None):
-        for node in self.children:
+        for node in self.children.values():
             node.make_fmu(fmu_directory, debug=debug)
 
-        container = FMUContainer(self.name, fmu_directory, description_pathname=description_pathname)
+        identifier = str(Path(self.name).stem)
+        container = FMUContainer(identifier, fmu_directory, description_pathname=description_pathname)
 
-        for fmu_name in sorted(self.fmu_names_list):
+        for fmu_name in self.fmu_names_list:
             container.get_fmu(fmu_name)
 
         for port, source in self.input_ports.items():
@@ -102,14 +127,77 @@ class AssemblyNode:
 
         container.add_implicit_rule(auto_input=self.auto_input,
                                     auto_output=self.auto_output,
-                                    auto_link=self.auto_link)
+                                    auto_link=self.auto_link,
+                                    auto_parameter=self.auto_parameter)
 
         container.make_fmu(self.name, self.step_size, mt=self.mt, profiling=self.profiling, debug=debug)
 
-        for node in self.children:
+        for node in self.children.values():
             logger.info(f"Deleting transient FMU Container '{node.name}'")
             (fmu_directory / node.name).unlink()
 
+    def get_final_from(self, port: Port) -> Port:
+        if port in self.input_ports:
+            ancestor = Port(self.name, self.input_ports[port])
+            if self.parent:
+                return self.parent.get_final_from(ancestor)  # input port
+            else:
+                return ancestor  # TOPLEVEL input port
+        elif port.fmu_name in self.fmu_names_list:
+            if port.fmu_name in self.children:
+                child = self.children[port.fmu_name]
+                ancestors = [key for key, val in child.output_ports.items() if val == port.port_name]
+                if len(ancestors) == 1:
+                    return child.get_final_from(ancestors[0])  # child output port
+            else:
+                return port  # embedded FMU
+
+        raise AssemblyError(f"{self.name}: Port {port} is not connected upstream.")
+
+    def get_final_to(self, port: Port) -> Port:
+        if port in self.output_ports:
+            successor = Port(self.name, self.output_ports[port])
+            if self.parent:
+                return self.parent.get_final_to(successor)  # Output port
+            else:
+                return successor  # TOLEVEL output port
+        elif port.fmu_name in self.fmu_names_list:
+            if port.fmu_name in self.children:
+                child = self.children[port.fmu_name]
+                successors = [key for key, val in child.input_ports.items() if val == port.port_name]
+                if len(successors) == 1:
+                    return child.get_final_to(successors[0])  # Child input port
+            else:
+                return port  # embedded FMU
+
+        raise AssemblyError(f"Node {self.name}: Port {port} is not connected downstream.")
+
+    def get_fmu_connections(self, fmu_name: str) -> List[Connection]:
+        connections = []
+        if fmu_name not in self.fmu_names_list:
+            raise AssemblyError(f"Internal Error: FMU {fmu_name} is not embedded by {self.name}.")
+        for link in self.links:
+            if link.from_port.fmu_name == fmu_name:
+                connections.append(Connection(link.from_port, self.get_final_to(link.to_port)))
+            elif link.to_port.fmu_name == fmu_name:
+                connections.append(Connection(self.get_final_from(link.from_port), link.to_port))
+
+        for to_port, input_port_name in self.input_ports.items():
+            if to_port.fmu_name == fmu_name:
+                if self.parent:
+                    connections.append(Connection(self.parent.get_final_from(Port(self.name, input_port_name)), to_port))
+                else:
+                    connections.append(Connection(Port(self.name, input_port_name), to_port))
+
+        for from_port, output_port_name in self.output_ports.items():
+            if from_port.fmu_name == fmu_name:
+                if self.parent:
+                    connections.append(Connection(from_port, self.parent.get_final_to(Port(self.name, output_port_name))))
+                else:
+                    connections.append(Connection(from_port, Port(self.name, output_port_name))) ###HERE
+
+        return connections
+
 
 class AssemblyError(Exception):
     def __init__(self, reason: str):
@@ -121,13 +209,14 @@ class AssemblyError(Exception):
 
 class Assembly:
     def __init__(self, filename: str, step_size=None, auto_link=True,  auto_input=True, debug=False,
-                 auto_output=True, mt=False, profiling=False, fmu_directory: Path = "."):
+                 auto_output=True, mt=False, profiling=False, fmu_directory: Path = Path("."), auto_parameter=False):
         self.filename = Path(filename)
         self.default_auto_input = auto_input
         self.debug = debug
         self.default_auto_output = auto_output
         self.default_step_size = step_size
         self.default_auto_link = auto_link
+        self.default_auto_parameter = auto_parameter
         self.default_mt = mt
         self.default_profiling = profiling
         self.fmu_directory = fmu_directory
@@ -135,9 +224,10 @@ class Assembly:
         self.transient_dirnames: Set[Path] = set()
 
         if not fmu_directory.is_dir():
-            raise FMUContainerError(f"FMU directory is not valid: '{fmu_directory}'")
+            raise AssemblyError(f"FMU directory is not valid: '{fmu_directory}'")
 
-        self.description_pathname = fmu_directory / self.filename  # For inclusion in FMU
+        self.input_pathname = fmu_directory / self.filename
+        self.description_pathname = self.input_pathname   # For inclusion in FMU
         self.root = None
         self.read()
 
@@ -169,7 +259,7 @@ class Assembly:
         elif self.filename.suffix == ".csv":
             self.read_csv()
         else:
-            raise FMUContainerError(f"Not supported file format '{self.filename}")
+            raise AssemblyError(f"Not supported file format '{self.filename}")
 
     def write(self, filename: str):
         if filename.endswith(".csv"):
@@ -183,11 +273,12 @@ class Assembly:
         name = str(self.filename.with_suffix(".fmu"))
         self.root = AssemblyNode(name, step_size=self.default_step_size, auto_link=self.default_auto_link,
                                  mt=self.default_mt, profiling=self.default_profiling,
-                                 auto_input=self.default_auto_input, auto_output=self.default_auto_output)
+                                 auto_input=self.default_auto_input, auto_output=self.default_auto_output,
+                                 auto_parameter=self.default_auto_parameter)
 
-        with open(self.description_pathname) as file:
+        with open(self.input_pathname) as file:
             reader = csv.reader(file, delimiter=';')
-            self.check_csv_headers(reader)
+            self._check_csv_headers(reader)
             for i, row in enumerate(reader):
                 if not row or row[0][0] == '#':  # skip blank line of comment
                     continue
@@ -198,36 +289,19 @@ class Assembly:
                     logger.error(f"Line #{i+2}: expecting 5 columns. Line skipped.")
                     continue
 
-                rule = rule.upper()
-                if rule in ("LINK", "INPUT", "OUTPUT", "DROP", "FMU", "START"):
-                    try:
-                        self._read_csv_rule(self.root, rule,
-                                            from_fmu_filename, from_port_name, to_fmu_filename, to_port_name)
-                    except AssemblyError as e:
-                        logger.error(f"Line #{i+2}: {e}. Line skipped.")
-                        continue
-                else:
-                    logger.error(f"Line #{i+2}: unexpected rule '{rule}'. Line skipped.")
-
-    def write_csv(self, filename: Union[str, Path]):
-        if self.root.children:
-            raise AssemblyError("This assembly is not flat. Cannot export to CSV file.")
+                try:
+                    self._read_csv_rule(self.root, rule.upper(),
+                                        from_fmu_filename, from_port_name, to_fmu_filename, to_port_name)
+                except AssemblyError as e:
+                    logger.error(f"Line #{i+2}: {e}. Line skipped.")
+                    continue
 
-        with open(self.fmu_directory / filename, "wt") as outfile:
-            outfile.write("rule;from_fmu;from_port;to_fmu;to_port\n")
-            for fmu in self.root.fmu_names_list:
-                outfile.write(f"FMU;{fmu};;;\n")
-            for port, source in self.root.input_ports.items():
-                outfile.write(f"INPUT;;{source};{port.fmu_name};{port.port_name}\n")
-            for port, target in self.root.output_ports.items():
-                outfile.write(f"OUTPUT;{port.fmu_name};{port.port_name};;{target}\n")
-            for link in self.root.links:
-                outfile.write(f"LINK;{link.from_port.fmu_name};{link.from_port.port_name};"
-                              f"{link.to_port.fmu_name};{link.to_port.port_name}\n")
-            for port, value in self.root.start_values.items():
-                outfile.write(f"START;{port.fmu_name};{port.port_name};{value};\n")
-            for port in self.root.drop_ports:
-                outfile.write(f"DROP;{port.fmu_name};{port.port_name};;\n")
+    @staticmethod
+    def _check_csv_headers(reader):
+        headers = next(reader)
+        headers_lowered = [h.lower() for h in headers]
+        if not headers_lowered == ["rule", "from_fmu", "from_port", "to_fmu", "to_port"]:
+            raise AssemblyError("Header (1st line of the file) is not well formatted.")
 
     @staticmethod
     def _read_csv_rule(node: AssemblyNode, rule: str, from_fmu_filename: str, from_port_name: str,
@@ -264,114 +338,147 @@ class Assembly:
                 raise AssemblyError("Missing START ports information.")
 
             node.add_start_value(from_fmu_filename, from_port_name, to_fmu_filename)
-        # no else: check on rule is already done in read_description()
+        else:
+            raise AssemblyError(f"unexpected rule '{rule}'. Line skipped.")
 
-    @staticmethod
-    def check_csv_headers(reader):
-        headers = next(reader)
-        if not headers == ["rule", "from_fmu", "from_port", "to_fmu", "to_port"]:
-            raise AssemblyError("Header (1st line of the file) is not well formatted.")
+    def write_csv(self, filename: Union[str, Path]):
+        if self.root.children:
+            raise AssemblyError("This assembly is not flat. Cannot export to CSV file.")
+
+        with open(self.fmu_directory / filename, "wt") as outfile:
+            outfile.write("rule;from_fmu;from_port;to_fmu;to_port\n")
+            for fmu in self.root.fmu_names_list:
+                outfile.write(f"FMU;{fmu};;;\n")
+            for port, source in self.root.input_ports.items():
+                outfile.write(f"INPUT;;{source};{port.fmu_name};{port.port_name}\n")
+            for port, target in self.root.output_ports.items():
+                outfile.write(f"OUTPUT;{port.fmu_name};{port.port_name};;{target}\n")
+            for link in self.root.links:
+                outfile.write(f"LINK;{link.from_port.fmu_name};{link.from_port.port_name};"
+                              f"{link.to_port.fmu_name};{link.to_port.port_name}\n")
+            for port, value in self.root.start_values.items():
+                outfile.write(f"START;{port.fmu_name};{port.port_name};{value};\n")
+            for port in self.root.drop_ports:
+                outfile.write(f"DROP;{port.fmu_name};{port.port_name};;\n")
 
     def read_json(self):
-        with open(self.description_pathname) as file:
+        with open(self.input_pathname) as file:
             try:
                 data = json.load(file)
             except json.decoder.JSONDecodeError as e:
-                raise FMUContainerError(f"Cannot read json: {e}")
-        self.root = self.json_decode_node(data)
+                raise AssemblyError(f"Cannot read json: {e}")
+        self.root = self._json_decode_node(data)
         if not self.root.name:
-            self.root.name = str(self.filename.with_suffix(".fmu"))
+            self.root.name = str(self.filename.with_suffix(".fmu").name)
+
+    def _json_decode_node(self, data: Dict) -> AssemblyNode:
+        name = data.get("name", None)                                                       # 1
+        mt = data.get("mt", self.default_mt)                                                # 2
+        profiling = data.get("profiling", self.default_profiling)                           # 3
+        auto_link = data.get("auto_link", self.default_auto_link)                           # 4
+        auto_input = data.get("auto_input", self.default_auto_input)                        # 5
+        auto_output = data.get("auto_output", self.default_auto_output)                     # 6
+        auto_parameter = data.get("auto_parameter", self.default_auto_parameter)            # 6b
+        step_size = data.get("step_size", self.default_step_size)                           # 7
+
+        node = AssemblyNode(name, step_size=step_size, auto_link=auto_link, mt=mt, profiling=profiling,
+                            auto_input=auto_input, auto_output=auto_output, auto_parameter=auto_parameter)
+
+        for key, value in data.items():
+            if key in ('name', 'step_size', 'auto_link', 'auto_input', 'auto_output', 'mt', 'profiling',
+                       'auto_parameter'):
+                continue  # Already read
+
+            elif key == "container":  # 8
+                if not isinstance(value, list):
+                    raise AssemblyError("JSON: 'container' keyword should define a list.")
+                for sub_data in value:
+                    node.add_sub_node(self._json_decode_node(sub_data))
+
+            elif key == "fmu":  # 9
+                if not isinstance(value, list):
+                    raise AssemblyError("JSON: 'fmu' keyword should define a list.")
+                for fmu in value:
+                    node.add_fmu(fmu)
+
+            elif key == "input":  # 10
+                self._json_decode_keyword('input', value, node.add_input)
+
+            elif key == "output":  # 11
+                self._json_decode_keyword('output', value, node.add_output)
+
+            elif key == "link":  # 12
+                self._json_decode_keyword('link', value, node.add_link)
+
+            elif key == "start":  # 13
+                self._json_decode_keyword('start', value, node.add_start_value)
+
+            elif key == "drop":  # 14
+                self._json_decode_keyword('drop', value, node.add_drop_port)
+
+            else:
+                logger.error(f"JSON: unexpected keyword {key}. Skipped.")
+
+        return node
+
+    @staticmethod
+    def _json_decode_keyword(keyword: str, value, function):
+        if not isinstance(value, list):
+            raise AssemblyError(f"JSON: '{keyword}' keyword should define a list.")
+        for line in value:
+            if not isinstance(line, list):
+                raise AssemblyError(f"JSON: unexpected '{keyword}' value: {line}.")
+            try:
+                function(*line)
+            except TypeError:
+                raise AssemblyError(f"JSON: '{keyword}' value does not contain right number of fields: {line}.")
 
     def write_json(self, filename: Union[str, Path]):
         with open(self.fmu_directory / filename, "wt") as file:
-            data = self.json_encode_node(self.root)
+            data = self._json_encode_node(self.root)
             json.dump(data, file, indent=2)
 
-    def json_encode_node(self, node: AssemblyNode) -> Dict[str, Any]:
+    def _json_encode_node(self, node: AssemblyNode) -> Dict[str, Any]:
         json_node = dict()
-        json_node["name"] = node.name
-        json_node["mt"] = node.mt
-        json_node["profiling"] = node.profiling
-        json_node["auto_link"] = node.auto_link
+        json_node["name"] = node.name                      # 1
+        json_node["mt"] = node.mt                          # 2
+        json_node["profiling"] = node.profiling            # 3
+        json_node["auto_link"] = node.auto_link            # 4
+        json_node["auto_input"] = node.auto_input          # 5
+        json_node["auto_output"] = node.auto_output        # 6
+        json_node["auto_parameter"] = node.auto_parameter  # 6b
+
         if node.step_size:
-            json_node["step_size"] = node.step_size
+            json_node["step_size"] = node.step_size        # 7
 
         if node.children:
-            json_node["container"] = [self.json_encode_node(child) for child in node.children]
+            json_node["container"] = [self._json_encode_node(child) for child in node.children.values()]  # 8
 
         if node.fmu_names_list:
-            json_node["fmu"] = [f"{fmu_name}" for fmu_name in sorted(node.fmu_names_list)]
+            json_node["fmu"] = [f"{fmu_name}" for fmu_name in sorted(node.fmu_names_list)]          # 9
 
         if node.input_ports:
-            json_node["input"] = [[f"{source}", f"{port.fmu_name}", f"{port.port_name}"]
+            json_node["input"] = [[f"{source}", f"{port.fmu_name}", f"{port.port_name}"]            # 10
                                   for port, source in node.input_ports.items()]
 
         if node.output_ports:
-            json_node["output"] = [[f"{port.fmu_name}", f"{port.port_name}", f"{target}"]
+            json_node["output"] = [[f"{port.fmu_name}", f"{port.port_name}", f"{target}"]           # 11
                                    for port, target in node.output_ports.items()]
 
         if node.links:
-            json_node["link"] = [[f"{link.from_port.fmu_name}", f"{link.from_port.port_name}",
+            json_node["link"] = [[f"{link.from_port.fmu_name}", f"{link.from_port.port_name}",      # 12
                                   f"{link.to_port.fmu_name}", f"{link.to_port.port_name}"]
                                  for link in node.links]
 
         if node.start_values:
-            json_node["start"] = [[f"{port.fmu_name}", f"{port.port_name}", value]
+            json_node["start"] = [[f"{port.fmu_name}", f"{port.port_name}", value]                  # 13
                                   for port, value in node.start_values.items()]
 
         if node.drop_ports:
-            json_node["drop"] = [[f"{port.fmu_name}", f"{port.port_name}"] for port in node.drop_ports]
+            json_node["drop"] = [[f"{port.fmu_name}", f"{port.port_name}"] for port in node.drop_ports]  # 14
 
         return json_node
 
-    def json_decode_node(self, data) -> AssemblyNode:
-        name = data.get("name", None)
-        step_size = data.get("step_size", self.default_step_size)
-        auto_link = data.get("auto_link", self.default_auto_link)
-        auto_input = data.get("auto_input", self.default_auto_input)
-        auto_output = data.get("auto_output", self.default_auto_output)
-        mt = data.get("mt", self.default_mt)
-        profiling = data.get("profiling", self.default_profiling)
-
-        node = AssemblyNode(name, step_size=step_size, auto_link=auto_link, mt=mt, profiling=profiling,
-                            auto_input=auto_input, auto_output=auto_output)
-
-        if "container" in data:
-            if not isinstance(data["container"], list):
-                raise FMUContainerError("JSON: 'container' keyword should define a list.")
-            for sub_data in data["container"]:
-                node.add_sub_node(self.json_decode_node(sub_data))
-
-        if "fmu" in data:
-            if not isinstance(data["fmu"], list):
-                raise FMUContainerError("JSON: 'fmu' keyword should define a list.")
-            for fmu in data["fmu"]:
-                node.add_fmu(fmu)
-
-        if "input" in data:
-            if not isinstance(data["input"], list):
-                raise FMUContainerError("JSON: 'input' keyword should define a list.")
-            for line in data["input"]:
-                node.add_input(line[1], line[2], line[0])
-
-        if "output" in data:
-            if not isinstance(data["output"], list):
-                raise FMUContainerError("JSON: 'output' keyword should define a list.")
-            for line in data["output"]:
-                node.add_output(line[0], line[1], line[2])
-
-        if "start" in data:
-            if not isinstance(data["start"], list):
-                raise FMUContainerError("JSON: 'start' keyword should define a list.")
-            for line in data["start"]:
-                node.add_start_value(line[0], line[1], line[2])
-
-        if "drop" in data:
-            for line in data["drop"]:
-                node.add_drop_port(line[0], line[1])
-
-        return node
-
     def read_ssp(self):
         logger.warning("This feature is ALPHA stage.")
 
@@ -388,11 +495,11 @@ class Assembly:
                             mt=self.default_mt, profiling=self.default_profiling,
                             auto_input=self.default_auto_input, auto_output=self.default_auto_output)
             self.root = sdd.parse(self.description_pathname)
+            self.root.name = str(self.filename.with_suffix(".fmu"))
 
     def make_fmu(self, dump_json=False):
         if dump_json:
-            dump_file = (self.description_pathname.with_stem(self.description_pathname.stem + "-dump")
-                         .with_suffix(".json"))
+            dump_file = Path(self.input_pathname.stem + "-dump").with_suffix(".json")
             logger.info(f"Dump Json '{dump_file}'")
             self.write_json(dump_file)
         self.root.make_fmu(self.fmu_directory, debug=self.debug, description_pathname=self.description_pathname)

{fmu_manipulation_toolbox-1.8 → fmu_manipulation_toolbox-1.8.2.dev2}/fmu_manipulation_toolbox/cli.py

@@ -5,7 +5,7 @@ from colorama import Fore, Style, init
 
 from .fmu_operations import *
 from .fmu_container import FMUContainerError
-from .assembly import Assembly
+from .assembly import Assembly, AssemblyError
 from .checker import checker_list
 from .version import __version__ as version
 from .help import Help
@@ -176,6 +176,9 @@ def fmucontainer():
     parser.add_argument("-no-auto-output", action="store_false", dest="auto_output", default=True,
                         help="Create ONLY explicit output.")
 
+    parser.add_argument("-auto-parameter", action="store_true", dest="auto_parameter", default=False,
+                        help="Expose parameters of the embedded fmu's.")
+
     parser.add_argument("-no-auto-link", action="store_false", dest="auto_link", default=True,
                         help="Create ONLY explicit links.")
 
@@ -206,12 +209,12 @@ def fmucontainer():
         try:
             assembly = Assembly(filename, step_size=step_size, auto_link=config.auto_link,
                                 auto_input=config.auto_input, auto_output=config.auto_output, mt=config.mt,
-                                profiling=config.profiling, fmu_directory=fmu_directory, debug=config.debug)
-
+                                profiling=config.profiling, fmu_directory=fmu_directory, debug=config.debug,
+                                auto_parameter=config.auto_parameter)
         except FileNotFoundError as e:
             logger.fatal(f"Cannot read file: {e}")
             continue
-        except FMUContainerError as e:
+        except (FMUContainerError, AssemblyError) as e:
             logger.fatal(f"{filename}: {e}")
             continue