molde 0.1.2__py3-none-any.whl → 0.1.3__py3-none-any.whl

molde/utils/format_sequences.py

@@ -1,44 +1,44 @@
-from math import ceil, floor
-
-
-def format_long_sequence(
-    sequence, max_width=30, max_lines=3, item_separator=", ", identation="► "
-):
-    strings = [str(i) for i in sequence]
-
-    initial_lines = []
-    for _ in range(ceil(max_lines / 2)):
-        new_line = _extract_line(strings, max_width, len(item_separator))
-        if not new_line:
-            break
-        initial_lines.append(new_line)
-        strings = strings[len(new_line) :]
-
-    strings.reverse()
-    final_lines = []
-    for _ in range(floor(max_lines / 2)):
-        new_line = _extract_line(strings, max_width, len(item_separator))
-        if not new_line:
-            break
-        final_lines.append(new_line)
-        strings = strings[len(new_line) :]
-    final_lines.reverse()
-
-    if strings and initial_lines:
-        initial_lines[-1] = ["..."]
-    lines = initial_lines + final_lines
-
-    formated_lines = [item_separator.join(line) for line in lines]
-    concatenated_lines = identation + f"\n{identation}".join(formated_lines)
-    return concatenated_lines
-
-
-def _extract_line(strings, max_width, separator_size):
-    line = []
-    current_width = 0
-    for string in strings:
-        if len(string) + current_width + separator_size > max_width:
-            break
-        line.append(string)
-        current_width += len(string) + separator_size
-    return line
+from math import ceil, floor
+
+
+def format_long_sequence(
+    sequence, max_width=30, max_lines=3, item_separator=", ", identation="► "
+):
+    strings = [str(i) for i in sequence]
+
+    initial_lines = []
+    for _ in range(ceil(max_lines / 2)):
+        new_line = _extract_line(strings, max_width, len(item_separator))
+        if not new_line:
+            break
+        initial_lines.append(new_line)
+        strings = strings[len(new_line) :]
+
+    strings.reverse()
+    final_lines = []
+    for _ in range(floor(max_lines / 2)):
+        new_line = _extract_line(strings, max_width, len(item_separator))
+        if not new_line:
+            break
+        final_lines.append(new_line)
+        strings = strings[len(new_line) :]
+    final_lines.reverse()
+
+    if strings and initial_lines:
+        initial_lines[-1] = ["..."]
+    lines = initial_lines + final_lines
+
+    formated_lines = [item_separator.join(line) for line in lines]
+    concatenated_lines = identation + f"\n{identation}".join(formated_lines)
+    return concatenated_lines
+
+
+def _extract_line(strings, max_width, separator_size):
+    line = []
+    current_width = 0
+    for string in strings:
+        if len(string) + current_width + separator_size > max_width:
+            break
+        line.append(string)
+        current_width += len(string) + separator_size
+    return line

molde/utils/poly_data_utils.py

@@ -1,25 +1,66 @@
-from vtkmodules.vtkCommonCore import vtkUnsignedCharArray, vtkUnsignedIntArray
-from vtkmodules.vtkCommonDataModel import vtkPolyData
-
-
-def set_polydata_colors(data: vtkPolyData, color: tuple) -> vtkUnsignedCharArray:
-    n_cells = data.GetNumberOfCells()
-    cell_colors = vtkUnsignedCharArray()
-    cell_colors.SetName("colors")
-    cell_colors.SetNumberOfComponents(3)
-    cell_colors.SetNumberOfTuples(n_cells)
-    cell_colors.FillComponent(0, color[0])
-    cell_colors.FillComponent(1, color[1])
-    cell_colors.FillComponent(2, color[2])
-    data.GetCellData().SetScalars(cell_colors)
-    return cell_colors
-
-
-def set_polydata_property(data: vtkPolyData, property_data: int, property_name: str) -> vtkUnsignedIntArray:
-    n_cells = data.GetNumberOfCells()
-    cell_identifier = vtkUnsignedIntArray()
-    cell_identifier.SetName(property_name)
-    cell_identifier.SetNumberOfTuples(n_cells)
-    cell_identifier.Fill(property_data)
-    data.GetCellData().AddArray(cell_identifier)
-    return cell_identifier
+from pathlib import Path
+
+from vtkmodules.vtkCommonCore import vtkUnsignedCharArray, vtkUnsignedIntArray
+from vtkmodules.vtkCommonDataModel import vtkPolyData
+from vtkmodules.vtkCommonTransforms import vtkTransform
+from vtkmodules.vtkFiltersGeneral import vtkTransformPolyDataFilter
+from vtkmodules.vtkIOGeometry import vtkOBJReader, vtkSTLReader
+
+
+def set_polydata_colors(data: vtkPolyData, color: tuple) -> vtkUnsignedCharArray:
+    n_cells = data.GetNumberOfCells()
+    cell_colors = vtkUnsignedCharArray()
+    cell_colors.SetName("colors")
+    cell_colors.SetNumberOfComponents(3)
+    cell_colors.SetNumberOfTuples(n_cells)
+    cell_colors.FillComponent(0, color[0])
+    cell_colors.FillComponent(1, color[1])
+    cell_colors.FillComponent(2, color[2])
+    data.GetCellData().SetScalars(cell_colors)
+    return cell_colors
+
+
+def set_polydata_property(
+    data: vtkPolyData, property_data: int, property_name: str
+) -> vtkUnsignedIntArray:
+    n_cells = data.GetNumberOfCells()
+    cell_identifier = vtkUnsignedIntArray()
+    cell_identifier.SetName(property_name)
+    cell_identifier.SetNumberOfTuples(n_cells)
+    cell_identifier.Fill(property_data)
+    data.GetCellData().AddArray(cell_identifier)
+    return cell_identifier
+
+
+def read_obj_file(path: str | Path) -> vtkPolyData:
+    reader = vtkOBJReader()
+    reader.SetFileName(str(path))
+    reader.Update()
+    return reader.GetOutput()
+
+
+def read_stl_file(path: str | Path) -> vtkPolyData:
+    reader = vtkSTLReader()
+    reader.SetFileName(str(path))
+    reader.Update()
+    return reader.GetOutput()
+
+
+def transform_polydata(
+    polydata: vtkPolyData,
+    position=(0, 0, 0),
+    rotation=(0, 0, 0),
+    scale=(1, 1, 1),
+) -> vtkPolyData:
+    transform = vtkTransform()
+    transform.Translate(position)
+    transform.Scale(scale)
+    transform.RotateX(rotation[0])
+    transform.RotateY(rotation[1])
+    transform.RotateZ(rotation[2])
+    transform.Update()
+    transformation = vtkTransformPolyDataFilter()
+    transformation.SetTransform(transform)
+    transformation.SetInputData(polydata)
+    transformation.Update()
+    return transformation.GetOutput()

molde/utils/tree_info.py

@@ -1,52 +1,52 @@
-from collections import namedtuple
-
-TreeItem = namedtuple("TreeItem", ["name", "data", "unity"])
-SEPARATOR = TreeItem("", "", "")
-
-
-class TreeInfo:
-    def __init__(self, name: str) -> None:
-        self.name = name
-        self.items = list()
-
-    def add_separator(self):
-        self.items.append(TreeItem("", "", ""))
-        return TreeItem("", "", "")
-
-    def add_item(self, name, data, unity="") -> TreeItem:
-        item = TreeItem(name, data, unity)
-        self.items.append(item)
-        return item
-
-    def items_without_extra_separators(self):
-        extra_separators = 0
-        for item in reversed(self.items):
-            if item != SEPARATOR:
-                break
-            extra_separators += 1
-        return self.items[: len(self.items) - extra_separators]
-
-    def __str__(self):
-        title = self.name.upper()
-        longest_name = max(0, *[len(item.name) for item in self.items])
-        longest_data = max(0, *[len(str(item.data)) for item in self.items])
-        spaces = longest_name + longest_data + 3
-
-        text = f"{title} \n"
-        pruned_items = self.items_without_extra_separators()
-
-        for item in pruned_items[:-1]:
-            if item == SEPARATOR:
-                text += "│\n"
-                continue
-            spacer = " " * (spaces - len(item.name) - len(str(item.data)))
-            unity = f"[{item.unity}]" if item.unity else ""
-            text += f"├─ {item.name}: {spacer}{item.data} {unity}\n"
-
-        # last item
-        item = pruned_items[-1]
-        spacer = " " * (spaces - len(item.name) - len(str(item.data)))
-        unity = f"[{item.unity}]" if item.unity else ""
-        text += f"╰─ {item.name}: {spacer}{item.data} {unity}\n"
-        text += "\n"
-        return text
+from collections import namedtuple
+
+TreeItem = namedtuple("TreeItem", ["name", "data", "unity"])
+SEPARATOR = TreeItem("", "", "")
+
+
+class TreeInfo:
+    def __init__(self, name: str) -> None:
+        self.name = name
+        self.items = list()
+
+    def add_separator(self):
+        self.items.append(TreeItem("", "", ""))
+        return TreeItem("", "", "")
+
+    def add_item(self, name, data, unity="") -> TreeItem:
+        item = TreeItem(name, data, unity)
+        self.items.append(item)
+        return item
+
+    def items_without_extra_separators(self):
+        extra_separators = 0
+        for item in reversed(self.items):
+            if item != SEPARATOR:
+                break
+            extra_separators += 1
+        return self.items[: len(self.items) - extra_separators]
+
+    def __str__(self):
+        title = self.name.upper()
+        longest_name = max(0, *[len(item.name) for item in self.items])
+        longest_data = max(0, *[len(str(item.data)) for item in self.items])
+        spaces = longest_name + longest_data + 3
+
+        text = f"{title} \n"
+        pruned_items = self.items_without_extra_separators()
+
+        for item in pruned_items[:-1]:
+            if item == SEPARATOR:
+                text += "│\n"
+                continue
+            spacer = " " * (spaces - len(item.name) - len(str(item.data)))
+            unity = f"[{item.unity}]" if item.unity else ""
+            text += f"├─ {item.name}: {spacer}{item.data} {unity}\n"
+
+        # last item
+        item = pruned_items[-1]
+        spacer = " " * (spaces - len(item.name) - len(str(item.data)))
+        unity = f"[{item.unity}]" if item.unity else ""
+        text += f"╰─ {item.name}: {spacer}{item.data} {unity}\n"
+        text += "\n"
+        return text

molde/windows/loading_window.py

@@ -1,189 +1,189 @@
-import logging
-import re
-from time import sleep
-
-from PyQt5.QtCore import Qt
-from PyQt5.QtWidgets import QApplication, QLabel, QProgressBar, QWidget
-from PyQt5 import uic
-
-from molde import UI_DIR
-
-
-# Catches every message that contains something like [n/N]
-PROGRESS_FRACTION_REGEX = re.compile(r"\[\d+/\d+\]")
-
-# Catches every message that contains something like n%
-PROGRESS_PERCENTAGE_REGEX = re.compile(r"\d+%")
-
-
-class LoadingWindow(QWidget):
-    """
-    This function is intended to be called for functions that take
-    a long time to run and should run together with a progress bar.
-
-    The indended use is explained in the following example:
-    ```
-    def long_function(param_a, param_b=0):
-        ...
-        return value_c
-    ```
-
-    To run this function with a progress bar you just need to write
-    ```
-    value_c = LoadingWindow(long_function, param_a, param_b=1234)
-    ```
-
-    Disclaimers:
-    This is a monstruosity, but it works.
-    I hope no one ever needs to modify it.
-    I am trying my best to explain every part of this code.
-
-    An easier way to do it would be using a QWorker and a QThread,
-    but it does not work for our Application.
-    Qt manages the windows in the main thread, therefore the function
-    to be loaded would need to run in a secondary thread.
-    The problem is GMSH (wow, what a surprise).
-
-    GMSH, for some reason, refuses to run in secondary thread.
-    And GMSH is an important part of our software, that of course
-    need a progress bar when it is running.
-    So this is an attempt to run everything (both GMSH and QT) in the
-    main thread without conflicts.
-
-    I also don't want to mix the interface code with the engine code
-    because it can easily became a mess and make the creation of
-    automated tests really hard.
-    """
-
-    def __init__(self, _function, application, window_icon):
-        super().__init__()
-
-        ui_path = UI_DIR / "messages/new_loading_window.ui"
-        uic.loadUi(ui_path, self)
-
-        self._function = _function
-        self._application = application
-        self._window_icon = window_icon
-    
-        self._config_window()
-
-    def _config_window(self):
-        self.setWindowIcon(self._window_icon)
-        self.setWindowTitle("Loading")
-        self.setWindowFlags(Qt.Window | Qt.CustomizeWindowHint | Qt.WindowTitleHint | Qt.WindowMinimizeButtonHint)
-        self.setWindowModality(Qt.ApplicationModal)
-        self.update_position()
-        self.progress_bar.setValue(0)
-
-    def _define_qt_variables(self):
-        self.progress_bar: QProgressBar
-        self.progress_label: QLabel
-
-    def update_position(self):
-        '''
-        Place the window on the center of the screen.
-        '''
-        desktop_geometry = self._application.primaryScreen().geometry()
-        pos_x = int((desktop_geometry.width() - self.width())/2)
-        pos_y = int((desktop_geometry.height() - self.height())/2)
-        self.setGeometry(pos_x, pos_y, self.width(), self.height())
-
-    def run(self, *args, **kwargs):
-        self.show()
-
-        # Changes the cursor to wait
-        QApplication.setOverrideCursor(Qt.WaitCursor)
-
-        # Creates a handler to update progress_bar and progress_label
-        # every time a logging containing [n/N] appears
-        progress_handler = ProgressBarLogUpdater(logging.DEBUG, loading_window=self)
-        logging.getLogger().addHandler(progress_handler)
-
-        # Waits the loading bar to appear and uptates pyqt
-        sleep(0.1)
-        QApplication.processEvents()
-
-        try:
-            # Calls the actual function
-            return_value = self._function(*args, **kwargs)
-
-        finally:
-            """
-            This piece of code will run even if the function have errors.
-            Because the error is not handled here it will propagate to the
-            function that called it.
-            The error should be threated there, here we are just mitigating
-            things related to the loading window.
-            """
-
-            # Restores the previous cursor
-            QApplication.restoreOverrideCursor()
-
-            # Removes the ProgressBarLogUpdater
-            logging.getLogger().removeHandler(progress_handler)
-
-            self.hide()
-
-        return return_value
-
-    def __call__(self, *args, **kwargs):
-        return self.run(self._function, *args, **kwargs)
-
-
-class ProgressBarLogUpdater(logging.Handler):
-    """
-    This class is an log observer. It is meant to watch logs
-    and use it to update an instance of the loading window.
-    """
-
-    def __init__(self, level=0, *, loading_window: LoadingWindow) -> None:
-        super().__init__(level)
-        self.loading_window = loading_window
-
-    def emit(self, record):
-        """
-        This function is fired when something is logged.
-        If the log have a marker like [n/N] or "..." in its message it
-        will update the LoadingWindow associated with this class.
-        """
-
-        # Updates QT to prevent freezing
-        QApplication.processEvents()
-
-        percent = self.get_percentage(record.msg)
-
-        if percent is not None:
-            self.loading_window.progress_label.setText(record.msg)
-            self.loading_window.progress_bar.setValue(percent)
-        
-        elif "..." in record.msg:
-            self.loading_window.progress_label.setText(record.msg)
-
-        # Updates QT to show the window modifications
-        QApplication.processEvents()
-
-    def get_percentage(self, message: str):
-        """
-        Uses regex to check if the message have a marker like [2/10]
-        If it does, it extracts the step (2) and the max_step (10) and
-        calculates the percentage (20%).
-        Otherwise it just returns None.
-        """
-
-        if not isinstance(message, str):
-            return
-
-        matches = PROGRESS_FRACTION_REGEX.findall(message)
-        if matches:
-            first_match: str = matches[0]
-            step, max_step = first_match.strip("[]").split("/")
-            percentage = 100 * int(step) // int(max_step)
-            return percentage
-
-        matches = PROGRESS_PERCENTAGE_REGEX.findall(message)
-        if matches:
-            first_match: str = matches[0]
-            percentage = int(first_match.strip("%"))
-            return percentage
-
-        return None
+import logging
+import re
+from time import sleep
+
+from PyQt5.QtCore import Qt
+from PyQt5.QtWidgets import QApplication, QLabel, QProgressBar, QWidget
+from PyQt5 import uic
+
+from molde import UI_DIR
+
+
+# Catches every message that contains something like [n/N]
+PROGRESS_FRACTION_REGEX = re.compile(r"\[\d+/\d+\]")
+
+# Catches every message that contains something like n%
+PROGRESS_PERCENTAGE_REGEX = re.compile(r"\d+%")
+
+
+class LoadingWindow(QWidget):
+    """
+    This function is intended to be called for functions that take
+    a long time to run and should run together with a progress bar.
+
+    The indended use is explained in the following example:
+    ```
+    def long_function(param_a, param_b=0):
+        ...
+        return value_c
+    ```
+
+    To run this function with a progress bar you just need to write
+    ```
+    value_c = LoadingWindow(long_function, param_a, param_b=1234)
+    ```
+
+    Disclaimers:
+    This is a monstruosity, but it works.
+    I hope no one ever needs to modify it.
+    I am trying my best to explain every part of this code.
+
+    An easier way to do it would be using a QWorker and a QThread,
+    but it does not work for our Application.
+    Qt manages the windows in the main thread, therefore the function
+    to be loaded would need to run in a secondary thread.
+    The problem is GMSH (wow, what a surprise).
+
+    GMSH, for some reason, refuses to run in secondary thread.
+    And GMSH is an important part of our software, that of course
+    need a progress bar when it is running.
+    So this is an attempt to run everything (both GMSH and QT) in the
+    main thread without conflicts.
+
+    I also don't want to mix the interface code with the engine code
+    because it can easily became a mess and make the creation of
+    automated tests really hard.
+    """
+
+    def __init__(self, _function, application, window_icon):
+        super().__init__()
+
+        ui_path = UI_DIR / "messages/new_loading_window.ui"
+        uic.loadUi(ui_path, self)
+
+        self._function = _function
+        self._application = application
+        self._window_icon = window_icon
+    
+        self._config_window()
+
+    def _config_window(self):
+        self.setWindowIcon(self._window_icon)
+        self.setWindowTitle("Loading")
+        self.setWindowFlags(Qt.Window | Qt.CustomizeWindowHint | Qt.WindowTitleHint | Qt.WindowMinimizeButtonHint)
+        self.setWindowModality(Qt.ApplicationModal)
+        self.update_position()
+        self.progress_bar.setValue(0)
+
+    def _define_qt_variables(self):
+        self.progress_bar: QProgressBar
+        self.progress_label: QLabel
+
+    def update_position(self):
+        '''
+        Place the window on the center of the screen.
+        '''
+        desktop_geometry = self._application.primaryScreen().geometry()
+        pos_x = int((desktop_geometry.width() - self.width())/2)
+        pos_y = int((desktop_geometry.height() - self.height())/2)
+        self.setGeometry(pos_x, pos_y, self.width(), self.height())
+
+    def run(self, *args, **kwargs):
+        self.show()
+
+        # Changes the cursor to wait
+        QApplication.setOverrideCursor(Qt.WaitCursor)
+
+        # Creates a handler to update progress_bar and progress_label
+        # every time a logging containing [n/N] appears
+        progress_handler = ProgressBarLogUpdater(logging.DEBUG, loading_window=self)
+        logging.getLogger().addHandler(progress_handler)
+
+        # Waits the loading bar to appear and uptates pyqt
+        sleep(0.1)
+        QApplication.processEvents()
+
+        try:
+            # Calls the actual function
+            return_value = self._function(*args, **kwargs)
+
+        finally:
+            """
+            This piece of code will run even if the function have errors.
+            Because the error is not handled here it will propagate to the
+            function that called it.
+            The error should be threated there, here we are just mitigating
+            things related to the loading window.
+            """
+
+            # Restores the previous cursor
+            QApplication.restoreOverrideCursor()
+
+            # Removes the ProgressBarLogUpdater
+            logging.getLogger().removeHandler(progress_handler)
+
+            self.hide()
+
+        return return_value
+
+    def __call__(self, *args, **kwargs):
+        return self.run(self._function, *args, **kwargs)
+
+
+class ProgressBarLogUpdater(logging.Handler):
+    """
+    This class is an log observer. It is meant to watch logs
+    and use it to update an instance of the loading window.
+    """
+
+    def __init__(self, level=0, *, loading_window: LoadingWindow) -> None:
+        super().__init__(level)
+        self.loading_window = loading_window
+
+    def emit(self, record):
+        """
+        This function is fired when something is logged.
+        If the log have a marker like [n/N] or "..." in its message it
+        will update the LoadingWindow associated with this class.
+        """
+
+        # Updates QT to prevent freezing
+        QApplication.processEvents()
+
+        percent = self.get_percentage(record.msg)
+
+        if percent is not None:
+            self.loading_window.progress_label.setText(record.msg)
+            self.loading_window.progress_bar.setValue(percent)
+        
+        elif "..." in record.msg:
+            self.loading_window.progress_label.setText(record.msg)
+
+        # Updates QT to show the window modifications
+        QApplication.processEvents()
+
+    def get_percentage(self, message: str):
+        """
+        Uses regex to check if the message have a marker like [2/10]
+        If it does, it extracts the step (2) and the max_step (10) and
+        calculates the percentage (20%).
+        Otherwise it just returns None.
+        """
+
+        if not isinstance(message, str):
+            return
+
+        matches = PROGRESS_FRACTION_REGEX.findall(message)
+        if matches:
+            first_match: str = matches[0]
+            step, max_step = first_match.strip("[]").split("/")
+            percentage = 100 * int(step) // int(max_step)
+            return percentage
+
+        matches = PROGRESS_PERCENTAGE_REGEX.findall(message)
+        if matches:
+            first_match: str = matches[0]
+            percentage = int(first_match.strip("%"))
+            return percentage
+
+        return None