flextool 4.0.0__py3-none-any.whl

flextool/gui/input_sources.py

@@ -0,0 +1,730 @@
+from __future__ import annotations
+
+import logging
+import shutil
+import sys
+from pathlib import Path
+
+from flextool.gui.data_models import InputSourceInfo, ProjectSettings, ScenarioInfo
+from flextool.gui.settings_io import save_project_settings
+
+logger = logging.getLogger(__name__)
+
+# File extensions recognised as input sources
+SUPPORTED_EXTENSIONS = {".xlsx", ".ods", ".sqlite"}
+
+
+def _relative_posix(target: Path, base: Path) -> str:
+    """Return ``target`` as a POSIX path relative to ``base``.
+
+    Falls back to ``os.path.relpath`` when the paths live on the same
+    drive but ``target`` is not under ``base`` (common for references
+    that go up with ``..``). Returns the absolute POSIX path when the
+    paths cannot be related (e.g. different Windows drives).
+    """
+    import os
+    target = target.resolve()
+    base = base.resolve()
+    try:
+        rel = os.path.relpath(str(target), str(base))
+    except ValueError:
+        return target.as_posix()
+    return Path(rel).as_posix()
+
+
+class InputSourceManager:
+    """Manages input source files and their scenario discovery.
+
+    Scans the ``input_sources/`` subdirectory of a project, reads scenario
+    names from xlsx and sqlite files, and keeps track of persistent source
+    numbering via project settings.
+    """
+
+    def __init__(self, project_path: Path, settings: ProjectSettings) -> None:
+        self.project_path = project_path
+        self.settings = settings
+        self.input_dir = project_path / "input_sources"
+        self._sources: list[InputSourceInfo] = []
+        # Retired "ghost" rows from the last refresh (file gone, results
+        # survive). Kept separate from ``_sources`` (live only) so scenario
+        # enumeration ignores them while the UI can still render them.
+        self._last_ghosts: list[InputSourceInfo] = []
+        # Track mtimes for files opened via Edit button (Linux xlsx fallback)
+        self._last_known_mtimes: dict[str, float] = {}
+        # Track which sources were explicitly opened for editing
+        self._editing_sources: set[str] = set()
+
+    # ── Public API ────────────────────────────────────────────────────
+
+    def scan_input_sources(self) -> list[InputSourceInfo]:
+        """List files in the input_sources/ directory plus external references.
+
+        Returns an :class:`InputSourceInfo` for each ``.xlsx``, ``.ods``, and
+        ``.sqlite`` file found inside ``input_sources/``, followed by one
+        entry per external reference registered in project settings.
+        No scenario reading is performed here.
+        """
+        sources: list[InputSourceInfo] = []
+        if self.input_dir.is_dir():
+            for filepath in sorted(self.input_dir.iterdir()):
+                if filepath.suffix.lower() not in SUPPORTED_EXTENSIONS:
+                    continue
+                if not filepath.is_file():
+                    continue
+                file_type = filepath.suffix.lstrip(".").lower()
+                sources.append(
+                    InputSourceInfo(
+                        name=filepath.name,
+                        file_type=file_type,
+                        number=0,  # assigned later in refresh()
+                        status="error",  # updated later
+                    )
+                )
+
+        for ext_name, rel_path in self.settings.external_refs.items():
+            ext = Path(ext_name).suffix.lower()
+            if ext not in SUPPORTED_EXTENSIONS:
+                continue
+            sources.append(
+                InputSourceInfo(
+                    name=ext_name,
+                    file_type=ext.lstrip("."),
+                    number=0,
+                    status="error",
+                    external_rel_path=rel_path,
+                )
+            )
+        return sources
+
+    def resolve_path(self, source: InputSourceInfo) -> Path:
+        """Return the absolute path to a source's underlying file."""
+        if source.external_rel_path:
+            return (self.project_path / source.external_rel_path).resolve()
+        return self.input_dir / source.name
+
+    def add_external_ref(self, filepath: Path) -> tuple[str, str]:
+        """Register an external file as an input source.
+
+        Returns ``(name, rel_path)`` where ``rel_path`` is POSIX-style and
+        relative to the project root. Raises ``ValueError`` if a reference
+        with the same name is already registered.
+        """
+        filepath = filepath.resolve()
+        rel_path = _relative_posix(filepath, self.project_path)
+        name = filepath.name
+        if name in self.settings.external_refs:
+            raise ValueError(
+                f"An external reference named '{name}' is already registered."
+            )
+        self.settings.external_refs[name] = rel_path
+        return name, rel_path
+
+    def remove_external_ref(self, name: str) -> bool:
+        """Remove an external reference. Returns True if found and removed."""
+        if name in self.settings.external_refs:
+            del self.settings.external_refs[name]
+            return True
+        return False
+
+    def read_scenarios_xlsx(self, filepath: Path) -> list[str] | None:
+        """Read scenario names from the 'scenario' sheet in an xlsx file.
+
+        Uses zipfile + xml.etree to read the xlsx directly without openpyxl,
+        avoiding any file handle leaks that could prevent LibreOffice from
+        opening the file afterwards.
+
+        Reads the 2nd row, skips the first column, and reads cell values
+        until an empty cell is encountered.
+        """
+        import zipfile
+        import xml.etree.ElementTree as ET
+
+        ns = {"s": "http://schemas.openxmlformats.org/spreadsheetml/2006/main"}
+
+        try:
+            with zipfile.ZipFile(str(filepath), "r") as zf:
+                # Find the scenario sheet: read workbook.xml for sheet names
+                wb_xml = ET.fromstring(zf.read("xl/workbook.xml"))
+                sheets = wb_xml.findall(".//s:sheet", ns)
+                scenario_sheet_id = None
+                for sheet in sheets:
+                    if sheet.get("name") == "scenario":
+                        # rId attribute links to the actual sheet file
+                        scenario_sheet_id = sheet.get(
+                            "{http://schemas.openxmlformats.org/officeDocument/2006/relationships}id"
+                        )
+                        break
+
+                if scenario_sheet_id is None:
+                    return None
+
+                # Resolve rId to a sheet file path via relationships
+                rels_xml = ET.fromstring(zf.read("xl/_rels/workbook.xml.rels"))
+                sheet_file = None
+                for rel in rels_xml:
+                    if rel.get("Id") == scenario_sheet_id:
+                        target = rel.get("Target", "")
+                        # Target may be relative (e.g. "worksheets/sheet3.xml")
+                        # or absolute (e.g. "/xl/worksheets/sheet3.xml")
+                        if target.startswith("/"):
+                            sheet_file = target.lstrip("/")
+                        else:
+                            sheet_file = "xl/" + target
+                        break
+
+                if sheet_file is None or sheet_file not in zf.namelist():
+                    return None
+
+                # Read shared strings (cell values may reference these)
+                shared_strings: list[str] = []
+                if "xl/sharedStrings.xml" in zf.namelist():
+                    ss_xml = ET.fromstring(zf.read("xl/sharedStrings.xml"))
+                    for si in ss_xml.findall("s:si", ns):
+                        t_elem = si.find("s:t", ns)
+                        shared_strings.append(t_elem.text if t_elem is not None and t_elem.text else "")
+
+                # Parse the scenario sheet — find row 2 cells
+                sheet_xml = ET.fromstring(zf.read(sheet_file))
+                scenarios: list[str] = []
+
+                for row in sheet_xml.findall(".//s:sheetData/s:row", ns):
+                    if row.get("r") != "2":
+                        continue
+                    # Found row 2 — read cells from column B onwards
+                    for cell in row.findall("s:c", ns):
+                        ref = cell.get("r", "")
+                        # Skip column A (ref is exactly "A2", not "AA2", "AB2", etc.)
+                        if ref == "A2":
+                            continue
+                        cell_type = cell.get("t", "")
+                        value = ""
+                        if cell_type == "s":
+                            # Shared string reference
+                            v_elem = cell.find("s:v", ns)
+                            if v_elem is not None and v_elem.text is not None:
+                                idx = int(v_elem.text)
+                                value = shared_strings[idx] if idx < len(shared_strings) else ""
+                        elif cell_type == "inlineStr":
+                            # Inline string: <is><t>text</t></is>
+                            is_elem = cell.find("s:is/s:t", ns)
+                            if is_elem is not None and is_elem.text is not None:
+                                value = is_elem.text
+                        else:
+                            v_elem = cell.find("s:v", ns)
+                            if v_elem is not None and v_elem.text is not None:
+                                value = v_elem.text
+                        value = value.strip()
+                        if value:
+                            scenarios.append(value)
+                    break
+
+                return scenarios
+
+        except Exception:
+            logger.warning("Error reading scenarios from %s", filepath, exc_info=True)
+            return None
+
+    def read_scenarios_sqlite(self, filepath: Path) -> list[str] | None:
+        """Read scenario names from a Spine database sqlite file.
+
+        Uses ``spinedb_api.DatabaseMapping`` to extract scenario names (or
+        alternative names as a fallback).  Returns ``None`` if the file is
+        not a valid Spine database or spinedb_api is not installed.
+        """
+        try:
+            from spinedb_api import DatabaseMapping
+        except ImportError:
+            logger.warning("spinedb_api is not installed -- cannot read sqlite scenarios")
+            return None
+
+        db_url = f"sqlite:///{filepath}"
+        try:
+            with DatabaseMapping(db_url) as db_map:
+                # Try scenarios first
+                try:
+                    items = db_map.get_scenario_items()
+                    scenarios = [x["name"] for x in items]
+                    if scenarios:
+                        return scenarios
+                except (AttributeError, Exception):
+                    pass
+
+                # Fallback to alternatives
+                try:
+                    items = db_map.get_alternative_items()
+                    alternatives = [x["name"] for x in items]
+                    if alternatives:
+                        return alternatives
+                except (AttributeError, Exception):
+                    pass
+
+                return []
+        except Exception:
+            logger.warning("Failed to read spine db: %s", filepath, exc_info=True)
+            return None
+
+    def _disk_source_counts(self) -> dict[int, int]:
+        """Map ``source_number -> number of executed-scenario folders`` on disk.
+
+        Scans ``output_parquet/`` and attributes each result folder to its
+        source number (via the ``_N`` suffix, honouring legacy bare-owner
+        records). A number present here is "in use" by results even if its
+        input file is gone — which is what keeps a ghost row alive and what
+        a new source must avoid colliding with.
+        """
+        from flextool.gui.scenario_key import resolve_source_number, LEGACY_SOURCE_NUMBER
+
+        parquet_dir = self.project_path / "output_parquet"
+        counts: dict[int, int] = {}
+        if not parquet_dir.is_dir():
+            return counts
+        owners = self.settings.bare_output_owners
+        for entry in parquet_dir.iterdir():
+            if not entry.is_dir() or entry.name.startswith("_"):
+                continue
+            n, _ = resolve_source_number(entry.name, owners)
+            if n != LEGACY_SOURCE_NUMBER:
+                counts[n] = counts.get(n, 0) + 1
+        return counts
+
+    def _rel_path_for(self, source: InputSourceInfo) -> str:
+        """Project-root-relative POSIX path recorded for a source's identity.
+
+        Internal files live under ``input_sources/``; external references
+        already store a project-root-relative path. Used as the primary
+        key for reclaiming a source's original number after its settings
+        entry was lost (see :meth:`refresh`).
+        """
+        if source.external_rel_path:
+            return source.external_rel_path
+        return f"input_sources/{source.name}"
+
+    def refresh(self) -> list[InputSourceInfo]:
+        """Re-scan directory, re-read scenarios, and assign persistent numbers.
+
+        Numbering is reconciled against two persistent records and the
+        result folders on disk:
+
+        * ``input_source_numbers`` (live name→number) gives a stable number
+          to a source that already has one.
+        * ``source_registry`` (number→identity) lets a source whose
+          settings entry was lost **reclaim its original number** by
+          matching on path (then name) — this is what stops a re-added or
+          settings-reset source from drifting onto a fresh number and
+          orphaning its own results.
+        * otherwise the source gets the lowest positive integer not used by
+          any live source or any executed-scenario result folder.
+
+        Numbers whose input file is gone but whose result folders survive
+        are emitted as **retired "ghost" rows**. The registry is garbage-
+        collected so an entry is dropped once its number has neither a live
+        file nor any results. Both records are persisted to settings.yaml.
+        Returns live sources followed by ghost rows.
+        """
+        from flextool.gui.data_models import SourceRecord
+
+        sources = self.scan_input_sources()
+        registry = dict(self.settings.source_registry)
+        disk_counts = self._disk_source_counts()
+        prior_numbers = dict(self.settings.input_source_numbers)
+
+        rel_paths = {id(s): self._rel_path_for(s) for s in sources}
+        assigned: dict[int, InputSourceInfo] = {}  # number -> source
+
+        # Pass A — keep the number a live source already holds (stability).
+        pending: list[InputSourceInfo] = []
+        for source in sources:
+            num = prior_numbers.get(source.name)
+            if num is not None and num not in assigned:
+                source.number = num
+                assigned[num] = source
+            else:
+                pending.append(source)
+
+        # Pass B — reclaim an original number from the registry by matching
+        # on path first, then name. Skips numbers already taken this pass.
+        def _reclaim(source: InputSourceInfo) -> int | None:
+            path = rel_paths[id(source)]
+            by_path = sorted(
+                int(k) for k, rec in registry.items()
+                if rec.path and rec.path == path and int(k) not in assigned
+            )
+            if by_path:
+                return by_path[0]
+            by_name = sorted(
+                int(k) for k, rec in registry.items()
+                if rec.name == source.name and int(k) not in assigned
+            )
+            if by_name:
+                return by_name[0]
+            return None
+
+        still_pending: list[InputSourceInfo] = []
+        for source in pending:
+            num = _reclaim(source)
+            if num is not None:
+                source.number = num
+                assigned[num] = source
+            else:
+                still_pending.append(source)
+
+        # Pass C — allocate the lowest free number, avoiding live sources
+        # and any result folders on disk (orphaned results of other files).
+        reserved = set(assigned) | set(disk_counts)
+
+        def _next_free() -> int:
+            n = 1
+            while n in reserved:
+                n += 1
+            return n
+
+        for source in still_pending:
+            source.number = _next_free()
+            assigned[source.number] = source
+            reserved.add(source.number)
+
+        # Read scenarios for each live source and determine status.
+        for source in sources:
+            filepath = self.resolve_path(source)
+            if not filepath.exists():
+                source.status = "error"
+                continue
+
+            # Check for lock file (editing indicator)
+            if self._check_lock(filepath):
+                source.status = "editing"
+                continue
+
+            scenarios = self._read_scenarios(source, filepath)
+            if scenarios is None:
+                source.status = "error"
+            elif len(scenarios) == 0:
+                source.status = "empty"
+            else:
+                source.status = "ok"
+                source.scenarios = scenarios
+
+        # Rebuild the live name→number index from scratch so deleted files
+        # drop out automatically, and refresh each live source's registry
+        # record with its current name + path.
+        numbers = {s.name: s.number for s in sources}
+        for source in sources:
+            registry[str(source.number)] = SourceRecord(
+                name=source.name, path=rel_paths[id(source)]
+            )
+
+        # Emit ghost rows for numbers whose results survive but whose input
+        # file is gone, and ensure each such number has a (possibly empty)
+        # registry record so it is documented in settings.yaml.
+        ghosts: list[InputSourceInfo] = []
+        for number in sorted(disk_counts):
+            if number in assigned:
+                continue  # a live source owns this number
+            rec = registry.get(str(number))
+            if rec is None:
+                rec = SourceRecord()  # legacy orphan: file identity unknown
+                registry[str(number)] = rec
+            ext = Path(rec.name).suffix.lstrip(".").lower() if rec.name else ""
+            ghosts.append(
+                InputSourceInfo(
+                    name=rec.name or f"(source {number})",
+                    file_type=ext,
+                    number=number,
+                    status="retired",
+                    external_rel_path=None,
+                    retired=True,
+                    result_count=disk_counts[number],
+                )
+            )
+
+        # Garbage-collect registry entries no longer backed by a live file
+        # or any result folders — so empty ghosts never accumulate.
+        keep = set(assigned) | set(disk_counts)
+        registry = {k: v for k, v in registry.items() if int(k) in keep}
+
+        # Persist reconciled records.
+        self.settings.input_source_numbers = numbers
+        self.settings.source_registry = registry
+        save_project_settings(self.project_path, self.settings)
+
+        self._sources = sources
+        self._last_ghosts = ghosts
+        return sources + ghosts
+
+    def result_folders_for_number(self, number: int) -> list[tuple[Path, str]]:
+        """List ``(folder, scenario_name)`` result dirs owned by *number*.
+
+        Honours legacy bare-owner records, so a bare folder owned by
+        *number* is included alongside suffixed folders.
+        """
+        from flextool.gui.scenario_key import resolve_source_number
+
+        parquet = self.project_path / "output_parquet"
+        out: list[tuple[Path, str]] = []
+        if not parquet.is_dir():
+            return out
+        owners = self.settings.bare_output_owners
+        for entry in sorted(parquet.iterdir()):
+            if not entry.is_dir() or entry.name.startswith("_"):
+                continue
+            n, scen = resolve_source_number(entry.name, owners)
+            if n == number:
+                out.append((entry, scen))
+        return out
+
+    def _release_bare_owners_for_number(self, number: int) -> None:
+        """Drop any legacy bare-owner records pointing at *number*."""
+        owners = self.settings.bare_output_owners
+        for scen in [k for k, v in owners.items() if v == number]:
+            del owners[scen]
+
+    def delete_results(self, number: int) -> int:
+        """Delete every result folder attributed to *number*.
+
+        Releases any legacy bare-owner records for the number and persists
+        settings. Returns the count of folders removed. The caller should
+        refresh afterwards; the now-unbacked registry entry is GC'd then.
+        """
+        folders = self.result_folders_for_number(number)
+        for folder, _scen in folders:
+            shutil.rmtree(folder, ignore_errors=True)
+        self._release_bare_owners_for_number(number)
+        save_project_settings(self.project_path, self.settings)
+        return len(folders)
+
+    def relink_results(
+        self, old_number: int, new_number: int
+    ) -> tuple[int, list[str]]:
+        """Re-attribute *old_number*'s result folders to *new_number*.
+
+        Renames each folder to the self-describing ``<scenario>_<new>``
+        form. Returns ``(moved_count, conflicts)`` where *conflicts* lists
+        scenarios skipped because a folder already existed under the target
+        number (or could not be moved). Releases legacy bare-owner records
+        for the old number and persists settings.
+        """
+        from flextool.gui.scenario_key import format_subdir
+
+        parquet = self.project_path / "output_parquet"
+        moved = 0
+        conflicts: list[str] = []
+        for folder, scen in self.result_folders_for_number(old_number):
+            target = parquet / format_subdir(new_number, scen)
+            if target.exists():
+                conflicts.append(scen)
+                continue
+            try:
+                folder.rename(target)
+                moved += 1
+            except OSError as exc:
+                conflicts.append(f"{scen} ({exc})")
+        self._release_bare_owners_for_number(old_number)
+        save_project_settings(self.project_path, self.settings)
+        return moved, conflicts
+
+    def get_all_scenarios(
+        self, selected_sources: list[str] | None = None
+    ) -> list[ScenarioInfo]:
+        """Get all scenarios, optionally filtered by source names.
+
+        If *selected_sources* is ``None`` or empty, returns scenarios from
+        all sources.
+        """
+        result: list[ScenarioInfo] = []
+        for source in self._sources:
+            if selected_sources and source.name not in selected_sources:
+                continue
+            if source.status != "ok":
+                continue
+            for scenario_name in source.scenarios:
+                result.append(
+                    ScenarioInfo(
+                        name=scenario_name,
+                        source_number=source.number,
+                        source_name=source.name,
+                    )
+                )
+        return result
+
+    def plan_db_migrations(
+        self,
+    ) -> tuple[
+        list[tuple[str, Path]],
+        list[tuple[str, Path, int, int]],
+        list[str],
+    ]:
+        """Probe sqlite input sources for needed FlexTool DB migrations.
+
+        Returns ``(internal_to_migrate, external_to_migrate, planning_messages)``.
+        Internal entries are ``(source_name, abs_path)``; external entries
+        include current and target version numbers for the consent dialog.
+        """
+        from flextool.gui.db_version_check import (
+            _read_flextool_version,
+            get_target_flextool_version,
+            needs_flextool_migration,
+        )
+
+        internal_to_migrate: list[tuple[str, Path]] = []
+        external_to_migrate: list[tuple[str, Path, int, int]] = []
+        planning_messages: list[str] = []
+
+        target_version = get_target_flextool_version()
+
+        if self.input_dir.is_dir():
+            for filepath in sorted(self.input_dir.iterdir()):
+                if filepath.suffix.lower() != ".sqlite" or not filepath.is_file():
+                    continue
+                needs = needs_flextool_migration(filepath)
+                if needs is True:
+                    internal_to_migrate.append((filepath.name, filepath))
+                elif needs is None:
+                    planning_messages.append(
+                        f"{filepath.name}: could not read FlexTool version; "
+                        f"migration will attempt to surface the error."
+                    )
+                    internal_to_migrate.append((filepath.name, filepath))
+
+        for ext_name, rel_path in self.settings.external_refs.items():
+            if Path(ext_name).suffix.lower() != ".sqlite":
+                continue
+            abs_path = (self.project_path / rel_path).resolve()
+            if not abs_path.is_file():
+                continue
+            needs = needs_flextool_migration(abs_path)
+            if needs is True:
+                current_version = _read_flextool_version(f"sqlite:///{abs_path}")
+                if current_version is None:
+                    planning_messages.append(
+                        f"{ext_name}: external file's FlexTool version "
+                        f"became unreadable between checks; skipped."
+                    )
+                    continue
+                external_to_migrate.append(
+                    (ext_name, abs_path, current_version, target_version)
+                )
+            elif needs is None:
+                planning_messages.append(
+                    f"{ext_name}: could not read external file's FlexTool "
+                    f"version; skipped (open it in a tool that can read the "
+                    f"file to investigate)."
+                )
+
+        return internal_to_migrate, external_to_migrate, planning_messages
+
+    def copy_external_to_project(
+        self, source_name: str
+    ) -> tuple[Path, str | None]:
+        """Copy an external sqlite into ``input_sources/`` and drop the ref.
+
+        Returns ``(destination_path, error)``. ``error`` is ``None`` on
+        success. The caller is responsible for persisting ``self.settings``.
+        """
+        rel_path = self.settings.external_refs.get(source_name)
+        if rel_path is None:
+            return (Path(), f"External reference '{source_name}' not found.")
+
+        src = (self.project_path / rel_path).resolve()
+        dst = self.input_dir / source_name
+
+        if dst.exists():
+            return (
+                dst,
+                f"Cannot copy {source_name}: a file with that name "
+                f"already exists in input_sources.",
+            )
+
+        try:
+            shutil.copy2(src, dst)
+        except OSError as exc:
+            return (dst, f"Failed to copy {source_name}: {exc}")
+
+        del self.settings.external_refs[source_name]
+        return (dst, None)
+
+    # ── Private helpers ───────────────────────────────────────────────
+
+    def _read_scenarios(
+        self, source: InputSourceInfo, filepath: Path
+    ) -> list[str] | None:
+        """Dispatch scenario reading based on file type."""
+        ext = filepath.suffix.lower()
+        if ext in (".xlsx", ".ods"):
+            return self.read_scenarios_xlsx(filepath)
+        elif ext == ".sqlite":
+            return self.read_scenarios_sqlite(filepath)
+        return None
+
+    def mark_as_editing(self, source_name: str) -> None:
+        """Mark a source as being edited (store mtime for comparison).
+
+        Called when the Edit button opens a file, so that subsequent
+        refreshes can detect ongoing editing via mtime comparison
+        (Linux xlsx fallback).
+        """
+        rel = self.settings.external_refs.get(source_name)
+        if rel is not None:
+            filepath = (self.project_path / rel).resolve()
+        else:
+            filepath = self.input_dir / source_name
+        self._editing_sources.add(source_name)
+        try:
+            self._last_known_mtimes[source_name] = filepath.stat().st_mtime
+        except OSError:
+            pass
+
+    def _check_lock(self, filepath: Path) -> bool:
+        """Detect if the file is currently being edited.
+
+        For .xlsx / .ods files:
+        - Windows/macOS: check for ``~$filename`` lock file in same directory.
+        - Linux: check for ``.~lock.filename#`` (LibreOffice lock file).
+        - Linux fallback: if the file was opened via the Edit button,
+          compare ``st_mtime`` against the stored value. If mtime
+          changed, the file is still being edited.
+
+        For .sqlite files:
+        - Check for ``<filepath>-journal`` or ``<filepath>-wal`` files.
+
+        Returns ``True`` if the file appears to be in an editing state.
+        """
+        ext = filepath.suffix.lower()
+
+        if ext in (".xlsx", ".ods"):
+            parent = filepath.parent
+            name = filepath.name
+
+            # Windows / macOS Excel lock file: ~$<filename>
+            excel_lock = parent / f"~${name}"
+            if excel_lock.exists():
+                return True
+
+            # LibreOffice lock file (Linux): .~lock.<filename>#
+            libreoffice_lock = parent / f".~lock.{name}#"
+            if libreoffice_lock.exists():
+                return True
+
+            # Linux mtime-based fallback for files opened via Edit button
+            if (
+                sys.platform not in ("win32", "darwin")
+                and name in self._editing_sources
+            ):
+                try:
+                    current_mtime = filepath.stat().st_mtime
+                except OSError:
+                    return False
+                last_mtime = self._last_known_mtimes.get(name)
+                if last_mtime is not None and current_mtime != last_mtime:
+                    # mtime changed -- file was modified externally
+                    return True
+
+            return False
+
+        if ext == ".sqlite":
+            journal = filepath.parent / (filepath.name + "-journal")
+            wal = filepath.parent / (filepath.name + "-wal")
+            if journal.exists() or wal.exists():
+                return True
+            return False
+
+        return False