sxs 2025.0.6__tar.gz → 2025.0.7__tar.gz

{sxs-2025.0.6 → sxs-2025.0.7}/.github/workflows/build.yml

@@ -34,6 +34,11 @@ jobs:
         exclude:
           - os: windows-latest
             python-version: '3.13'
+          - os: macos-latest
+            python-version: '3.13'
+        include:
+          - os: macos-latest
+            python-version: '3.12'
 
     steps:
       - name: Skip replicates unless on main branch or using ubuntu-latest

{sxs-2025.0.6 → sxs-2025.0.7}/CITATION.cff

@@ -10,5 +10,5 @@ authors:
 title: "The sxs package"
 license: MIT
 doi: 10.5281/zenodo.4034006
-version: 2025.0.6
-date-released: 2025-04-11
+version: 2025.0.7
+date-released: 2025-04-15

{sxs-2025.0.6 → sxs-2025.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sxs
-Version: 2025.0.6
+Version: 2025.0.7
 Summary: Interface to data produced by the Simulating eXtreme Spacetimes collaboration
 Project-URL: Homepage, https://github.com/sxs-collaboration/sxs
 Project-URL: Documentation, https://sxs.readthedocs.io/
@@ -47,7 +47,7 @@ Requires-Dist: quaternionic>=1.0.15
 Requires-Dist: requests>=2.24.0
 Requires-Dist: scipy>=1.13
 Requires-Dist: spherical>=1.0.15
-Requires-Dist: sxscatalog>=3.0.12
+Requires-Dist: sxscatalog>=3.0.13
 Requires-Dist: tqdm>=4.63.1
 Requires-Dist: urllib3>=1.25.10
 Provides-Extra: docs

{sxs-2025.0.6 → sxs-2025.0.7}/pyproject.toml

@@ -18,7 +18,7 @@ classifiers = [
   "Topic :: Scientific/Engineering :: Astronomy"
 ]
 dependencies = [
-  "sxscatalog >=3.0.12",
+  "sxscatalog >=3.0.13",
   "numpy >=1.25",
   "scipy >=1.13",
   "numba >=0.55; implementation_name == 'cpython'",

sxs-2025.0.7/sxs/__version__.py

@@ -0,0 +1 @@
+__version__ = "2025.0.7"

{sxs-2025.0.6 → sxs-2025.0.7}/sxs/simulations/simulation.py

@@ -7,6 +7,32 @@ from ..utilities import (
 )
 
 
+def search_prefixes(file, lev, files, ending=""):
+    """Find the actual filename present in the list of files
+
+    Different versions of Zenodo and CaltechDATA place different
+    restrictions on filenames — and specifically, things I would
+    consider to be directories.  If there are multiple Levs for a
+    simulation, we have to somehow specify the Lev in the filename.
+    The permitted strings for doing so have changed over the years, so
+    the directory separator was allowed to be a "/" for old systems,
+    but must be something else now; we settled on ":".  However, if
+    there is just one Lev in a simulation, and we try to save the
+    files in a consistent way — including the Lev with the appropriate
+    separator, different versions of Zenodo and CaltechDATA will
+    either allow or silently remove that prefix.  The simplest
+    approach is to just search over all possibilities, for which
+    filename is actually present in the data.  That's what this
+    function does.
+    
+    """
+    for prefix in [f"{lev}:", f"{lev}/", ""]:
+        fn = f"{prefix}{file}"
+        if f"{fn}{ending}" in files:
+            return fn
+    raise ValueError(f"{file}{ending} not found in any form in files")
+
+
 def Simulation(location, *args, **kwargs):
     """Construct a Simulation object from a location string
 
@@ -113,8 +139,8 @@ def Simulation(location, *args, **kwargs):
     # Extract the simulation ID, version, and Lev from the location string
     simulation_id, input_version = sxs_id_and_version(location)
     if not simulation_id:
-        if location.split("/Lev")[0] in simulations:
-            simulation_id = location.split("/Lev")[0]
+        if (sim_id := location.split("/Lev")[0]) in simulations:
+            simulation_id = sim_id
             input_version = latest_version
         else:
             raise ValueError(f"Invalid SXS ID in '{simulation_id}'")
@@ -129,7 +155,11 @@ def Simulation(location, *args, **kwargs):
     series = simulations.dataframe.loc[simulation_id]
 
     # If input_version is not the default, remove "files" from metadata
-    if input_version and input_version != max(metadata.get("DOI_versions", []), default=""):
+    version_is_not_default = (
+        input_version
+        and input_version != max(metadata.get("DOI_versions", []), default="")
+    )
+    if version_is_not_default:
         metadata = type(metadata)({
             key: value for key, value in metadata.items() if key != "files"
         })
@@ -211,26 +241,35 @@ def Simulation(location, *args, **kwargs):
     kwargs["deprecated"] = deprecated
 
     # We want to do this *after* deprecation checking, to avoid possibly unnecessary web requests
-    if 1 <= float(version[1:]) < 3.0 and "files" in metadata:
-        # The simulation metadata is points to files with a different version
-        del metadata["files"]
+    if version_is_not_default:
+        # The default metadata points to files with a different version, so delete this info
+        if "files" in metadata:
+            del metadata["files"]
     files = get_file_info(metadata, sxs_id, download=kwargs.get("download_file_info", None))
 
     # If Lev is given as part of `location`, use it; otherwise, use the highest available
-    lev_numbers = sorted({lev for f in files if (lev:=lev_number(f))})
-    if input_lev_number is not None and lev_numbers:
-        if input_lev_number not in lev_numbers:
-            raise ValueError(
-                f"Lev number '{input_lev_number}' not found in simulation files for {sxs_id}"
-            )
-    max_lev_number = max(lev_numbers, default=np.nan)
+    lev_numbers = metadata.get(
+        "lev_numbers",
+        sorted({lev_num for f in metadata.get("files", []) if (lev_num:=lev_number(f))})
+    )
+    if not lev_numbers:
+        raise ValueError(f"Could not find Levs for {location}")
+    if input_lev_number is not None and input_lev_number not in lev_numbers:
+        raise ValueError(
+            f"Lev number '{input_lev_number}' not found in simulation files for {sxs_id}"
+        )
+    max_lev_number = max(lev_numbers)
     output_lev_number = input_lev_number or max_lev_number
+    if output_lev_number is None:
+        raise ValueError(
+            f"No Lev number found for {location}"
+        )
     location = f"{sxs_id_stem}{version}/Lev{output_lev_number}"
 
     # Keep the metadata around unless we're asking for an old version
     # or a less-than-maximal Lev
     if (
-        version != latest_version
+        version_is_not_default
         or (lev_numbers and output_lev_number != max_lev_number)
     ):
         metadata = None
@@ -462,9 +501,9 @@ class SimulationBase:
     def metadata_path(self):
         for separator in [":", "/"]:
             for ending in [".json", ".txt"]:
-                prefix = f"{self.lev}{separator}" if self.lev else ""
-                if (fn := f"{prefix}metadata{ending}") in self.files:
-                    return fn
+                for prefix in ["", f"{self.lev}{separator}" if self.lev else ""]:
+                    if (fn := f"{prefix}metadata{ending}") in self.files:
+                        return fn
         raise ValueError(
             f"Metadata file not found in simulation files for {self.location}"
         )
@@ -758,50 +797,29 @@ class Simulation_v1(SimulationBase):
 
     @property
     def horizons_path(self):
-        prefix = f"{self.lev}/" if self.lev else ""
-        return f"{prefix}Horizons.h5"
-    
-    def load_horizons(self):
-        from .. import load
-        sxs_id_path = Path(self.sxs_id)
-        horizons_path = self.horizons_path
-        if horizons_path in self.files:
-            horizons_location = self.files.get(horizons_path)["link"]
-        else:
-            # Some simulations used the SXS ID as a prefix in file paths
-            # within the Zenodo upload in version 1.x of the catalog.
-            if (extended_horizons_path := f"{self.sxs_id_stem}/{horizons_path}") in self.files:
-                horizons_location = self.files.get(extended_horizons_path)["link"]
-            else:
-                raise ValueError(
-                    f"File '{horizons_path}' not found in simulation files for {self.location}"
-                )
-        horizons_truepath = Path(sxs_path_to_system_path(sxs_id_path / horizons_path))
-        return load(horizons_location, truepath=horizons_truepath)
+        return search_prefixes("Horizons.h5", self.lev, self.files)
 
     @property
     def strain_path(self):
-        prefix = f"{self.lev}/" if self.lev else ""
         extrapolation = (
             f"Extrapolated_{self.extrapolation}.dir"
             if self.extrapolation != "Outer"
             else "OutermostExtraction.dir"
         )
         return (
-            f"{prefix}rhOverM_Asymptotic_GeometricUnits_CoM.h5",
+            search_prefixes("rhOverM_Asymptotic_GeometricUnits_CoM.h5", self.lev, self.files),
             extrapolation
         )
 
     @property
     def psi4_path(self):
-        prefix = f"{self.lev}/" if self.lev else ""
         extrapolation = (
             f"Extrapolated_{self.extrapolation}.dir"
             if self.extrapolation != "Outer"
             else "OutermostExtraction.dir"
         )
         return (
-            f"{prefix}rMPsi4_Asymptotic_GeometricUnits_CoM.h5",
+            search_prefixes("rMPsi4_Asymptotic_GeometricUnits_CoM.h5", self.lev, self.files),
             extrapolation
         )
 
@@ -848,14 +866,12 @@ class Simulation_v2(SimulationBase):
 
     @property
     def horizons_path(self):
-        prefix = f"{self.lev}:" if self.lev else ""
-        return f"{prefix}Horizons.h5"
+        return search_prefixes("Horizons.h5", self.lev, self.files)
 
     @property
     def strain_path(self):
-        prefix = f"{self.lev}:" if self.lev else ""
         return (
-            f"{prefix}Strain_{self.extrapolation}",
+            search_prefixes(f"Strain_{self.extrapolation}", self.lev, self.files, ".h5"),
             "/"
         )
 
@@ -866,9 +882,9 @@ class Simulation_v2(SimulationBase):
             if self.extrapolation != "Outer"
             else "OutermostExtraction.dir"
         )
-        prefix = f"{self.lev}:" if self.lev else ""
+        prefix = f"{self.lev}:" if len(self.lev_numbers)>1 else ""
         return (
-            f"{prefix}ExtraWaveforms",
+            search_prefixes(f"ExtraWaveforms", self.lev, self.files, ".h5"),
             f"/rMPsi4_Asymptotic_GeometricUnits_CoM_Mem/{extrapolation}"
         )
 
@@ -905,20 +921,18 @@ class Simulation_v3(Simulation_v2):
 
     @property
     def strain_path(self):
-        prefix = f"{self.lev}:" if self.lev else ""
         return (
-            f"{prefix}Strain_{self.extrapolation}",
+            search_prefixes(f"Strain_{self.extrapolation}", self.lev, self.files, ".h5"),
             "/"
         ) if self.extrapolation == self.default_extrapolation else (
-            f"{prefix}ExtraWaveforms",
+            search_prefixes("ExtraWaveforms", self.lev, self.files, ".h5"),
             f"/Strain_{self.extrapolation}.dir"
         )
 
     @property
     def psi4_path(self):
-        prefix = f"{self.lev}:" if self.lev else ""
         return (
-            f"{prefix}ExtraWaveforms",
+            search_prefixes("ExtraWaveforms", self.lev, self.files, ".h5"),
             f"/Psi4_{self.extrapolation}.dir"
         )
 

{sxs-2025.0.6 → sxs-2025.0.7}/tests/conftest.py

@@ -44,19 +44,29 @@ def pytest_addoption(parser):
                      help="Maximum ell value to test with slow tests")
     parser.addoption("--run_slow_tests", action="store_true", default=False,
                      help="Run all tests, including slow ones")
+    parser.addoption("--run_many_downloads", action="store_true", default=False,
+                     help="Run tests marked with @many_downloads")
 
 
 def pytest_configure(config):
     config.addinivalue_line("markers", "slow: marks tests as slow")
 
 
+def pytest_configure(config):
+    config.addinivalue_line("markers", "many_downloads: marks tests that require many downloads")
+
+
 def pytest_collection_modifyitems(config, items):
-    if config.getoption("--run_slow_tests"):
-        return
-    skip_slow = pytest.mark.skip(reason="need --run_slow_tests option to run")
-    for item in items:
-        if "slow" in item.keywords:
-            item.add_marker(skip_slow)
+    if not config.getoption("--run_slow_tests"):
+        skip_slow = pytest.mark.skip(reason="need --run_slow_tests option to run")
+        for item in items:
+            if "slow" in item.keywords:
+                item.add_marker(skip_slow)
+    if not config.getoption("--run_many_downloads"):
+        skip_many_downloads = pytest.mark.skip(reason="need --run_many_downloads option to run")
+        for item in items:
+            if "many_downloads" in item.keywords:
+                item.add_marker(skip_many_downloads)
 
 
 def pytest_runtest_setup(item):

{sxs-2025.0.6 → sxs-2025.0.7}/tests/test_horizons.py

@@ -68,5 +68,5 @@ def test_horizon_existence():
     assert bhns_horizon.B is None
     assert bhns_horizon.C is None
     nsns = sxs.load("SXS:NSNS:0001", auto_supersede=True)
-    with pytest.raises(ValueError, match="File '.*?' not found in simulation files for"):
+    with pytest.raises(ValueError, match="Horizons.h5 not found in any form in files"):
         nsns_horizon = nsns.horizons

sxs-2025.0.7/tests/test_simulation.py

@@ -0,0 +1,236 @@
+import pytest
+import sxs
+from .conftest import skip_macOS_GH_actions_downloads
+
+@pytest.mark.xfail(reason="Missing files in the catalog should be updated soon")
+def test_catalog_file_sizes():
+    simulations = sxs.load("simulations")
+    success = True
+    missing_files = ""
+    for sxs_id, metadata in simulations.items():
+        for filename, fileinfo in metadata.get("files", {}).items():
+            if fileinfo.get("size", 0) < 500:
+                missing_files += f"{sxs_id} {filename}\n"
+                success = False
+    if not success:
+        print("\nThe following files are missing or suspiciously small:")
+        print(missing_files)
+    assert success
+
+
+@skip_macOS_GH_actions_downloads
+def test_sxs_load_v2():
+    # We'll use SXS:BBH:0001, even though it's deprecated, because we
+    # want to be sure that it always exists, and is accessible as a
+    # v2.0 record.
+    with pytest.warns(UserWarning):
+        s = sxs.load("SXS:BBH:0001v2.0")
+    assert s.sxs_id_stem == "SXS:BBH:0001"
+    assert s.version == "v2.0"
+    s.h
+    s.strain
+    s.H
+    s.Strain
+    s.horizons
+    s.Horizons
+    s.psi4
+    s.Psi4
+
+
+@skip_macOS_GH_actions_downloads
+def test_sxs_load_v2_levs():
+    # Check that a bad Lev raises an error
+    with pytest.raises(ValueError):
+        sxs.load("SXS:BBH:1001v2.0/Lev189", ignore_deprecation=True)
+    # Check that the default Lev works, and different Levs produce different metadata
+    assert (
+        sxs.load("SXS:BBH:1001v2.0").metadata.reference_time
+        == sxs.load("SXS:BBH:1001v2.0/Lev3").metadata.reference_time
+    )
+    assert (
+        sxs.load("SXS:BBH:1001v2.0/Lev1").metadata.reference_time
+        != sxs.load("SXS:BBH:1001v2.0/Lev3").metadata.reference_time
+    )
+    for lev, lev_number in [("", 3), ("/Lev3", 3), ("/Lev2", 2), ("/Lev1", 1)]:
+        s = sxs.load(f"SXS:BBH:1001v2.0{lev}", ignore_deprecation=True)
+        assert s.sxs_id_stem == "SXS:BBH:1001"
+        assert s.version == "v2.0"
+        assert s.lev_number == lev_number
+        s.h
+        s.strain
+        s.H
+        s.Strain
+        s.horizons
+        s.Horizons
+
+
+@skip_macOS_GH_actions_downloads
+def test_sxs_load_v3():
+    # # This is necessary only after the deprecation of SXS:BBH:4000v3.0
+    # with pytest.warns(UserWarning):
+    #     s = sxs.load("SXS:BBH:4000v3.0")
+    s = sxs.load("SXS:BBH:4000v3.0")
+    assert s.sxs_id_stem == "SXS:BBH:4000"
+    assert s.version == "v3.0"
+    s.h
+    s.strain
+    s.H
+    s.Strain
+    s.horizons
+    s.Horizons
+    s.psi4
+    s.Psi4
+
+
+@skip_macOS_GH_actions_downloads
+def test_sxs_load_v3_levs():
+    # Check that a bad Lev raises an error
+    with pytest.raises(ValueError):
+        sxs.load("SXS:BBH:4000v3.0/Lev189", ignore_deprecation=True)
+    # Check that the default Lev works, and different Levs produce different metadata
+    assert (  # Check that the default Lev loads the highest Lev
+        sxs.load("SXS:BBH:4000v3.0", ignore_deprecation=True).metadata.reference_time
+        == sxs.load("SXS:BBH:4000v3.0/Lev3", ignore_deprecation=True).metadata.reference_time
+    )
+    assert (  # Check that different Levs have different reference times
+        sxs.load("SXS:BBH:4000v3.0/Lev1", ignore_deprecation=True).metadata.reference_time
+        != sxs.load("SXS:BBH:4000v3.0/Lev3", ignore_deprecation=True).metadata.reference_time
+    )
+    for lev, lev_number in [("", 3), ("/Lev3", 3), ("/Lev2", 2), ("/Lev1", 1)]:
+        s = sxs.load(f"SXS:BBH:4000v3.0{lev}", ignore_deprecation=True)
+        assert s.sxs_id_stem == "SXS:BBH:4000"
+        assert s.version == "v3.0"
+        assert s.lev_number == lev_number
+        s.h
+        s.strain
+        s.H
+        s.Strain
+        s.horizons
+        s.Horizons
+
+
+@pytest.mark.many_downloads  # runs only with pytest flag ` --run_many_downloads`
+def test_sxs_load_v3_catalog():
+    # This test goes right up to the point of loading every simulation
+    # at each Lev with each extrapolation order, but doesn't download
+    # any data
+    from pathlib import Path
+
+    def fake_load_metadata(self):
+        metadata_path = self.metadata_path
+        if metadata_path not in self.files:
+            return False
+        if "link" not in self.files[metadata_path]:
+            return False
+        if self.files[metadata_path].get("size", 0) < 500:
+            return False
+        return True
+
+    def fake_load_horizons(self):
+        horizons_path = self.horizons_path
+        if horizons_path in self.files:
+            if "link" not in self.files[horizons_path]:
+                return False
+        else:
+            # Some simulations used the SXS ID as a prefix in file paths
+            # within the Zenodo upload in version 1.x of the catalog.
+            if (extended_location := f"{self.sxs_id_stem}/{horizons_path}") in self.files:
+                if "link" not in self.files[extended_location]:
+                    return False
+                elif self.files[extended_location].get("size", 0) < 500:
+                    return False
+            else:
+                return False
+        return True
+
+    def fake_load_waveform(self, file_name, group):
+        file_name = Path(file_name)
+        h5_path = str(file_name.with_suffix(".h5"))
+        json_path = str(file_name.with_suffix(".json"))
+        return bool(
+            self.files.get(h5_path, {}).get("link", False)
+            and self.files.get(h5_path, {}).get("size", 0) > 500
+            and self.files.get(json_path, {}).get("link", False)
+            and self.files.get(json_path, {}).get("size", 0) > 500
+        )
+
+    simulations = sxs.load("simulations")
+
+    success = True
+    for sxs_id, metadata in simulations.items():
+        if "NSNS" in sxs_id or "BHNS" in sxs_id:
+            continue
+
+        sim = sxs.load(sxs_id, ignore_deprecation=True)
+        if sim.version != "v3.0":
+            # print(
+            #     f"Skipping {sxs_id} because its version is {sim.version} != v3.0"
+            # )
+            continue
+
+        for lev_number in metadata["lev_numbers"]:
+            for extrapolation in ["Outer", "N2", "N3", "N4"]:
+                sim = sxs.load(
+                    f"{sxs_id}/Lev{lev_number}",
+                    extrapolation=extrapolation,
+                    ignore_deprecation=True,
+                )
+
+                if not fake_load_metadata(sim):
+                    print(f"Failed to load {sxs_id}/Lev{lev_number} {extrapolation} metadata")
+                    success = False
+
+                if not fake_load_horizons(sim):
+                    print(f"Failed to load {sxs_id}/Lev{lev_number} {extrapolation} horizons")
+                    success = False
+
+                if not fake_load_waveform(sim, *sim.strain_path):
+                    print(f"Failed to load {sxs_id}/Lev{lev_number} {extrapolation} strain")
+                    success = False
+
+                if not fake_load_waveform(sim, *sim.psi4_path):
+                    print(f"Failed to load {sxs_id}/Lev{lev_number} {extrapolation} psi4")
+                    success = False
+
+    assert success
+
+
+@skip_macOS_GH_actions_downloads
+@pytest.mark.parametrize("loader", [sxs.Simulation, sxs.load])
+def test_superseding(loader):
+    simulation = "SXS:BBH:0001"
+
+    # No version, no arguments
+    with pytest.raises(ValueError):
+        loader(f"{simulation}")
+
+    # Version, no arguments
+    with pytest.warns(UserWarning):
+        s = loader(f"{simulation}v2.0")
+    assert s.sxs_id_stem == simulation
+
+    # No version, ignore_deprecation
+    s = loader(f"{simulation}", ignore_deprecation=True)
+    assert s.sxs_id_stem == simulation
+
+    # Version, ignore_deprecation
+    s = loader(f"{simulation}v2.0", ignore_deprecation=True)
+    assert s.sxs_id_stem == simulation
+
+    # No version, auto_supersede
+    with pytest.warns(UserWarning):
+        s = loader(f"{simulation}", auto_supersede=True)
+    assert s.sxs_id_stem != simulation
+
+    # Version, auto_supersede
+    with pytest.warns(UserWarning):
+        s = loader(f"{simulation}v2.0", auto_supersede=True)
+    assert s.sxs_id_stem == simulation
+
+    # No version, ignore_deprecation, auto_supersede
+    s = loader(f"{simulation}", ignore_deprecation=True, auto_supersede=True)
+    assert s.sxs_id_stem == simulation
+
+    # Version, ignore_deprecation, auto_supersede
+    s = loader(f"{simulation}v2.0", ignore_deprecation=True, auto_supersede=True)
+    assert s.sxs_id_stem == simulation

sxs-2025.0.6/sxs/__version__.py

@@ -1 +0,0 @@
-__version__ = "2025.0.6"

sxs-2025.0.6/tests/test_simulation.py

@@ -1,135 +0,0 @@
-import pytest
-import sxs
-from .conftest import skip_macOS_GH_actions_downloads
-
-
-@skip_macOS_GH_actions_downloads
-def test_sxs_load_v2():
-    # We'll use SXS:BBH:0001, even though it's deprecated, because we
-    # want to be sure that it always exists, and is accessible as a
-    # v2.0 record.
-    with pytest.warns(UserWarning):
-        s = sxs.load("SXS:BBH:0001v2.0")
-    assert s.sxs_id_stem == "SXS:BBH:0001"
-    assert s.version == "v2.0"
-    s.h
-    s.strain
-    s.H
-    s.Strain
-    s.horizons
-    s.Horizons
-    s.psi4
-    s.Psi4
-
-
-@skip_macOS_GH_actions_downloads
-def test_sxs_load_v2_levs():
-    # Check that a bad Lev raises an error
-    with pytest.raises(ValueError):
-        sxs.load("SXS:BBH:1001v2.0/Lev189", ignore_deprecation=True)
-    # Check that the default Lev works, and different Levs produce different metadata
-    assert (
-        sxs.load("SXS:BBH:1001v2.0").metadata.reference_time
-        == sxs.load("SXS:BBH:1001v2.0/Lev3").metadata.reference_time
-    )
-    assert (
-        sxs.load("SXS:BBH:1001v2.0/Lev1").metadata.reference_time
-        != sxs.load("SXS:BBH:1001v2.0/Lev3").metadata.reference_time
-    )
-    for lev, lev_number in [("", 3), ("/Lev3", 3), ("/Lev2", 2), ("/Lev1", 1)]:
-        s = sxs.load(f"SXS:BBH:1001v2.0{lev}", ignore_deprecation=True)
-        assert s.sxs_id_stem == "SXS:BBH:1001"
-        assert s.version == "v2.0"
-        assert s.lev_number == lev_number
-        s.h
-        s.strain
-        s.H
-        s.Strain
-        s.horizons
-        s.Horizons
-
-
-@skip_macOS_GH_actions_downloads
-def test_sxs_load_v3():
-    # # This is necessary only after the deprecation of SXS:BBH:4000v3.0
-    # with pytest.warns(UserWarning):
-    #     s = sxs.load("SXS:BBH:4000v3.0")
-    s = sxs.load("SXS:BBH:4000v3.0")
-    assert s.sxs_id_stem == "SXS:BBH:4000"
-    assert s.version == "v3.0"
-    s.h
-    s.strain
-    s.H
-    s.Strain
-    s.horizons
-    s.Horizons
-    s.psi4
-    s.Psi4
-
-
-@skip_macOS_GH_actions_downloads
-def test_sxs_load_v3_levs():
-    # Check that a bad Lev raises an error
-    with pytest.raises(ValueError):
-        sxs.load("SXS:BBH:4000v3.0/Lev189", ignore_deprecation=True)
-    # Check that the default Lev works, and different Levs produce different metadata
-    assert (
-        sxs.load("SXS:BBH:4000v3.0").metadata.reference_time
-        == sxs.load("SXS:BBH:4000v3.0/Lev3").metadata.reference_time
-    )
-    assert (
-        sxs.load("SXS:BBH:4000v3.0/Lev1").metadata.reference_time
-        != sxs.load("SXS:BBH:4000v3.0/Lev3").metadata.reference_time
-    )
-    for lev, lev_number in [("", 3), ("/Lev3", 3), ("/Lev2", 2), ("/Lev1", 1)]:
-        s = sxs.load(f"SXS:BBH:4000v3.0{lev}", ignore_deprecation=True)
-        assert s.sxs_id_stem == "SXS:BBH:4000"
-        assert s.version == "v3.0"
-        assert s.lev_number == lev_number
-        s.h
-        s.strain
-        s.H
-        s.Strain
-        s.horizons
-        s.Horizons
-
-
-@skip_macOS_GH_actions_downloads
-@pytest.mark.parametrize("loader", [sxs.Simulation, sxs.load])
-def test_superseding(loader):
-    simulation = "SXS:BBH:0001"
-
-    # No version, no arguments
-    with pytest.raises(ValueError):
-        loader(f"{simulation}")
-
-    # Version, no arguments
-    with pytest.warns(UserWarning):
-        s = loader(f"{simulation}v2.0")
-    assert s.sxs_id_stem == simulation
-
-    # No version, ignore_deprecation
-    s = loader(f"{simulation}", ignore_deprecation=True)
-    assert s.sxs_id_stem == simulation
-
-    # Version, ignore_deprecation
-    s = loader(f"{simulation}v2.0", ignore_deprecation=True)
-    assert s.sxs_id_stem == simulation
-
-    # No version, auto_supersede
-    with pytest.warns(UserWarning):
-        s = loader(f"{simulation}", auto_supersede=True)
-    assert s.sxs_id_stem != simulation
-
-    # Version, auto_supersede
-    with pytest.warns(UserWarning):
-        s = loader(f"{simulation}v2.0", auto_supersede=True)
-    assert s.sxs_id_stem == simulation
-
-    # No version, ignore_deprecation, auto_supersede
-    s = loader(f"{simulation}", ignore_deprecation=True, auto_supersede=True)
-    assert s.sxs_id_stem == simulation
-
-    # Version, ignore_deprecation, auto_supersede
-    s = loader(f"{simulation}v2.0", ignore_deprecation=True, auto_supersede=True)
-    assert s.sxs_id_stem == simulation