emmet-builders 0.51.11__py3-none-any.whl → 0.51.12__py3-none-any.whl

emmet/builders/materials/elasticity.py

@@ -73,7 +73,9 @@ class ElasticityBuilder(Builder):
         self.elasticity.ensure_index("material_id")
         self.elasticity.ensure_index("last_updated")
 
-    def get_items(self,) -> Generator[Tuple[str, Dict[str, str], List[Dict]], None, None]:
+    def get_items(
+        self,
+    ) -> Generator[Tuple[str, Dict[str, str], List[Dict]], None, None]:
         """
         Gets all items to process into elasticity docs.
 
@@ -93,7 +95,6 @@ class ElasticityBuilder(Builder):
         query = self.query.copy()
 
         for i, doc in enumerate(cursor):
-
             material_id = doc["material_id"]
             calc_types = {str(k): v for k, v in doc["calc_types"].items()}
 
@@ -106,6 +107,7 @@ class ElasticityBuilder(Builder):
                 "output",
                 "orig_inputs",
                 "completed_at",
+                "last_updated",
                 "transmuter",
                 "task_id",
                 "dir_name",
@@ -172,12 +174,14 @@ class ElasticityBuilder(Builder):
         stresses = []
         deform_task_ids = []
         deform_dir_names = []
+        deform_last_updated = []
         for doc in final_deform:
             deforms.append(Deformation(doc["transmuter"]["transformation_params"][0]["deformation"]))
             # -0.1 to convert to GPa from kBar and s
             stresses.append(-0.1 * Stress(doc["output"]["stress"]))
             deform_task_ids.append(doc["task_id"])
             deform_dir_names.append(doc["dir_name"])
+            deform_last_updated.append(doc["last_updated"])
 
         elasticity_doc = ElasticityDoc.from_deformations_and_stresses(
             structure=Structure.from_dict(final_opt["output"]["structure"]),
@@ -186,6 +190,7 @@ class ElasticityBuilder(Builder):
             stresses=stresses,
             deformation_task_ids=deform_task_ids,
             deformation_dir_names=deform_dir_names,
+            deform_last_updated=deform_last_updated,
             equilibrium_stress=-0.1 * Stress(final_opt["output"]["stress"]),
             optimization_task_id=final_opt["task_id"],
             optimization_dir_name=final_opt["dir_name"],
@@ -208,7 +213,9 @@ class ElasticityBuilder(Builder):
 
 
 def filter_opt_tasks(
-    tasks: List[Dict], calc_types: Dict[str, str], target_calc_type: str = CalcType.GGA_Structure_Optimization,
+    tasks: List[Dict],
+    calc_types: Dict[str, str],
+    target_calc_type: str = CalcType.GGA_Structure_Optimization,
 ) -> List[Dict]:
     """
     Filter optimization tasks, by
@@ -220,7 +227,9 @@ def filter_opt_tasks(
 
 
 def filter_deform_tasks(
-    tasks: List[Dict], calc_types: Dict[str, str], target_calc_type: str = CalcType.GGA_Deformation,
+    tasks: List[Dict],
+    calc_types: Dict[str, str],
+    target_calc_type: str = CalcType.GGA_Deformation,
 ) -> List[Dict]:
     """
     Filter deformation tasks, by
@@ -326,7 +335,6 @@ def filter_deform_tasks_by_time(tasks: List[Dict], deform_comp_tol: float = 1e-5
     mapping = TensorMapping(tol=deform_comp_tol, tensors=[], values=[])
 
     for doc in tasks:
-
         # assume only one deformation, should be checked in `filter_deform_tasks()`
         deform = doc["transmuter"]["transformation_params"][0]["deformation"]
 

emmet/builders/materials/electronic_structure.py

@@ -70,9 +70,7 @@ class ElectronicStructureBuilder(Builder):
         """
         q = dict(self.query)
 
-        keys = self.electronic_structure.newer_in(
-            self.materials, criteria=q, exhaustive=True
-        )
+        keys = self.electronic_structure.newer_in(self.materials, criteria=q, exhaustive=True)
 
         N = ceil(len(keys) / number_splits)
         for split in grouper(keys, N):
@@ -93,17 +91,13 @@ class ElectronicStructureBuilder(Builder):
         mat_ids = self.materials.distinct(self.materials.key, criteria=q)
         es_ids = self.electronic_structure.distinct(self.electronic_structure.key)
 
-        mats_set = set(
-            self.electronic_structure.newer_in(
-                target=self.materials, criteria=q, exhaustive=True
-            )
-        ) | (set(mat_ids) - set(es_ids))
+        mats_set = set(self.electronic_structure.newer_in(target=self.materials, criteria=q, exhaustive=True)) | (
+            set(mat_ids) - set(es_ids)
+        )
 
         mats = [mat for mat in mats_set]
 
-        self.logger.info(
-            "Processing {} materials for electronic structure".format(len(mats))
-        )
+        self.logger.info("Processing {} materials for electronic structure".format(len(mats)))
 
         self.total = len(mats)
 
@@ -133,13 +127,7 @@ class ElectronicStructureBuilder(Builder):
         for bs_type, bs_entry in mat["bandstructure"].items():
             if bs_entry.get("object", None) is not None:
                 bs[bs_type] = (
-                    {
-                        bs_entry["task_id"]: BandStructureSymmLine.from_dict(
-                            bs_entry["object"]
-                        )
-                    }
-                    if bs_entry
-                    else None
+                    {bs_entry["task_id"]: BandStructureSymmLine.from_dict(bs_entry["object"])} if bs_entry else None
                 )
 
                 structures[bs_entry["task_id"]] = bs_entry["output_structure"]
@@ -147,17 +135,13 @@ class ElectronicStructureBuilder(Builder):
         if mat["dos"]:
             if mat["dos"]["object"] is not None:
                 self.logger.info("Processing density of states")
-                dos = {
-                    mat["dos"]["task_id"]: CompleteDos.from_dict(mat["dos"]["object"])
-                }
+                dos = {mat["dos"]["task_id"]: CompleteDos.from_dict(mat["dos"]["object"])}
 
                 structures[mat["dos"]["task_id"]] = mat["dos"]["output_structure"]
 
         if bs:
             self.logger.info(
-                "Processing band structure types: {}".format(
-                    [bs_type for bs_type, bs_entry in bs.items() if bs_entry]
-                )
+                "Processing band structure types: {}".format([bs_type for bs_type, bs_entry in bs.items() if bs_entry])
             )
 
         # Default summary data
@@ -173,6 +157,7 @@ class ElectronicStructureBuilder(Builder):
             is_gap_direct=mat["other"]["is_gap_direct"],
             is_metal=mat["other"]["is_metal"],
             magnetic_ordering=mat["other"]["magnetic_ordering"],
+            origins=mat["origins"],
             warnings=[],
         )
 
@@ -180,10 +165,7 @@ class ElectronicStructureBuilder(Builder):
         eig_values = mat["other"].get("eigenvalue_band_properties", None)
 
         if eig_values is not None:
-            if not np.isclose(
-                mat["other"]["band_gap"], eig_values["bandgap"], atol=0.2, rtol=0.0
-            ):
-
+            if not np.isclose(mat["other"]["band_gap"], eig_values["bandgap"], atol=0.2, rtol=0.0):
                 d["warnings"].append(
                     "Regular parsed band gap and band gap from eigenvalue_band_properties do not agree. "
                     "Using data from eigenvalue_band_properties where appropriate."
@@ -193,16 +175,13 @@ class ElectronicStructureBuilder(Builder):
                 d["cbm"] = eig_values["cbm"]
                 d["vbm"] = eig_values["vbm"]
                 d["is_gap_direct"] = eig_values["is_gap_direct"]
-                d["is_metal"] = (
-                    True if np.isclose(d["band_gap"], 0.0, atol=0.01, rtol=0) else False
-                )
+                d["is_metal"] = True if np.isclose(d["band_gap"], 0.0, atol=0.01, rtol=0) else False
 
         if dos is None:
             doc = ElectronicStructureDoc.from_structure(**d)
 
         else:
             try:
-
                 doc = ElectronicStructureDoc.from_bsdos(
                     material_id=mat[self.materials.key],
                     structures=structures,
@@ -210,14 +189,13 @@ class ElectronicStructureBuilder(Builder):
                     is_gap_direct=d["is_gap_direct"],
                     is_metal=d["is_metal"],
                     deprecated=d["deprecated"],
+                    origins=d["origins"],
                     **bs,
                 )
                 doc = self._bsdos_checks(doc, dos[mat["dos"]["task_id"]], structures)
 
             except Exception:
-                d["warnings"].append(
-                    "Band structure and/or data exists but an error occured while processing."
-                )
+                d["warnings"].append("Band structure and/or data exists but an error occured while processing.")
                 doc = ElectronicStructureDoc.from_structure(**d)
 
         # Magnetic ordering check
@@ -233,16 +211,11 @@ class ElectronicStructureBuilder(Builder):
 
         if doc.dos is not None:
             dos_dict = doc.dos.dict()
-            mag_orderings.update(
-                {dos_dict["total"][Spin.up]["task_id"]: dos_dict["magnetic_ordering"]}
-            )
+            mag_orderings.update({dos_dict["total"][Spin.up]["task_id"]: dos_dict["magnetic_ordering"]})
 
         for task_id, ordering in mag_orderings.items():
             if doc.magnetic_ordering != ordering:
-
-                doc.warnings.append(
-                    f"Summary data magnetic ordering does not agree with the ordering from {task_id}"
-                )
+                doc.warnings.append(f"Summary data magnetic ordering does not agree with the ordering from {task_id}")
 
         # LMAXMIX check, VASP default is 2
         expected_lmaxmix = MPStaticSet(structure).incar.get("LMAXMIX", 2)
@@ -303,14 +276,9 @@ class ElectronicStructureBuilder(Builder):
         for task_id, struct in structures.items():
             pair_list.append((task_id, struct))
 
-            struct_prim = SpacegroupAnalyzer(struct).get_primitive_standard_structure(
-                international_monoclinic=False
-            )
-
-            if not np.allclose(
-                struct.lattice.matrix, struct_prim.lattice.matrix, atol=1e-3
-            ):
+            struct_prim = SpacegroupAnalyzer(struct).get_primitive_standard_structure(international_monoclinic=False)
 
+            if not np.allclose(struct.lattice.matrix, struct_prim.lattice.matrix, atol=1e-3):
                 if doc.warnings is None:
                     doc.warnings = []
 
@@ -362,10 +330,8 @@ class ElectronicStructureBuilder(Builder):
         other_calcs = []
 
         for task_id in mat["task_types"].keys():
-
             # Handle all line-mode tasks
             if "NSCF Line" in mat["task_types"][task_id]:
-
                 bs_type = None
 
                 task_query = self.tasks.query_one(
@@ -381,18 +347,14 @@ class ElectronicStructureBuilder(Builder):
                     criteria={"task_id": str(task_id)},
                 )
 
-                fs_id = str(
-                    task_query["calcs_reversed"][0].get("bandstructure_fs_id", None)
-                )
+                fs_id = str(task_query["calcs_reversed"][0].get("bandstructure_fs_id", None))
 
                 if fs_id is not None:
                     structure = Structure.from_dict(task_query["output"]["structure"])
 
                     kpoints = task_query["orig_inputs"]["kpoints"]
                     labels_dict = {
-                        label: point
-                        for label, point in zip(kpoints["labels"], kpoints["kpoints"])
-                        if label is not None
+                        label: point for label, point in zip(kpoints["labels"], kpoints["kpoints"]) if label is not None
                     }
 
                     try:
@@ -401,18 +363,12 @@ class ElectronicStructureBuilder(Builder):
                         bs_type = None
 
                     if bs_type is None:
-
-                        bs_dict = self.bandstructure_fs.query_one(
-                            {self.bandstructure_fs.key: str(task_id)}
-                        )
+                        bs_dict = self.bandstructure_fs.query_one({self.bandstructure_fs.key: str(task_id)})
 
                         if bs_dict is not None:
-
                             bs = BandStructureSymmLine.from_dict(bs_dict["data"])
 
-                            bs_type = self._obtain_path_type(
-                                bs.labels_dict, bs.structure
-                            )
+                            bs_type = self._obtain_path_type(bs.labels_dict, bs.structure)
 
                     is_hubbard = task_query["input"]["is_hubbard"]
                     lmaxmix = task_query["input"]["incar"].get(
@@ -461,14 +417,10 @@ class ElectronicStructureBuilder(Builder):
                     structure = Structure.from_dict(task_query["output"]["structure"])
 
                     if (
-                        task_query["orig_inputs"]["kpoints"]["generation_style"]
-                        == "Monkhorst"
-                        or task_query["orig_inputs"]["kpoints"]["generation_style"]
-                        == "Gamma"
+                        task_query["orig_inputs"]["kpoints"]["generation_style"] == "Monkhorst"
+                        or task_query["orig_inputs"]["kpoints"]["generation_style"] == "Gamma"
                     ):
-                        nkpoints = np.prod(
-                            task_query["orig_inputs"]["kpoints"]["kpoints"][0], axis=0
-                        )
+                        nkpoints = np.prod(task_query["orig_inputs"]["kpoints"]["kpoints"][0], axis=0)
 
                     else:
                         nkpoints = task_query["orig_inputs"]["kpoints"]["nkpoints"]
@@ -504,9 +456,7 @@ class ElectronicStructureBuilder(Builder):
 
                 structure = Structure.from_dict(task_query["output"]["structure"])
 
-                other_mag_ordering = CollinearMagneticStructureAnalyzer(
-                    structure
-                ).ordering
+                other_mag_ordering = CollinearMagneticStructureAnalyzer(structure).ordering
 
                 is_hubbard = task_query["input"]["is_hubbard"]
 
@@ -516,9 +466,7 @@ class ElectronicStructureBuilder(Builder):
                     last_calc["input"]["kpoints"]["generation_style"] == "Monkhorst"
                     or last_calc["input"]["kpoints"]["generation_style"] == "Gamma"
                 ):
-                    nkpoints = np.prod(
-                        last_calc["input"]["kpoints"]["kpoints"][0], axis=0
-                    )
+                    nkpoints = np.prod(last_calc["input"]["kpoints"]["kpoints"][0], axis=0)
                 else:
                     nkpoints = last_calc["input"]["kpoints"]["nkpoints"]
 
@@ -526,9 +474,7 @@ class ElectronicStructureBuilder(Builder):
 
                 other_calcs.append(
                     {
-                        "is_static": True
-                        if "Static" in mat["task_types"][task_id]
-                        else False,
+                        "is_static": True if "Static" in mat["task_types"][task_id] else False,
                         "task_id": task_id,
                         "is_hubbard": int(is_hubbard),
                         "nkpoints": int(nkpoints),
@@ -538,18 +484,15 @@ class ElectronicStructureBuilder(Builder):
                     }
                 )
 
-        updated_materials_doc = self._obtain_blessed_calculations(
-            mat, bs_calcs, dos_calcs, other_calcs
-        )
+        updated_materials_doc = self._obtain_blessed_calculations(mat, bs_calcs, dos_calcs, other_calcs)
 
         return updated_materials_doc
 
-    def _obtain_blessed_calculations(
-        self, materials_doc, bs_calcs, dos_calcs, other_calcs
-    ):
-
+    def _obtain_blessed_calculations(self, materials_doc, bs_calcs, dos_calcs, other_calcs):
         bs_types = ["setyawan_curtarolo", "hinuma", "latimer_munro"]
 
+        materials_doc["origins"] = []
+
         for bs_type in bs_types:
             # select "blessed" bs of each type
             if bs_calcs[bs_type]:
@@ -563,28 +506,25 @@ class ElectronicStructureBuilder(Builder):
                     reverse=True,
                 )
 
-                materials_doc["bandstructure"][bs_type]["task_id"] = sorted_bs_data[0][
-                    "task_id"
-                ]
+                materials_doc["bandstructure"][bs_type]["task_id"] = sorted_bs_data[0]["task_id"]
 
-                materials_doc["bandstructure"][bs_type]["lmaxmix"] = sorted_bs_data[0][
-                    "lmaxmix"
-                ]
+                materials_doc["bandstructure"][bs_type]["lmaxmix"] = sorted_bs_data[0]["lmaxmix"]
 
-                bs_obj = self.bandstructure_fs.query_one(
-                    criteria={"fs_id": sorted_bs_data[0]["fs_id"]}
-                )
+                bs_obj = self.bandstructure_fs.query_one(criteria={"fs_id": sorted_bs_data[0]["fs_id"]})
 
-                materials_doc["bandstructure"][bs_type]["object"] = (
-                    bs_obj["data"] if bs_obj is not None else None
-                )
+                materials_doc["bandstructure"][bs_type]["object"] = bs_obj["data"] if bs_obj is not None else None
 
-                materials_doc["bandstructure"][bs_type][
-                    "output_structure"
-                ] = sorted_bs_data[0]["output_structure"]
+                materials_doc["bandstructure"][bs_type]["output_structure"] = sorted_bs_data[0]["output_structure"]
 
-        if dos_calcs:
+                materials_doc["origins"].append(
+                    {
+                        "name": bs_type,
+                        "task_id": sorted_bs_data[0]["task_id"],
+                        "last_updated": sorted_bs_data[0]["updated_on"],
+                    }
+                )
 
+        if dos_calcs:
             sorted_dos_data = sorted(
                 dos_calcs,
                 key=lambda entry: (
@@ -600,19 +540,20 @@ class ElectronicStructureBuilder(Builder):
 
             materials_doc["dos"]["lmaxmix"] = sorted_dos_data[0]["lmaxmix"]
 
-            dos_obj = self.dos_fs.query_one(
-                criteria={"fs_id": sorted_dos_data[0]["fs_id"]}
-            )
-            materials_doc["dos"]["object"] = (
-                dos_obj["data"] if dos_obj is not None else None
-            )
+            dos_obj = self.dos_fs.query_one(criteria={"fs_id": sorted_dos_data[0]["fs_id"]})
+            materials_doc["dos"]["object"] = dos_obj["data"] if dos_obj is not None else None
 
-            materials_doc["dos"]["output_structure"] = sorted_dos_data[0][
-                "output_structure"
-            ]
+            materials_doc["dos"]["output_structure"] = sorted_dos_data[0]["output_structure"]
 
-        if other_calcs:
+            materials_doc["origins"].append(
+                {
+                    "name": "dos",
+                    "task_id": sorted_dos_data[0]["task_id"],
+                    "last_updated": sorted_dos_data[0]["updated_on"],
+                }
+            )
 
+        if other_calcs:
             sorted_other_data = sorted(
                 other_calcs,
                 key=lambda entry: (
@@ -628,12 +569,17 @@ class ElectronicStructureBuilder(Builder):
 
             task_output_data = sorted_other_data[0]["calcs_reversed"][-1]["output"]
             materials_doc["other"]["band_gap"] = task_output_data["bandgap"]
-            materials_doc["other"]["magnetic_ordering"] = sorted_other_data[0][
-                "magnetic_ordering"
-            ]
+            materials_doc["other"]["magnetic_ordering"] = sorted_other_data[0]["magnetic_ordering"]
+            materials_doc["other"]["last_updated"] = sorted_other_data[0]["updated_on"]
+
+            materials_doc["other"]["is_metal"] = materials_doc["other"]["band_gap"] == 0.0
 
-            materials_doc["other"]["is_metal"] = (
-                materials_doc["other"]["band_gap"] == 0.0
+            materials_doc["origins"].append(
+                {
+                    "name": "electronic_structure",
+                    "task_id": sorted_other_data[0]["task_id"],
+                    "last_updated": sorted_other_data[0]["updated_on"],
+                }
             )
 
             for prop in [
@@ -644,7 +590,6 @@ class ElectronicStructureBuilder(Builder):
                 "is_metal",
                 "eigenvalue_band_properties",
             ]:
-
                 # First try other calcs_reversed entries if properties are not found in last
                 if prop not in task_output_data:
                     for calc in sorted_other_data[0]["calcs_reversed"]:
@@ -663,7 +608,6 @@ class ElectronicStructureBuilder(Builder):
         angle_tolerance=SETTINGS.ANGLE_TOL,
         atol=1e-5,
     ):
-
         bs_type = None
 
         if any([label.islower() for label in labels_dict]):
@@ -680,24 +624,17 @@ class ElectronicStructureBuilder(Builder):
                     atol=atol,
                 )
                 hs_labels_full = hskp.kpath["kpoints"]
-                hs_path_uniq = set(
-                    [label for segment in hskp.kpath["path"] for label in segment]
-                )
+                hs_path_uniq = set([label for segment in hskp.kpath["path"] for label in segment])
 
-                hs_labels = {
-                    k: hs_labels_full[k] for k in hs_path_uniq if k in hs_path_uniq
-                }
+                hs_labels = {k: hs_labels_full[k] for k in hs_path_uniq if k in hs_path_uniq}
 
                 shared_items = {
                     k: labels_dict[k]
                     for k in labels_dict
-                    if k in hs_labels
-                    and np.allclose(labels_dict[k], hs_labels[k], atol=1e-3)
+                    if k in hs_labels and np.allclose(labels_dict[k], hs_labels[k], atol=1e-3)
                 }
 
-                if len(shared_items) == len(labels_dict) and len(shared_items) == len(
-                    hs_labels
-                ):
+                if len(shared_items) == len(labels_dict) and len(shared_items) == len(hs_labels):
                     bs_type = ptype
 
         return bs_type

{emmet_builders-0.51.11.dist-info → emmet_builders-0.51.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: emmet-builders
-Version: 0.51.11
+Version: 0.51.12
 Summary: Builders for the Emmet Library
 Home-page: https://github.com/materialsproject/emmet
 Author: The Materials Project

{emmet_builders-0.51.11.dist-info → emmet_builders-0.51.12.dist-info}/RECORD

@@ -14,9 +14,9 @@ emmet/builders/materials/bonds.py,sha256=ZT-W3i0mX5tGRr1Aq4pHhxGZX-MMg58i-2L-QeG
 emmet/builders/materials/chemenv.py,sha256=eQHDJDxG8AWK9KWEqfBuyeSVnS6cvS0hJMYZupUsUR0,1222
 emmet/builders/materials/corrected_entries.py,sha256=I8lsE5mjI-LntrftoJrZnzPjHo48FTgxRNtwj-b9exM,11255
 emmet/builders/materials/dielectric.py,sha256=StspDPLgl-rN87daz3T3jfnM2wXZkjZOP4RKbKld_NA,6524
-emmet/builders/materials/elasticity.py,sha256=TH9jDMTyU0gB6HPrzaXQ4-QiL2e0Rr4RJ69E6cBlSI4,15234
+emmet/builders/materials/elasticity.py,sha256=ETshFVSksTmDYyTkxjpL6E1btAfFEwmhKUOZM4EJNIM,15440
 emmet/builders/materials/electrodes.py,sha256=7lUF943lojyJc6hBIuYMznp_0rfHHHu-jjmssTpDdA4,21992
-emmet/builders/materials/electronic_structure.py,sha256=WJmY6S8ytnKfgZcHGweJ76Zx1kTXo4jDM0nemSUIC4E,25365
+emmet/builders/materials/electronic_structure.py,sha256=d2tQS2HN2JR2fonScfpuxEPmQFxmoJ-jouMchXrRPdo,24917
 emmet/builders/materials/magnetism.py,sha256=Aw55dOeIXGOVQBYTYQN-q6VduZdOMAPfJvYKoD7vzl0,4578
 emmet/builders/materials/optimade.py,sha256=8S9vSGC5TaSZfkNJvDqISWOKuIWDeiLoV48EalJTkkk,1433
 emmet/builders/materials/oxidation_states.py,sha256=eYiMum3Jio6WdiJ0W_DHo9j7hOP-qeU6DyoW0MBTE6Q,1518
@@ -42,7 +42,7 @@ emmet/builders/qchem/molecules.py,sha256=myR8zaZg2GDFb6TFoHDUtvtbvBp4K55bkTC-mJw
 emmet/builders/vasp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 emmet/builders/vasp/materials.py,sha256=JnV_5Kd0qCU0hsqAcyhZwgMTYVcs54NmYKS9kNS9bhI,13334
 emmet/builders/vasp/task_validator.py,sha256=9hiYdnG_Wz4zxzG6mrxjPIJbZTm_N-22UwpYPT5zXFE,3601
-emmet_builders-0.51.11.dist-info/METADATA,sha256=SfZpgx3-pM-BiHuPwqYXGviJKfXd_p4D16WfxMmhRfo,1450
-emmet_builders-0.51.11.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-emmet_builders-0.51.11.dist-info/top_level.txt,sha256=6GcpbmWPeFhNCTfDFilb8GQ4T1UQu4z9c5jpobjwE-Q,6
-emmet_builders-0.51.11.dist-info/RECORD,,
+emmet_builders-0.51.12.dist-info/METADATA,sha256=k6Xkbdv2F1sb6hPq703p4x9hf4vYZl0zCa1SzZ2nA18,1450
+emmet_builders-0.51.12.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+emmet_builders-0.51.12.dist-info/top_level.txt,sha256=6GcpbmWPeFhNCTfDFilb8GQ4T1UQu4z9c5jpobjwE-Q,6
+emmet_builders-0.51.12.dist-info/RECORD,,