rapmat 0.2.2__tar.gz → 0.2.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rapmat
-Version: 0.2.2
+Version: 0.2.4
 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>
@@ -18,7 +18,6 @@ Requires-Dist: phonopy>=2.47.1
 Requires-Dist: platformdirs>=4.9.4
 Requires-Dist: pydantic>=2.12.5
 Requires-Dist: pymatgen>=2025.10.7
-Requires-Dist: pytest>=8.0.0
 Requires-Dist: pyxtal>=1.1.2
 Requires-Dist: seekpath>=2.2.1
 Requires-Dist: spglib>=2.7.0
@@ -32,6 +31,8 @@ Provides-Extra: all-calculators
 Requires-Dist: mattersim>=1.2.0; extra == 'all-calculators'
 Requires-Dist: nequip>=0.16.2; extra == 'all-calculators'
 Requires-Dist: upet>=0.2.1; extra == 'all-calculators'
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
 Provides-Extra: mattersim
 Requires-Dist: mattersim>=1.2.0; extra == 'mattersim'
 Provides-Extra: nequip

{rapmat-0.2.2 → rapmat-0.2.4}/pyproject.toml

@@ -21,7 +21,6 @@ dependencies = [
     "dscribe==2.1.2",
     "surrealdb>=2.0.0",
     "matplotlib>=3.8.0",
-    "pytest>=8.0.0",
     "platformdirs>=4.9.4",
     "filelock>=3.13.0",
     "tomli-w>=1.2.0",
@@ -39,6 +38,7 @@ mattersim = ["mattersim>=1.2.0"]
 nequip = ["nequip>=0.16.2"]
 upet = ["upet>=0.2.1"]
 all-calculators = ["mattersim>=1.2.0", "nequip>=0.16.2", "upet>=0.2.1"]
+dev = ["pytest>=8.0.0"]
 
 [build-system]
 requires = ["hatchling", "hatch-vcs"]

{rapmat-0.2.2 → rapmat-0.2.4}/rapmat/calculators/__init__.py

@@ -63,6 +63,15 @@ class CalculatorCallback(Protocol):
     def on_status(self, message: str) -> None: ...
 
 
+class ProgressCalcCallback:
+    def __init__(self, progress_callback) -> None:
+        self._progress_callback = progress_callback
+
+    def on_status(self, message: str) -> None:
+        if self._progress_callback:
+            self._progress_callback(0, 0, message)
+
+
 def _notify(callback: CalculatorCallback | None, message: str) -> None:
     if callback is not None:
         callback.on_status(message)

{rapmat-0.2.2 → rapmat-0.2.4}/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.4}/rapmat/core/csp.py

@@ -1,7 +1,8 @@
 import traceback
-from enum import Enum
 from pathlib import Path
 
+from rapmat.storage.status import StructureStatus
+from rapmat.utils.progress import ProgressCallback
 
 # ------------------------------------------------------------------ #
 #  Orchestration loops (used by TUI and tests)
@@ -18,34 +19,26 @@ def run_processing_loop(
     config: dict,
     workdir_path: Path,
     worker_id: str | None = None,
-    progress_callback=None,
+    progress_callback: ProgressCallback | None = None,
     cancel_flag: list[bool] | None = None,
 ):
     import numpy as np
-    import torch
     from ase.units import GPa as _GPa
 
-    from rapmat.calculators import CalculatorCallback, Calculators
+    from rapmat.calculators import Calculators, ProgressCalcCallback
     from rapmat.calculators.factory import load_calculator
     from rapmat.core.relaxation import structure_relax
     from rapmat.core.sanity import check_sanity
+    from rapmat.utils.common import free_cuda_memory
     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
 
-    class _ProgressCalcCallback:
-
-        def on_status(self, message: str) -> None:
-            if progress_callback:
-                progress_callback(0, 0, message)
-
-    _calc_cb = _ProgressCalcCallback()
+    _calc_cb = ProgressCalcCallback(progress_callback)
 
     calculator_name = config.get("calculator", "MATTERSIM").upper()
     calculator_config = config.get("calculator_config", {})
     domain_val = config.get("domain", "bulk")
-    search_dim = 3 if domain_val == "bulk" else 2
     symprec = config.get("symprec", 1e-5)
     pressure_gpa = config.get("pressure_gpa", 0.0)
     pressure_evA3 = pressure_gpa * _GPa
@@ -64,11 +57,7 @@ def run_processing_loop(
 
     relaxed_structures = []
 
-    try:
-        if torch.cuda.is_available():
-            torch.cuda.empty_cache()
-    except Exception:
-        pass
+    free_cuda_memory()
 
     _calc_cb.on_status(f"Loading calculator {calculator_name}...")
     calculator = load_calculator(
@@ -80,9 +69,6 @@ def run_processing_loop(
 
     counter: int = 0
     discarded_sanity = 0
-    discarded_unstable = 0
-    discarded_dup = 0
-    discarded_candidate_dup = 0
     n_candidates = len(candidates)
 
     def _report(msg: str) -> None:
@@ -91,7 +77,6 @@ def run_processing_loop(
 
     def _run_loop():
         nonlocal counter, discarded_sanity
-        nonlocal discarded_unstable, discarded_dup, discarded_candidate_dup
         nonlocal calculator
 
         for candidate in candidates:
@@ -121,7 +106,9 @@ def run_processing_loop(
                     def _optim_cb(step: int, max_steps: int, msg: str) -> None:
                         if progress_callback:
                             msg_fmt = f"Relaxing {struct_id}: {msg}"
-                            progress_callback(counter, n_candidates, msg_fmt, False)
+                            progress_callback(
+                                counter, n_candidates, msg_fmt, is_log=False
+                            )
 
                     converged, relaxed_structure = structure_relax(
                         structure,
@@ -161,17 +148,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...")
@@ -185,22 +166,16 @@ def run_processing_loop(
                         _report(f"Discarded {struct_id}: failed sanity check")
                         store.update_structure(
                             struct_id,
-                            status="discarded",
+                            status=StructureStatus.DISCARDED,
                             atoms=relaxed_structure,
                             metadata=meta,
                         )
                         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,
-                        status="relaxed",
+                        status=StructureStatus.RELAXED,
                         atoms=relaxed_structure,
                         metadata=meta,
                     )
@@ -216,15 +191,16 @@ def run_processing_loop(
                             "Failed to relax structure %s: %s",
                             struct_id, ex, exc_info=True,
                         )
-                        store.update_structure(struct_id, status="error")
+                        store.update_structure(
+                            struct_id, status=StructureStatus.ERROR
+                        )
                         break
 
                     try:
                         del calculator
-                        if torch.cuda.is_available():
-                            torch.cuda.empty_cache()
                     except Exception:
                         pass
+                    free_cuda_memory()
 
                     _report(
                         f"Reloading calculator {calculator_name} after error (attempt {attempt + 1})..."
@@ -243,7 +219,9 @@ def run_processing_loop(
                         )
                         _report(f"CRITICAL ERROR: Reload failed: {reload_ex}")
                         _report(f"Reload traceback:\n{traceback.format_exc()}")
-                        store.update_structure(struct_id, status="error")
+                        store.update_structure(
+                            struct_id, status=StructureStatus.ERROR
+                        )
                         break
 
             if progress_callback:
@@ -254,18 +232,10 @@ def run_processing_loop(
     _run_loop()
 
     n_relaxed = len(relaxed_structures)
-    discarded_parts = [
-        f"{discarded_candidate_dup} cand-dup",
-        f"{discarded_sanity} sanity",
-        f"{discarded_unstable} unstable",
-        f"{discarded_dup} dup",
-    ]
-    discarded_str = ", ".join(discarded_parts)
-
     pressure_msg = f" | Pressure: {pressure_gpa} GPa" if pressure_gpa > 0 else ""
     logger.info(
-        "Done. Run: %s | Storage: %s%s | Relaxed: %d | Discarded: %s",
-        run_name, store._db_url, pressure_msg, n_relaxed, discarded_str,
+        "Done. Run: %s | Storage: %s%s | Relaxed: %d | Discarded (sanity): %d",
+        run_name, store.get_url(), pressure_msg, n_relaxed, discarded_sanity,
     )
 
     return None
@@ -277,7 +247,7 @@ def run_generation_loop(
     config: dict,
     worker_id: str | None = None,
     workers: int = 1,
-    progress_callback=None,
+    progress_callback: ProgressCallback | None = None,
     cancel_flag: list[bool] | None = None,
     log_callback=None,
 ) -> int:
@@ -327,13 +297,13 @@ def run_generation_loop(
     def _handle_result(status, struct_id, atoms, spg, fu):
         nonlocal generated, discarded, errors
         match status:
-            case "generated":
+            case StructureStatus.GENERATED:
                 store.update_generated_structure(struct_id, atoms)
                 generated += 1
-            case "discarded":
+            case StructureStatus.DISCARDED:
                 store.discard_generation_placeholder(struct_id)
                 discarded += 1
-            case "error":
+            case StructureStatus.ERROR:
                 logger.error(
                     "Structure for group %s / fu %s failed", spg, fu,
                 )

{rapmat-0.2.2 → rapmat-0.2.4}/rapmat/core/dedup.py

@@ -1,9 +1,7 @@
 import warnings
-from typing import Optional
 
 import numpy as np
 from ase import Atoms
-from pymatgen.analysis.structure_matcher import StructureMatcher
 from pymatgen.io.ase import AseAtomsAdaptor
 
 

{rapmat-0.2.2 → rapmat-0.2.4}/rapmat/core/dedup_analysis.py

@@ -11,6 +11,8 @@ except ImportError:
     StructureMatcher = None  # type: ignore[assignment,misc]
 
 from rapmat.core.dedup import _to_pymatgen, forces_cosine_similarity
+from rapmat.utils.console import get_logger
+from rapmat.utils.progress import ProgressCallback
 
 
 @dataclass
@@ -47,7 +49,7 @@ def simulate_deduplication(
     angle_tol: float = 5.0,
     use_forces: bool = False,
     force_cosine_threshold: float = 0.95,
-    progress_callback=None,
+    progress_callback: ProgressCallback | None = None,
 ) -> DedupSimulationResult:
     result = DedupSimulationResult(total=len(structures))
 
@@ -72,7 +74,7 @@ def simulate_deduplication(
 
     for i in range(N):
         if progress_callback:
-            progress_callback(i, N, False)
+            progress_callback(i, N, f"Dedup: {i}/{N}", is_log=False)
 
         if i in dropped:
             continue
@@ -98,7 +100,12 @@ def simulate_deduplication(
                         result.rescued_by_pymatgen += 1
                         result.dropped_by_vector -= 1
                         confirmed = False
-                except Exception:
+                except Exception as exc:
+                    get_logger("rapmat.dedup").warning(
+                        "pymatgen comparison failed for pair (%s, %s), "
+                        "treating as non-duplicate: %s",
+                        with_vec[i]["id"], with_vec[j]["id"], exc,
+                    )
                     result.pymatgen_mismatches += 1
                     result.rescued_by_pymatgen += 1
                     result.dropped_by_vector -= 1
@@ -124,7 +131,7 @@ def simulate_deduplication(
                 dropped.add(j)
 
     if progress_callback:
-        progress_callback(N, N, False)
+        progress_callback(N, N, f"Dedup: {N}/{N}", is_log=False)
 
     result.final_dropped = len(dropped)
     result.kept = N - len(dropped)

{rapmat-0.2.2 → rapmat-0.2.4}/rapmat/core/evaluation.py

@@ -1,6 +1,6 @@
 from typing import Sequence
 
-from rapmat.utils.structure import standardize_atoms
+from rapmat.utils.progress import ProgressCallback
 
 # ------------------------------------------------------------------ #
 #  Evaluation loop (used by TUI and tests)
@@ -19,14 +19,13 @@ def run_eval_loop(
     phonon_displacement: float = 1e-2,
     phonon_supercell: tuple = (3, 3, 3),
     phonon_mesh: tuple = (20, 20, 20),
-    progress_callback=None,
+    progress_callback: ProgressCallback | None = None,
     log_callback=None,
     reduce_to_primitive: bool = True,
     symprec: float = 1e-3,
 ) -> None:
     from rapmat.calculators import cleanup_calculator_files
-    from rapmat.core.phonon import (get_mesh_min_frequency,
-                                    structure_calculate_phonons)
+    from rapmat.core.phonon import calculate_min_phonon_freq
     from rapmat.utils.console import get_logger
     logger = get_logger("rapmat.evaluation")
 
@@ -45,26 +44,18 @@ def run_eval_loop(
 
             ref_phonon_freq = None
             if run_phonons:
-                if reduce_to_primitive:
-                    atoms_len_before = len(atoms)
-                    atoms = standardize_atoms(atoms, to_primitive=True, symprec=symprec)
-                    atoms_len_after = len(atoms)
-
-                    atoms.calc = calculator
-
-                    if log_callback:
-                        log_callback(
-                            f"Reducing {rec['id']}: {atoms_len_before} -> {atoms_len_after} atoms"
-                        )
-
-                phonons = structure_calculate_phonons(
+                ref_phonon_freq = calculate_min_phonon_freq(
                     atoms,
+                    calculator=calculator,
                     displacement=phonon_displacement,
                     supercell=phonon_supercell,
                     qpoint_mesh=phonon_mesh,
+                    reduce_primitive=reduce_to_primitive,
+                    symprec=symprec,
                     progress_callback=progress_callback,
+                    log_label=rec["id"],
+                    log_callback=log_callback,
                 )
-                ref_phonon_freq = get_mesh_min_frequency(phonons)
 
             store.add_evaluation(
                 structure_id=rec["id"],

{rapmat-0.2.2 → rapmat-0.2.4}/rapmat/core/generation_worker.py

@@ -1,3 +1,5 @@
+from rapmat.storage.status import StructureStatus
+
 
 def generate_one_structure(
     struct_id: str,
@@ -27,9 +29,9 @@ def generate_one_structure(
         if crystal.valid:
             atoms = crystal.to_ase()
 
-            return ("generated", struct_id, atoms)
-        return ("discarded", struct_id, None)
+            return (StructureStatus.GENERATED, struct_id, atoms)
+        return (StructureStatus.DISCARDED, struct_id, None)
     except pyxtal.msg.Comp_CompatibilityError:
-        return ("discarded", struct_id, None)
+        return (StructureStatus.DISCARDED, struct_id, None)
     except RuntimeError:
-        return ("error", struct_id, None)
+        return (StructureStatus.ERROR, struct_id, None)

{rapmat-0.2.2 → rapmat-0.2.4}/rapmat/core/phonon.py

@@ -70,6 +70,38 @@ def structure_calculate_phonons(
     return phonons
 
 
+def calculate_min_phonon_freq(
+    atoms: Atoms,
+    *,
+    calculator,
+    displacement: float,
+    supercell: Tuple[int, int, int],
+    qpoint_mesh: Tuple[int, int, int],
+    reduce_primitive: bool = True,
+    symprec: float = 1e-3,
+    progress_callback=None,
+    log_label: str | None = None,
+    log_callback=None,
+) -> float:
+    if reduce_primitive:
+        from rapmat.utils.structure import standardize_atoms
+
+        n_before = len(atoms)
+        atoms = standardize_atoms(atoms, to_primitive=True, symprec=symprec)
+        if log_callback and log_label:
+            log_callback(f"Reducing {log_label}: {n_before} -> {len(atoms)} atoms")
+
+    atoms.calc = calculator
+    phonons = structure_calculate_phonons(
+        atoms,
+        displacement=displacement,
+        supercell=supercell,
+        qpoint_mesh=qpoint_mesh,
+        progress_callback=progress_callback,
+    )
+    return get_mesh_min_frequency(phonons)
+
+
 def get_mesh_min_frequency(phonons: Phonopy) -> float:
     return float(np.min(phonons.get_mesh_dict()["frequencies"]))
 

{rapmat-0.2.2 → rapmat-0.2.4}/rapmat/core/phonon_stability.py

@@ -1,15 +1,14 @@
-from typing import Callable, List, Optional, Tuple
+from typing import List, Optional, Tuple
 
 from ase import Atoms
 
-from rapmat.calculators import CalculatorCallback, Calculators
+from rapmat.calculators import Calculators, ProgressCalcCallback
 from rapmat.calculators.factory import load_calculator
-from rapmat.core.phonon import (get_mesh_min_frequency,
-                                structure_calculate_phonons,
-                                structure_has_imag_phonon_freq)
+from rapmat.core.phonon import calculate_min_phonon_freq
 from rapmat.storage.base import StructureStore
 from rapmat.utils.common import workdir_context
 from rapmat.utils.console import get_logger
+from rapmat.utils.progress import ProgressCallback
 
 _logger = get_logger("rapmat.phonon_stability")
 
@@ -25,7 +24,7 @@ def compute_dynamical_stability_for_results(
     phonon_calculator: Calculators,
     store: Optional["StructureStore"] = None,
     calculator_config: dict | None = None,
-    progress_callback: Callable[[int, int, str], None] | None = None,
+    progress_callback: ProgressCallback | None = None,
     symprec: float = 1e-3,
     reduce_primitive: bool = True,
 ) -> bool:
@@ -44,17 +43,12 @@ def compute_dynamical_stability_for_results(
     if not target_results:
         return False
 
-    class _ProgressCalcCallback:
-        def on_status(self, message: str) -> None:
-            if progress_callback:
-                progress_callback(0, 0, message)
-
     with workdir_context(None) as wdir:
         calculator = load_calculator(
             phonon_calculator,
             wdir,
             config=calculator_config,
-            callback=_ProgressCalcCallback(),
+            callback=ProgressCalcCallback(progress_callback),
         )
         updated = False
         total = len(target_results)
@@ -73,25 +67,20 @@ def compute_dynamical_stability_for_results(
                 return
 
             atoms = structures[structure_index]
-            if reduce_primitive:
-                from rapmat.utils.structure import standardize_atoms
-
-                atoms = standardize_atoms(atoms, to_primitive=True, symprec=symprec)
-            atoms.calc = calculator
 
             try:
-                phonons = structure_calculate_phonons(
+                min_freq = calculate_min_phonon_freq(
                     atoms,
+                    calculator=calculator,
                     displacement=phonon_displacement,
                     supercell=phonon_supercell,
                     qpoint_mesh=phonon_mesh,
+                    reduce_primitive=reduce_primitive,
+                    symprec=symprec,
                     progress_callback=progress_callback,
                 )
-                min_freq = get_mesh_min_frequency(phonons)
                 result["min_phonon_freq"] = min_freq
-                result["dynamical_stability"] = not structure_has_imag_phonon_freq(
-                    phonons, threshold=phonon_cutoff
-                )
+                result["dynamical_stability"] = not (min_freq < phonon_cutoff)
                 if store is not None and result.get("structure_id"):
                     store.update_structure_phonon(result["structure_id"], min_freq)
                 updated = True

{rapmat-0.2.2 → rapmat-0.2.4}/rapmat/core/relaxation.py

@@ -3,9 +3,12 @@ from typing import Optional, Tuple, Type
 
 import numpy as np
 from ase import Atoms
-from ase.filters import Filter, FrechetCellFilter
+from ase.filters import FrechetCellFilter
 from ase.optimize import BFGS
 
+from rapmat.utils.common import free_cuda_memory
+from rapmat.utils.progress import ProgressCallback
+
 
 def _max_force(atoms) -> float:
     return float(np.max(np.linalg.norm(atoms.get_forces(), axis=1)))
@@ -23,10 +26,8 @@ def structure_relax(
     suppress_warnings: bool = True,
     scalar_pressure: float = 0.0,
     cancel_flag: list[bool] | None = None,
-    progress_callback=None,
+    progress_callback: ProgressCallback | None = None,
 ) -> Tuple[bool, Atoms]:
-    import torch
-
     if atoms.calc is None:
         raise RuntimeError("No calculator set for the structure.")
 
@@ -67,7 +68,7 @@ def structure_relax(
 
     converged = not force_broken and _max_force(atoms_cf) <= force_conv_crit
 
-    if cleanup_gpu and torch.cuda.is_available():
-        torch.cuda.empty_cache()
+    if cleanup_gpu:
+        free_cuda_memory()
 
     return converged, atoms_cf.atoms

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

@@ -1,29 +1,9 @@
-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
 
-# ------------------------------------------------------------------ #
-#  Descriptor ABC
-# ------------------------------------------------------------------ #
-
-
-class StructureDescriptor(ABC):
-    @abstractmethod
-    def dimension(self) -> int: ...
-
-    @abstractmethod
-    def compute(self, atoms: Atoms) -> np.ndarray: ...
-
-    @abstractmethod
-    def code_version(self) -> str: ...
-
-    @abstractmethod
-    def descriptor_id(self) -> str: ...
-
+from rapmat.storage.status import StructureStatus
 
 # ------------------------------------------------------------------ #
 #  Store ABC
@@ -31,13 +11,6 @@ class StructureDescriptor(ABC):
 
 
 class StructureStore(ABC):
-    @abstractmethod
-    def register_descriptor(
-        self,
-        desc: StructureDescriptor,
-    ) -> str:
-        ...
-
     @abstractmethod
     def create_run(
         self,
@@ -66,7 +39,7 @@ class StructureStore(ABC):
     def claim_run(self, run_name: str, worker_id: str) -> bool: ...
 
     @abstractmethod
-    def release_run(self, run_name: str, final_status: str = "completed") -> None: ...
+    def release_run(self, run_name: str, final_status: str) -> None: ...
 
     @abstractmethod
     def update_heartbeat(self, run_name: str, worker_id: str) -> None: ...
@@ -83,7 +56,6 @@ class StructureStore(ABC):
         struct_id: str,
         status: str,
         atoms: Optional[Atoms] = None,
-        vector: Optional[np.ndarray] = None,
         metadata: Optional[dict] = None,
     ) -> None: ...
 
@@ -108,13 +80,14 @@ 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
     def get_structures_for_analysis(
         self,
         run_id: str,
-        statuses: tuple = ("relaxed",),
+        statuses: tuple = (StructureStatus.RELAXED,),
     ) -> List[dict]: ...
 
     @abstractmethod
@@ -193,7 +166,6 @@ class StructureStore(ABC):
         self,
         struct_id: str,
         atoms: Atoms,
-        vector: Optional[np.ndarray] = None,
     ) -> None: ...
 
     @abstractmethod
@@ -201,7 +173,3 @@ class StructureStore(ABC):
 
     @abstractmethod
     def get_url(self) -> Optional[str]: ...
-
-    @classmethod
-    def from_path(cls, db_path: Path, **kwargs) -> "StructureStore":
-        raise NotImplementedError