fmu-manipulation-toolbox 1.9.2rc1__py3-none-any.whl → 1.9.2rc2__py3-none-any.whl

fmu_manipulation_toolbox/__version__.py

@@ -1 +1 @@
-'V1.9.2rc1'
+'V1.9.2rc2'

fmu_manipulation_toolbox/container.py

@@ -196,6 +196,7 @@ class EmbeddedFMU(OperationAbstract):
         self.model_identifier = None
         self.guid = None
         self.fmi_version = None
+        self.platforms = set()
         self.ports: Dict[str, EmbeddedFMUPort] = {}
 
         self.has_event_mode = False
@@ -240,6 +241,22 @@ class EmbeddedFMU(OperationAbstract):
         port = EmbeddedFMUPort(fmu_port.fmi_type, fmu_port, fmi_version=self.fmi_version)
         self.ports[port.name] = port
 
+    def closure(self):
+        osname = {
+            "win64": "Windows",
+            "linux64": "Linux",
+            "darwin64": "Darwin",
+            "x86_64-windows": "Windows",
+            "x86_64-linux": "Linux",
+            "aarch64-darwin": "Darwin"
+        }
+        try:
+            for directory in (Path(self.fmu.tmp_directory) / "binaries").iterdir():
+                if directory.is_dir() and str(directory.stem) in osname:
+                    self.platforms.add(osname[str(directory.stem)])
+        except FileNotFoundError:
+            pass  # no binaries
+
     def __repr__(self):
         properties = f"{len(self.ports)} variables, ts={self.step_size}s"
         if len(self.terminals) > 0:
@@ -1218,7 +1235,20 @@ class FMUContainer:
         logger.debug(f"Copying {origin} in {destination}")
         shutil.copy(origin, destination)
 
-    def get_bindir_and_suffixe(self) -> Tuple[str, str, str]:
+    def get_bindir_and_suffixe(self) -> Generator[Tuple[str, str, str], Any, None]:
+        fmu_iter = iter(self.involved_fmu.values())
+        try:
+            fmu = next(fmu_iter)
+        except StopIteration:
+            raise FMUContainerError("No fmu declared in this container.")
+
+        os_list = fmu.platforms
+        logger.debug(f"FMU '{fmu.name}' OS support: {', '.join(fmu.platforms)}.")
+
+        for fmu in fmu_iter:
+            logger.debug(f"FMU '{fmu.name}' OS support: {', '.join(fmu.platforms)}.")
+            os_list &= fmu.platforms
+
         suffixes = {
             "Windows": "dll",
             "Linux": "so",
@@ -1240,11 +1270,16 @@ class FMUContainer:
         else:
             target_bindirs = origin_bindirs
 
-        os_name = platform.system()
-        try:
-            return origin_bindirs[os_name], suffixes[os_name], target_bindirs[os_name]
-        except KeyError:
-            raise FMUContainerError(f"OS '{os_name}' is not supported.")
+        if os_list:
+            logger.info(f"Container will be built for {', '.join(os_list)}.")
+        else:
+            logger.critical("No common OS found for embedded FMU. Try to re-run with '-debug'. Container won't be runnable.")
+
+        for os_name in os_list:
+            try:
+                yield origin_bindirs[os_name], suffixes[os_name], target_bindirs[os_name]
+            except KeyError:
+                raise FMUContainerError(f"OS '{os_name}' is not supported.")
 
     def make_fmu_skeleton(self, base_directory: Path) -> Path:
         logger.debug(f"Initialize directory '{base_directory}'")
@@ -1264,14 +1299,14 @@ class FMUContainer:
 
         self.copyfile(origin / "model.png", base_directory)
 
-        origin_bindir, suffixe, target_bindir = self.get_bindir_and_suffixe()
-
-        library_filename = origin / origin_bindir / f"container.{suffixe}"
-        if not library_filename.is_file():
-            raise FMUContainerError(f"File {library_filename} not found")
-        binary_directory = binaries_directory / target_bindir
-        binary_directory.mkdir(exist_ok=True)
-        self.copyfile(library_filename, binary_directory / f"{self.identifier}.{suffixe}")
+        for origin_bindir, suffixe, target_bindir in self.get_bindir_and_suffixe():
+            library_filename = origin / origin_bindir / f"container.{suffixe}"
+            if library_filename.is_file():
+                binary_directory = binaries_directory / target_bindir
+                binary_directory.mkdir(exist_ok=True)
+                self.copyfile(library_filename, binary_directory / f"{self.identifier}.{suffixe}")
+            else:
+                logger.critical(f"File {library_filename} not found.")
 
         for i, fmu in enumerate(self.involved_fmu.values()):
             shutil.copytree(self.long_path(fmu.fmu.tmp_directory),

fmu_manipulation_toolbox/gui/gui.py

@@ -0,0 +1,749 @@
+import os.path
+import sys
+import textwrap
+
+from PySide6.QtCore import Qt, QUrl, QDir, Signal, QPoint, QModelIndex
+from PySide6.QtWidgets import (QApplication, QWidget, QGridLayout, QLabel, QLineEdit, QPushButton, QFileDialog,
+                               QTextBrowser, QInputDialog, QMenu, QTreeView, QAbstractItemView, QTabWidget, QTableView,
+                               QCheckBox)
+from PySide6.QtGui import (QPixmap, QTextCursor, QStandardItem, QIcon, QDesktopServices, QAction,
+                           QPainter, QColor, QImage, QStandardItemModel)
+from functools import partial
+
+
+from fmu_manipulation_toolbox.gui.gui_style import gui_style, log_color
+from fmu_manipulation_toolbox.operations import *
+from fmu_manipulation_toolbox.remoting import (OperationAddRemotingWin32, OperationAddRemotingWin64, OperationAddFrontendWin32,
+                                               OperationAddFrontendWin64)
+from fmu_manipulation_toolbox.assembly import Assembly, AssemblyNode
+from fmu_manipulation_toolbox.checker import get_checkers
+from fmu_manipulation_toolbox.help import Help
+from fmu_manipulation_toolbox.version import __version__ as version
+
+logger = logging.getLogger("fmu_manipulation_toolbox")
+
+
+class DropZoneWidget(QLabel):
+    WIDTH = 150
+    HEIGHT = 150
+    fmu = None
+    last_directory = None
+    clicked = Signal()
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setAcceptDrops(True)
+        self.set_image(None)
+        self.setProperty("class", "dropped_fmu")
+        self.setFixedSize(self.WIDTH, self.HEIGHT)
+
+    def dragEnterEvent(self, event):
+        if event.mimeData().hasUrls():
+            event.accept()
+        else:
+            event.ignore()
+
+    def dragMoveEvent(self, event):
+        if event.mimeData().hasUrls():
+            event.accept()
+        else:
+            event.ignore()
+
+    def dropEvent(self, event):
+        if event.mimeData().hasUrls():
+            event.setDropAction(Qt.DropAction.CopyAction)
+            try:
+                file_path = event.mimeData().urls()[0].toLocalFile()
+            except IndexError:
+                logger.error("Please select a regular file.")
+                return
+            self.set_fmu(file_path)
+            event.accept()
+        else:
+            event.ignore()
+
+    def mousePressEvent(self, event):
+        if self.last_directory:
+            default_directory = self.last_directory
+        else:
+            default_directory = os.path.expanduser('~')
+
+        fmu_filename, _ = QFileDialog.getOpenFileName(parent=self, caption='Select FMU to Manipulate',
+                                                      dir=default_directory, filter="FMU files (*.fmu)")
+        if fmu_filename:
+            self.set_fmu(fmu_filename)
+
+    def set_image(self, filename=None):
+        if not filename:
+            filename = os.path.join(os.path.dirname(__file__), "../resources", "drop_fmu.png")
+        elif not os.path.isfile(filename):
+            filename = os.path.join(os.path.dirname(__file__), "../resources", "fmu.png")
+
+        base_image = QImage(filename).scaled(self.WIDTH, self.HEIGHT, Qt.AspectRatioMode.IgnoreAspectRatio,
+                                             Qt.TransformationMode.SmoothTransformation)
+        mask_filename = os.path.join(os.path.dirname(__file__), "../resources", "mask.png")
+        mask_image = QImage(mask_filename).scaled(self.WIDTH, self.HEIGHT, Qt.AspectRatioMode.IgnoreAspectRatio,
+                                                  Qt.TransformationMode.SmoothTransformation)
+        rounded_image = QImage(self.WIDTH, self.HEIGHT, QImage.Format.Format_ARGB32)
+        rounded_image.fill(QColor(0, 0, 0, 0))
+        painter = QPainter()
+        painter.begin(rounded_image)
+        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+        painter.drawImage(QPoint(0, 0), base_image)
+        painter.drawImage(QPoint(0, 0), mask_image)
+        painter.end()
+        pixmap = QPixmap.fromImage(rounded_image)
+
+        self.setPixmap(pixmap)
+
+    def set_fmu(self, filename: str):
+        try:
+            self.last_directory = os.path.dirname(filename)
+            self.fmu = FMU(filename)
+            self.set_image(os.path.join(self.fmu.tmp_directory, "model.png"))
+        except Exception as e:
+            logger.error(f"Cannot load this FMU: {e}")
+            self.set_image(None)
+            self.fmu = None
+        self.clicked.emit()
+
+
+class LogHandler(logging.Handler):
+    LOG_COLOR = {
+        logging.DEBUG: QColor(log_color["DEBUG"]),
+        logging.INFO: QColor(log_color["INFO"]),
+        logging.WARNING: QColor(log_color["WARNING"]),
+        logging.ERROR: QColor(log_color["ERROR"]),
+        logging.CRITICAL: QColor(log_color["CRITICAL"]),
+    }
+
+    def __init__(self, text_browser, level):
+        super().__init__(level)
+        self.text_browser: QTextBrowser = text_browser
+        logger.addHandler(self)
+        logger.setLevel(level)
+
+    def emit(self, record) -> None:
+        self.text_browser.setTextColor(self.LOG_COLOR[record.levelno])
+        self.text_browser.insertPlainText(record.msg+"\n")
+
+
+class LogWidget(QTextBrowser):
+    def __init__(self, parent=None, level=logging.INFO):
+        super().__init__(parent)
+
+        self.setMinimumWidth(900)
+        self.setMinimumHeight(500)
+        self.setSearchPaths([os.path.join(os.path.dirname(__file__), "../resources")])
+        self.insertHtml('<center><img src="fmu_manipulation_toolbox.png"/></center><br/>')
+        self.log_handler = LogHandler(self, logging.DEBUG)
+
+    def loadResource(self, _, name):
+        image_path = os.path.join(os.path.dirname(__file__), "../resources", name.toString())
+        return QPixmap(image_path)
+
+
+class HelpWidget(QLabel):
+    HELP_URL = "https://github.com/grouperenault/fmu_manipulation_toolbox/blob/main/README.md"
+
+    def __init__(self):
+        super().__init__()
+        self.setProperty("class", "help")
+
+        filename = os.path.join(os.path.dirname(__file__), "../resources", "help.png")
+        image = QPixmap(filename)
+        self.setPixmap(image)
+        self.setAlignment(Qt.AlignmentFlag.AlignRight)
+
+    def mousePressEvent(self, event):
+        QDesktopServices.openUrl(QUrl(self.HELP_URL))
+
+
+class FilterWidget(QPushButton):
+    def __init__(self, items: Optional[list[str]] = (), parent=None):
+        super().__init__(parent)
+        self.items_selected = set(items)
+        self.nb_items = len(items)
+        self.update_filter_text()
+        if items:
+            self.menu = QMenu()
+            for item in items:
+                action = QAction(item, self)
+                action.setCheckable(True)
+                action.setChecked(True)
+                action.triggered.connect(partial(self.toggle_item, action))
+                self.menu.addAction(action)
+            self.setMenu(self.menu)
+
+    def toggle_item(self, action: QAction):
+        if not action.isChecked() and len(self.items_selected) == 1:
+            action.setChecked(True)
+
+        if action.isChecked():
+            self.items_selected.add(action.text())
+        else:
+            self.items_selected.remove(action.text())
+
+        self.update_filter_text()
+
+    def update_filter_text(self):
+        if len(self.items_selected) == self.nb_items:
+            self.setText("All causalities")
+        else:
+            self.setText(", ".join(sorted(self.items_selected)))
+
+    def get(self):
+        if len(self.items_selected) == self.nb_items:
+            return []
+        else:
+            return sorted(self.items_selected)
+
+
+class AssemblyTreeWidget(QTreeView):
+    class AssemblyTreeModel(QStandardItemModel):
+
+        def __init__(self, assembly: Assembly, parent=None):
+            super().__init__(parent)
+
+            self.lastDroppedItems = []
+            self.pendingRemoveRowsAfterDrop = False
+            self.setHorizontalHeaderLabels(['col1'])
+            self.dnd_target_node: Optional[AssemblyNode] = None
+
+            self.icon_container = QIcon(os.path.join(os.path.dirname(__file__), '../resources', 'container.png'))
+            self.icon_fmu = QIcon(os.path.join(os.path.dirname(__file__), '../resources', 'icon_fmu.png'))
+
+            if assembly:
+                self.add_node(assembly.root, self)
+
+        def add_node(self, node: AssemblyNode, parent_item):
+            # Add Container
+            item = QStandardItem(self.icon_container, node.name)
+            parent_item.appendRow(item)
+            item.setFlags(Qt.ItemFlag.ItemIsEnabled | Qt.ItemFlag.ItemIsSelectable | Qt.ItemFlag.ItemIsDragEnabled |
+                          Qt.ItemFlag.ItemIsDropEnabled)
+            item.setData(node, role=Qt.ItemDataRole.UserRole + 1)
+            item.setData("container", role=Qt.ItemDataRole.UserRole + 2)
+
+            # Add FMU's
+            children_name = node.children.keys()
+            for fmu_name in node.fmu_names_list:
+                if fmu_name not in children_name:
+                    fmu_node = QStandardItem(self.icon_fmu, fmu_name)
+                    fmu_node.setData(node, role=Qt.ItemDataRole.UserRole + 1)
+                    fmu_node.setData("fmu", role=Qt.ItemDataRole.UserRole + 2)
+                    fmu_node.setFlags(Qt.ItemFlag.ItemIsEnabled | Qt.ItemFlag.ItemIsSelectable |
+                                      Qt.ItemFlag.ItemIsDragEnabled)
+                    item.appendRow(fmu_node)
+
+            # Add Sub-Containers
+            for child in node.children.values():
+                self.add_node(child, item)
+
+        def insertRows(self, row, count, parent=QModelIndex()):
+            self.dnd_target_node = parent.data(role=Qt.ItemDataRole.UserRole + 1)
+            return super().insertRows(row, count, parent=parent)
+
+        def removeRows(self, row, count, parent=QModelIndex()):
+            if not self.dnd_target_node:
+                logger.error("NO DROP NODE!?")
+
+            source_index = self.itemFromIndex(parent).child(row, 0).data(role=Qt.ItemDataRole.UserRole+1)
+            logger.debug(f"{source_index} ==> {self.dnd_target_node.name}")
+
+            self.dnd_target_node = None
+            return super().removeRows(row, count, parent)
+
+        def dropMimeData(self, data, action, row, column, parent: QModelIndex):
+            if parent.column() < 0:  # Avoid to drop item as a sibling of the root.
+                return False
+            return super().dropMimeData(data, action, row, column, parent)
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+
+        self.model = self.AssemblyTreeModel(None)
+        self.setModel(self.model)
+
+        self.expandAll()
+        self.setDropIndicatorShown(True)
+        self.setDragDropOverwriteMode(False)
+        self.setAcceptDrops(True)
+        self.setDragDropMode(QAbstractItemView.DragDropMode.InternalMove)
+        self.setRootIsDecorated(True)
+        self.setHeaderHidden(True)
+
+    def load_container(self, filename):
+        assembly = Assembly(filename)
+        self.model = self.AssemblyTreeModel(assembly)
+        self.setModel(self.model)
+
+    def setTopIndex(self):
+        topIndex = self.model.index(0, 0, self.rootIndex())
+        logger.debug(topIndex.isValid(), topIndex.model())
+        if topIndex.isValid():
+            self.setCurrentIndex(topIndex)
+            if self.layoutCheck:
+                self.model.layoutChanged.disconnect(self.setTopIndex)
+        else:
+            if not self.layoutCheck:
+                self.model.layoutChanged.connect(self.setTopIndex)
+                self.layoutCheck = True
+
+
+    def dragEnterEvent2(self, event):
+        if event.mimeData().hasImage:
+            event.accept()
+        else:
+            event.ignore()
+
+    def dragMoveEvent2(self, event):
+        if event.mimeData().hasImage:
+            event.accept()
+        else:
+            event.ignore()
+
+    def dropEvent2(self, event):
+        if event.mimeData().hasImage:
+            event.setDropAction(Qt.DropAction.CopyAction)
+            try:
+                file_path = event.mimeData().urls()[0].toLocalFile()
+            except IndexError:
+                logger.error("Please select a regular file.")
+                return
+            logger.debug(f"DROP: {file_path}")
+            event.accept()
+        else:
+            event.ignore()
+
+
+class AssemblPropertiesWidget(QWidget):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+
+        self.layout = QGridLayout()
+        self.layout.setVerticalSpacing(4)
+        self.layout.setHorizontalSpacing(4)
+        self.layout.setContentsMargins(10, 10, 10, 10)
+        self.setLayout(self.layout)
+
+        mt_check = QCheckBox("Multi-Threaded", self)
+        self.layout.addWidget(mt_check, 1, 0)
+
+        profiling_check = QCheckBox("Profiling", self)
+        self.layout.addWidget(profiling_check, 1, 1)
+
+        auto_inputs_check = QCheckBox("Auto Inputs", self)
+        self.layout.addWidget(auto_inputs_check, 0, 0)
+
+        auto_outputs_check = QCheckBox("Auto Outputs", self)
+        self.layout.addWidget(auto_outputs_check, 0, 1)
+
+        auto_links_check = QCheckBox("Auto Links", self)
+        self.layout.addWidget(auto_links_check, 0, 2)
+
+
+class AssemblyTabWidget(QTabWidget):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+
+        table = AssemblPropertiesWidget(parent=self)
+        self.addTab(table, "Properties")
+        table = QTableView()
+        self.addTab(table, "Links")
+        table = QTableView()
+        self.addTab(table, "Inputs")
+        table = QTableView()
+        self.addTab(table, "Outputs")
+        table = QTableView()
+        self.addTab(table, "Start values")
+
+        self.tabBar().setDocumentMode(True)
+        self.tabBar().setExpanding(True)
+
+
+class WindowWithLayout(QWidget):
+    def __init__(self, title: str):
+        super().__init__(None)  # Do not set parent to have a separated window
+        self.setWindowTitle(title)
+
+        self.layout = QGridLayout()
+        self.layout.setVerticalSpacing(4)
+        self.layout.setHorizontalSpacing(4)
+        self.layout.setContentsMargins(10, 10, 10, 10)
+        self.setLayout(self.layout)
+
+
+class MainWindow(WindowWithLayout):
+    def __init__(self):
+        super().__init__('FMU Manipulation Toolbox')
+
+        self.dropped_fmu = DropZoneWidget()
+        self.dropped_fmu.clicked.connect(self.update_fmu)
+
+        self.layout.addWidget(self.dropped_fmu, 0, 0, 4, 1)
+
+        self.fmu_title = QLabel()
+        self.fmu_title.setProperty("class", "title")
+        self.layout.addWidget(self.fmu_title, 0, 1, 1, 4)
+
+        self.container_window = None
+        #TODO: Container Window
+        #container_button = QPushButton("Make a container")
+        #container_button.setProperty("class", "quit")
+        #container_button.clicked.connect(self.launch_container)
+        #self.layout.addWidget(container_button, 4, 1, 1, 1)
+
+        help_widget = HelpWidget()
+        self.layout.addWidget(help_widget, 0, 5, 1, 1)
+
+        # Operations
+        self.help = Help()
+        operations_list = [
+            ("Save port names",    '-dump-csv',           'save',    OperationSaveNamesToCSV, {"prompt_file": "write"}),
+            ("Rename ports from CSV", '-rename-from-csv',   'modify',  OperationRenameFromCSV, {"prompt_file": "read"}),
+            ("Remove Toplevel",       '-remove-toplevel',    'modify',  OperationStripTopLevel),
+            ("Remove Regexp",         '-remove-regexp',      'removal', OperationRemoveRegexp, {"prompt": "regexp"}),
+            ("Keep only Regexp",      '-keep-only-regexp',   'removal', OperationKeepOnlyRegexp, {"prompt": "regexp"}),
+            ("Save description.xml",  '-extract-descriptor', 'save',    None, {"func": self.save_descriptor}),
+            ("Trim Until",            '-trim-until',         'modify',  OperationTrimUntil, {"prompt": "Prefix"}),
+            ("Merge Toplevel",        '-merge-toplevel',     'modify',  OperationMergeTopLevel),
+            ("Remove all",            '-remove-all',         'removal', OperationRemoveRegexp, {"arg": ".*"}),
+            ("Remove sources",        '-remove-sources',     'removal', OperationRemoveSources),
+            ("Add Win32 remoting",    '-add-remoting-win32', 'info',    OperationAddRemotingWin32),
+            ("Add Win64 remoting",    '-add-remoting-win64', 'info',    OperationAddRemotingWin64),
+            ("Add Win32 frontend",    '-add-frontend-win32', 'info',    OperationAddFrontendWin32),
+            ("Add Win64 frontend",    '-add-frontend-win64', 'info',    OperationAddFrontendWin64),
+            ("Check",                 '-check',              'info',    get_checkers()),
+        ]
+
+        width = 5
+        line = 1
+        for i, operation in enumerate(operations_list):
+            col = i % width + 1
+            line = int(i / width) + 1
+
+            if len(operation) < 5:
+                self.add_operation(operation[0], operation[1], operation[2], operation[3], line, col)
+            else:
+                self.add_operation(operation[0], operation[1], operation[2], operation[3], line, col, **operation[4])
+
+        line += 1
+        self.apply_filter_label = QLabel("Apply only on: ")
+        self.layout.addWidget(self.apply_filter_label, line, 2, 1, 1, alignment=Qt.AlignmentFlag.AlignRight)
+        self.set_tooltip(self.apply_filter_label, 'gui-apply-only')
+
+        causality = ["parameter", "calculatedParameter", "input", "output", "local", "independent"]
+        self.filter_list = FilterWidget(items=causality)
+        self.layout.addWidget(self.filter_list, line, 3, 1, 3)
+        self.filter_list.setProperty("class", "quit")
+
+        # Text
+        line += 1
+        self.log_widget = LogWidget()
+        self.layout.addWidget(self.log_widget, line, 0, 1, width + 1)
+
+        # buttons
+        line += 1
+
+        reload_button = QPushButton('Reload')
+        self.layout.addWidget(reload_button, 4, 0, 1, 1)
+        reload_button.clicked.connect(self.reload_fmu)
+        reload_button.setProperty("class", "quit")
+
+        exit_button = QPushButton('Exit')
+        self.layout.addWidget(exit_button, line, 0, 1, 2)
+        exit_button.clicked.connect(self.close)
+        exit_button.setProperty("class", "quit")
+
+        save_log_button = QPushButton('Save log as')
+        self.layout.addWidget(save_log_button, line, 2, 1, 2)
+        save_log_button.clicked.connect(self.save_log)
+        save_log_button.setProperty("class", "save")
+
+        save_fmu_button = QPushButton('Save modified FMU as')
+        self.layout.addWidget(save_fmu_button, line, 4, 1, 2)
+        save_fmu_button.clicked.connect(self.save_fmu)
+        save_fmu_button.setProperty("class", "save")
+        self.set_tooltip(save_fmu_button, '-output')
+
+        # show the window
+        self.show()
+
+    def closeEvent(self, event):
+        if self.container_window:
+            self.container_window.close()
+            self.container_window = None
+        event.accept()
+
+    def launch_container(self):
+        if not self.container_window:
+            self.container_window = ContainerWindow(self)
+
+    def closing_container(self):
+        self.container_window = None
+
+    def set_tooltip(self, widget, usage):
+        widget.setToolTip("\n".join(textwrap.wrap(self.help.usage(usage))))
+
+    def reload_fmu(self):
+        if self.dropped_fmu.fmu:
+            filename = self.dropped_fmu.fmu.fmu_filename
+            self.dropped_fmu.fmu = None
+            self.dropped_fmu.set_fmu(filename)
+
+    def save_descriptor(self):
+        if self.dropped_fmu.fmu:
+            fmu = self.dropped_fmu.fmu
+            filename, ok = QFileDialog.getSaveFileName(self, "Select a file",
+                                                       os.path.dirname(fmu.fmu_filename),
+                                                       "XML files (*.xml)")
+            if ok and filename:
+                fmu.save_descriptor(filename)
+
+    def save_fmu(self):
+        if self.dropped_fmu.fmu:
+            fmu = self.dropped_fmu.fmu
+            filename, ok = QFileDialog.getSaveFileName(self, "Select a file",
+                                                       os.path.dirname(fmu.fmu_filename),
+                                                       "FMU files (*.fmu)")
+            if ok and filename:
+                fmu.repack(filename)
+                logger.info(f"Modified version saved as {filename}.")
+
+    def save_log(self):
+        if self.dropped_fmu.fmu:
+            default_dir = os.path.dirname(self.dropped_fmu.fmu.fmu_filename)
+        else:
+            default_dir = None
+        filename, ok = QFileDialog.getSaveFileName(self, "Select a file",
+                                                   default_dir,
+                                                   "TXT files (*.txt)")
+        if ok and filename:
+            try:
+                with open(filename, "wt") as file:
+                    file.write(str(self.log_widget.toPlainText()))
+            except Exception as e:
+                logger.error(f"{e}")
+
+    def add_operation(self, name, usage, severity, operation, x, y, prompt=None, prompt_file=None, arg=None,
+                      func=None):
+        if prompt:
+            def operation_handler():
+                local_arg = self.prompt_string(prompt)
+                if local_arg:
+                    self.apply_operation(operation(local_arg))
+        elif prompt_file:
+            def operation_handler():
+                local_arg = self.prompt_file(prompt_file)
+                if local_arg:
+                    self.apply_operation(operation(local_arg))
+        elif arg:
+            def operation_handler():
+                self.apply_operation(operation(arg))
+        else:
+            def operation_handler():
+                # Checker can be a list of operations!
+                if isinstance(operation, list):
+                    for op in operation:
+                        self.apply_operation(op())
+                else:
+                    self.apply_operation(operation())
+
+        button = QPushButton(name)
+        self.set_tooltip(button, usage)
+        button.setProperty("class", severity)
+        if func:
+            button.clicked.connect(func)
+        else:
+            button.clicked.connect(operation_handler)
+        self.layout.addWidget(button, x, y)
+
+    def prompt_string(self, message):
+        text, ok = QInputDialog().getText(self, "Enter value", f"{message}:", QLineEdit.EchoMode.Normal, "")
+
+        if ok and text:
+            return text
+        else:
+            return None
+
+    def prompt_file(self, access):
+        if self.dropped_fmu.fmu:
+            default_dir = os.path.dirname(self.dropped_fmu.fmu.fmu_filename)
+
+            if access == 'read':
+                filename, ok = QFileDialog.getOpenFileName(self, "Select a file",
+                                                           default_dir, "CSV files (*.csv)")
+            else:
+                filename, ok = QFileDialog.getSaveFileName(self, "Select a file",
+                                                           default_dir, "CSV files (*.csv)")
+
+            if ok and filename:
+                return filename
+        return None
+
+    def update_fmu(self):
+        if self.dropped_fmu.fmu:
+            self.fmu_title.setText(os.path.basename(self.dropped_fmu.fmu.fmu_filename))
+            self.log_widget.clear()
+            self.apply_operation(OperationSummary())
+        else:
+            self.fmu_title.setText('')
+
+    def apply_operation(self, operation):
+        if self.dropped_fmu.fmu:
+            self.log_widget.moveCursor(QTextCursor.MoveOperation.End)
+            fmu_filename = os.path.basename(self.dropped_fmu.fmu.fmu_filename)
+            logger.info('-' * 100)
+            self.log_widget.insertHtml(f"<strong>{fmu_filename}: {operation}</strong><br>")
+
+            apply_on = self.filter_list.get()
+            if apply_on:
+                self.log_widget.insertHtml(f"<i>Applied only for ports with  causality = " +
+                                           ", ".join(apply_on) + "</i><br>")
+            logger.info('-' * 100)
+            try:
+                self.dropped_fmu.fmu.apply_operation(operation, apply_on=apply_on)
+            except Exception as e:
+                logger.error(f"{e}")
+
+            scroll_bar = self.log_widget.verticalScrollBar()
+            scroll_bar.setValue(scroll_bar.maximum())
+
+
+class ContainerWindow(WindowWithLayout):
+    def __init__(self, parent: MainWindow):
+        super().__init__('FMU Manipulation Toolbox - Container')
+        self.main_window = parent
+        self.last_directory = None
+
+        # ROW 0
+        load_button = QPushButton("Load Description")
+        load_button.clicked.connect(self.load_container)
+        load_button.setProperty("class", "quit")
+        self.layout.addWidget(load_button, 0, 0)
+
+        self.container_label = QLabel()
+        self.container_label.setProperty("class", "title")
+        self.container_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.layout.addWidget(self.container_label, 0, 1, 1, 2)
+
+        # ROW 1
+        add_fmu_button = QPushButton("Add FMU")
+        add_fmu_button.setProperty("class", "modify")
+        add_fmu_button.setDisabled(True)
+        self.layout.addWidget(add_fmu_button, 1, 1)
+
+        add_sub_button = QPushButton("Add SubContainer")
+        add_sub_button.setProperty("class", "modify")
+        add_sub_button.setDisabled(True)
+        self.layout.addWidget(add_sub_button, 1, 2)
+
+        self.assembly_tree = AssemblyTreeWidget(parent=self)
+        self.assembly_tree.setMinimumHeight(600)
+        self.assembly_tree.setMinimumWidth(200)
+        self.layout.addWidget(self.assembly_tree, 1, 0, 3, 1)
+
+        # ROW 2
+        del_fmu_button = QPushButton("Remove FMU")
+        del_fmu_button.setProperty("class", "removal")
+        del_fmu_button.setDisabled(True)
+        self.layout.addWidget(del_fmu_button, 2, 1)
+
+        del_sub_button = QPushButton("Remove SubContainer")
+        del_sub_button.setProperty("class", "removal")
+        del_sub_button.setDisabled(True)
+        self.layout.addWidget(del_sub_button, 2, 2)
+
+        # ROW 3
+        self.assembly_tab = AssemblyTabWidget(parent=self)
+        self.assembly_tab.setMinimumWidth(600)
+        self.layout.addWidget(self.assembly_tab, 3, 1, 1, 2)
+
+        # ROW 4
+        close_button = QPushButton("Close")
+        close_button.setProperty("class", "quit")
+        close_button.clicked.connect(self.close)
+        self.layout.addWidget(close_button, 4, 0)
+
+        save_button = QPushButton("Save Container")
+        save_button.setProperty("class", "save")
+        self.layout.addWidget(save_button, 4, 2)
+
+        self.assembly_tree.selectionModel().currentChanged.connect(self.item_selected)
+        topIndex = self.assembly_tree.model.index(0, 0, self.assembly_tree.rootIndex())
+        self.assembly_tree.setCurrentIndex(topIndex)
+
+        self.show()
+
+    def closeEvent(self, event):
+        if self.main_window:
+            self.main_window.closing_container()
+        event.accept()
+
+    def item_selected(self, current: QModelIndex, previous: QModelIndex):
+        if current.isValid():
+            node = current.data(role=Qt.ItemDataRole.UserRole + 1)
+            node_type = current.data(role=Qt.ItemDataRole.UserRole + 2)
+            self.container_label.setText(f"{node.name} ({node_type})")
+        else:
+            self.container_label.setText("")
+
+    def load_container(self):
+        if self.last_directory:
+            default_directory = self.last_directory
+        else:
+            default_directory = os.path.expanduser('~')
+
+        filename, _ = QFileDialog.getOpenFileName(parent=self, caption='Select FMU to Manipulate',
+                                                  dir=default_directory,
+                                                  filter="JSON files (*.json);;SSP files (*.ssp)")
+        if filename:
+            try:
+                self.last_directory = os.path.dirname(filename)
+                self.assembly_tree.load_container(filename)
+            except Exception as e:
+                logger.error(e)
+
+
+class Application(QApplication):
+    """
+Analyse and modify your FMUs.
+
+Note: modifying the modelDescription.xml can damage your FMU !
+Communicating with the FMU-developer and adapting the way the FMU is generated, is preferable when possible.
+
+    """
+    def __init__(self, *args, **kwargs):
+        self.setHighDpiScaleFactorRoundingPolicy(Qt.HighDpiScaleFactorRoundingPolicy.RoundPreferFloor)
+        super().__init__(*args, **kwargs)
+
+
+        QDir.addSearchPath('images', os.path.join(os.path.dirname(__file__), "../resources"))
+        self.setStyleSheet(gui_style)
+
+        if os.name == 'nt':
+            import ctypes
+            self.setWindowIcon(QIcon(os.path.join(os.path.dirname(__file__), '../resources', 'icon-round.png')))
+
+            # https://stackoverflow.com/questions/1551605/how-to-set-applications-taskbar-icon-in-windows-7/1552105#1552105
+
+            application_id = 'FMU_Manipulation_Toolbox'  # arbitrary string
+            ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(application_id)
+        else:
+            self.setWindowIcon(QIcon(os.path.join(os.path.dirname(__file__), '../resources', 'icon.png')))
+
+        self.window = MainWindow()
+
+
+def main():
+    application = Application(sys.argv)
+
+    logger.info(" " * 80 + f"Version {version}")
+    logger.info(application.__doc__)
+
+    sys.exit(application.exec())
+
+
+if __name__ == "__main__":
+    main()

fmu_manipulation_toolbox/gui/gui_style.py

@@ -0,0 +1,252 @@
+import os
+
+if os.name == 'nt':
+    gui_style = """
+    QWidget {
+        font: 10pt "Verdana";
+        background: #4b4e51;
+        color: #b5bab9;
+    }
+    QPushButton, QComboBox {
+        min-height: 30px;
+        padding: 1px 1px 0.2em 0.2em;
+        border: 1px solid #282830;
+        border-radius: 5px;
+        color: #dddddd;
+    }
+    QPushButton:pressed {
+        border: 2px solid #282830;
+    }
+    QPushButton.info {
+        background-color: #4e6749;
+    }
+    QPushButton.info:hover {
+        background-color: #5f7850;
+    }
+    QPushButton.modify {
+        background-color: #98763f;
+    }
+    QPushButton.modify:hover {
+        background-color: #a9874f;
+    }
+    QPushButton.removal {
+        background-color: #692e2e;
+    }
+    QPushButton.removal:hover {
+        background-color: #7a3f3f;
+    }
+    QPushButton.save {
+        background-color: #564967;
+    }
+    QPushButton.save:hover {
+        background-color: #675a78;
+    }
+    QPushButton.quit {
+        background-color: #4571a4;
+    }
+    QPushButton.quit:hover {
+        background-color: #5682b5;
+    }
+    QPushButton::disabled {
+        background-color: gray;
+    }
+    QToolTip {
+        color: black
+    }
+    QLabel.dropped_fmu {
+        background-color: #b5bab9
+    }
+    QLabel.title {
+        font: 14pt bold "Verdana";
+    }
+    QLabel.dropped_fmu:hover {
+        background-color: #c6cbca
+    }
+    QTextBrowser, QTreeView {
+        font: 11pt "Consolas";
+        background-color: #282830;
+        color: #b5bab9;
+    }
+    QMenu::item {
+        padding: 2px 250px 2px 20px;
+        border: 1px solid transparent;
+    }
+    QMenu::item::indicator, QCheckBox::item::indicator {
+        width: 32px;
+        height: 32px;
+    }
+    QMenu::indicator:checked, QCheckBox::indicator:checked {
+        image: url(images:checkbox-checked.png);
+    }
+    QMenu::indicator:checked:hover, QCheckBox::indicator:checked:hover {
+        image: url(images:checkbox-checked-hover.png);
+    }
+    QMenu::indicator:checked:disabled, QCheckBox::indicator:checked:disabled {
+        image: url(images:checkbox-checked-disabled.png);
+    }
+    QMenu::indicator:unchecked, QCheckBox::indicator:unchecked {
+        image: url(images:checkbox-unchecked.png);
+    }
+    QMenu::indicator:unchecked:hover, QCheckBox::indicator:unchecked:hover {
+        image: url(images:checkbox-unchecked-hover.png);
+    }
+    QMenu::indicator:unchecked:disabled, QCheckBox::indicator:unchecked:disabled {
+        image: url(images:checkbox-unchecked-disabled.png);
+    }
+    QCheckBox::item {
+        padding: 2px 250px 2px 20px;
+        border: 1px solid transparent;
+    }
+    QTabBar::tab {
+        min-height: 30px;
+        padding: 1px 1px 0.2em 0.2em;
+        color: #dddddd;
+        margin: 2px;
+        margin-bottom: 0px;
+        border: 1px solid #282830;
+        border-top-left-radius: 5px;
+        border-top-right-radius: 5px;
+    } 
+    QTabBar::tab:selected, QTabBar::tab:hover {
+        background-color: #5f7850;
+        margin-bottom:-1px;
+    }
+    QTabBar {
+        border-bottom: 1px solid #282830;
+    }
+    QTabBar::tab:top:last, QTabBar::tab:bottom:last {
+        margin-right: 0;
+    }
+    QTabBar::tab:top:first, QTabBar::tab:bottom:first {
+        margin-left: 0;
+    }
+    """
+else:
+    gui_style = """
+    QWidget {
+        font: 12pt;
+        background: #4b4e51;
+        color: #b5bab9;
+    }
+    QPushButton, QComboBox {
+        min-height: 30px;
+        padding: 1px 1px 0.2em 0.2em;
+        border: 1px solid #282830;
+        border-radius: 5px;
+        color: #dddddd;
+    }
+    QPushButton:pressed {
+        border: 2px solid #282830;
+    }
+    QPushButton.info {
+        background-color: #4e6749;
+    }
+    QPushButton.info:hover {
+        background-color: #5f7850;
+    }
+    QPushButton.modify {
+        background-color: #98763f;
+    }
+    QPushButton.modify:hover {
+        background-color: #a9874f;
+    }
+    QPushButton.removal {
+        background-color: #692e2e;
+    }
+    QPushButton.removal:hover {
+        background-color: #7a3f3f;
+    }
+    QPushButton.save {
+        background-color: #564967;
+    }
+    QPushButton.save:hover {
+        background-color: #675a78;
+    }
+    QPushButton.quit {
+        background-color: #4571a4;
+    }
+    QPushButton.quit:hover {
+        background-color: #5682b5;
+    }
+    QPushButton::disabled {
+        background-color: gray;
+    }
+    QToolTip {
+        color: black
+    }
+    QLabel.dropped_fmu {
+        background-color: #b5bab9
+    }
+    QLabel.title {
+        font: 14pt bold "Verdana";
+    }
+    QLabel.dropped_fmu:hover {
+        background-color: #c6cbca
+    }
+    QTextBrowser, QTreeView {
+        font: 14pt "Courier New";
+        background-color: #282830;
+        color: #b5bab9;
+    }
+    QMenu::item {
+        padding: 2px 250px 2px 20px;
+        border: 1px solid transparent;
+    }
+    QMenu::item::indicator, QCheckBox::item::indicator {
+        width: 32px;
+        height: 32px;
+    }
+    QMenu::indicator:checked, QCheckBox::indicator:checked {
+        image: url(images:checkbox-checked.png);
+    }
+    QMenu::indicator:checked:hover, QCheckBox::indicator:checked:hover {
+        image: url(images:checkbox-checked-hover.png);
+    }
+    QMenu::indicator:checked:disabled, QCheckBox::indicator:checked:disabled {
+        image: url(images:checkbox-checked-disabled.png);
+    }
+    QMenu::indicator:unchecked, QCheckBox::indicator:unchecked {
+        image: url(images:checkbox-unchecked.png);
+    }
+    QMenu::indicator:unchecked:hover, QCheckBox::indicator:unchecked:hover {
+        image: url(images:checkbox-unchecked-hover.png);
+    }
+    QMenu::indicator:unchecked:disabled, QCheckBox::indicator:unchecked:disabled {
+        image: url(images:checkbox-unchecked-disabled.png);
+    }
+    QCheckBox::item {
+        padding: 2px 250px 2px 20px;
+        border: 1px solid transparent;
+    }
+    QTabBar::tab {
+        min-height: 30px;
+        padding: 1px 1px 0.2em 0.2em;
+        color: #dddddd;
+        margin: 2px;
+        margin-bottom: 0px;
+        border: 1px solid #282830;
+        border-top-left-radius: 5px;
+        border-top-right-radius: 5px;
+    } 
+    QTabBar::tab:selected, QTabBar::tab:hover {
+        background-color: #5f7850;
+        margin-bottom:-1px;
+    }
+    QTabBar {
+        border-bottom: 1px solid #282830;
+    }
+    QTabBar::tab:top:last, QTabBar::tab:bottom:last {
+        margin-right: 0;
+    }
+    QTabBar::tab:top:first, QTabBar::tab:bottom:first {
+        margin-left: 0;
+    }
+    """
+
+log_color = {
+    "DEBUG": "#6E6B6B",
+    "INFO": "#b5bab9",
+    "WARNING": "#F7C61B",
+    "ERROR": "#F54927",
+    "CRITICAL": "#FF00FF",
+}

{fmu_manipulation_toolbox-1.9.2rc1.dist-info → fmu_manipulation_toolbox-1.9.2rc2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fmu_manipulation_toolbox
-Version: 1.9.2rc1
+Version: 1.9.2rc2
 Summary: FMU Manipulation Toolbox is a python package which helps to analyze, modify or combine Functional Mock-up Units (FMUs) without recompilation.
 Home-page: https://github.com/grouperenault/fmu_manipulation_toolbox/
 Author: Nicolas.LAURENT@Renault.com

{fmu_manipulation_toolbox-1.9.2rc1.dist-info → fmu_manipulation_toolbox-1.9.2rc2.dist-info}/RECORD

@@ -1,9 +1,9 @@
 fmu_manipulation_toolbox/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fmu_manipulation_toolbox/__main__.py,sha256=g0ZhVsMiAs5KnhyVNwTe01N2PQjAg7F9YCnXHZB-HwA,356
-fmu_manipulation_toolbox/__version__.py,sha256=fTyJ9LrsqumarkNI8x2J8OaXjD3NU3bBSG-iZvTnuKM,12
+fmu_manipulation_toolbox/__version__.py,sha256=6ttw5N6nrGXzLg1BgjLnWFMx2u8lpo92IH6dsBWPlJw,12
 fmu_manipulation_toolbox/assembly.py,sha256=QmFihza_I0hK0Ia6tWbjdZeoREhveLrv3d7ERrBUaDk,27217
 fmu_manipulation_toolbox/checker.py,sha256=Dh47b3blibCWjHCeZ61Y_w9Ug0PWvEuSiemZtp-llQA,3141
-fmu_manipulation_toolbox/container.py,sha256=DaE4GQjKPTGg2zp4CXGevFjgW9B8dFCVQWh08IRXG5w,57167
+fmu_manipulation_toolbox/container.py,sha256=yME00RUudrRIzc6ZSguBFzyd9hkp6eFIdp91QWaOcVo,58561
 fmu_manipulation_toolbox/help.py,sha256=j8xmnCrwQpaW-SZ8hSqA1dlTXgaqzQWc4Yr3RH_oqck,6012
 fmu_manipulation_toolbox/ls.py,sha256=wmyoKrvDLXpL-PFz6cUhLLqxDMD5E9L_P4KswWpQHsk,975
 fmu_manipulation_toolbox/operations.py,sha256=y3QDMiLaG1TUhIQ4r_onWp1kGm8QZaFfTOdQr0oC7_A,21177
@@ -17,6 +17,9 @@ fmu_manipulation_toolbox/cli/fmucontainer.py,sha256=ZLoC8QMVBVG2S3cdNthMIQ0gYIU9
 fmu_manipulation_toolbox/cli/fmusplit.py,sha256=sLzdxiC4R5hJYJo9F2TZOMrJOHcadqCvUo9KoCjUaxE,1773
 fmu_manipulation_toolbox/cli/fmutool.py,sha256=E-CCymksBwGFlS3-zJ7DIDA8xIdp_synsxMDYXst8dc,6186
 fmu_manipulation_toolbox/cli/utils.py,sha256=pvedN6cRiDkZ7RdPO1koBOZaGuydYhgcoO0-_QQpOoI,1601
+fmu_manipulation_toolbox/gui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fmu_manipulation_toolbox/gui/gui.py,sha256=usnMIyMeBcn81oYOBufkosCVBj0JRmKoaTUYG3e9o48,29430
+fmu_manipulation_toolbox/gui/gui_style.py,sha256=s6WdrnNd_lCMWhuBf5LKK8wrfLXCU7pFTLUfvqkJVno,6633
 fmu_manipulation_toolbox/resources/checkbox-checked-disabled.png,sha256=FWIuyrXlaNLLePHfXj7j9ca5rT8Hgr14KCe1EqTCZyk,2288
 fmu_manipulation_toolbox/resources/checkbox-checked-hover.png,sha256=KNlV-d_aJNTTvUVXKGT9DBY30sIs2LwocLJrFKNKv8k,2419
 fmu_manipulation_toolbox/resources/checkbox-checked.png,sha256=gzyFqvRFsZixVh6ZlV4SMWUKzglY1rSn7SvJUKMVvtk,2411
@@ -34,7 +37,7 @@ fmu_manipulation_toolbox/resources/icon_fmu.png,sha256=EuygB2xcoM2WAfKKdyKG_UvTL
 fmu_manipulation_toolbox/resources/license.txt,sha256=5ODuU8g8pIkK-NMWXu_rjZ6k7gM7b-N2rmg87-2Kmqw,1583
 fmu_manipulation_toolbox/resources/mask.png,sha256=px1U4hQGL0AmZ4BQPknOVREpMpTSejbah3ntkpqAzFA,3008
 fmu_manipulation_toolbox/resources/model.png,sha256=EAf_HnZJe8zYGZygerG1MMt2U-tMMZlifzXPj4_iORA,208788
-fmu_manipulation_toolbox/resources/darwin64/container.dylib,sha256=px6TxvPDKZBakjHE183KMoyiADA8a3_-Sh1LbYrvqLc,230704
+fmu_manipulation_toolbox/resources/darwin64/container.dylib,sha256=0O1swE0kqgk3mK0sAH8_n1fZfzL9Ovb9dQ_lXlnkWak,230704
 fmu_manipulation_toolbox/resources/fmi-2.0/fmi2Annotation.xsd,sha256=OGfyJtaJntKypX5KDpuZ-nV1oYLZ6HV16pkpKOmYox4,2731
 fmu_manipulation_toolbox/resources/fmi-2.0/fmi2AttributeGroups.xsd,sha256=HwyV7LBse-PQSv4z1xjmtzPU3Hjnv4mluq9YdSBNHMQ,3704
 fmu_manipulation_toolbox/resources/fmi-2.0/fmi2ModelDescription.xsd,sha256=JM4j_9q-pc40XYHb28jfT3iV3aYM5JLqD5aRjO72K1E,18939
@@ -54,19 +57,19 @@ fmu_manipulation_toolbox/resources/fmi-3.0/fmi3Type.xsd,sha256=TaHRoUBIFtmdEwBKB
 fmu_manipulation_toolbox/resources/fmi-3.0/fmi3Unit.xsd,sha256=CK_F2t5LfyQ6eSNJ8soTFMVK9DU8vD2WiMi2MQvjB0g,3746
 fmu_manipulation_toolbox/resources/fmi-3.0/fmi3Variable.xsd,sha256=3YU-3q1-c-namz7sMe5cxnmOVOJsRSmfWR02PKv3xaU,19171
 fmu_manipulation_toolbox/resources/fmi-3.0/fmi3VariableDependency.xsd,sha256=YQSBwXt4IsDlyegY8bX-qQHGSfE5TipTPfo2g2yqq1c,3082
-fmu_manipulation_toolbox/resources/linux32/client_sm.so,sha256=bG2SLZpGVEXXFyDlqEUaFwhpcHvuyGUEBOtLxmfY5_4,34664
+fmu_manipulation_toolbox/resources/linux32/client_sm.so,sha256=LnxxVwaZJpheBY9_OwCNWIiT7xokFGd7WBwqxfZwg50,34664
 fmu_manipulation_toolbox/resources/linux32/server_sm,sha256=gzKU0BTeaRkvhTMQtHHj3K8uYFyEdyGGn_mZy_jG9xo,21304
-fmu_manipulation_toolbox/resources/linux64/client_sm.so,sha256=1hUExrfYF0nuCiHMxXS1SfggkcxKJVh2X8eIIsT9mTk,32464
-fmu_manipulation_toolbox/resources/linux64/container.so,sha256=432wFrnzOA-AwvX-Fq4WDJJkYSL8U3fCyZW5-LPH-mQ,194120
+fmu_manipulation_toolbox/resources/linux64/client_sm.so,sha256=yP3h3mfT_Jzy0j-CN0POSlcGy8tMR13ca6g0K4FZWMk,32464
+fmu_manipulation_toolbox/resources/linux64/container.so,sha256=QKrG1i2AKH3DPqWoSY7Rdy-xnISy2ohnKAcnip83I2c,194064
 fmu_manipulation_toolbox/resources/linux64/server_sm,sha256=MZn6vITN2qpBHYt_RaK2VnFFp00hk8fTALBHmXPtLwc,22608
-fmu_manipulation_toolbox/resources/win32/client_sm.dll,sha256=o1fd4agl_I_weOD_XaA-MNtgOxoj8JWTeqg_dcBmBDQ,17920
-fmu_manipulation_toolbox/resources/win32/server_sm.exe,sha256=HGU6d1wohheSOI6TnojomLRDlXsl1kpbh1LKvDd_sBM,15360
-fmu_manipulation_toolbox/resources/win64/client_sm.dll,sha256=bs8CsHa26F0sry-bPRz1X1ETTIS3gexm1-fkTmPftRg,20992
-fmu_manipulation_toolbox/resources/win64/container.dll,sha256=NvBPdeFGUjeS4RdESOXG1kiFJjkDY3qvpXcSF8Lr2Kc,153088
-fmu_manipulation_toolbox/resources/win64/server_sm.exe,sha256=q-t1lCsree15azU0uDbBAEfooxSqSzNszQiZqikpam4,18432
-fmu_manipulation_toolbox-1.9.2rc1.dist-info/licenses/LICENSE.txt,sha256=0Q8zhEwTu1K-MDmg8Khay5j56BIz2VLI6RcijIFbU_g,1255
-fmu_manipulation_toolbox-1.9.2rc1.dist-info/METADATA,sha256=OXL37xMzbMCFOj7LRwgx_G6UtuRcNk__WLCVkHBzwcw,1900
-fmu_manipulation_toolbox-1.9.2rc1.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-fmu_manipulation_toolbox-1.9.2rc1.dist-info/entry_points.txt,sha256=VOWf1jbG1O-2JrqXOvSoHRRfdH3RNONvz-2RIPHNX0s,338
-fmu_manipulation_toolbox-1.9.2rc1.dist-info/top_level.txt,sha256=9D_h-5BMjSqf9z-XFkbJL_bMppR2XNYW3WNuPkXou0k,25
-fmu_manipulation_toolbox-1.9.2rc1.dist-info/RECORD,,
+fmu_manipulation_toolbox/resources/win32/client_sm.dll,sha256=GzLBrNR2RT-UGo8rfJcIXyRxv9-UreKG1MPy0Rab_8M,17920
+fmu_manipulation_toolbox/resources/win32/server_sm.exe,sha256=SXDSyWBZteYJxC4icno0uXI9MYzD-EafYwA4cEhrXno,15360
+fmu_manipulation_toolbox/resources/win64/client_sm.dll,sha256=Tv2F_mBH56jREbcH8uPczTp3O3EU7cIlCrbOEp2mS-g,20992
+fmu_manipulation_toolbox/resources/win64/container.dll,sha256=jub3YR6C-4h7kUKojVcSWspIW9B8yAVU30SwZYQ0lYQ,153088
+fmu_manipulation_toolbox/resources/win64/server_sm.exe,sha256=91n336TCk2_0ODI7NGUcAr7TVccJyxnDmk3iUZ0ijxY,18432
+fmu_manipulation_toolbox-1.9.2rc2.dist-info/licenses/LICENSE.txt,sha256=0Q8zhEwTu1K-MDmg8Khay5j56BIz2VLI6RcijIFbU_g,1255
+fmu_manipulation_toolbox-1.9.2rc2.dist-info/METADATA,sha256=K_ovw0Ra0TCFf99xxFANilNn47FAt5J2rK1I6P0e-yE,1900
+fmu_manipulation_toolbox-1.9.2rc2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+fmu_manipulation_toolbox-1.9.2rc2.dist-info/entry_points.txt,sha256=VOWf1jbG1O-2JrqXOvSoHRRfdH3RNONvz-2RIPHNX0s,338
+fmu_manipulation_toolbox-1.9.2rc2.dist-info/top_level.txt,sha256=9D_h-5BMjSqf9z-XFkbJL_bMppR2XNYW3WNuPkXou0k,25
+fmu_manipulation_toolbox-1.9.2rc2.dist-info/RECORD,,

{fmu_manipulation_toolbox-1.9.2rc1.dist-info → fmu_manipulation_toolbox-1.9.2rc2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.10.1)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any