Merge branch 'master' into hotfix/pmg-io-vasp-MPScanRelaxSet

Author: junchichen21

.gitignore

@@ -1,14 +1,13 @@
 __pycache__/
 .DS_Store
-pymatgen.egg-info
+*.egg-info
 *.o
 *.so
 *.pyc
 *.swp
 *.swo
 *.pyd
 *.c
-pymatgen/pymatgen.cfg
 dist
 _build
 _site
@@ -21,13 +20,12 @@ build
 setuptools*
 .ipynb_checkpoints
 .cache
-.tox
 .eggs/
 .coverage
 .*_cache
 # VS Code
 .vscode/*
-
+*.code-workspace
 # Environments
 .env
 .venv

src/pymatgen/analysis/phase_diagram.py

@@ -389,12 +389,17 @@ def __init__(
 
     def as_dict(self):
         """Get MSONable dict representation of PhaseDiagram."""
+
+        qhull_entry_indices = [self.all_entries.index(e) for e in self.qhull_entries]
+
         return {
             "@module": type(self).__module__,
             "@class": type(self).__name__,
-            "all_entries": [e.as_dict() for e in self.all_entries],
             "elements": [e.as_dict() for e in self.elements],
-            "computed_data": self.computed_data,
+            "computed_data": self.computed_data
+            | {
+                "qhull_entries": qhull_entry_indices,
+            },
         }
 
     @classmethod
@@ -406,9 +411,19 @@ def from_dict(cls, dct: dict[str, Any]) -> Self:
         Returns:
             PhaseDiagram
         """
-        entries = [MontyDecoder().process_decoded(entry) for entry in dct["all_entries"]]
-        elements = [Element.from_dict(elem) for elem in dct["elements"]]
         computed_data = dct.get("computed_data")
+        elements = [Element.from_dict(elem) for elem in dct["elements"]]
+
+        # for backwards compatibility, check for old format
+        if "all_entries" in dct:
+            entries = [MontyDecoder().process_decoded(entry) for entry in dct["all_entries"]]
+        else:
+            entries = [MontyDecoder().process_decoded(entry) for entry in computed_data["all_entries"]]
+
+            complete_qhull_entries = [computed_data["all_entries"][i] for i in computed_data["qhull_entries"]]
+
+            computed_data = computed_data | {"qhull_entries": complete_qhull_entries}
+
         return cls(entries, elements, computed_data=computed_data)
 
     def _compute(self) -> dict[str, Any]:
@@ -1609,7 +1624,7 @@ class PatchedPhaseDiagram(PhaseDiagram):
 
     def __init__(
         self,
-        entries: Sequence[PDEntry] | set[PDEntry],
+        entries: Sequence[Entry] | set[Entry],
         elements: Sequence[Element] | None = None,
         keep_all_spaces: bool = False,
         verbose: bool = False,

src/pymatgen/entries/compatibility.py

@@ -9,7 +9,7 @@
 import os
 import warnings
 from collections import defaultdict
-from typing import TYPE_CHECKING, TypeAlias, cast
+from typing import TYPE_CHECKING, TypeAlias, TypeVar, cast
 
 import numpy as np
 from joblib import Parallel, delayed
@@ -77,6 +77,7 @@
     raise RuntimeError("MP2020Compatibility.yaml expected to have the same Hubbard U corrections for O and F")
 
 AnyComputedEntry: TypeAlias = ComputedEntry | ComputedStructureEntry
+TypeVarAnyEntry = TypeVar("TypeVarAnyEntry", bound=AnyComputedEntry)
 
 
 class CompatibilityError(Exception):
@@ -577,10 +578,10 @@ def get_adjustments(self, entry: AnyComputedEntry) -> list[EnergyAdjustment]:
 
     def process_entry(
         self,
-        entry: ComputedEntry,
+        entry: TypeVarAnyEntry,
         inplace: bool = True,
         **kwargs,
-    ) -> ComputedEntry | None:
+    ) -> TypeVarAnyEntry | None:
         """Process a single entry with the chosen Corrections.
         Note that this method may change the original entry.
 
@@ -595,29 +596,29 @@ def process_entry(
         if not inplace:
             entry = copy.deepcopy(entry)
 
-        _entry: tuple[ComputedEntry, bool] | None = self._process_entry_inplace(entry, **kwargs)
+        _entry: tuple[TypeVarAnyEntry, bool] | None = self._process_entry_inplace(entry, **kwargs)
 
         return _entry[0] if _entry is not None else None
 
     def _process_entry_inplace(
         self,
-        entry: AnyComputedEntry,
+        entry: TypeVarAnyEntry,
         clean: bool = True,
         on_error: Literal["ignore", "warn", "raise"] = "ignore",
-    ) -> tuple[ComputedEntry, bool] | None:
+    ) -> tuple[TypeVarAnyEntry, bool] | None:
         """Process a single entry with the chosen Corrections.
         Note that this method will change the original entry.
 
         Args:
-            entry (AnyComputedEntry): An AnyComputedEntry object.
+            entry (TypeVarAnyEntry): A TypeVarAnyEntry object.
             clean (bool): Whether to remove any previously-applied energy adjustments.
                 If True, all EnergyAdjustment are removed prior to processing the Entry.
                 Defaults to True.
             on_error ("ignore" | "warn" | "raise"): What to do when get_adjustments(entry)
                 raises CompatibilityError. Defaults to "ignore".
 
         Returns:
-            tuple[AnyComputedEntry, ignore_entry (bool)] if entry is compatible, else None.
+            tuple[TypeVarAnyEntry, ignore_entry (bool)] if entry is compatible, else None.
         """
         ignore_entry: bool = False
         # If clean, remove all previous adjustments from the entry
@@ -662,13 +663,13 @@ def _process_entry_inplace(
 
     def process_entries(
         self,
-        entries: AnyComputedEntry | list[AnyComputedEntry],
+        entries: TypeVarAnyEntry | list[TypeVarAnyEntry],
         clean: bool = True,
         verbose: bool = False,
         inplace: bool = True,
         n_workers: int = 1,
         on_error: Literal["ignore", "warn", "raise"] = "ignore",
-    ) -> list[AnyComputedEntry]:
+    ) -> list[TypeVarAnyEntry]:
         """Process a sequence of entries with the chosen Compatibility scheme.
 
         Warning: This method changes entries in place! All changes can be undone and original entries
@@ -695,7 +696,7 @@ def process_entries(
         if isinstance(entries, ComputedEntry):  # True for ComputedStructureEntry too
             entries = [entries]
 
-        processed_entry_list: list[AnyComputedEntry] = []
+        processed_entry_list: list[TypeVarAnyEntry] = []
 
         # if inplace = False, process entries on a copy
         if not inplace:
@@ -1570,13 +1571,13 @@ def get_adjustments(self, entry: ComputedEntry) -> list[EnergyAdjustment]:
 
     def process_entries(
         self,
-        entries: list[AnyComputedEntry],
+        entries: list[TypeVarAnyEntry],
         clean: bool = False,
         verbose: bool = False,
         inplace: bool = True,
         n_workers: int = 1,
         on_error: Literal["ignore", "warn", "raise"] = "ignore",
-    ) -> list[AnyComputedEntry]:
+    ) -> list[TypeVarAnyEntry]:
         """Process a sequence of entries with the chosen Compatibility scheme.
 
         Args:

src/pymatgen/entries/mixing_scheme.py

@@ -16,10 +16,10 @@
 from pymatgen.analysis.phase_diagram import PhaseDiagram
 from pymatgen.analysis.structure_matcher import StructureMatcher
 from pymatgen.entries.compatibility import (
-    AnyComputedEntry,
     Compatibility,
     CompatibilityError,
     MaterialsProject2020Compatibility,
+    TypeVarAnyEntry,
 )
 from pymatgen.entries.computed_entries import ComputedStructureEntry, ConstantEnergyAdjustment
 from pymatgen.entries.entry_tools import EntrySet
@@ -121,12 +121,12 @@ def __init__(
 
     def process_entries(
         self,
-        entries: AnyComputedEntry | list[AnyComputedEntry],
+        entries: TypeVarAnyEntry | list[TypeVarAnyEntry],
         clean: bool = True,
         verbose: bool = False,
         inplace: bool = True,
         mixing_state_data=None,
-    ) -> list[AnyComputedEntry]:
+    ) -> list[TypeVarAnyEntry]:
         """Process a sequence of entries with the DFT mixing scheme. Note
         that this method will change the data of the original entries.