fmu-manipulation-toolbox 1.7.5__tar.gz

fmu_manipulation_toolbox-1.7.5/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2024 Renault SAS - Nicolas.LAURENT@Renault.com
+
+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 AUTHOR 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 AUTHOR 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.

fmu_manipulation_toolbox-1.7.5/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.1
+Name: fmu_manipulation_toolbox
+Version: 1.7.5
+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: xmlschema>=3.3.1
+Requires-Dist: elementpath>=4.4.0
+Requires-Dist: colorama>=0.4.6
+
+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.
+
+Manipulating the `modelDescription.xml` can be a dangerous thing! Communicating with the FMU-developer and adapting
+the way the FMU is generated, is the preferable when possible.
+
+FMU Manipulation Toolbox also allows to group FMU's inside FMU Containers.
+    

fmu_manipulation_toolbox-1.7.5/README.md

@@ -0,0 +1,220 @@
+![Title](fmu_manipulation_toolbox/resources/fmu_manipulation_toolbox.png)
+
+FMU Manipulation Toolbox is a python package which help to analyse and modify a [Functional Mock-up Units (FMUs)](http://fmi-standard.org/)
+without recompilation. It is highly customizable. It can even modify the `modelDescription.xml` file.
+
+Manipulating the `modelDescription.xml` can be a dangerous thing! Communicating with the FMU-developer and adapting
+the way the FMU is generated, is preferable when possible.
+
+FMU Manipulation Toolbox also allows to group FMU's inside FMU Containers. (see [container/README.md](container/README.md))
+
+## Installation
+
+Two options available to install FMU Manipulation Toolbox:
+
+- (Easiest option) Install with from PyPI: `python -m pip install fmu_manipulation`
+- Compile and install from [github repository](https://github.com/grouperenault/fmu_manipulation_toolbox). You will need 
+  - Python required packages. See `requirements.txt`.
+  - C compiler
+
+    
+## Graphical User Interface
+
+FMU Manipulation Toolbox is released with a GUI. You can launch it with the following command `fmutool`
+(without any option)
+
+![GUI](doc/gui.png "GUI")
+
+
+## Command Line Interface
+
+FMU Manipulation Toolbox comes with 2 commands:
+- `fmutool`: a versatile analysis and manipulation tool for FMU.
+- `fmucontainer`: group FMU's inside FMU Containers. (see [container/README.md](container/README.md))
+
+
+### Analysis and Manipulation tool:
+
+You can use `fmutool -help` to get usage:
+
+```
+usage: fmutool [-h] -input path/to/module.fmu [-output path/to/module-modified.fmu] [-remove-toplevel] [-merge-toplevel]
+               [-trim-until prefix] [-remove-regexp regular-expression] [-keep-only-regexp regular-expression]
+               [-remove-all] [-dump-csv path/to/list.csv] [-rename-from-csv path/to/translation.csv]
+               [-add-remoting-win32] [-add-remoting-win64] [-add-frontend-win32] [-add-frontend-win64]
+               [-extract-descriptor path/to/saved-modelDescriptor.xml] [-remove-sources] [-only-parameters]
+               [-only-inputs] [-only-outputs] [-summary] [-check]
+
+fmutool is program to manipulate FMU.
+
+optional arguments:
+  -h, -help                         display help.
+  -input path/to/module.fmu         this option is mandatory to specify the filename of the FMU to be loaded. (default:
+                                    None)
+  -output path/to/module-modified.fmu
+                                    this option is used to specify the filename of the FMU to be created after
+                                    manipulations. If it is not provided, no new fmu will be saved and some
+                                    manipulations can be lost. (default: None)
+  -remove-toplevel                  rename the ports of the input fmu by striping all characters until the first '.'
+                                    (toplevel bus). If no '.' is present, the port won't be renamed. Resulting fmu
+                                    should be saved by using -output option. Note: before version 1.2.6, this option was
+                                    spelled -remove-toplel. (default: None)
+  -merge-toplevel                   replace first '.' by an '_' on every port name. (default: None)
+  -trim-until prefix                remove a prefix from port name. Example '-trim-until _' : will rename port names of
+                                    the FMU by removing part of the name until the first '_'. Prefix can be longer than
+                                    a single character. (default: None)
+  -remove-regexp regular-expression
+                                    remove ports that match the regular-expression. Other ports will be kept. Resulting
+                                    fmu should be saved by using -output option. This option is available from version
+                                    1.1. See https://en.wikipedia.org/wiki/Regular_expression to have more detail of
+                                    expected format. (default: None)
+  -keep-only-regexp regular-expression
+                                    keep only ports that match the regular-expression. Other ports will be removed.
+                                    Resulting fmu should be saved by using -output option. This option is available from
+                                    version 1.1. See https://en.wikipedia.org/wiki/Regular_expression to have more
+                                    detail of expected format. (default: None)
+  -remove-all                       equivalent to '-remove-regexp .*'. Typical use case is to use it with -only-*
+                                    options. Example: in order ro suppress all parameters of FMU: -only-parameters
+                                    -remove-all (default: None)
+  -dump-csv path/to/list.csv        list all names of the ports of the input fmu and store them inside path/to/list.csv.
+                                    This file is ';' separated. It contains two columns in order to be easily reused by
+                                    -rename-from-csv option. (default: None)
+  -rename-from-csv path/to/translation.csv
+                                    rename the ports of fmu accordingly to path/to/translation.csv. This file is ';'
+                                    separated. It contains two columns. First column contains original names. Second
+                                    column contains new names. * If a port is not found in the file, it won't be
+                                    renamed. This is working with version > 1.2.6. It is safer to keep ALL port in csv.
+                                    * If the new name is empty, the port will be removed. This is working starting
+                                    version 1.1. * If a name in the file is not present in input FMU, it will be
+                                    ignored. (no warning will be issued). Resulting fmu should be saved by using -output
+                                    option. (default: None)
+  -add-remoting-win32               this option is windows specific. It will add 'win32' interface to a 'win64' fmu.
+                                    Please upgrade to version 1.2.1 before using this option. Resulting fmu should be
+                                    saved by using -output option. (default: None)
+  -add-remoting-win64               this option is windows specific. It will add 'win64' interface to a 'win32' fmu.
+                                    Please upgrade to version 1.2.1 before using this option. Resulting fmu should be
+                                    saved by using -output option. (default: None)
+  -add-frontend-win32               this option is windows specific. It can be used with 'win32' fmu. At simulation
+                                    time, the FMU will spawn a dedicated process tu run the model. This option is
+                                    available from version 1.4. Resulting fmu should be saved by using -output option.
+                                    (default: None)
+  -add-frontend-win64               this option is windows specific. It can be used with 'win64' fmu. At simulation
+                                    time, the FMU will spawn a dedicated process tu run the model. This option is
+                                    available from version 1.4. Resulting fmu should be saved by using -output option.
+                                    (default: None)
+  -extract-descriptor path/to/saved-modelDescriptor.xml
+                                    save the modelDescription.xml into the specified location. If modification options
+                                    (like -rename-from-csv or -remove-toplevel are set), the saved file will contain
+                                    modification. This option is available from version 1.1. (default: None)
+  -remove-sources                   Remove sources folder from the FMU. This option is available from version 1.3.
+                                    (default: None)
+  -only-parameters                  apply operation only on ports with causality = 'parameter'. This option is available
+                                    from version 1.3. (default: None)
+  -only-inputs                      apply operation only on ports with causality = 'parameter'. This option is available
+                                    from version 1.3. (default: None)
+  -only-outputs                     apply operation only on ports with causality = 'output'. This option is available
+                                    from version 1.3. (default: None)
+  -summary                          display useful information regarding the FMU. (default: None)
+  -check                            performs some check of FMU and display Errors or Warnings. This is useful to avoid
+                                    later issues when using the FMU. (default: None)
+```
+
+### 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]
+
+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
+                                    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)
+  -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)
+```
+
+## API
+
+You can write your own FMU Manipulation scripts. Once you downloaded fmutool module, 
+adding the `import` statement lets you access the API :
+
+```python
+from fmu_manipulation_toolbox.fmu_operations import FMU, OperationExtractNames, OperationStripTopLevel,
+  OperationRenameFromCSV
+```
+
+### remove toplevel bus (if any)
+
+Give a FMU with the following I/O structure
+```
+├── Parameters
+│   ├── Foo
+│   │   ├── param_A
+│   ├── Bar
+├── Generator
+│   ├── Input_A
+│   ├── Output_B
+```
+
+The following transformation will lead into:
+```
+├── Foo
+│   ├── param_A
+├── Bar
+├── Input_A
+├── Output_B
+```
+
+**Note:** removing toplevel bus can lead to names collisions !
+
+The following code will do this transformation: 
+```python
+fmu = FMU(r"bouncing_ball.fmu")
+operation = OperationStripTopLevel()
+fmu.apply_operation(operation)
+fmu.repack(r"bouncing_ball-modified.fmu")
+```
+
+### Extract names and write a CSV
+
+The following code will dump all FMU's Scalars names into a CSV:
+
+```python
+fmu = FMU(r"bouncing_ball.fmu")
+operation = OperationExtractNames()
+fmu.apply_operation(operation)
+operation.write_csv(r"bouncing_ball.csv")
+```
+
+The produced CSV contains 2 columns in order to be reused in the next transformation.
+The 2 columns are identical.
+
+```csv
+name;newName;valueReference;causality;variability
+h;h;0;local;continuous
+der(h);der(h);1;local;continuous
+v;v;2;local;continuous
+der(v);der(v);3;local;continuous
+g;g;4;parameter;fixed
+e;e;5;parameter;tunable
+```
+
+### Read CSV and rename FMU ports
+
+CSV file should contain- 2 columns:
+1. the current name
+2. the new name
+
+```python
+fmu = FMU(r"bouncing_ball.fmu")
+operation = OperationRenameFromCSV(r"bouncing_ball-modified.csv")
+fmu.apply_operation(operation)
+fmu.repack(r"bouncing_ball-renamed.fmu")
+```

fmu_manipulation_toolbox-1.7.5/fmu_manipulation_toolbox/__init__.py

@@ -0,0 +1 @@
+

fmu_manipulation_toolbox-1.7.5/fmu_manipulation_toolbox/__main__.py

@@ -0,0 +1,25 @@
+import sys
+
+
+def gui():
+    try:
+        from .gui import main
+        main()
+    except ModuleNotFoundError as e:
+        print(f"FATAL ERROR: {e}. No GUI Available.")
+
+
+def cli():
+    from .cli import fmutool
+    fmutool()
+
+
+def main():
+    if len(sys.argv) == 1:
+        gui()
+    else:
+        cli()
+
+
+if __name__ == '__main__':
+    main()

fmu_manipulation_toolbox-1.7.5/fmu_manipulation_toolbox/__version__.py

@@ -0,0 +1 @@
+'V1.7.5'

fmu_manipulation_toolbox-1.7.5/fmu_manipulation_toolbox/checker.py

@@ -0,0 +1,61 @@
+import importlib.util
+import inspect
+import os
+import xmlschema
+from xmlschema.validators.exceptions import XMLSchemaValidationError
+from .fmu_operations import OperationAbstract
+
+
+class OperationGenericCheck(OperationAbstract):
+    SUPPORTED_FMI_VERSIONS = ('2.0',)
+
+    def __init__(self):
+        self.compliant_with_version = None
+
+    def __repr__(self):
+        return f"FMU Generic Conformity Checks"
+
+    def fmi_attrs(self, attrs):
+        if attrs['fmiVersion'] not in self.SUPPORTED_FMI_VERSIONS:
+            print(f"ERROR: Expected FMI {','.join(self.SUPPORTED_FMI_VERSIONS)} versions.")
+            return
+
+        xsd_filename = os.path.join(os.path.dirname(__file__), "resources", "fmi-" + attrs['fmiVersion'],
+                                    "fmi2ModelDescription.xsd")
+        try:
+            xmlschema.validate(self.fmu.descriptor_filename, schema=xsd_filename)
+        except XMLSchemaValidationError as error:
+            print(error.reason, error.msg)
+        else:
+            self.compliant_with_version = attrs['fmiVersion']
+
+    def closure(self):
+        if self.compliant_with_version:
+            print(f"INFO: This FMU seems to be compliant with FMI-{self.compliant_with_version}.")
+        else:
+            print(f"ERROR: This FMU does not validate with FMI standard.")
+
+
+checker_list = [OperationGenericCheck]
+
+
+def add_from_file(checker_filename: str):
+    spec = importlib.util.spec_from_file_location(checker_filename, checker_filename)
+    if not spec:
+        print(f"ERROR: Cannot load {checker_filename}. Is this a python file?")
+        return
+    try:
+        checker_module = importlib.util.module_from_spec(spec)
+        try:
+            spec.loader.exec_module(checker_module)
+        except (ModuleNotFoundError, SyntaxError) as error:
+            print(f"ERROR: Cannot load {checker_filename}: {error})")
+            return
+
+        for checker_name, checker_class in inspect.getmembers(checker_module, inspect.isclass):
+            if OperationAbstract in checker_class.__bases__:
+                checker_list.append(checker_class)
+                print(f"Adding checker: {checker_filename}|{checker_name}")
+
+    except AttributeError:
+        print(f"ERROR: {checker_filename} should implement class 'OperationCheck'")

fmu_manipulation_toolbox-1.7.5/fmu_manipulation_toolbox/cli.py

@@ -0,0 +1,216 @@
+import argparse
+import logging
+import sys
+from colorama import Fore, Style, init
+
+from .fmu_operations import *
+from .fmu_container import FMUContainerSpecReader, FMUContainerError
+from .checker import checker_list
+from .version import __version__ as version
+from .help import Help
+
+
+def setup_logger():
+    class CustomFormatter(logging.Formatter):
+        def format(self, record):
+            log_format = "%(levelname)-8s | %(message)s"
+            format_per_level = {
+                logging.DEBUG: str(Fore.BLUE) + log_format,
+                logging.INFO: str(Fore.CYAN) + log_format,
+                logging.WARNING: str(Fore.YELLOW) + log_format,
+                logging.ERROR: str(Fore.RED) + log_format,
+                logging.CRITICAL: str(Fore.RED + Style.BRIGHT) + log_format,
+            }
+            formatter = logging.Formatter(format_per_level[record.levelno])
+            return formatter.format(record)
+    init()
+    logger = logging.getLogger("fmu_manipulation_toolbox")
+    handler = logging.StreamHandler(stream=sys.stdout)
+    handler.setFormatter(CustomFormatter())
+    logger.addHandler(handler)
+    logger.setLevel(logging.INFO)
+
+    return logger
+
+
+def make_wide(formatter, w=120, h=36):
+    """Return a wider HelpFormatter, if possible."""
+    try:
+        # https://stackoverflow.com/a/5464440
+        # beware: "Only the name of this class is considered a public API."
+        kwargs = {'width': w, 'max_help_position': h}
+        formatter(None, **kwargs)
+        return lambda prog: formatter(prog, **kwargs)
+    except TypeError:
+        return formatter
+
+
+def fmutool():
+    print(f"FMU Manipulation Toolbox version {version}")
+    help_message = Help()
+
+    parser = argparse.ArgumentParser(prog='fmutool',
+                                     description="Analyse and Manipulate a FMU by modifying its 'modelDescription.xml'",
+                                     formatter_class=make_wide(argparse.HelpFormatter),
+                                     add_help=False,
+                                     epilog="see: https://github.com/grouperenault/fmu_manipulation_toolbox/blob/main/README.md")
+
+    def add_option(option, *args, **kwargs):
+        parser.add_argument(option, *args, help=help_message.usage(option), **kwargs)
+
+    add_option('-h', '-help', action="help")
+
+    # I/O
+    add_option('-input', action='store', dest='fmu_input', default=None, required=True, metavar='path/to/module.fmu')
+    add_option('-output', action='store', dest='fmu_output', default=None, metavar='path/to/module-modified.fmu')
+
+    # Port name manipulation
+    add_option('-remove-toplevel', action='append_const', dest='operations_list', const=OperationStripTopLevel())
+    add_option('-merge-toplevel', action='append_const', dest='operations_list', const=OperationMergeTopLevel())
+    add_option('-trim-until', action='append', dest='operations_list', type=OperationTrimUntil, metavar='prefix')
+    add_option('-remove-regexp', action='append', dest='operations_list', type=OperationRemoveRegexp,
+               metavar='regular-expression')
+    add_option('-keep-only-regexp', action='append', dest='operations_list', type=OperationKeepOnlyRegexp,
+               metavar='regular-expression')
+    add_option('-remove-all', action='append_const', dest='operations_list', const=OperationRemoveRegexp('.*'))
+
+    # Batch Rename
+    add_option('-dump-csv', action='append', dest='operations_list', type=OperationSaveNamesToCSV,
+               metavar='path/to/list.csv')
+    add_option('-rename-from-csv', action='append', dest='operations_list', type=OperationRenameFromCSV,
+               metavar='path/to/translation.csv')
+
+    # Remoting
+    add_option('-add-remoting-win32', action='append_const', dest='operations_list', const=OperationAddRemotingWin32())
+    add_option('-add-remoting-win64', action='append_const', dest='operations_list', const=OperationAddRemotingWin64())
+    add_option('-add-frontend-win32', action='append_const', dest='operations_list', const=OperationAddFrontendWin32())
+    add_option('-add-frontend-win64', action='append_const', dest='operations_list', const=OperationAddFrontendWin64())
+
+    # Extraction / Removal
+    add_option('-extract-descriptor', action='store', dest='extract_description',
+               metavar='path/to/saved-modelDescriptor.xml')
+    add_option('-remove-sources', action='append_const', dest='operations_list',
+               const=OperationRemoveSources())
+    # Filter
+    add_option('-only-parameters', action='append_const', dest='apply_on', const='parameter')
+    add_option('-only-inputs', action='append_const', dest='apply_on', const='input')
+    add_option('-only-outputs', action='append_const', dest='apply_on', const='output')
+    # Checker
+    add_option('-summary', action='append_const', dest='operations_list', const=OperationSummary())
+    add_option('-check', action='append_const', dest='operations_list', const=[checker() for checker in checker_list])
+
+    cli_options = parser.parse_args()
+    # handle the "no operation" use case
+    if not cli_options.operations_list:
+        cli_options.operations_list = []
+
+    if cli_options.fmu_input == cli_options.fmu_output:
+        print(f"FATAL ERROR: '-input' and '-output' should point to different files.")
+        sys.exit(-3)
+
+    print(f"READING Input='{cli_options.fmu_input}'")
+    try:
+        fmu = FMU(cli_options.fmu_input)
+    except FMUException as reason:
+        print(f"FATAL ERROR: {reason}")
+        sys.exit(-4)
+
+    if cli_options.apply_on:
+        print("Applying operation for :")
+        for causality in cli_options.apply_on:
+            print(f"     - causality = {causality}")
+
+    def flatten(list_of_list: list):
+        return [x for xs in list_of_list for x in xs]
+
+    for operation in flatten(cli_options.operations_list):
+        print(f"     => {operation}")
+        try:
+            fmu.apply_operation(operation, cli_options.apply_on)
+        except OperationException as reason:
+            print(f"ERROR: {reason}")
+            sys.exit(-6)
+
+    if cli_options.extract_description:
+        print(f"WRITING ModelDescriptor='{cli_options.extract_description}'")
+        fmu.save_descriptor(cli_options.extract_description)
+
+    if cli_options.fmu_output:
+        print(f"WRITING Output='{cli_options.fmu_output}'")
+        try:
+            fmu.repack(cli_options.fmu_output)
+        except FMUException as reason:
+            print(f"FATAL ERROR: {reason}")
+            sys.exit(-5)
+    else:
+        print(f"INFO    Modified FMU is not saved. If necessary use '-output' option.")
+
+
+def fmucontainer():
+    logger = setup_logger()
+
+    logger.info(f"FMUContainer version {version}")
+    parser = argparse.ArgumentParser(prog="fmucontainer", description="Generate FMU from FMU's",
+                                     formatter_class=make_wide(argparse.ArgumentDefaultsHelpFormatter),
+                                     add_help=False,
+                                     epilog="see: https://github.com/grouperenault/fmu_manipulation_toolbox/blob/main/"
+                                            "container/README.md")
+
+    parser.add_argument('-h', '-help', action="help")
+
+    parser.add_argument("-fmu-directory", action="store", dest="fmu_directory", required=True,
+                        help="Directory containing initial FMU’s and used to generate containers.")
+
+    parser.add_argument("-container", action="append", dest="container_descriptions_list", default=[],
+                        metavar="filename.csv:step_size",
+                        help="Description of the container to create.")
+
+    parser.add_argument("-debug", action="store_true", dest="debug",
+                        help="Add lot of useful log during the process.")
+
+    parser.add_argument("-no-auto-input", action="store_false", dest="auto_input", default=True,
+                        help="Create ONLY explicit input.")
+
+    parser.add_argument("-no-auto-output", action="store_false", dest="auto_output", default=True,
+                        help="Create ONLY explicit output.")
+
+    parser.add_argument("-no-auto-link", action="store_false", dest="auto_link", default=True,
+                        help="Create ONLY explicit links.")
+
+    parser.add_argument("-mt", action="store_true", dest="mt", default=False,
+                        help="Enable Multi-Threaded mode for the generated container.")
+
+    parser.add_argument("-profile", action="store_true", dest="profiling", default=False,
+                        help="Enable Profiling mode for the generated container.")
+
+    config = parser.parse_args()
+
+    if config.debug:
+        logger.setLevel(logging.DEBUG)
+
+    for description in config.container_descriptions_list:
+        try:
+            filename_description, step_size = description.split(":")
+            step_size = float(step_size)
+        except ValueError:
+            step_size = None
+            filename_description = description
+
+        container_filename = Path(filename_description).with_suffix(".fmu")
+
+        try:
+            csv_reader = FMUContainerSpecReader(Path(config.fmu_directory))
+            container = csv_reader.read(filename_description)
+            container.add_implicit_rule(auto_input=config.auto_input,
+                                        auto_output=config.auto_output,
+                                        auto_link=config.auto_link)
+            container.make_fmu(container_filename, step_size=step_size, debug=config.debug, mt=config.mt,
+                               profiling=config.profiling)
+        except (FileNotFoundError, FMUContainerError, FMUException) as e:
+            logger.error(f"Cannot build container from '{filename_description}': {e}")
+            continue
+
+
+# for debug purpose
+if __name__ == "__main__":
+    fmucontainer()