cleanup

Signed-off-by: Callan Gray <cal.j.gray@gmail.com>

Author: calgray

astropy_xarray/__init__.py

@@ -17,7 +17,7 @@
 
 import astropy.units
 
-import astropy_xarray.time_compat
+import astropy_xarray.time_compat  # noqa: F401
 from astropy_xarray import accessors, formatting, testing  # noqa: F401
 from astropy_xarray.index import AstropyIndex
 

astropy_xarray/coordinates/sky_coord.py

@@ -1,6 +1,5 @@
 import itertools
 from collections.abc import Generator
-from enum import Enum, auto
 
 import astropy.units as u
 import numpy as np
@@ -10,35 +9,6 @@
 from astropy_xarray.coordinates.frame import dump_frame, load_frame, load_representation
 
 
-class DatasetRepresentation(Enum):
-    FRAME = auto()
-    """
-    Frame selected repesentation and differential component names, simplifying for any `unitspherical` types in data.
-
-    Same as `get_representation_component_names()` and `get_differential_component_names()`
-    """
-
-    FRAME_FULL = auto()
-    """
-    Frame selected repesentation and differential component names.
-
-    Same as `get_representation_component_names()` and `get_differential_component_names()`
-    """
-
-    FRAME_DEFAULT = auto()
-    """Frame default components names."""
-
-    FRAME_DATA = auto()
-    """
-    Frame component names from resetting the display representation and differential to match the data.
-
-    Guarentees roundtrip accuracy.
-    """
-
-    DATA = auto()
-    """Data representation components. Guarentees roundtrip accuracy."""
-
-
 def _skycoord_representation_component_names(
     skycoord: SkyCoord,
 ) -> tuple[str, ...]:

astropy_xarray/tests/multi_index_utils.py

@@ -1,3 +1,5 @@
+from importlib.metadata import version
+
 import astropy.units as u
 import numpy.testing
 import pytest
@@ -7,6 +9,7 @@
     SkyCoord,
 )
 from astropy.coordinates.builtin_frames import ICRS
+from packaging.version import Version
 
 from astropy_xarray.coordinates import (
     skycoord_to_dataset,
@@ -41,7 +44,10 @@ def test_frame_conversion_aliasing():
     numpy.testing.assert_array_equal(sc.pm_ra_cosdec, sc2.pm_ra_cosdec)
 
 
-@pytest.mark.xfail(reason="astropy 6.0.0 skycoords not supported")
+@pytest.mark.xfail(
+    condition=Version(version("astropy")) <= Version("7.0.0"),
+    reason="astropy 6.0.0 skycoords not supported",
+)
 def test_frame_conversion_components():
     sc = SkyCoord(
         ICRS().realize_frame(

astropy_xarray/tests/test_frame_rep.py …py_xarray/tests/test_frame_conversion.pyastropy_xarray/tests/test_frame_rep.py renamed to astropy_xarray/tests/test_frame_conversion.py astropy_xarray/tests/test_frame_rep.py renamed to astropy_xarray/tests/test_frame_conversion.py

@@ -1,5 +1,4 @@
-from collections.abc import Generator
-from typing import Any
+import sys
 
 import astropy.units as u
 import numpy as np
@@ -47,18 +46,21 @@
     Supergalactic,
 )
 from astropy.time import Time
-from xarray.tests import requires_zarr
 
 from astropy_xarray.coordinates import (
     dataset_to_skycoord,
     skycoord_to_dataset,
 )
 from astropy_xarray.coordinates.sky_coord import (
-    DatasetRepresentation,
     _skycoord_differential_component_names,
     _skycoord_representation_component_names,
 )
 
+pytestmark = pytest.mark.skipif(
+    sys.version_info < (3, 11),
+    reason="python3.10 or higher required for skycoords support",
+)
+
 
 @pytest.mark.parametrize(
     ("expected_base", "expected_s"),
@@ -84,26 +86,15 @@ def test_unitspherical_repr_components(expected_base, expected_s):
 
 
 @pytest.mark.parametrize(
-    ("representation", "expected_base", "expected_s"),
+    ("expected_base", "expected_s"),
     [
         (
-            DatasetRepresentation.FRAME,
             ("ra", "dec", "distance"),
             ("pm_ra_cosdec", "pm_dec"),
-        ),
-        (
-            DatasetRepresentation.FRAME_DEFAULT,
-            ("ra", "dec", "distance"),
-            ("pm_ra_cosdec", "pm_dec", "radial_velocity"),
-        ),
-        (
-            DatasetRepresentation.DATA,
-            ("lon", "lat", "distance"),
-            ("d_lon_coslat", "d_lat"),
-        ),
+        )
     ],
 )
-def test_unitspherical_diff_components(representation, expected_base, expected_s):
+def test_unitspherical_diff_components(expected_base, expected_s):
     sc = SkyCoord(
         ra=[[0.1], [2], [0.2]] * u.deg,
         dec=[[0.5], [7], [0.7]] * u.deg,
@@ -118,31 +109,26 @@ def test_unitspherical_diff_components(representation, expected_base, expected_s
 
 
 @pytest.mark.parametrize(
-    ("representation", "frame", "expected_base", "expected_s"),
+    ("frame", "expected_base", "expected_s"),
     [
         (
-            DatasetRepresentation.FRAME_DATA,
             ICRS(),
             ("ra", "dec"),
             ("pm_ra_cosdec", "pm_dec"),
         ),
         (
-            DatasetRepresentation.FRAME_DATA,
             AltAz(),
             ("az", "alt"),
             ("pm_az_cosalt", "pm_alt"),
         ),
         (
-            DatasetRepresentation.FRAME_DATA,
             ITRS(),
             ("lon", "lat"),
             ("pm_lon_coslat", "pm_lat"),
         ),
     ],
 )
-def test_spherical_direction_components_realize_frame(
-    representation, frame, expected_base, expected_s
-):
+def test_spherical_direction_components_realize_frame(frame, expected_base, expected_s):
     rep = UnitSphericalRepresentation(
         [[0.1], [2], [0.2]] * u.deg,
         [[0.5], [7], [0.7]] * u.deg,
@@ -157,12 +143,12 @@ def test_spherical_direction_components_realize_frame(
 
 
 @pytest.mark.parametrize(
-    ("representation", "expected_base", "expected_s"),
+    ("expected_base", "expected_s"),
     [
-        (DatasetRepresentation.FRAME_DATA, ("x", "y", "z"), ("v_x", "v_y", "v_z")),
+        (("x", "y", "z"), ("v_x", "v_y", "v_z")),
     ],
 )
-def test_cartesian_direction_components(representation, expected_base, expected_s):
+def test_cartesian_direction_components(expected_base, expected_s):
     sc = SkyCoord(
         x=[[0.1], [2], [0.2]] * u.dimensionless_unscaled,
         y=[[0.5], [7], [0.7]] * u.dimensionless_unscaled,
@@ -176,20 +162,11 @@ def test_cartesian_direction_components(representation, expected_base, expected_
     assert _skycoord_differential_component_names(sc) == expected_s
 
 
-@pytest.fixture(name="store", scope="session")
-def store_fixture() -> Generator[Any, None, None]:
-    import zarr.storage as zs
-
-    with zs.MemoryStore() as store:
-        yield store
-
-
-@requires_zarr
 @pytest.mark.parametrize(
-    "representation",
+    "use_default_representation",
     [
-        pytest.param(DatasetRepresentation.FRAME_DATA),
-        pytest.param(DatasetRepresentation.FRAME_DEFAULT),
+        pytest.param(True),
+        pytest.param(False),
     ],
 )
 @pytest.mark.parametrize(
@@ -308,37 +285,29 @@ def store_fixture() -> Generator[Any, None, None]:
     ids=lambda param: param.name,
 )
 def test_skycoord_roundtrip(
-    store,
     frame: BaseCoordinateFrame,
     data: BaseRepresentation,
     expected_data_classes: tuple[type, ...],
-    representation: DatasetRepresentation,
+    use_default_representation: bool,
 ):
     # all frames support all representation types
     representation_type = type(data)
     differential_type = type(data.differentials["s"])
 
-    if representation == DatasetRepresentation.FRAME_DATA:
-        expected = SkyCoord(frame.realize_frame(data))
-    elif representation == DatasetRepresentation.FRAME_DEFAULT:
+    if use_default_representation:
         expected = SkyCoord(
             frame.realize_frame(
                 data.represent_as(
                     frame.default_representation, frame.default_differential
                 )
             )
         )
-    else:
-        raise NotImplementedError()
-
-    if representation == DatasetRepresentation.FRAME_DEFAULT:
         expected_frame_data_rep_name = frame.default_representation.name
         expected_frame_data_diff_name = frame.default_differential.name
-    elif representation == DatasetRepresentation.FRAME_DATA:
+    else:
+        expected = SkyCoord(frame.realize_frame(data))
         expected_frame_data_rep_name = representation_type.name
         expected_frame_data_diff_name = differential_type.name
-    else:
-        raise NotImplementedError()
 
     assert expected.frame.data.name == expected_frame_data_rep_name
     assert expected.frame.data.differentials["s"].name == expected_frame_data_diff_name
@@ -360,46 +329,9 @@ def test_skycoord_roundtrip(
     )
     assert set(ds.data_vars) == expected_keys
 
-    # data_var value types
-    if representation in (
-        DatasetRepresentation.FRAME,
-        DatasetRepresentation.FRAME_DEFAULT,
-    ):
-        print(expected_keys)
-    elif representation == DatasetRepresentation.DATA:
-        expected_classes = zip(
-            expected.get_representation_component_names(), expected_data_classes
-        )
-        for expected_key, expected_class_type in expected_classes:
-            assert isinstance(ds.data_vars[expected_key].data, expected_class_type)
-            assert ds.data_vars[expected_key].coords.identical(
-                xr.Coordinates(dict(coords))
-            )
-
-        # sanity check dataset
-        assert ds.attrs["frame"]["representation_type"] == representation_type.name
-        assert ds.attrs["frame"]["differential_type"] == differential_type.name
-        assert ds.attrs["frame"]["data"]["representation_type"] == data.name
-        assert (
-            ds.attrs["frame"]["data"]["differential_type"]
-            == data.differentials["s"].name
-        )
-
     # Convert back
     actual = dataset_to_skycoord(ds)
 
-    # check representations
-    if representation in (
-        DatasetRepresentation.FRAME,
-        DatasetRepresentation.FRAME_DEFAULT,
-    ):
-        print(actual)
-    if representation == DatasetRepresentation.DATA:
-        assert actual.representation_type.name == representation_type.name
-        assert actual.differential_type.name == differential_type.name
-        assert actual.frame.data.name == data.name
-        assert actual.frame.data.differentials["s"].name == data.differentials["s"].name
-
     # Check Representation
     for component_name in actual.frame.representation_component_names:
         np.testing.assert_array_equal(
@@ -418,10 +350,3 @@ def test_skycoord_roundtrip(
     assert actual.is_equivalent_frame(expected)
     assert ds.coords.equals(xr.Coordinates(dict(coords)))
     np.testing.assert_array_equal(actual, expected)
-
-    # Check intermediate dataset is serializable
-    # ds.astropy.dequantify().to_zarr(store, mode="w", consolidated=True)
-    # ds_store = xr.open_dataset(
-    #     store, engine="zarr", consolidated=True
-    # ).astropy.quantify()
-    # xr.testing.assert_identical(ds, ds_store)