emmet-builders 0.87.0.dev0__tar.gz → 0.87.0.dev2__tar.gz

{emmet_builders-0.87.0.dev0/emmet_builders.egg-info → emmet_builders-0.87.0.dev2}/PKG-INFO

@@ -1,14 +1,13 @@
 Metadata-Version: 2.4
 Name: emmet-builders
-Version: 0.87.0.dev0
+Version: 0.87.0.dev2
 Summary: Builders for the Emmet Library
 Author-email: The Materials Project <feedback@materialsproject.org>
 License: Modified BSD
 Project-URL: Homepage, https://github.com/materialsproject/emmet/tree/main/emmet-builders/
 Project-URL: Documentation, https://materialsproject.github.io/emmet/
 Requires-Python: >=3.11
-Requires-Dist: emmet-core[all]>=0.85
-Requires-Dist: maggma>=0.57.6
+Requires-Dist: emmet-core[all]>=0.86.1
 Requires-Dist: matminer>=0.9.1
 Requires-Dist: pymatgen-io-validation>=0.1.1
 Provides-Extra: test

emmet_builders-0.87.0.dev2/emmet/builders/base.py

@@ -0,0 +1,20 @@
+from pydantic import Field
+from pymatgen.core import Structure
+
+from emmet.core.base import EmmetBaseModel
+from emmet.core.types.typing import IdentifierType
+
+
+class BaseBuilderInput(EmmetBaseModel):
+    """
+    Document model with the minimum inputs required
+    to run builders that only require a Pymatgen structure
+    object for property analysis.
+
+    A material_id and builder_meta information may be optionally
+    included.
+    """
+
+    deprecated: bool = Field(False)
+    material_id: IdentifierType | None = Field(None)
+    structure: Structure

emmet_builders-0.87.0.dev2/emmet/builders/materials/bonds.py

@@ -0,0 +1,38 @@
+from pymatgen.symmetry.analyzer import SpacegroupAnalyzer
+
+from emmet.builders.base import BaseBuilderInput
+from emmet.core.bonds import BondingDoc
+
+
+def build_bonding_docs(
+    input_documents: list[BaseBuilderInput],
+) -> list[BondingDoc]:
+    """
+    Generate bonding documents from input structures.
+
+    Transforms a list of BaseBuilderInput documents containing
+    Pymatgen structures into corresponding BondingDoc instances by
+    analyzing the bonding environment of each structure.
+
+    Caller is responsible for creating BaseBuilderInput instances
+    within their data pipeline context.
+
+    Args:
+        input_documents: List of BaseBuilderInput documents to process.
+
+    Returns:
+       list[BondingDoc]
+    """
+    return list(
+        map(
+            lambda x: BondingDoc.from_structure(
+                builder_meta=x.builder_meta,
+                deprecated=x.deprecated,
+                material_id=x.material_id,
+                structure=SpacegroupAnalyzer(
+                    x.structure
+                ).get_conventional_standard_structure(),
+            ),
+            input_documents,
+        )
+    )

emmet_builders-0.87.0.dev2/emmet/builders/materials/chemenv.py

@@ -0,0 +1,34 @@
+from emmet.builders.base import BaseBuilderInput
+from emmet.core.chemenv import ChemEnvDoc
+
+
+def build_chemenv_docs(
+    input_documents: list[BaseBuilderInput],
+) -> list[ChemEnvDoc]:
+    """
+    Generate chemical environment documents from input structures.
+
+    Transforms a list of BaseBuilderInput documents containing
+    Pymatgen structures into corresponding ChemEnvDoc instances by
+    analyzing the chemical environment of each structure.
+
+    Caller is responsible for creating BaseBuilderInput instances
+    within their data pipeline context.
+
+    Args:
+        input_documents: List of BaseBuilderInput documents to process.
+
+    Returns:
+        list[ChemEnvDoc]
+    """
+    return list(
+        map(
+            lambda x: ChemEnvDoc.from_structure(
+                builder_meta=x.builder_meta,
+                deprecated=x.deprecated,
+                material_id=x.material_id,
+                structure=x.structure,
+            ),
+            input_documents,
+        )
+    )

emmet_builders-0.87.0.dev2/emmet/builders/materials/corrected_entries.py

@@ -0,0 +1,107 @@
+import copy
+import warnings
+
+from pydantic import BaseModel, Field
+from pymatgen.entries.compatibility import Compatibility
+
+from emmet.builders.utils import HiddenPrints
+from emmet.core.corrected_entries import CorrectedEntriesDoc
+from emmet.core.thermo import ThermoType
+from emmet.core.types.pymatgen_types.computed_entries_adapter import (
+    ComputedStructureEntryType,
+)
+
+
+class CorrectedEntriesBuilderInput(BaseModel):
+    entries: list[ComputedStructureEntryType] = Field(
+        ...,
+        description="""
+        List of computed structure entries to apply corrections to.
+        Entries MUST belong to a single chemical system (chemsys).
+        """,
+    )
+
+
+def build_corrected_entries_doc(
+    input: CorrectedEntriesBuilderInput,
+    compatibilities: list[Compatibility | None] = [None],
+) -> CorrectedEntriesDoc:
+    """
+    Process computed structure entries using corrections defined in pymatgen
+    compatibility classes. Ensures compatibility of energies for entries for
+    different thermodynamic hulls.
+
+    Input entries must all belong to the same chemical system. Caller is
+    responsible for constructing CorrectedEntriesBuilderInput instances within
+    their data pipeline context.
+
+    Args:
+        input: CorrectedEntriesBuilderInput with an aggregated list of computed
+            structure entries for a single chemical system.
+        compatibilities: List of pymatgen compatibility classes to apply to
+            input entries.
+
+    Returns:
+        CorrectedEntriesDoc: if no Compatibility class(es) are provided, and all
+            entries have the same functional, no corrections will be applied and
+            entries will simply be passed through to CorrectedEntriesDoc constructor.
+    """
+    all_entry_types = {str(e.data["run_type"]) for e in input.entries}
+
+    elements = sorted(
+        set([el.symbol for e in input.entries for el in e.composition.elements])
+    )
+    chemsys = "-".join(elements)
+
+    corrected_entries = {}
+
+    for compatibility in compatibilities:
+        if compatibility is not None:
+            with warnings.catch_warnings():
+                warnings.simplefilter("ignore")
+                with HiddenPrints():
+                    if compatibility.name == "MP DFT mixing scheme":
+                        thermo_type = ThermoType.GGA_GGA_U_R2SCAN
+
+                        if "R2SCAN" in all_entry_types:
+                            only_scan_pd_entries = [
+                                e
+                                for e in input.entries
+                                if str(e.data["run_type"]) == "R2SCAN"
+                            ]
+                            corrected_entries["R2SCAN"] = only_scan_pd_entries
+
+                            pd_entries = compatibility.process_entries(
+                                copy.deepcopy(input.entries),
+                                verbose=False,
+                            )
+
+                        else:
+                            corrected_entries["R2SCAN"] = None
+                            pd_entries = None
+
+                    elif compatibility.name == "MP2020":
+                        thermo_type = ThermoType.GGA_GGA_U
+                        pd_entries = compatibility.process_entries(
+                            copy.deepcopy(input.entries), verbose=False
+                        )
+                    else:
+                        thermo_type = ThermoType.UNKNOWN
+                        pd_entries = compatibility.process_entries(
+                            copy.deepcopy(input.entries), verbose=False
+                        )
+
+                    corrected_entries[str(thermo_type)] = pd_entries
+
+        else:
+            if len(all_entry_types) > 1:
+                # TODO: logging over raising
+                raise ValueError(
+                    "More than one functional type has been provided without a mixing scheme!"
+                )
+            else:
+                thermo_type = all_entry_types.pop()
+
+            corrected_entries[str(thermo_type)] = copy.deepcopy(input.entries)
+
+    return CorrectedEntriesDoc(chemsys=chemsys, entries=corrected_entries)

emmet_builders-0.87.0.dev2/emmet/builders/materials/oxidation_states.py

@@ -0,0 +1,34 @@
+from emmet.builders.base import BaseBuilderInput
+from emmet.core.oxidation_states import OxidationStateDoc
+
+
+def build_oxidation_states_docs(
+    input_documents: list[BaseBuilderInput],
+) -> list[OxidationStateDoc]:
+    """
+    Generate oxidation state documents from input structures.
+
+    Transforms a list of BaseBuilderInput documents containing
+    Pymatgen structures into corresponding OxidationStateDoc instances by
+    analyzing the oxidation states of each structure.
+
+    Caller is responsible for creating BaseBuilderInput instances
+    within their data pipeline context.
+
+    Args:
+        input_documents: List of BaseBuilderInput documents to process.
+
+    Returns:
+        list[OxidationStateDoc]
+    """
+    return list(
+        map(
+            lambda x: OxidationStateDoc.from_structure(
+                builder_meta=x.builder_meta,
+                deprecated=x.deprecated,
+                material_id=x.material_id,
+                structure=x.structure,
+            ),
+            input_documents,
+        )
+    )

emmet_builders-0.87.0.dev2/emmet/builders/materials/robocrys.py

@@ -0,0 +1,40 @@
+from robocrys import __version__ as __robocrys_version__
+from robocrys.condense.mineral import MineralMatcher
+
+from emmet.builders.base import BaseBuilderInput
+from emmet.core.robocrys import RobocrystallogapherDoc
+
+
+def build_robocrys_docs(
+    input_documents: list[BaseBuilderInput],
+) -> list[RobocrystallogapherDoc]:
+    """
+    Generate robocrystallographer descriptions from input structures.
+
+    Transforms a list of BaseBuilderInput documents containing
+    Pymatgen structures into corresponding RobocrystallogapherDoc instances by
+    using robocrys' StructureCondenser and StructureDescriber classes.
+
+    Caller is responsible for creating BaseBuilderInput instances
+    within their data pipeline context.
+
+    Args:
+        input_documents: List of BaseBuilderInput documents to process.
+
+    Returns:
+        list[RobocrystallogapherDoc]
+    """
+    mineral_matcher = MineralMatcher()
+    return list(
+        map(
+            lambda x: RobocrystallogapherDoc.from_structure(
+                builder_meta=x.builder_meta,
+                deprecated=x.deprecated,
+                material_id=x.material_id,
+                mineral_matcher=mineral_matcher,
+                robocrys_version=__robocrys_version__,
+                structure=x.structure,
+            ),
+            input_documents,
+        )
+    )

emmet_builders-0.87.0.dev2/emmet/builders/materials/thermo.py

@@ -0,0 +1,121 @@
+import logging
+import warnings
+
+from pydantic import BaseModel, Field
+from pymatgen.analysis.phase_diagram import PhaseDiagram, PhaseDiagramError
+from pymatgen.entries.computed_entries import ComputedStructureEntry
+
+from emmet.builders.utils import HiddenPrints
+from emmet.core.thermo import PhaseDiagramDoc, ThermoDoc
+from emmet.core.types.enums import ThermoType
+from emmet.core.types.pymatgen_types.computed_entries_adapter import (
+    ComputedStructureEntryType,
+)
+from emmet.core.vasp.calc_types.enums import RunType
+
+
+class ThermoBuilderInput(BaseModel):
+    """
+    Minimum inputs required to build ThermoDocs and PhaseDiagramDocs
+    for a chemical system.
+    """
+
+    chemsys: str = Field(
+        ...,
+        description="Dash-delimited string of elements in the material.",
+    )
+
+    entries: dict[RunType | ThermoType, list[ComputedStructureEntryType]] = Field(
+        ...,
+        description="""
+        List of all computed entries for 'chemsys' that are valid for the specified thermo type.
+        Entries for elemental endpoints of 'chemsys' are required.
+        """,
+    )
+
+
+class ThermoBuilderOutput(BaseModel):
+    """Output of build_thermo_docs_and_phase_diagram_docs function"""
+
+    chemsys: str
+    thermo_docs: dict[RunType | ThermoType, list[ThermoDoc] | None]
+    phase_diagram_docs: dict[RunType | ThermoType, PhaseDiagramDoc | None]
+
+
+ThermoPDPair = tuple[list[ThermoDoc] | None, PhaseDiagramDoc | None]
+
+logger = logging.getLogger()
+
+
+def build_thermo_docs_and_phase_diagram_docs(
+    thermo_input: ThermoBuilderInput,
+) -> ThermoBuilderOutput:
+    chemsys = thermo_input.chemsys
+
+    thermo_docs = dict()
+    phase_diagram_docs = dict()
+    for thermo_type, entry_list in thermo_input.entries.items():
+        logger.debug(
+            f"Processing {len(entry_list)} entries for: {chemsys} and thermo type: {thermo_type}"
+        )
+
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            with HiddenPrints():
+                _thermo_docs, _phase_diagram_doc = _produce_pair(
+                    entry_list, thermo_type
+                )
+                thermo_docs[thermo_type] = _thermo_docs
+                phase_diagram_docs[thermo_type] = _phase_diagram_doc
+
+    return ThermoBuilderOutput(
+        chemsys=chemsys,
+        thermo_docs=thermo_docs,
+        phase_diagram_docs=phase_diagram_docs,
+    )
+
+
+def _produce_pair(
+    computed_structure_entries: list[ComputedStructureEntry],
+    thermo_type: RunType | ThermoType,
+) -> ThermoPDPair:
+    phase_diagram_doc = None
+    try:
+        phase_diagram: PhaseDiagram = ThermoDoc.construct_phase_diagram(
+            computed_structure_entries
+        )
+        thermo_docs: list[ThermoDoc] = ThermoDoc.from_entries(
+            computed_structure_entries,
+            thermo_type,
+            phase_diagram,
+            use_max_chemsys=True,
+            deprecated=False,
+        )
+
+        if phase_diagram:
+            chemsys = "-".join(
+                sorted(set([el.symbol for el in phase_diagram.elements]))
+            )
+            phase_diagram_id = f"{chemsys}_{thermo_type.value}"
+            phase_diagram_doc = PhaseDiagramDoc(
+                phase_diagram_id=phase_diagram_id,
+                chemsys=chemsys,
+                phase_diagram=phase_diagram,
+                thermo_type=thermo_type,
+            )
+
+        if not thermo_docs:
+            return None, phase_diagram_doc
+
+        return thermo_docs, phase_diagram_doc
+
+    except PhaseDiagramError as p:
+        elsyms = []
+        for entry in computed_structure_entries:
+            elsyms.extend([el.symbol for el in entry.composition.elements])
+
+        logger.error(
+            f"Phase diagram error in chemsys {'-'.join(sorted(set(elsyms)))}: {p}"
+        )
+
+        return None, None

emmet_builders-0.87.0.dev2/emmet/builders/vasp/materials.py

@@ -0,0 +1,112 @@
+from itertools import groupby
+from typing import Iterator
+
+from emmet.builders.settings import EmmetBuildSettings
+from emmet.core.tasks import CoreTaskDoc
+from emmet.core.utils import group_structures, undeform_structure
+from emmet.core.vasp.calc_types import TaskType
+from emmet.core.vasp.material import MaterialsDoc
+from pydantic import Field
+
+
+class ValidationTaskDoc(CoreTaskDoc):
+    """
+    Wrapper for TaskDoc to ensure compatiblity with validation checks
+    in MaterialsDoc.from_tasks(...) if validation builder is skipped
+    """
+
+    is_valid: bool = Field(True)
+
+
+def build_material_docs(
+    input_documents: list[ValidationTaskDoc],
+    settings: EmmetBuildSettings = EmmetBuildSettings(),
+) -> list[MaterialsDoc]:
+    """
+    Aggregate ValidationTaskDocs into MaterialsDocs by chemical formula.
+    Caller is responsible for creating ValidationTaskDoc instances within
+    their data pipeline context.
+
+    Groups input documents by formula_pretty, performs structure matching
+    on each formula group, and constructs a MaterialsDoc for each group of
+    task documents with matching structures within each formula group.
+
+    Args:
+        input_documents: List of ValidationTaskDoc objects to process. Must contain
+            ALL documents for each unique formula_pretty value to avoid incorrect
+            material splitting. Documents for the same formula should not be split
+            across multiple function calls.
+        settings: Builder configuration settings, defaults defined in EmmetBuildSettings.
+            Relevant settings: VASP_STRUCTURE_QUALITY_SCORES, VASP_USE_STATICS,
+            VASP_ALLOWED_VASP_TYPES, LTOL, STOL, ANGLE_TOL, and SYMPREC.
+
+    Returns:
+        list[MaterialsDoc]
+    """
+
+    input_documents.sort(key=lambda x: x.formula_pretty)
+    materials = []
+    for _, group in groupby(input_documents, key=lambda x: x.formula_pretty):
+        # TODO: logging - task_ids = [task.task_id for task in group]
+        group = list(group)
+        task_transformations = [task.transformations for task in group]
+        grouped_tasks = filter_and_group_tasks(group, task_transformations, settings)
+        for group in grouped_tasks:
+            try:
+                doc = MaterialsDoc.from_tasks(
+                    group,
+                    structure_quality_scores=settings.VASP_STRUCTURE_QUALITY_SCORES,
+                    use_statics=settings.VASP_USE_STATICS,
+                )
+                materials.append(doc)
+            except Exception as e:
+                # TODO: logging - failed_ids = list({t_.task_id for t_ in group})
+                doc = MaterialsDoc.construct_deprecated_material(group)
+                doc.warnings.append(str(e))
+                materials.append(doc)
+
+    return materials
+
+
+def filter_and_group_tasks(
+    tasks: list[ValidationTaskDoc],
+    task_transformations: list[dict | None],
+    settings: EmmetBuildSettings,
+) -> Iterator[list[ValidationTaskDoc]]:
+    """Groups tasks by structure matching"""
+
+    filtered_tasks = []
+    filtered_transformations = []
+    for task, transformations in zip(tasks, task_transformations):
+        if any(
+            allowed_type == task.task_type
+            for allowed_type in settings.VASP_ALLOWED_VASP_TYPES
+        ):
+            filtered_tasks.append(task)
+            filtered_transformations.append(transformations)
+    structures = []
+    for idx, (task, transformations) in enumerate(
+        zip(filtered_tasks, filtered_transformations)
+    ):
+        if task.task_type == TaskType.Deformation:
+            if transformations is None:
+                # Do not include deformed tasks without transformation information
+                continue
+            else:
+                s = undeform_structure(task.input.structure, transformations)
+        else:
+            s = task.output.structure
+
+        s.index = idx
+        structures.append(s)
+
+    grouped_structures = group_structures(
+        structures,
+        ltol=settings.LTOL,
+        stol=settings.STOL,
+        angle_tol=settings.ANGLE_TOL,
+        symprec=settings.SYMPREC,
+    )
+    for group in grouped_structures:
+        grouped_tasks = [filtered_tasks[struct.index] for struct in group]
+        yield grouped_tasks

emmet_builders-0.87.0.dev2/emmet/builders/vasp/task_validator.py

@@ -0,0 +1,48 @@
+from typing import Any
+
+from emmet.builders.settings import EmmetBuildSettings
+from emmet.builders.utils import get_potcar_stats
+from emmet.core.tasks import CoreTaskDoc, TaskDoc
+from emmet.core.types.enums import DeprecationMessage
+from emmet.core.vasp.task_valid import TaskDocument
+from emmet.core.vasp.validation_legacy import ValidationDoc
+
+
+def build_validation_doc(
+    input: CoreTaskDoc | TaskDoc | TaskDocument,
+    settings: EmmetBuildSettings = EmmetBuildSettings(),
+    potcar_stats: dict[str, Any] = get_potcar_stats(method="stored"),
+) -> ValidationDoc:
+    """
+    Build a ValidationDoc from a CoreTaskDoc by checking CoreTaskDoc
+    parameters against reference values.
+
+    Args:
+        input: Parsed task document to validate.
+        settings: Reference values used in validation, defaults defined in EmmetBuildSettings.
+            Relevant settings: VASP_KSPACING_TOLERANCE, VASP_DEFAULT_INPUT_SETS, VASP_CHECKED_LDAU_FIELDS,
+            VASP_MAX_SCF_GRADIENT, and DEPRECATED_TAGS.
+        potcar_stats: POTCAR stats used to validate POTCARs used for the source calculation
+            for 'input'. Defaults to compiled values in 'emmet.builders.vasp.mp_potcar_stats.json.gz'
+
+    Returns:
+        ValidationDoc
+    """
+    validation_doc = ValidationDoc.from_task_doc(
+        task_doc=input,
+        kpts_tolerance=0.4 if "mp_production_old" in input.tags else 0.9,
+        kspacing_tolerance=settings.VASP_KSPACING_TOLERANCE,
+        input_sets=settings.VASP_DEFAULT_INPUT_SETS,
+        LDAU_fields=settings.VASP_CHECKED_LDAU_FIELDS,
+        max_allowed_scf_gradient=settings.VASP_MAX_SCF_GRADIENT,
+        potcar_stats=potcar_stats,
+    )
+
+    bad_tags = list(set(input.tags).intersection(settings.DEPRECATED_TAGS))
+
+    if len(bad_tags) > 0:
+        validation_doc.warnings.append(f"Manual Deprecation by tags: {bad_tags}")
+        validation_doc.valid = False
+        validation_doc.reasons.append(DeprecationMessage.MANUAL)
+
+    return validation_doc

{emmet_builders-0.87.0.dev0 → emmet_builders-0.87.0.dev2/emmet_builders.egg-info}/PKG-INFO

@@ -1,14 +1,13 @@
 Metadata-Version: 2.4
 Name: emmet-builders
-Version: 0.87.0.dev0
+Version: 0.87.0.dev2
 Summary: Builders for the Emmet Library
 Author-email: The Materials Project <feedback@materialsproject.org>
 License: Modified BSD
 Project-URL: Homepage, https://github.com/materialsproject/emmet/tree/main/emmet-builders/
 Project-URL: Documentation, https://materialsproject.github.io/emmet/
 Requires-Python: >=3.11
-Requires-Dist: emmet-core[all]>=0.85
-Requires-Dist: maggma>=0.57.6
+Requires-Dist: emmet-core[all]>=0.86.1
 Requires-Dist: matminer>=0.9.1
 Requires-Dist: pymatgen-io-validation>=0.1.1
 Provides-Extra: test

emmet_builders-0.87.0.dev2/emmet_builders.egg-info/SOURCES.txt

@@ -0,0 +1,29 @@
+MANIFEST.in
+pyproject.toml
+emmet/builders/__init__.py
+emmet/builders/base.py
+emmet/builders/py.typed
+emmet/builders/settings.py
+emmet/builders/utils.py
+emmet/builders/materials/__init__.py
+emmet/builders/materials/bonds.py
+emmet/builders/materials/chemenv.py
+emmet/builders/materials/corrected_entries.py
+emmet/builders/materials/oxidation_states.py
+emmet/builders/materials/robocrys.py
+emmet/builders/materials/thermo.py
+emmet/builders/vasp/materials.py
+emmet/builders/vasp/mp_potcar_stats.json.gz
+emmet/builders/vasp/task_validator.py
+emmet_builders.egg-info/PKG-INFO
+emmet_builders.egg-info/SOURCES.txt
+emmet_builders.egg-info/dependency_links.txt
+emmet_builders.egg-info/requires.txt
+emmet_builders.egg-info/top_level.txt
+requirements/deployment.txt
+requirements/ubuntu-latest_py3.11.txt
+requirements/ubuntu-latest_py3.11_extras.txt
+requirements/ubuntu-latest_py3.12.txt
+requirements/ubuntu-latest_py3.12_extras.txt
+requirements/ubuntu-latest_py3.13.txt
+requirements/ubuntu-latest_py3.13_extras.txt

{emmet_builders-0.87.0.dev0 → emmet_builders-0.87.0.dev2}/emmet_builders.egg-info/requires.txt

@@ -1,5 +1,4 @@
-emmet-core[all]>=0.85
-maggma>=0.57.6
+emmet-core[all]>=0.86.1
 matminer>=0.9.1
 pymatgen-io-validation>=0.1.1
 

{emmet_builders-0.87.0.dev0 → emmet_builders-0.87.0.dev2}/pyproject.toml

@@ -27,8 +27,7 @@ authors = [
 ]
 license = { text = "Modified BSD" }
 dependencies = [
-  "emmet-core[all]>=0.85",
-  "maggma>=0.57.6",
+  "emmet-core[all]>=0.86.1",
   "matminer>=0.9.1",
   "pymatgen-io-validation>=0.1.1",
 ]