py-pluto 1.1.4__py3-none-any.whl

pyPLUTO/configure.py

@@ -0,0 +1,261 @@
+"""Module to configure the pyPLUTO package."""
+
+import importlib
+import sys
+import traceback
+import warnings
+from collections.abc import Callable
+from types import TracebackType
+from typing import TYPE_CHECKING, cast
+
+if TYPE_CHECKING:
+    from IPython.core.interactiveshell import InteractiveShell
+
+FormatWarning = Callable[
+    [Warning | str, type[Warning], str, int, str | None], str
+]
+
+
+class Configure:
+    """Handle the init tools for pyPLUTO.
+
+    Tools include finding the session, setting up the handlers, and other
+    initialization tasks.
+    """
+
+    greeted = False
+
+    def __init__(
+        self, colorerr: bool = True, colorwarn: bool = True, greet: bool = True
+    ) -> None:
+        """Initialize the Configure class.
+
+        Parameters
+        ----------
+        - colorerr: bool, default True
+            If True, color the errors in red.
+        - colorwarn: bool, default True
+            If True, color the warnings in yellow.
+        - greet: bool, default True
+            If True, print a greeting message with the version and session.
+
+        Returns
+        -------
+        - None
+
+        """
+        self.version: str = "1.1.1"
+        self.colorerr: bool = colorerr
+        self.colorwarn: bool = colorwarn
+        self.session: str = self._find_session()
+        self._setup_handlers(colorwarn, colorerr)
+        if greet and not Configure.greeted:
+            print(f"PyPLUTO version: {self.version}   session: {self.session}")
+            Configure.greeted = True
+
+    def _find_session(self) -> str:
+        """Find the session in which the code is running.
+
+        Returns
+        -------
+        - session: str
+            The name of the session.
+
+        Parameters
+        ----------
+        - None
+
+        ----
+
+        Examples
+        --------
+        - Example #1: Standard Python interpreter
+
+            >>> find_session()
+            'Standard Python interpreter'
+
+        - Example #2: Jupyter notebook or qtconsole
+
+            >>> find_session()
+            'Jupyter notebook or qtconsole'
+
+        - Example #3: Terminal running IPython
+
+            >>> find_session()
+            'Terminal running IPython'
+
+        - Example #4: Unknown session
+
+            >>> find_session()
+            'Unknown session'
+
+        """
+
+        # Try to get IPython. If not available, it's not an IPython session.
+        # Note the quotes around the return type of the get_ipython_wrapper
+        # function. This is because pylint would throw an error.
+        def get_ipython_wrapper() -> "InteractiveShell | None":
+            """Return the IPython instance, or None if not available."""
+            warnings.filterwarnings(
+                "ignore",
+                message=r".*importing 'Const' from 'astroid' is deprecated.*",
+                category=DeprecationWarning,
+            )
+
+            try:
+                ipy_mod = importlib.import_module("IPython.core.getipython")
+                get_ipython = ipy_mod.get_ipython
+                return cast("InteractiveShell | None", get_ipython())
+            except (ImportError, AttributeError):
+                return None
+
+        # Get the ipython method (from IPthon or from the ImportError)
+
+        ipython = get_ipython_wrapper()
+
+        # Standard Python interpreter
+        if ipython is None:
+            return "Standard Python interpreter"
+
+        # Find the session name
+        shell = ipython.__class__.__name__
+
+        # Jupyter notebook or qtconsole
+        if shell == "ZMQInteractiveShell":
+            return "Jupyter notebook or qtconsole"
+        # Terminal running IPython
+        elif shell == "TerminalInteractiveShell":
+            return "Terminal running IPython"
+        # Unknown session
+        return "Unknown session"
+
+    def color_warning(
+        self,
+        message: Warning | str,
+        category: type[Warning],
+        filename: str,
+        lineno: int,
+        _file: str | None = None,
+        _line: str | None = None,
+    ) -> str:
+        """Color the warnings in yellow.
+
+        Parameters
+        ----------
+        - message: Warning | str
+            The warning message.
+        - category: type[Warning]
+            The category of the warning.
+        - filename: str
+            The name of the file where the warning occurred.
+        - lineno: int
+            The line number where the warning occurred.
+        - _file: str | None, optional
+            Not used, kept for compatibility.
+        - _line: str | None, optional
+            Not used, kept for compatibility.
+
+        Returns
+        -------
+        - str
+            The formatted warning message with color codes.
+
+        """
+        # Format the warning message with color codes
+        msg = str(message)
+
+        return f"\33[33m{category.__name__}: {msg}[{filename}:{lineno}]\33[0m\n"
+
+    def color_error(
+        self,
+        _type: type[BaseException] | None,
+        value: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        """Color the errors in red.
+
+        Parameters
+        ----------
+        - _type: type[BaseException] | None
+            The type of the exception.
+        - value: BaseException | None
+            The exception instance.
+        - tb: TracebackType | None
+            The traceback object.
+
+        Returns
+        -------
+        - None
+
+        """
+        # Traces the error and writes it in red
+        traceback_str = "".join(traceback.format_tb(tb))
+        sys.stderr.write(f"\033[91m{traceback_str}\033[0m")
+        sys.stderr.write(f"\33[31m{value}\33[0m\n")  # Red color for errors
+
+    def _setup_handlers(
+        self, colorwarn: bool = True, colorerr: bool = True
+    ) -> None:
+        """Set up the handlers for the warnings and errors.
+
+        Note that a type ignore is placed on the line where the warning handler
+        is set up because mypy and pyrefly would throw the following error:
+
+        (Warning | str, type[Warning], str, int, str | None) -> str is not
+        assignable to attribute formatwarning with type (message: Warning | str,
+        category: type[Warning], filename: str, lineno: int, line: str |
+        None = None) -> str
+        Incompatible types in assignment (expression has type
+        "Callable[[Warning | str, type[Warning], str, int, str | None], str]",
+        variable has type "Callable[[Arg(Warning | str, 'message'),
+        Arg(type[Warning], 'category'), Arg(str, 'filename'),
+        Arg(int, 'lineno'), DefaultArg(str | None, 'line')], str]")
+
+        This is because the signature of the color_warning method does not
+        exactly match the expected signature of the formatwarning attribute.
+        However, since the color_warning method is designed to be compatible
+        with the formatwarning attribute, we can safely ignore this type error.
+
+        The correct approach would be to use the following piece of code:
+
+        if colorwarn:
+            def _formatwarning(
+                message: Warning | str,
+                category: type[Warning],
+                filename: str,
+                lineno: int,
+                line: str | None = None,
+            ) -> str:
+                return self.color_warning(
+                    message,
+                    category,
+                    filename,
+                    lineno,
+                    line
+                )
+
+            warnings.formatwarning = _formatwarning
+
+        but, for simplicity, we directly assign the color_warning method to the
+        formatwarning attribute and ignore the type error.
+
+        Parameters
+        ----------
+        - colorwarn: bool, default True
+            If True, color the warnings in yellow.
+        - colorerr: bool, default True
+            If True, color the errors in red.
+
+        Returns
+        -------
+        - None
+
+        """
+        # Set up the "always" filter for warnings
+        warnings.simplefilter("always")
+
+        # Set up the handlers for warnings and errors
+        if colorwarn:
+            warnings.formatwarning = self.color_warning  # type: ignore
+        if colorerr:
+            sys.excepthook = self.color_error

pyPLUTO/gui/config.py

@@ -0,0 +1,174 @@
+"""Configure the Load object for th GUI."""
+
+import os
+
+import numpy as np
+from PySide6.QtWidgets import QFileDialog
+
+import pyPLUTO as pp
+
+from .custom_var import setup_var_selector
+
+
+def load_data(self):
+    """Load the data from the selected folder."""
+    try:
+        if self.varstext.text():
+            vars = self.varstext.text().replace(" ", "")
+            vars = vars.replace("-", ",").split(",")
+        else:
+            vars = True
+        self.D = pp.Load(
+            self.nout,
+            path=self.folder_path,
+            datatype=self.datatype,
+            vars=vars,
+            full3d=None,
+        )
+        self.data_loaded = True
+
+        self.var_selector.clear()
+        self.xaxis_selector.clear()
+        self.yaxis_selector.clear()
+
+        keep = []
+        self.D.nshp = (
+            self.D.nshp[::-1]
+            if isinstance(self.D.nshp, tuple)
+            else (int(self.D.nshp),)
+        )
+        for v in list(map(str, self.D._load_vars)):
+            a = getattr(self.D, v, None)
+
+            # keep only full-grid arrays
+            if isinstance(a, np.ndarray) and (a.shape == self.D.nshp):
+                keep.append(v)
+        self.D._load_vars = keep
+        self.var_selector.addItems(self.D._load_vars)
+
+        self.var_selector.addItems(["Custom var..."])
+        setup_var_selector(self.var_selector, self.D)
+
+        if self.D.geom == "POLAR":
+            xaxis_labels = ["R", "phi", "z", "x", "y"]
+            yaxis_labels = ["phi", "z", "R", "x", "y"]
+        elif self.D.geom == "SPHERICAL":
+            xaxis_labels = ["r", "theta", "phi", "R", "z", "Rt", "zt"]
+            yaxis_labels = ["theta", "phi", "r", "R", "z", "Rt", "zt"]
+        else:
+            xaxis_labels = ["x", "y", "z"]
+            yaxis_labels = ["y", "z", "x"]
+
+        self.xaxis_selector.addItems(xaxis_labels)
+        self.yaxis_selector.addItems(yaxis_labels)
+
+        # Base info
+        base = (
+            f"Loaded folder: {self.folder_path}\n"
+            f"Format file: {self.D.format}\n"
+            f"Geometry: {self.D.geom}\n"
+            f"Domain: {self.D.nx1} x {self.D.nx2} x {self.D.nx3}\n"
+            f"Loaded step = {self.D.nout[0]}\nPresent Time = {self.D.ntime}\n"
+            f"Variables: {', '.join(self.D._load_vars)}"
+        )
+
+        # Append custom vars defined in this session (if any)
+        defs = self.var_selector.property("_cv_defs") or []
+        CUSTOM_VAR_TUPLE_LENGTH = 3
+        if defs:
+            lines = []
+            for tup in defs:
+                if len(tup) == CUSTOM_VAR_TUPLE_LENGTH:
+                    name, _clean, disp = tup
+                    lines.append(f"{name} = {disp}")
+                else:
+                    # backward-compat: (name, expr)
+                    name, expr = tup
+                    lines.append(f"{name} = {expr}")
+            base += "\n\nCustom variables:\n" + "\n".join(lines)
+
+        self.info_label.setPlainText(base)
+
+    except Exception as e:
+        print(f"Error loading data: {e}")
+        self.data_loaded = False
+
+
+def select_folder(self):
+    """Open a dialog to select the folder containing the data."""
+    format_name = self.format_selector.currentText()
+    formats_list = {
+        "dbl": "*.dbl",
+        "flt": "*.flt",
+        "vtk": "*.vtk",
+        "dbl,h5": "*.dbl,h5",
+        "flt.h5": "*.flt.h5",
+        "hdf5": "*.hdf5",
+        "tab": "*.tab",
+        "None": None,
+    }
+    bigstr = (
+        f"Preferred format: {format_name} Files ({formats_list[format_name]});;"
+        if format_name != "None"
+        else ""
+    )
+    starting_dir = self.folder_path if self.folder_path else os.getcwd()
+    bigstr += (
+        "PLUTO Files (*.dbl *.vtk *.flt *.dbl.h5 *.flt.h5 *.out "
+        "*.hdf5 *.tab);;All Files (*)"
+    )
+    dialog = QFileDialog(self, "Select a File or Folder", starting_dir, bigstr)
+    dialog.setOption(QFileDialog.Option.DontUseNativeDialog, True)
+    dialog.setFileMode(QFileDialog.FileMode.ExistingFile)
+
+    def on_accept():
+        selected = dialog.selectedFiles()
+        if selected:
+            file_path = selected[0]
+            self._finalize_load_path(file_path)
+
+    dialog.accepted.connect(on_accept)
+    dialog.open()
+    self._file_dialog = dialog  # Save for automation access
+
+
+def reload_data(self):
+    """Reload the data from the selected folder."""
+    var_name = self.var_selector.currentText()
+    self.nout = int(self.outtext.text()) if self.outtext.text() else "last"
+    self.folder_path = "./" if self.folder_path is None else self.folder_path
+    self.load_data()
+    defs = self.var_selector.property("_cv_defs") or []
+    custom_names = []
+    for item in defs:
+        display_name = item[0]
+        clean_name = (
+            display_name[1:]
+            if str(display_name).startswith("!")
+            else display_name
+        )
+        custom_names.append(clean_name)
+
+    if var_name in self.D._load_vars or var_name in custom_names:
+        self.var_selector.setCurrentText(var_name)
+
+
+def clearload(self):
+    """Clear the loaded data and reset the GUI fields."""
+    self.folder_path = "./"
+    self.format_selector.setCurrentIndex(0)
+    self.outtext.clear()
+    self.varstext.clear()
+
+
+def _finalize_load_path(self, file_path):
+    """Finalize the load path and extract relevant information."""
+    self.folder_path = os.path.dirname(file_path)
+    filename = os.path.basename(file_path)
+    parts = filename.split(".")
+    self.datatype = parts[-1]
+    try:
+        self.nout = int(parts[1])
+    except Exception:
+        self.nout = "last"
+    self.load_data()