rapmat 0.2.2__tar.gz → 0.2.3__tar.gz

{rapmat-0.2.2 → rapmat-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rapmat
-Version: 0.2.2
+Version: 0.2.3
 Summary: Rapmat - rapid materials discovery using MLIPs and random search
 Project-URL: Homepage, https://github.com/milevevvvv/rapmat
 Author-email: Michael Levenets <milevev256@gmail.com>

{rapmat-0.2.2 → rapmat-0.2.3}/rapmat/calculators/vasp.py

@@ -5,7 +5,8 @@ from ase.calculators.vasp import Vasp
 
 def build_calculator_vasp(config: dict, directory: Path | None = None) -> Vasp:
     kwargs = dict(config)
-    if directory is not None:
+
+    if directory is not None and "directory" not in kwargs:
         kwargs["directory"] = str(directory)
 
     if "txt" not in kwargs:

{rapmat-0.2.2 → rapmat-0.2.3}/rapmat/core/csp.py

@@ -31,8 +31,7 @@ def run_processing_loop(
     from rapmat.core.sanity import check_sanity
     from rapmat.utils.console import get_logger
     logger = get_logger("rapmat.csp")
-    from rapmat.utils.structure import (calculate_thickness, format_spg,
-                                        standardize_atoms)
+    from rapmat.utils.structure import format_spg, standardize_atoms
 
     class _ProgressCalcCallback:
 
@@ -161,17 +160,11 @@ def run_processing_loop(
 
                     _report("Metadata preparation...")
                     energy = relaxed_structure.info["energy"]
-                    volume = relaxed_structure.get_volume()
-                    enthalpy = energy + pressure_evA3 * volume
 
                     meta = {
                         "energy_per_atom": energy / len(relaxed_structure),
-                        "energy_total": energy,
-                        "enthalpy_per_atom": enthalpy / len(relaxed_structure),
-                        "volume": volume,
                         "fmax": relaxed_structure.info["fmax"],
                         "converged": relaxed_structure.info["converged"],
-                        "thickness": 0.0,
                     }
 
                     _report("Checking sanity...")
@@ -191,12 +184,6 @@ def run_processing_loop(
                         )
                         break
 
-                    if search_dim == 2:
-                        _report("Calculating thickness...")
-                        current_thickness = calculate_thickness(relaxed_structure)
-                        relaxed_structure.info["thickness"] = current_thickness
-                        meta["thickness"] = current_thickness
-
                     _report("Saving to database...")
                     store.update_structure(
                         struct_id,

{rapmat-0.2.2 → rapmat-0.2.3}/rapmat/storage/base.py

@@ -1,7 +1,7 @@
 from pymatgen.util import string
 from abc import ABC, abstractmethod
 from pathlib import Path
-from typing import List, Optional, Tuple
+from typing import Callable, List, Optional, Tuple
 
 import numpy as np
 from ase import Atoms
@@ -108,6 +108,7 @@ class StructureStore(ABC):
         status: Optional[str] = None,
         statuses: Optional[tuple[str, ...]] = None,
         symprec: float = 1e-3,
+        progress_callback: Optional[Callable[..., None]] = None,
     ) -> List[dict]: ...
 
     @abstractmethod

{rapmat-0.2.2 → rapmat-0.2.3}/rapmat/storage/surrealdb_store.py

@@ -2,17 +2,18 @@ import json
 import threading
 from datetime import datetime
 from pathlib import Path
-from typing import List, Optional, Tuple
+from typing import Callable, List, Optional, Tuple
 
 import numpy as np
 from ase import Atoms
 from ase.io.jsonio import decode as ase_decode
 from ase.io.jsonio import encode as ase_encode
+from ase.units import GPa
 from filelock import FileLock, Timeout
 from surrealdb import RecordID, Surreal
 
 from rapmat.storage.base import StructureStore, StructureDescriptor
-from rapmat.utils.structure import format_spg
+from rapmat.utils.structure import calculate_thickness, format_spg
 
 # ------------------------------------------------------------------ #
 #  Schema
@@ -46,19 +47,19 @@ DEFINE FIELD IF NOT EXISTS status           ON structure TYPE string
     ASSERT $value IN ["generating", "generated", "relaxed", "discarded", "error"];
 DEFINE FIELD IF NOT EXISTS gen_spg          ON structure TYPE option<int>;
 DEFINE FIELD IF NOT EXISTS gen_fu           ON structure TYPE option<int>;
-DEFINE FIELD IF NOT EXISTS formula          ON structure TYPE string;
 DEFINE FIELD IF NOT EXISTS energy_per_atom  ON structure TYPE float;
-DEFINE FIELD IF NOT EXISTS energy_total     ON structure TYPE float;
 DEFINE FIELD IF NOT EXISTS fmax             ON structure TYPE float;
 DEFINE FIELD IF NOT EXISTS converged        ON structure TYPE bool;
-DEFINE FIELD IF NOT EXISTS thickness        ON structure TYPE option<float>;
-DEFINE FIELD IF NOT EXISTS enthalpy_per_atom ON structure TYPE option<float>;
-DEFINE FIELD IF NOT EXISTS volume            ON structure TYPE option<float>;
 DEFINE FIELD IF NOT EXISTS min_phonon_freq   ON structure TYPE option<float>;
 DEFINE FIELD IF NOT EXISTS duplicate          ON structure TYPE option<bool>;
 DEFINE FIELD IF NOT EXISTS initial_atoms_json ON structure TYPE string;
 DEFINE FIELD IF NOT EXISTS final_atoms_json   ON structure TYPE string;
 DEFINE FIELD IF NOT EXISTS timestamp        ON structure TYPE string;
+REMOVE FIELD IF EXISTS formula ON TABLE structure;
+REMOVE FIELD IF EXISTS energy_total ON TABLE structure;
+REMOVE FIELD IF EXISTS volume ON TABLE structure;
+REMOVE FIELD IF EXISTS enthalpy_per_atom ON TABLE structure;
+REMOVE FIELD IF EXISTS thickness ON TABLE structure;
 DEFINE INDEX IF NOT EXISTS idx_struct_run        ON structure FIELDS run;
 DEFINE INDEX IF NOT EXISTS idx_struct_status     ON structure FIELDS status;
 DEFINE INDEX IF NOT EXISTS idx_struct_run_status ON structure FIELDS run, status;
@@ -500,14 +501,9 @@ class SurrealDBStore(StructureStore):
                     "status": "generating",
                     "gen_spg": spg,
                     "gen_fu": fu,
-                    "formula": "",
                     "energy_per_atom": 0.0,
-                    "energy_total": 0.0,
                     "fmax": 0.0,
                     "converged": False,
-                    "thickness": None,
-                    "enthalpy_per_atom": None,
-                    "volume": None,
                     "min_phonon_freq": None,
                     "initial_atoms_json": "",
                     "final_atoms_json": "",
@@ -543,7 +539,6 @@ class SurrealDBStore(StructureStore):
     ) -> None:
         updates: dict = {
             "status": "generated",
-            "formula": atoms.get_chemical_formula(),
             "initial_atoms_json": ase_encode(atoms),
             "timestamp": datetime.now().isoformat(),
         }
@@ -583,24 +578,13 @@ class SurrealDBStore(StructureStore):
 
         if atoms is not None:
             updates["final_atoms_json"] = ase_encode(atoms)
-            updates["formula"] = atoms.get_chemical_formula()
         if vector is not None:
             col = self._vec_col()
             updates[col] = vector.astype(np.float32).tolist()
 
         updates["energy_per_atom"] = float(meta.get("energy_per_atom", 0.0))
-        updates["energy_total"] = float(meta.get("energy_total", 0.0))
         updates["fmax"] = float(meta.get("fmax", 0.0))
         updates["converged"] = bool(meta.get("converged", False))
-        updates["thickness"] = (
-            float(meta.get("thickness", 0.0))
-            if meta.get("thickness") is not None
-            else None
-        )
-        if "enthalpy_per_atom" in meta:
-            updates["enthalpy_per_atom"] = float(meta["enthalpy_per_atom"])
-        if "volume" in meta:
-            updates["volume"] = float(meta["volume"])
 
         self._db.query(
             f"UPDATE {_record_id('structure', struct_id)} MERGE $data",
@@ -697,6 +681,7 @@ class SurrealDBStore(StructureStore):
         status: Optional[str] = None,
         statuses: Optional[tuple[str, ...]] = None,
         symprec: float = 1e-3,
+        progress_callback: Optional[Callable[..., None]] = None,
     ) -> List[dict]:
         effective = statuses or ((status,) if status else None)
 
@@ -714,28 +699,57 @@ class SurrealDBStore(StructureStore):
             self._db.query(f"SELECT * FROM structure WHERE {where}", params)
         )
 
+        try:
+            meta = self.get_run_metadata(run_name)
+            cfg = (meta or {}).get("config", {})
+        except Exception:
+            cfg = {}
+        pressure_gpa = float(cfg.get("pressure_gpa", 0.0))
+        domain = cfg.get("domain", "bulk")
+        pressure_evA3 = pressure_gpa * GPa
+
         results: List[dict] = []
-        for row in rows:
+        total = len(rows)
+        for i, row in enumerate(rows):
+            if progress_callback is not None:
+                progress_callback(i + 1, total, f"Processing structure {i + 1}/{total}…")
             initial_raw = row.get("initial_atoms_json", "")
             final_raw = row.get("final_atoms_json", "")
             initial_atoms = ase_decode(initial_raw) if initial_raw else None
             final_atoms = ase_decode(final_raw) if final_raw else None
 
+            atoms = final_atoms if final_atoms is not None else initial_atoms
+            energy_per_atom = row["energy_per_atom"]
+
+            n = len(atoms) if atoms is not None else 0
+            formula = atoms.get_chemical_formula() if atoms is not None else ""
+            volume = atoms.get_volume() if atoms is not None else None
+            energy_total = energy_per_atom * n if n else 0.0
+            if pressure_gpa > 0 and volume is not None and n:
+                enthalpy_per_atom = energy_per_atom + pressure_evA3 * volume / n
+            else:
+                enthalpy_per_atom = None
+            thickness = (
+                calculate_thickness(atoms)
+                if domain != "bulk" and atoms is not None
+                else None
+            )
+
             d: dict = {
                 "id": _extract_id(row["id"]),
-                "formula": row["formula"],
-                "energy_per_atom": row["energy_per_atom"],
-                "energy_total": row.get("energy_total", 0.0),
-                "enthalpy_per_atom": row.get("enthalpy_per_atom"),
-                "volume": row.get("volume"),
+                "formula": formula,
+                "energy_per_atom": energy_per_atom,
+                "energy_total": energy_total,
+                "enthalpy_per_atom": enthalpy_per_atom,
+                "volume": volume,
                 "fmax": row["fmax"],
                 "converged": row["converged"],
-                "thickness": row.get("thickness"),
+                "thickness": thickness,
                 "min_phonon_freq": row.get("min_phonon_freq"),
                 "duplicate": row.get("duplicate"),
                 "initial_atoms": initial_atoms,
                 "final_atoms": final_atoms,
-                "atoms": (final_atoms if final_atoms is not None else initial_atoms),
+                "atoms": atoms,
                 "status": row["status"],
                 "timestamp": row.get("timestamp", ""),
                 "gen_spg": row.get("gen_spg"),

{rapmat-0.2.2 → rapmat-0.2.3}/rapmat/tui/screens/base_results.py

@@ -12,6 +12,7 @@ from rapmat.tui.router import ScreenRouter
 from rapmat.tui.state import AppState
 from rapmat.tui.tasks import BackgroundTask
 from rapmat.tui.widgets.dropdown import DropdownSelect
+from rapmat.tui.widgets.progress import ProgressPanel
 from rapmat.tui.widgets.table import SortableTable
 
 
@@ -230,10 +231,74 @@ class BaseResultsScreen:
         self._phonon_task: "BackgroundTask | None" = None
         self._phonon_modal_body: urwid.Widget | None = None
 
+        self._outer_placeholder: urwid.WidgetPlaceholder | None = None
+        self._loading_task: "BackgroundTask | None" = None
+
     def build(self) -> urwid.Widget:
-        self._fetch_data()
-        self._main_frame = self._build_frame()
-        return self._main_frame
+        self._outer_placeholder = urwid.WidgetPlaceholder(urwid.SolidFill(" "))
+        self.update_footer_keys()
+        self._start_async_fetch()
+        return self._outer_placeholder
+
+    def _loading_title(self) -> str:
+        return f" Loading {self.title} "
+
+    def _start_async_fetch(self) -> None:
+        panel = ProgressPanel(title=self._loading_title())
+        panel.set_progress(0, 1, "Loading structures from database…")
+
+        loading_widget = urwid.Filler(urwid.BoxAdapter(panel, 10), valign="middle")
+        if self._outer_placeholder is not None:
+            self._outer_placeholder.original_widget = loading_widget
+
+        loop = self._state.loop
+
+        if loop is None:
+            self._fetch_data()
+            self._main_frame = self._build_frame()
+            if self._outer_placeholder is not None:
+                self._outer_placeholder.original_widget = self._main_frame
+            return
+
+        def _worker(progress) -> None:
+            def _cb(
+                current: int, total: int, message: str = "", is_log: bool = False
+            ) -> None:
+                if progress.cancelled:
+                    raise KeyboardInterrupt("Cancelled by user")
+                progress.update(current=current, total=total, message=message)
+                if is_log and message:
+                    progress.log(message)
+
+            self._fetch_data(progress_callback=_cb)
+
+        def _on_progress(current: int, total: int, message: str) -> None:
+            panel.set_progress(current, total, message)
+
+        def _on_log(line: str) -> None:
+            panel.add_log(line)
+
+        def _on_complete() -> None:
+            self._main_frame = self._build_frame()
+            if self._outer_placeholder is not None:
+                self._outer_placeholder.original_widget = self._main_frame
+
+            current = self._router.current
+            if current is not self and current is not None:
+                current.on_resume()
+
+        def _on_error(error: str) -> None:
+            panel.set_finished(False, f"Error: {error}")
+
+        self._loading_task = BackgroundTask(
+            fn=_worker,
+            loop=loop,
+            on_progress=_on_progress,
+            on_log=_on_log,
+            on_complete=_on_complete,
+            on_error=_on_error,
+        )
+        self._loading_task.start()
 
     def on_resume(self) -> None:
         self.update_footer_keys()
@@ -244,7 +309,7 @@ class BaseResultsScreen:
     def update_footer_keys(self, message: str = "") -> None:
         pass
 
-    def _fetch_data(self) -> None:
+    def _fetch_data(self, progress_callback=None) -> None:
         pass
 
     def _columns_def(self) -> list[tuple[str, int]]:
@@ -798,6 +863,8 @@ class BaseResultsScreen:
                 return None
             if self._phonon_task is not None:
                 self._phonon_task.cancel()
+            if self._loading_task is not None:
+                self._loading_task.cancel()
             self._router.pop()
             return None
         return key

{rapmat-0.2.2 → rapmat-0.2.3}/rapmat/tui/screens/hull.py

@@ -1,13 +1,9 @@
 from pathlib import Path
 
-import urwid
-
 from rapmat.tui.router import ScreenRouter
 from rapmat.tui.screens.base_results import BaseResultsScreen, _dyn_stability
 from rapmat.tui.state import AppState
-from rapmat.tui.tasks import BackgroundTask
 from rapmat.tui.widgets.dialog import ModalDialog
-from rapmat.tui.widgets.progress import ProgressPanel
 
 
 class PhaseAnalysisScreen(BaseResultsScreen):
@@ -21,8 +17,6 @@ class PhaseAnalysisScreen(BaseResultsScreen):
         self._use_enthalpy: bool = False
         self._show_all: bool = True
         self._hull_cutoff: float = 0.0
-        self._loading_task: BackgroundTask | None = None
-        self._outer_placeholder: urwid.WidgetPlaceholder | None = None
 
     def update_footer_keys(self, message: str = "") -> None:
         if not self._state.status_bar:
@@ -47,118 +41,9 @@ class PhaseAnalysisScreen(BaseResultsScreen):
             self._state.status_bar.clear_message()
 
     # ------------------------------------------------------------------ #
-    #  Async build: show loading panel, compute in background, then table
+    #  Data fetch
     # ------------------------------------------------------------------ #
 
-    def build(self) -> urwid.Widget:
-        self._outer_placeholder = urwid.WidgetPlaceholder(urwid.SolidFill(" "))
-        self.update_footer_keys()
-        self._start_async_fetch()
-        return self._outer_placeholder
-
-    def _start_async_fetch(self) -> None:
-        panel = ProgressPanel(title=" Phase Analysis ")
-        panel.set_progress(0, 1, "Computing phase analysis...")
-        panel.add_log("Loading structures from database...")
-
-        loading_widget = urwid.Filler(urwid.BoxAdapter(panel, 10), valign="middle")
-        if self._outer_placeholder is not None:
-            self._outer_placeholder.original_widget = loading_widget
-
-        loop = self._state.loop
-        if loop is None:
-            self._fetch_data()
-            self._main_frame = self._build_frame()
-            if self._outer_placeholder is not None:
-                self._outer_placeholder.original_widget = self._main_frame
-            return
-
-        _store = self._state.store
-        _active_study = self._state.active_study
-        _show_all = self._show_all
-        _hull_cutoff = self._hull_cutoff
-
-        _result_box: dict = {}
-
-        def _worker(progress) -> None:
-            progress.log("Resolving study...")
-            study_id = _active_study
-            if not study_id:
-                progress.fail("No active study selected.")
-                return
-            if isinstance(study_id, str) and ":" in study_id:
-                study_id = study_id.split(":")[-1]
-
-            study = _store.get_study(str(study_id))
-            if not study:
-                progress.fail(f"Study '{study_id}' not found.")
-                return
-
-            symprec = study.get("config", {}).get("symprec", 1e-3)
-            system = study.get("system", "")
-            from rapmat.utils.common import parse_system
-
-            elements = parse_system(system)
-            system_size = len(elements)
-
-            progress.log(
-                f"System: {system} ({system_size} element{'s' if system_size != 1 else ''})"
-            )
-
-            if system_size < 2:
-                from rapmat.core.hull import build_energy_ranking
-
-                progress.log("Building energy ranking...")
-                sd, use_enthalpy = build_energy_ranking(
-                    _store, str(study_id), show_all=_show_all, hull_cutoff=_hull_cutoff
-                )
-            else:
-                from rapmat.core.hull import build_phase_diagram
-
-                progress.log("Building phase diagram...")
-                _, sd, use_enthalpy = build_phase_diagram(
-                    _store,
-                    str(study_id),
-                    symprec=symprec,
-                    show_all=_show_all,
-                    hull_cutoff=_hull_cutoff,
-                )
-
-            progress.update(1, 1, f"Done - {len(sd)} structures")
-            progress.log(f"Computed {len(sd)} structures.")
-
-            _result_box["study_id"] = str(study_id)
-            _result_box["study"] = study
-            _result_box["system"] = system
-            _result_box["system_size"] = system_size
-            _result_box["sd"] = sd
-            _result_box["use_enthalpy"] = use_enthalpy
-
-        def _on_progress(current: int, total: int, message: str) -> None:
-            panel.set_progress(current, total, message)
-
-        def _on_log(line: str) -> None:
-            panel.add_log(line)
-
-        def _on_complete() -> None:
-            self._apply_fetch_result(_result_box)
-            self._main_frame = self._build_frame()
-            if self._outer_placeholder is not None:
-                self._outer_placeholder.original_widget = self._main_frame
-
-        def _on_error(error: str) -> None:
-            panel.set_finished(False, f"Error: {error}")
-
-        self._loading_task = BackgroundTask(
-            fn=_worker,
-            loop=loop,
-            on_progress=_on_progress,
-            on_log=_on_log,
-            on_complete=_on_complete,
-            on_error=_on_error,
-        )
-        self._loading_task.start()
-
     def _apply_fetch_result(self, box: dict) -> None:
         self._study_id = box.get("study_id", "")
         self._study_system = box.get("system", "")
@@ -202,7 +87,12 @@ class PhaseAnalysisScreen(BaseResultsScreen):
             r.get("duplicate") is not None for r in self._results
         )
 
-    def _fetch_data(self) -> None:
+    def _fetch_data(self, progress_callback=None) -> None:
+        def _log(msg: str) -> None:
+            if progress_callback is not None:
+                progress_callback(0, 1, msg, True)
+
+        _log("Resolving study…")
         study_id = self._state.active_study
         if not study_id:
             return
@@ -221,10 +111,15 @@ class PhaseAnalysisScreen(BaseResultsScreen):
 
         elements = parse_system(system)
         system_size = len(elements)
+        _log(
+            f"System: {system} "
+            f"({system_size} element{'s' if system_size != 1 else ''})"
+        )
 
         if system_size < 2:
             from rapmat.core.hull import build_energy_ranking
 
+            _log("Building energy ranking…")
             sd, use_enthalpy = build_energy_ranking(
                 store,
                 str(study_id),
@@ -234,6 +129,7 @@ class PhaseAnalysisScreen(BaseResultsScreen):
         else:
             from rapmat.core.hull import build_phase_diagram
 
+            _log("Building phase diagram…")
             _, sd, use_enthalpy = build_phase_diagram(
                 store,
                 str(study_id),
@@ -242,6 +138,9 @@ class PhaseAnalysisScreen(BaseResultsScreen):
                 hull_cutoff=self._hull_cutoff,
             )
 
+        if progress_callback is not None:
+            progress_callback(1, 1, f"Done - {len(sd)} structures")
+
         box.update(
             {
                 "study_id": str(study_id),

{rapmat-0.2.2 → rapmat-0.2.3}/rapmat/tui/screens/results.py

@@ -30,7 +30,7 @@ class ResultsScreen(BaseResultsScreen):
         else:
             self._state.status_bar.clear_message()
 
-    def _fetch_data(self) -> None:
+    def _fetch_data(self, progress_callback=None) -> None:
         run_name = self._state.active_run or ""
         self._run_name = run_name
 
@@ -41,7 +41,9 @@ class ResultsScreen(BaseResultsScreen):
         self._pressure_gpa = float(config.get("pressure_gpa", 0.0))
         self._phonon_cutoff = config.get("phonon_cutoff")
 
-        records = store.get_structures(run_name, status="relaxed")
+        records = store.get_structures(
+            run_name, status="relaxed", progress_callback=progress_callback
+        )
 
         if self._pressure_gpa > 0:
             records.sort(

{rapmat-0.2.2 → rapmat-0.2.3}/tests/conftest.py

@@ -52,6 +52,21 @@ def _ensure_descriptor(store: StructureStore) -> None:
     store.register_descriptor(_TEST_DESCRIPTOR)
 
 
+def add_generated_candidate(
+    store: StructureStore,
+    run_name: str,
+    struct_id: str,
+    atoms: Atoms,
+    vector: np.ndarray | None = None,
+    spg: int = 1,
+    fu: int = 1,
+) -> str:
+    """Insert a single 'generated' candidate via the placeholder pipeline."""
+    store.add_generation_placeholders(run_name, [(struct_id, spg, fu)])
+    store.update_generated_structure(struct_id, atoms, vector=vector)
+    return struct_id
+
+
 def add_relaxed_structure(
     store: StructureStore,
     run_name: str,
@@ -59,35 +74,29 @@ def add_relaxed_structure(
     energy_per_atom: float,
     struct_id: str,
     vector: np.ndarray | None = None,
-    enthalpy_per_atom: float | None = None,
 ) -> None:
-    """Add a structure and immediately mark it relaxed with the given energy."""
-    n_atoms = len(atoms)
-    energy_total = energy_per_atom * n_atoms
+    """Add a structure and immediately mark it relaxed with the given energy.
+
+    Derived quantities (formula, volume, energy_total, enthalpy, thickness)
+    are computed at read time by get_structures, so only the canonical
+    metadata is written here.
+    """
     if vector is None:
         vector = np.zeros(VECTOR_DIM, dtype=np.float32)
     _ensure_descriptor(store)
 
-    # Insert as "generated" candidate via add_structures
-    store.add_structures(run_name, [
-        {"id": struct_id, "atoms": atoms, "vector": vector, "status": "generated"},
-    ])
-
-    # Immediately update to relaxed
-    metadata = {
-        "energy_per_atom": energy_per_atom,
-        "energy_total": energy_total,
-        "fmax": 0.01,
-        "converged": True,
-    }
-    if enthalpy_per_atom is not None:
-        metadata["enthalpy_per_atom"] = enthalpy_per_atom
+    add_generated_candidate(store, run_name, struct_id, atoms, vector=vector)
+
     store.update_structure(
         struct_id,
         "relaxed",
         atoms=atoms,
         vector=vector,
-        metadata=metadata,
+        metadata={
+            "energy_per_atom": energy_per_atom,
+            "fmax": 0.01,
+            "converged": True,
+        },
     )
 
 

{rapmat-0.2.2 → rapmat-0.2.3}/tests/test_db_config_and_locking.py

@@ -16,35 +16,12 @@ from rapmat.storage import SurrealDBStore
 class TestDbConfig:
     def test_load_returns_none_when_no_file(self, tmp_path, monkeypatch):
         monkeypatch.setattr("rapmat.db_config._DB_CONFIG_FILE", tmp_path / "nope.toml")
-        monkeypatch.delenv("RAPMAT_DB_URL", raising=False)
-        monkeypatch.delenv("RAPMAT_DB_NS", raising=False)
-        monkeypatch.delenv("RAPMAT_DB_NAME", raising=False)
-        monkeypatch.delenv("RAPMAT_DB_USER", raising=False)
-        monkeypatch.delenv("RAPMAT_DB_PASSWORD", raising=False)
         assert load_db_config() is None
 
-    def test_env_vars_override(self, tmp_path, monkeypatch):
-        cfg_file = tmp_path / "db.toml"
-        cfg_file.write_text(
-            '[server]\nurl = "ws://old/rpc"\nnamespace = "ns"\n'
-            'database = "db"\nusername = "u"\npassword = "p"\n'
-        )
-        monkeypatch.setattr("rapmat.db_config._DB_CONFIG_FILE", cfg_file)
-        monkeypatch.setenv("RAPMAT_DB_URL", "ws://new/rpc")
-        full = load_db_config()
-        assert full is not None
-        assert full["server"]["url"] == "ws://new/rpc"
-        assert full["server"]["namespace"] == "ns"
-
     def test_save_and_load_roundtrip(self, tmp_path, monkeypatch):
         cfg_file = tmp_path / "db.toml"
         monkeypatch.setattr("rapmat.db_config._DB_CONFIG_FILE", cfg_file)
         monkeypatch.setattr("rapmat.db_config.APP_CONFIG_DIR", tmp_path)
-        monkeypatch.delenv("RAPMAT_DB_URL", raising=False)
-        monkeypatch.delenv("RAPMAT_DB_NS", raising=False)
-        monkeypatch.delenv("RAPMAT_DB_NAME", raising=False)
-        monkeypatch.delenv("RAPMAT_DB_USER", raising=False)
-        monkeypatch.delenv("RAPMAT_DB_PASSWORD", raising=False)
 
         save_db_config(
             general={"mode": "remote"},