@mat3ra/made 2026.8.7-0 → 2026.8.18-0

package/tests/py/unit/test_tools_convert.py

@@ -1,174 +0,0 @@
-import numpy as np
-import pytest
-from ase import Atoms
-from ase.build import molecule
-from mat3ra.code.array_with_ids import ArrayWithIds
-from mat3ra.made.material import Material
-from mat3ra.made.tools.convert import from_ase, from_poscar, from_pymatgen, to_ase, to_poscar, to_pymatgen
-from mat3ra.made.tools.convert.utils import DEFAULT_NON_PERIODIC_MIN_LATTICE_SIZE, calculate_padded_cell_simple_cubic
-from mat3ra.utils import assertion as assertion_utils
-from pymatgen.core.structure import Element, Lattice, Structure
-
-from .fixtures.monolayer import GRAPHENE
-from .fixtures.thrid_party.ase_atoms import (
-    ASE_MOLECULE_H2O,
-    BULK_SI_LABELS,
-    BULK_SI_LATTICE_A,
-    BULK_SI_LATTICE_ALPHA,
-    ASE_BULK_Si,
-)
-
-PYMATGEN_LATTICE = Lattice.from_parameters(a=3.84, b=3.84, c=3.84, alpha=120, beta=90, gamma=60)
-PYMATGEN_STRUCTURE = Structure(PYMATGEN_LATTICE, ["Si", "Si"], [[0, 0, 0], [0.75, 0.5, 0.75]])
-
-POSCAR_CONTENT = """Si2
-1.0
-   3.3489202364344242    0.0000000000000000    1.9335000000000004
-   1.1163067454781415    3.1573922784475164    1.9335000000000004
-   0.0000000000000000    0.0000000000000000    3.8670000000000000
-Si
-2
-direct
-   0.0000000000000000    0.0000000000000000    0.0000000000000000 Si
-   0.2500000000000000    0.2500000000000000    0.2500000000000000 Si
-"""
-
-
-@pytest.mark.parametrize(
-    "material_config, expected_lattice_params, expected_species, expected_frac_coords",
-    [
-        (
-            Material.__default_config__,
-            {"a": 3.867, "b": 3.867, "c": 3.867, "alpha": 60, "beta": 60, "gamma": 60},
-            [Element("Si"), Element("Si")],
-            [[0.0, 0.0, 0.0], [0.25, 0.25, 0.25]],
-        ),
-        (
-            GRAPHENE,
-            {"a": 2.467291, "b": 2.467291, "c": 20.0, "alpha": 90, "beta": 90, "gamma": 120},
-            [Element("C"), Element("C")],
-            [[0.0, 0.0, 0.0], [0.333333, 0.666667, 0.0]],
-        ),
-    ],
-)
-def test_to_pymatgen(material_config, expected_lattice_params, expected_species, expected_frac_coords):
-    material = Material.create(material_config)
-    structure = to_pymatgen(material)
-    assert isinstance(structure, Structure)
-    assert np.allclose(structure.lattice.parameters, tuple(expected_lattice_params.values()), atol=1e-6)
-    assert structure.species == expected_species
-    assert np.allclose(structure.frac_coords, expected_frac_coords, atol=1e-6)
-
-    structure_to_poscar_str = structure.to(fmt="poscar")
-    material_to_poscar_str = to_poscar(material)
-    assert structure_to_poscar_str == material_to_poscar_str
-
-
-def test_from_pymatgen():
-    material_data = from_pymatgen(PYMATGEN_STRUCTURE)
-    assert material_data["lattice"]["a"] == 3.84
-    assert material_data["lattice"]["alpha"] == 120
-    assert material_data["basis"]["elements"] == [{"id": 0, "value": "Si"}, {"id": 1, "value": "Si"}]
-
-    converted_material = Material.create(material_data)
-    default_material = Material.create_default()
-    assertion_utils.assert_deep_almost_equal(converted_material, default_material)
-
-
-def test_to_poscar():
-    material = Material.create_default()
-    poscar = to_poscar(material)
-    assert poscar == POSCAR_CONTENT
-
-
-def test_from_poscar():
-    material_data = from_poscar(POSCAR_CONTENT)
-    assert material_data["lattice"]["a"] == 3.867
-    assert material_data["lattice"]["alpha"] == 60
-
-
-def test_to_ase():
-    material = Material.create_default()
-    labels_array = [{"id": 0, "value": 0}, {"id": 1, "value": 1}]
-    material.basis.labels = ArrayWithIds.from_list_of_dicts(labels_array)
-    ase_atoms = to_ase(material)
-    assert isinstance(ase_atoms, Atoms)
-    assert np.allclose(
-        ase_atoms.get_cell().tolist(),
-        [
-            [3.3489202364344242, 0.0, 1.9335000000000004],
-            [1.1163067454781415, 3.1573922784475164, 1.9335000000000004],
-            [0.0, 0.0, 3.8670000000000000],
-        ],
-    )
-    assert ase_atoms.get_chemical_symbols() == ["Si", "Si"]
-    assert np.allclose(ase_atoms.get_scaled_positions().tolist(), [[0.0, 0.0, 0.0], [0.25, 0.25, 0.25]])
-    assert ase_atoms.get_tags().tolist() == [0, 1]
-
-
-@pytest.mark.parametrize(
-    "ase_atoms, expected_lattice_a, expected_lattice_alpha, expected_labels,"
-    + " expected_is_non_periodic, expected_lattice_type",
-    [
-        (
-            ASE_BULK_Si,
-            BULK_SI_LATTICE_A,
-            BULK_SI_LATTICE_ALPHA,
-            BULK_SI_LABELS,
-            False,
-            None,
-        ),
-        (
-            ASE_MOLECULE_H2O,
-            None,
-            None,
-            [],
-            True,
-            "CUB",
-        ),
-    ],
-)
-def test_from_ase(
-    ase_atoms,
-    expected_lattice_a,
-    expected_lattice_alpha,
-    expected_labels,
-    expected_is_non_periodic,
-    expected_lattice_type,
-):
-    material_data = from_ase(ase_atoms)
-    if expected_lattice_a is not None:
-        assertion_utils.assert_almost_equal_numbers(material_data["lattice"]["a"], expected_lattice_a, atol=1e-4)
-    if expected_lattice_alpha is not None:
-        assert material_data["lattice"]["alpha"] == expected_lattice_alpha
-    assert material_data["basis"]["labels"] == expected_labels
-    assert material_data["isNonPeriodic"] == expected_is_non_periodic
-    if expected_lattice_type is not None:
-        assert material_data["lattice"]["type"] == expected_lattice_type
-
-
-TOLERANCE = 1e-4
-
-H2_EXPECTED_LATTICE_A = DEFAULT_NON_PERIODIC_MIN_LATTICE_SIZE
-O2_EXPECTED_LATTICE_A = 3.7379
-H2O_EXPECTED_LATTICE_A = 3.0530
-C2H4_EXPECTED_LATTICE_A = 6.1754
-
-
-@pytest.mark.parametrize(
-    "molecule_name, expected_lattice_a",
-    [
-        ("H2", H2_EXPECTED_LATTICE_A),
-        ("O2", O2_EXPECTED_LATTICE_A),
-        ("H2O", H2O_EXPECTED_LATTICE_A),
-        ("C2H4", C2H4_EXPECTED_LATTICE_A),
-    ],
-)
-def test_calculate_padded_cell_simple_cubic(molecule_name, expected_lattice_a):
-    atoms = molecule(molecule_name)
-    cell_vectors = calculate_padded_cell_simple_cubic(atoms.get_positions().tolist())
-    lattice_a = cell_vectors[0][0]
-    assert np.isclose(lattice_a, expected_lattice_a, atol=TOLERANCE)
-    assert lattice_a >= DEFAULT_NON_PERIODIC_MIN_LATTICE_SIZE
-    assert np.isclose(cell_vectors[0][0], cell_vectors[1][1], atol=TOLERANCE)
-    assert np.isclose(cell_vectors[0][0], cell_vectors[2][2], atol=TOLERANCE)

package/tests/py/unit/test_tools_modify.py

@@ -1,248 +0,0 @@
-import pytest
-from ase.build import bulk
-from mat3ra.made.material import Material
-from mat3ra.made.tools.build.compound_pristine_structures.two_dimensional.interface import get_optimal_film_displacement
-from mat3ra.made.tools.build_components.metadata import MaterialWithBuildMetadata
-from mat3ra.made.tools.calculate.calculators import InterfaceMaterialCalculator
-from mat3ra.made.tools.convert import from_ase
-from mat3ra.made.tools.convert.interface_parts_enum import InterfacePartsEnum
-from mat3ra.made.tools.modify import (
-    add_vacuum,
-    filter_by_circle_projection,
-    filter_by_ids,
-    filter_by_label,
-    filter_by_layers,
-    filter_by_rectangle_projection,
-    filter_by_sphere,
-    filter_by_triangle_projection,
-    interface_displace_part,
-    remove_vacuum,
-    translate_to_z_level,
-)
-from mat3ra.made.tools.operations.core.unary import rotate
-from mat3ra.utils import assertion as assertion_utils
-
-from .fixtures.bulk import BULK_Si_CONVENTIONAL, BULK_Si_CONVENTIONAL_FILTERED
-from .fixtures.interface.zsl import GRAPHENE_NICKEL_INTERFACE
-from .fixtures.slab import SI_SLAB_001_2_ATOMS, SI_SLAB_001_WITH_VACUUM
-from .utils import assert_two_entities_deep_almost_equal
-
-COMMON_PART = {
-    "units": "crystal",
-    "labels": [],
-}
-
-expected_basis_layers_section = {
-    "elements": [
-        {"id": 0, "value": "Si"},
-        {"id": 3, "value": "Si"},
-        {"id": 5, "value": "Si"},
-        {"id": 6, "value": "Si"},
-    ],
-    "coordinates": [
-        {"id": 0, "value": [0.5, 0.0, 0.0]},
-        {"id": 3, "value": [0.25, 0.75, 0.25]},
-        {"id": 5, "value": [0.75, 0.25, 0.25]},
-        {"id": 6, "value": [0.0, 0.5, 0.0]},
-    ],
-    **COMMON_PART,
-}
-
-expected_basis_layers_cavity = {
-    "elements": [
-        {"id": 1, "value": "Si"},
-        {"id": 2, "value": "Si"},
-        {"id": 4, "value": "Si"},
-        {"id": 7, "value": "Si"},
-    ],
-    "coordinates": [
-        {"id": 1, "value": [0.25, 0.25, 0.75]},
-        {"id": 2, "value": [0.5, 0.5, 0.5]},
-        {"id": 4, "value": [0.0, 0.0, 0.5]},
-        {"id": 7, "value": [0.75, 0.75, 0.75]},
-    ],
-    **COMMON_PART,
-}
-
-
-expected_basis_sphere_cluster = {
-    "elements": [{"id": 2, "value": "Si"}],
-    "coordinates": [{"id": 2, "value": [0.5, 0.5, 0.5]}],
-    **COMMON_PART,
-}
-
-expected_basis_sphere_cavity = {
-    "elements": [
-        {"id": 0, "value": "Si"},
-        {"id": 1, "value": "Si"},
-        {"id": 3, "value": "Si"},
-        {"id": 4, "value": "Si"},
-        {"id": 5, "value": "Si"},
-        {"id": 6, "value": "Si"},
-        {"id": 7, "value": "Si"},
-    ],
-    "coordinates": [
-        {"id": 0, "value": [0.5, 0.0, 0.0]},
-        {"id": 1, "value": [0.25, 0.25, 0.75]},
-        {"id": 3, "value": [0.25, 0.75, 0.25]},
-        {"id": 4, "value": [0.0, 0.0, 0.5]},
-        {"id": 5, "value": [0.75, 0.25, 0.25]},
-        {"id": 6, "value": [0.0, 0.5, 0.0]},
-        {"id": 7, "value": [0.75, 0.75, 0.75]},
-    ],
-    **COMMON_PART,
-}
-
-CRYSTAL_RADIUS = 0.25  # in crystal coordinates
-CRYSTAL_CENTER_3D = [0.5, 0.5, 0.5]  # in crystal coordinates
-
-
-def test_filter_by_ids():
-    material = Material.create(BULK_Si_CONVENTIONAL)
-    material_filtered = filter_by_ids(material, [0, 2])
-    # Move to fixtures
-    expected_material = Material.create(BULK_Si_CONVENTIONAL_FILTERED)
-    assert_two_entities_deep_almost_equal(material_filtered.basis, expected_material.basis)
-
-
-def test_filter_by_label():
-    # TODO: create in fixtures
-    substrate = bulk("Si", cubic=True)
-    film = bulk("Cu", cubic=True)
-    interface_atoms = substrate + film
-    interface_atoms.set_tags([1] * len(substrate) + [2] * len(film))
-    material_interface = Material.create(from_ase(interface_atoms))
-    film_extracted = filter_by_label(material_interface, 2)
-    film_material = Material.create(from_ase(film))
-
-    # Ids of filtered elements will be missing, comparing the resulting values
-    assert [el for el in film_material.basis.elements.values] == [el for el in film_extracted.basis.elements.values]
-
-
-def test_filter_by_layers():
-    material = Material.create(BULK_Si_CONVENTIONAL)
-    section = filter_by_layers(material=material, central_atom_id=0, layer_thickness=3.0)
-    cavity = filter_by_layers(material=material, central_atom_id=0, layer_thickness=3.0, invert_selection=True)
-    assert_two_entities_deep_almost_equal(section.basis, expected_basis_layers_section)
-    assert_two_entities_deep_almost_equal(cavity.basis, expected_basis_layers_cavity)
-
-
-def test_filter_by_sphere():
-    material = Material.create(BULK_Si_CONVENTIONAL)
-    cluster = filter_by_sphere(material, center_coordinate=CRYSTAL_CENTER_3D, radius=CRYSTAL_RADIUS)
-    cavity = filter_by_sphere(material, center_coordinate=CRYSTAL_CENTER_3D, radius=CRYSTAL_RADIUS, invert=True)
-    assert_two_entities_deep_almost_equal(cluster.basis, expected_basis_sphere_cluster)
-    assert_two_entities_deep_almost_equal(cavity.basis, expected_basis_sphere_cavity)
-
-
-def test_filter_by_circle_projection():
-    material = Material.create(BULK_Si_CONVENTIONAL)
-    # Small cylinder in the middle of the cell containing the central atom will be removed -- the same as with sphere
-    section = filter_by_circle_projection(material, 0.5, 0.5, CRYSTAL_RADIUS)
-    cavity = filter_by_circle_projection(material, 0.5, 0.5, CRYSTAL_RADIUS, invert_selection=True)
-    assert_two_entities_deep_almost_equal(section.basis, expected_basis_sphere_cluster)
-    assert_two_entities_deep_almost_equal(cavity.basis, expected_basis_sphere_cavity)
-
-
-def test_filter_by_rectangle_projection():
-    material = Material.create(BULK_Si_CONVENTIONAL)
-    # Default will contain all the atoms
-    section = filter_by_rectangle_projection(material)
-    assert_two_entities_deep_almost_equal(material.basis, section.basis)
-
-
-def test_filter_by_triangle_projection():
-    # Small prism in the middle of the cell containing the central atom will be removed -- the same as with sphere
-    material = Material.create(BULK_Si_CONVENTIONAL)
-    section = filter_by_triangle_projection(material, [0.4, 0.4], [0.4, 0.5], [0.5, 0.5])
-    cavity = filter_by_triangle_projection(material, [0.4, 0.4], [0.4, 0.5], [0.5, 0.5], invert_selection=True)
-    assert_two_entities_deep_almost_equal(section.basis, expected_basis_sphere_cluster)
-    assert_two_entities_deep_almost_equal(cavity.basis, expected_basis_sphere_cavity)
-
-
-def test_add_vacuum():
-    material = Material.create(SI_SLAB_001_2_ATOMS)
-    material_with_vacuum = add_vacuum(material, 5.0)
-    assert_two_entities_deep_almost_equal(material_with_vacuum, SI_SLAB_001_WITH_VACUUM)
-
-
-def test_remove_vacuum():
-    material_with_vacuum = Material.create(SI_SLAB_001_WITH_VACUUM)
-    vacuum = 7.368
-    material_with_no_vacuum = remove_vacuum(material_with_vacuum, from_top=True, from_bottom=True, fixed_padding=0)
-    expected_material = add_vacuum(material_with_no_vacuum, vacuum)
-    # to compare correctly, we need to translate the expected material to the bottom
-    # as it is effectively moved down when vacuum is removed (set to 0), use atol=1e-3 to account for the translation
-    reference_material = Material.create(SI_SLAB_001_2_ATOMS)
-    reference_material_translated_down = translate_to_z_level(reference_material, z_level="bottom")
-    # compare absolute coordinates
-
-    assert_two_entities_deep_almost_equal(expected_material, reference_material_translated_down, atol=1e-3)
-
-
-@pytest.mark.parametrize(
-    "material_config, rotations",
-    [
-        (
-            SI_SLAB_001_2_ATOMS,
-            [([0, 0, 1], 180), ([1, 0, 0], 180)],
-        ),
-        (
-            SI_SLAB_001_WITH_VACUUM,
-            [([1, 0, 0], 10)],
-        ),
-    ],
-)
-def test_rotate(material_config, rotations):
-    material = Material.create(material_config)
-    rotated_material = material
-    for axis, angle in rotations:
-        rotated_material = rotate(rotated_material, axis, angle)
-    assertion_utils.assert_deep_almost_equal(
-        material.basis.coordinates.values.sort(), rotated_material.basis.coordinates.values.sort()
-    )
-    assertion_utils.assert_deep_almost_equal(material.lattice, rotated_material.lattice)
-
-
-def test_displace_interface():
-    material = Material.create(GRAPHENE_NICKEL_INTERFACE)
-    expected_coordinates = [
-        {"id": 0, "value": [0.999999, 0.999999, 0]},
-        {"id": 1, "value": [0.666665667, 0.666665667, 0.100960811]},
-        {"id": 2, "value": [0.333332333, 0.333332333, 0.201921319]},
-        {"id": 3, "value": [0.993759493, 0.093159552, 0.366525839]},
-        {"id": 4, "value": [0.660425493, 0.759826552, 0.366525839]},
-    ]
-
-    expected_labels = GRAPHENE_NICKEL_INTERFACE["basis"]["labels"]
-    displaced_material = interface_displace_part(
-        material, [0.1, 0.2, 0.3], InterfacePartsEnum.FILM, use_cartesian_coordinates=True
-    )
-    assertion_utils.assert_deep_almost_equal(
-        expected_coordinates, displaced_material.basis.coordinates.to_dict(), atol=1e-6
-    )
-    assertion_utils.assert_deep_almost_equal(expected_labels, displaced_material.basis.labels.to_dict())
-
-
-def test_displace_interface_optimized():
-    material = MaterialWithBuildMetadata.create(GRAPHENE_NICKEL_INTERFACE)
-    expected_coordinates = [
-        {"id": 0, "value": [0.999999, 0.999999, 3.03e-7]},
-        {"id": 1, "value": [0.666665667, 0.666665667, 0.100960811]},
-        {"id": 2, "value": [0.333332333, 0.333332333, 0.201921319]},
-        {"id": 3, "value": [0.11112456, 0.181143574, 0.351561882]},
-        {"id": 4, "value": [0.77779056, 0.847810574, 0.351561882]},
-    ]
-    expected_labels = GRAPHENE_NICKEL_INTERFACE["basis"]["labels"]
-
-    optimal_displacement = get_optimal_film_displacement(
-        material,
-        calculator=InterfaceMaterialCalculator(),
-        grid_size_xy=(10, 10),
-        grid_range_x=(-0.5, 0.5),
-        grid_range_y=(-0.5, 0.5),
-        use_cartesian_coordinates=True,
-    )
-    displaced_material = interface_displace_part(material, optimal_displacement, use_cartesian_coordinates=True)
-    assertion_utils.assert_deep_almost_equal(expected_coordinates, displaced_material.basis.coordinates.to_dict())
-    assertion_utils.assert_deep_almost_equal(expected_labels, displaced_material.basis.labels.to_dict())

package/tests/py/unit/utils.py

@@ -1,142 +0,0 @@
-import copy
-import difflib
-import json
-import sys
-from enum import Enum
-from typing import Any, Dict
-
-from mat3ra.made.tools.convert import to_pymatgen
-from mat3ra.made.tools.third_party import PymatgenAseAtomsAdaptor
-from mat3ra.made.tools.utils import unwrap
-from mat3ra.utils import assertion as assertion_utils
-from pymatgen.analysis.structure_matcher import StructureMatcher
-from pymatgen.core.structure import Structure
-
-UPDATED_COORDINATE_TOLERANCE = 1e-6
-
-
-class OSPlatform(Enum):
-    """Platform enum for architecture-specific test handling."""
-
-    DARWIN = "darwin"
-    OTHER = "other"
-
-
-def get_current_platform() -> OSPlatform:
-    return OSPlatform.DARWIN if sys.platform == "darwin" else OSPlatform.OTHER
-
-
-def get_platform_specific_value(platform_values: Any) -> Any:
-    """
-    Get platform-specific value for the test cases that are architecture-specific.
-
-    Args:
-        platform_values: Either a dictionary mapping TestPlatform to values, or any other value
-
-    Returns:
-        Platform-specific value if input is a platform dictionary, otherwise returns input unchanged
-    """
-    if isinstance(platform_values, dict) and OSPlatform.DARWIN in platform_values:
-        current_platform = get_current_platform()
-        return platform_values[current_platform]
-    return platform_values
-
-
-ATOMS_TAGS_TO_INTERFACE_STRUCTURE_LABELS: Dict = {1: "substrate", 2: "film"}
-INTERFACE_STRUCTURE_LABELS_TO_ATOMS_TAGS: Dict = {v: k for k, v in ATOMS_TAGS_TO_INTERFACE_STRUCTURE_LABELS.items()}
-
-
-def atoms_to_interface_structure(atoms) -> Structure:
-    """
-    Converts ASE Atoms object to pymatgen Interface object.
-    Args:
-        atoms (Atoms): The ASE Atoms object.
-    Returns:
-        Interface: The pymatgen Interface object.
-    """
-
-    adaptor = PymatgenAseAtomsAdaptor()
-    interface_structure = adaptor.get_structure(atoms)
-    interface_structure.add_site_property(
-        "interface_label",
-        [ATOMS_TAGS_TO_INTERFACE_STRUCTURE_LABELS[tag] for tag in interface_structure.site_properties["tags"]],
-    )
-    return interface_structure
-
-
-def prune_extra_keys(data: Any, reference: Any) -> Any:
-    if isinstance(data, dict) and isinstance(reference, dict):
-        return {key: prune_extra_keys(data[key], reference[key]) for key in data if key in reference}
-    elif isinstance(data, list) and isinstance(reference, list):
-        return [prune_extra_keys(d_item, r_item) for d_item, r_item in zip(data, reference)]
-    else:
-        return data
-
-
-def sort_dict_recursively(d):
-    """Sort dictionary keys recursively."""
-    if isinstance(d, dict):
-        return {k: sort_dict_recursively(v) for k, v in sorted(d.items())}
-    elif isinstance(d, list):
-        return [sort_dict_recursively(x) for x in d]
-    else:
-        return d
-
-
-def show_difference(expected_data, actual_data):
-    diff = difflib.ndiff(
-        json.dumps(expected_data, indent=4).splitlines(),
-        json.dumps(actual_data, indent=4).splitlines(),
-    )
-    diff_str = "\n".join(diff)
-    # Filter out the lines that are the same
-    diff_str = "\n".join(line for line in diff_str.splitlines() if not line.startswith("  "))
-    if diff_str:
-        raise AssertionError(f"Entities differ:\n{diff_str}")
-
-
-def assert_two_entities_deep_almost_equal(entity1, entity2, rtol=1e-5, atol=1e-9):
-    # First unwrap any nested schema objects
-    entity1 = unwrap(entity1)
-    entity2 = unwrap(entity2)
-
-    dict_1 = entity1 if isinstance(entity1, (dict, list)) else json.loads(entity1.to_json())
-    dict_2 = entity2 if isinstance(entity2, (dict, list)) else json.loads(entity2.to_json())
-
-    cleaned_dict_1 = prune_extra_keys(dict_1, dict_2)
-
-    sorted_dict_1 = sort_dict_recursively(cleaned_dict_1)
-    sorted_dict_2 = sort_dict_recursively(dict_2)
-
-    actual_data = json.loads(json.dumps(sorted_dict_1))
-    expected_data = json.loads(json.dumps(sorted_dict_2))
-
-    try:
-        assertion_utils.assert_deep_almost_equal(expected_data, actual_data, rtol=rtol, atol=atol)
-    except AssertionError as e:
-        show_difference(expected_data, actual_data)
-        raise e
-
-
-def assert_interfaces_almost_equal(interface1: Any, interface2: Any) -> None:
-    """
-    Assert that two interface structures are almost equal, checking bases permutation-invariantly.
-    """
-    obj1 = unwrap(interface1)
-    obj2 = unwrap(interface2)
-    s1 = to_pymatgen(obj1)
-    s2 = to_pymatgen(obj2)
-    matcher = StructureMatcher(ltol=1e-3, stol=1e-3, angle_tol=0.1, primitive_cell=False, scale=False)
-    if not matcher.fit(s1, s2):
-        print("\n=== STRUCTURE MATCHER FAILED ===")
-        print("s1 (actual):\n", s1)
-        print("s2 (expected):\n", s2)
-        assert False, "Bases are not structurally equivalent"
-    dict_1 = copy.deepcopy(json.loads(obj1.to_json()))
-    dict_2 = copy.deepcopy(obj2 if isinstance(obj2, dict) else json.loads(obj2.to_json()))
-    # Remove name, basis, and coordinate hashes (fragile under translations, rotation, or wrapping)
-    for d in [dict_1, dict_2]:
-        for key in ["basis", "name", "hash", "scaledHash"]:
-            if key in d:
-                del d[key]
-    assert_two_entities_deep_almost_equal(dict_1, dict_2, atol=UPDATED_COORDINATE_TOLERANCE)

package/tsconfig-transpile.json

@@ -1,3 +0,0 @@
-{
-    "extends": "@mat3ra/tsconfig/tsconfig-js-py-transpile.json"
-}

package/tsconfig.json

@@ -1,3 +0,0 @@
-{
-    "extends": "@mat3ra/tsconfig/tsconfig-js-py-dev.json"
-}