flextool 4.0.4__tar.gz → 4.0.5__tar.gz

{flextool-4.0.4 → flextool-4.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flextool
-Version: 4.0.4
+Version: 4.0.5
 Summary: IRENA FlexTool is an energy and power systems model for understanding the role of variable power generation in future energy systems.
 Author: IRENA FlexTool contributors
 License: © International Renewable Energy Agency 2018-2022

{flextool-4.0.4 → flextool-4.0.5}/flextool/cli/cmd_open_results_db.py

@@ -33,6 +33,7 @@ from pathlib import Path
 
 from flextool.cli._console import run_tool
 from flextool.cli.cmd_run_flextool import resolve_output_path
+from flextool.gui.platform_utils import spine_db_editor_argv
 
 
 def resolve_results_db_path(project_folder_file, output_location=None):
@@ -100,16 +101,10 @@ def _build_launch_argv(db_urls):
     ``db_urls`` may be a single URL string or a list of URLs (each becomes a
     tab).  The supported standalone entry point is
     ``spinetoolbox.spine_db_editor.main:main``, whose ``main()`` reads
-    positional ``url`` args.
+    positional ``url`` args.  Shared with the GUI launchers
+    (:func:`flextool.gui.platform_utils.spine_db_editor_argv`).
     """
-    if isinstance(db_urls, str):
-        db_urls = [db_urls]
-    return [
-        sys.executable,
-        "-m",
-        "spinetoolbox.spine_db_editor.main",
-        *db_urls,
-    ]
+    return spine_db_editor_argv(db_urls)
 
 
 def launch_db_editor(db_urls, _popen=subprocess.Popen):

{flextool-4.0.4 → flextool-4.0.5}/flextool/engine_polars/_pdt_join.py

@@ -43,6 +43,25 @@ __all__ = (
 )
 
 
+def _cross(left: pl.DataFrame, right: pl.DataFrame) -> pl.DataFrame:
+    """``left × right`` in left-major order (each left row, then every
+    right row in order).
+
+    The order is part of the contract: with sorted inputs the product
+    is sorted by ``(*left.columns, *right.columns)`` — the canonical
+    order that ``add_var`` / ``add_cstr`` assign ids in (the
+    determinism wrapper skips its sort when the frame is already
+    sorted) and that :mod:`._warm` relies on to align a rolled
+    sub-solve's RHS vector with the warm problem's rows by position.
+    ``maintain_order`` must be explicit: polars 2 no longer keeps
+    left-major order by default for a lazy cross join (it may swap the
+    sides and emit right-major order).
+    """
+    return (left.lazy()
+            .join(right.lazy(), how="cross", maintain_order="left_right")
+            .collect())
+
+
 def compute_pss_dt(flex_data: "FlexData") -> pl.DataFrame | None:
     """Lazy-build the ``(p, source, sink, d, t)`` cross-product from
     ``flex_data.process_source_sink`` × ``flex_data.dt``.
@@ -53,7 +72,7 @@ def compute_pss_dt(flex_data: "FlexData") -> pl.DataFrame | None:
     dt = getattr(flex_data, "dt", None)
     if pss is None or dt is None or pss.height == 0 or dt.height == 0:
         return None
-    return pss.lazy().join(dt.lazy(), how="cross").collect()
+    return _cross(pss, dt)
 
 
 def compute_nodeBalance_dt(flex_data: "FlexData") -> pl.DataFrame | None:
@@ -66,7 +85,7 @@ def compute_nodeBalance_dt(flex_data: "FlexData") -> pl.DataFrame | None:
     dt = getattr(flex_data, "dt", None)
     if nb is None or dt is None or nb.height == 0 or dt.height == 0:
         return None
-    return nb.lazy().join(dt.lazy(), how="cross").collect()
+    return _cross(nb, dt)
 
 
 def compute_nodeState_dt(flex_data: "FlexData") -> pl.DataFrame | None:
@@ -79,7 +98,7 @@ def compute_nodeState_dt(flex_data: "FlexData") -> pl.DataFrame | None:
     dt = getattr(flex_data, "dt", None)
     if ns is None or dt is None or ns.height == 0 or dt.height == 0:
         return None
-    return ns.lazy().join(dt.lazy(), how="cross").collect()
+    return _cross(ns, dt)
 
 
 def compute_nodeState_first_dt(flex_data: "FlexData") -> pl.DataFrame | None:
@@ -128,7 +147,7 @@ def compute_nodeState_rp_dt(flex_data: "FlexData") -> pl.DataFrame | None:
     dt = getattr(flex_data, "dt", None)
     if nsrp is None or dt is None or nsrp.height == 0 or dt.height == 0:
         return None
-    return nsrp.lazy().join(dt.lazy(), how="cross").collect()
+    return _cross(nsrp, dt)
 
 
 def compute_nodeState_rp_block_first_dt(
@@ -151,7 +170,7 @@ def compute_nodeState_rp_block_first_dt(
     if (nsrp is None or rpbf is None
             or nsrp.height == 0 or rpbf.height == 0):
         return None
-    return nsrp.lazy().join(rpbf.lazy(), how="cross").collect()
+    return _cross(nsrp, rpbf)
 
 
 def compute_process_indirect_dt(flex_data: "FlexData") -> pl.DataFrame | None:
@@ -164,4 +183,4 @@ def compute_process_indirect_dt(flex_data: "FlexData") -> pl.DataFrame | None:
     dt = getattr(flex_data, "dt", None)
     if pi is None or dt is None or pi.height == 0 or dt.height == 0:
         return None
-    return pi.lazy().join(dt.lazy(), how="cross").collect()
+    return _cross(pi, dt)

{flextool-4.0.4 → flextool-4.0.5}/flextool/engine_polars/_warm.py

@@ -743,17 +743,28 @@ def _apply_warm_updates(warm: WarmProblem,
                     raise _IncompatibleUpdate(
                         f"warm-update needs FlexData.{over_field}, but it "
                         f"is None on the new sub-solve")
+                # The cstr's rows are in ``over`` sorted by its columns
+                # (the add_cstr determinism wrapper,
+                # ``engine_polars/__init__.py``), so sort ``new_over``
+                # the same way: position i then names the same row in
+                # both sub-solves (labels shift, order does not).  Do
+                # not trust the producer's row order — a polars 2 lazy
+                # cross join emits right-major order unless told
+                # otherwise, which pushed every other (n, t) inflow onto
+                # the wrong row.
+                new_over = new_over.sort(new_over.columns)
                 # Left-join new_over with next_p on shared dims; values
-                # come out aligned to new_over's row order, which by
-                # fingerprint match has the same row count as the
-                # original LP cstr over.
+                # come out aligned to new_over's row order (kept by
+                # ``maintain_order="left"``), which by fingerprint match
+                # has the same row count as the original LP cstr over.
                 shared = [c for c in next_p.dims if c in new_over.columns]
                 if not shared:
                     rhs_vec = np.full(new_over.height,
                                       float(next_p.frame["value"][0]),
                                       dtype=np.float64)
                 else:
-                    j = new_over.join(next_p.frame, on=shared, how="left")
+                    j = new_over.join(next_p.frame, on=shared, how="left",
+                                      maintain_order="left")
                     rhs_vec = (j["value"].fill_null(0.0)
                                          .to_numpy()
                                          .astype(np.float64, copy=False))

{flextool-4.0.4 → flextool-4.0.5}/flextool/gui/db_editor_integration.py

@@ -4,11 +4,14 @@ from __future__ import annotations
 
 import logging
 import os
-import shutil
 import subprocess
+import sys
 import tempfile
+from collections.abc import Sequence
 from pathlib import Path
 
+from flextool.gui.platform_utils import spine_db_editor_argv, spine_toolbox_available
+
 logger = logging.getLogger(__name__)
 
 
@@ -20,11 +23,14 @@ class DbEditorManager:
       is still open in an editor.
     - Open additional databases by launching new editor instances.
 
-    Spine DB Editor (``spine-db-editor``) accepts multiple database URLs
-    on the command line and opens them as tabs (use ``-s`` for separate
-    tabs).  However, there is no IPC mechanism to add a tab to an
-    already-running instance, so each call to :meth:`open_database`
-    launches a new process.
+    The editor is started with the interpreter running FlexTool
+    (``<sys.executable> -m spinetoolbox.spine_db_editor.main <url>...``,
+    see :func:`~flextool.gui.platform_utils.spine_db_editor_argv`), never
+    via a ``spine-db-editor`` looked up on PATH: a ``flextool-gui`` started
+    from a venv that is not activated has no venv ``bin`` on PATH.  It
+    accepts multiple database URLs and opens them as tabs.  However, there
+    is no IPC mechanism to add a tab to an already-running instance, so
+    each call to :meth:`open_database` launches a new process.
     """
 
     def __init__(self) -> None:
@@ -37,26 +43,33 @@ class DbEditorManager:
 
     # ── Opening databases ─────────────────────────────────────────
 
-    def open_database(self, db_url: str, source_name: str) -> subprocess.Popen | None:
-        """Launch ``spine-db-editor`` for *db_url* and track the process.
+    def open_database(
+        self, db_url: str | Sequence[str], source_name: str
+    ) -> subprocess.Popen | None:
+        """Launch the Spine DB editor for *db_url* and track the process.
 
         The editor's own stdout/stderr is redirected to a temporary log file
         so that, if it exits immediately, the caller can read the failure via
         :meth:`read_launch_output` and surface it to the user.
 
         Args:
-            db_url: SQLAlchemy-style database URL (e.g. ``sqlite:///path``).
+            db_url: SQLAlchemy-style database URL (e.g. ``sqlite:///path``),
+                or several URLs to open as tabs of one editor.
             source_name: Logical name used to track which input source is
                 being edited.
 
         Returns:
-            The :class:`subprocess.Popen` object, or ``None`` if the
-            editor executable is not found on ``PATH``.
+            The :class:`subprocess.Popen` object, or ``None`` if Spine
+            Toolbox is not importable by the interpreter running FlexTool
+            (or the launch itself fails).
         """
-        exe = shutil.which("spine-db-editor")
-        if exe is None:
-            logger.warning("spine-db-editor not found on PATH")
+        if not spine_toolbox_available():
+            logger.warning(
+                "Spine Toolbox (spinetoolbox) is not installed in this Python "
+                "environment (%s); cannot open the Spine DB editor",
+                sys.executable)
             return None
+        argv = spine_db_editor_argv(db_url)
 
         log_path: Path | None = None
         log_handle = None
@@ -71,12 +84,12 @@ class DbEditorManager:
         try:
             if log_handle is not None:
                 proc = subprocess.Popen(
-                    [exe, db_url], stdout=log_handle, stderr=subprocess.STDOUT
+                    argv, stdout=log_handle, stderr=subprocess.STDOUT
                 )
             else:
-                proc = subprocess.Popen([exe, db_url])
+                proc = subprocess.Popen(argv)
         except OSError:
-            logger.warning("Failed to launch spine-db-editor", exc_info=True)
+            logger.warning("Failed to launch the Spine DB editor", exc_info=True)
             if log_path is not None:
                 try:
                     log_path.unlink(missing_ok=True)

{flextool-4.0.4 → flextool-4.0.5}/flextool/gui/main_window.py

@@ -3123,14 +3123,16 @@ class MainWindow(tk.Tk):
             db_url = f"sqlite:///{filepath}"
             proc = self.db_editor_mgr.open_database(db_url, source_name)
             if proc is None:
-                # spine-db-editor not found: point at 'Update FlexTool' and
+                # Spine Toolbox not installed in this environment: point at
+                # 'Update FlexTool' and
                 # offer the system default .sqlite app as a fallback.
                 # askyesnocancel: Yes=Update, No=default app, Cancel=nothing.
                 from flextool.update_flextool import install_info
                 choice = messagebox.askyesnocancel(
                     "Spine DB Editor not available",
-                    "The 'spine-db-editor' command was not found, so .sqlite "
-                    "input sources cannot be opened in the Spine DB Editor.\n\n"
+                    "Spine Toolbox is not installed in the Python environment "
+                    "running FlexTool, so .sqlite input sources cannot be "
+                    "opened in the Spine DB Editor.\n\n"
                     "It is part of Spine Toolbox. You can install it via "
                     "'Update FlexTool' (tick 'Install Spine Toolbox'), or "
                     "manually:\n\n"
@@ -3150,7 +3152,7 @@ class MainWindow(tk.Tk):
                             "Error", f"Could not open file:\n{exc}"
                         )
                 return
-            # spine-db-editor was found and launched, but an incomplete Spine
+            # The Spine DB editor was launched, but an incomplete Spine
             # Toolbox install can still crash it on startup. Check shortly after
             # launch and explain the failure instead of leaving the user with a
             # silent no-op (the crash otherwise only shows in the terminal).
@@ -5999,8 +6001,9 @@ class MainWindow(tk.Tk):
     def _on_show_comp_spinedb(self) -> None:
         """Open the project-wide results.sqlite SpineDB.
 
-        Prefer the Spine DB Editor when ``spine-db-editor`` is available on
-        PATH (i.e. Spine Toolbox is installed in the venv). If it is not,
+        Prefer the Spine DB Editor when Spine Toolbox is installed in the
+        environment running FlexTool (launched as
+        ``python -m spinetoolbox.spine_db_editor.main``). If it is not,
         explain that Spine Toolbox can be added via 'Update FlexTool' and
         offer to open the file with the system's default .sqlite application
         instead.
@@ -6029,15 +6032,15 @@ class MainWindow(tk.Tk):
         db_url = f"sqlite:///{results_db}"
         proc = self.db_editor_mgr.open_database(db_url, source_name)
         if proc is None:
-            # spine-db-editor not found: inform the user, point at
+            # Spine Toolbox not installed here: inform the user, point at
             # 'Update FlexTool', and offer the system default .sqlite app
             # as a fallback. askyesnocancel: Yes=Update, No=default app,
             # Cancel=do nothing.
             choice = messagebox.askyesnocancel(
                 "Spine DB Editor not available",
-                "The 'spine-db-editor' command was not found, so the "
-                "comparison results.sqlite cannot be opened in the Spine DB "
-                "Editor.\n\n"
+                "Spine Toolbox is not installed in the Python environment "
+                "running FlexTool, so the comparison results.sqlite cannot be "
+                "opened in the Spine DB Editor.\n\n"
                 "It is part of Spine Toolbox, which can be added via "
                 "'Update FlexTool' (tick 'Install Spine Toolbox').\n\n"
                 "Open 'Update FlexTool' now?\n\n"
@@ -6053,7 +6056,7 @@ class MainWindow(tk.Tk):
                 except OSError as exc:
                     logger.warning("Could not open results SpineDB: %s", exc)
             return
-        # spine-db-editor was found and launched, but an incomplete Spine
+        # The Spine DB editor was launched, but an incomplete Spine
         # Toolbox install can still crash it on startup. Check shortly after
         # launch and explain the failure instead of leaving a silent no-op.
         self.after(2000, self._check_db_editor_launch, proc, source_name)

{flextool-4.0.4 → flextool-4.0.5}/flextool/gui/platform_utils.py

@@ -6,6 +6,7 @@ import logging
 import os
 import subprocess
 import sys
+from collections.abc import Sequence
 from pathlib import Path
 from typing import TYPE_CHECKING
 
@@ -93,26 +94,53 @@ def open_folder(dirpath: Path) -> None:
         )
 
 
-def open_spine_db_editor(db_url: str) -> subprocess.Popen | None:
-    """Launch the Spine DB editor on *db_url* as a subprocess, using the current
-    environment's Spine Toolbox (``python -m spinetoolbox.spine_db_editor.main``,
-    matching the CLI launcher) rather than a ``spine-db-editor`` found anywhere
-    on PATH.
+#: Module run (``python -m``) to start the standalone Spine DB editor — the
+#: target of Spine Toolbox's ``spine-db-editor`` console script.
+SPINE_DB_EDITOR_MODULE = "spinetoolbox.spine_db_editor.main"
+
+
+def spine_toolbox_available() -> bool:
+    """Whether Spine Toolbox is importable by the interpreter running FlexTool.
+
+    Deliberately not a PATH lookup: ``flextool-gui`` started from a venv that
+    is not activated (``.venv/bin/flextool-gui``) does not have the venv's
+    ``bin`` on PATH, and a ``spine-db-editor`` found on PATH may belong to a
+    different environment.
+    """
+    import importlib.util
+
+    return importlib.util.find_spec("spinetoolbox") is not None
+
+
+def spine_db_editor_argv(db_urls: str | Sequence[str]) -> list[str]:
+    """argv that opens *db_urls* (one URL or several, each a tab) in the
+    Spine DB editor of the current environment
+    (``<sys.executable> -m spinetoolbox.spine_db_editor.main <url>...``).
+
+    The single source for every FlexTool launcher of the editor (GUI and
+    CLI), so they cannot drift back to a PATH lookup.
+    """
+    urls = [db_urls] if isinstance(db_urls, str) else list(db_urls)
+    return [sys.executable, "-m", SPINE_DB_EDITOR_MODULE, *urls]
+
+
+def open_spine_db_editor(db_urls: str | Sequence[str]) -> subprocess.Popen | None:
+    """Launch the Spine DB editor on *db_urls* as a subprocess, using the
+    current environment's Spine Toolbox (:func:`spine_db_editor_argv`)
+    rather than a ``spine-db-editor`` found anywhere on PATH.
 
     Returns:
         The :class:`subprocess.Popen` object, or ``None`` if Spine Toolbox is
         not installed in this environment.
     """
-    import importlib.util
-
-    if importlib.util.find_spec("spinetoolbox") is None:
-        logger.warning("spinetoolbox is not installed in this environment")
+    if not spine_toolbox_available():
+        logger.warning(
+            "Spine Toolbox (spinetoolbox) is not installed in this Python "
+            "environment (%s); cannot open the Spine DB editor", sys.executable)
         return None
 
     try:
-        proc = subprocess.Popen(
-            [sys.executable, "-m", "spinetoolbox.spine_db_editor.main", db_url]
-        )
+        proc = subprocess.Popen(spine_db_editor_argv(db_urls))
         return proc
     except OSError:
         logger.warning("Failed to launch the Spine DB editor", exc_info=True)

{flextool-4.0.4 → flextool-4.0.5}/flextool.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flextool
-Version: 4.0.4
+Version: 4.0.5
 Summary: IRENA FlexTool is an energy and power systems model for understanding the role of variable power generation in future energy systems.
 Author: IRENA FlexTool contributors
 License: © International Renewable Energy Agency 2018-2022

{flextool-4.0.4 → flextool-4.0.5}/pyproject.toml

@@ -3,7 +3,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "flextool"
-version = "4.0.4"
+version = "4.0.5"
 description = "IRENA FlexTool is an energy and power systems model for understanding the role of variable power generation in future energy systems."
 readme = "README.md"
 license = { file = "LICENSE.txt" }