astropy 7.2.1__tar.gz → 7.2.2__tar.gz

{astropy-7.2.1 → astropy-7.2.2}/.pre-commit-config.yaml

@@ -35,6 +35,10 @@ repos:
       - id: end-of-file-fixer
         # Makes sure files end in a newline and only a newline.
         exclude: ".*(data.*|extern.*|licenses.*|_static.*|_parsetab.py)$"
+      - id: mixed-line-ending
+        args: ["--fix=lf"]
+        # Forces all text files to use LF line endings.
+        exclude: ".*(data.*|extern.*|licenses.*|_static.*|_parsetab.py)$"
       # - id: fix-encoding-pragma  # covered by pyupgrade
       - id: trailing-whitespace
         # Trims trailing whitespace.

{astropy-7.2.1 → astropy-7.2.2}/CHANGES.rst

@@ -1,3 +1,49 @@
+Version v7.2.2 (2026-07-03)
+===========================
+
+API Changes
+-----------
+
+astropy.utils
+^^^^^^^^^^^^^
+
+- Astropy will now no longer download the latest IERS-A table over the network unless it is actually needed, and will also not warn about download issues unless all mirrors fail. The ``IERS_Auto.open`` method now always reads the table bundled in ``astropy-iers-data`` (or a ``finals2000A.all`` file in the current working directory, if present), and the auto-download is deferred until a calculation actually requests ``UT1-UTC`` or polar motion values beyond the predictive range of the bundled table while that table is older than ``astropy.utils.iers.conf.auto_max_age`` days. This avoids network access, and the associated warnings when offline, in the common case where the bundled table is recent enough. [#19995]
+
+
+Bug Fixes
+---------
+
+astropy.modeling
+^^^^^^^^^^^^^^^^
+
+- Bugfix for a ``Parameter`` with a custom ``getter`` / ``setter`` pair raising an
+  ``AttributeError`` when accessing the ``value`` of the ``Parameter`` before any
+  value for the parameter has been set. The ``Parameter`` will now return the result
+  of the ``getter`` applied to a ``nan`` value in this case which is consistent
+  with the behavior of a ``Parameter`` without a custom ``getter`` / ``setter`` pair. [#19979]
+
+astropy.table
+^^^^^^^^^^^^^
+
+- Fixed a bug where a ``Table.loc[]`` range query using the default
+  ``SortedArray`` index engine silently dropped rows when the upper bound
+  matched a value that appears more than once in the indexed column. [#19903]
+
+- Fixed a bug where a ``Table.loc[]`` range query using the ``BST`` index
+  engine returned rows in scrambled order if rows had been added after the
+  index was created. [#19912]
+
+astropy.units
+^^^^^^^^^^^^^
+
+- Fixed a bug where ``numpy.lib.recfunctions.structured_to_unstructured`` failed when applied to a ``StructuredQuantity`` by improving unit extraction logic. [#19106]
+
+astropy.wcs
+^^^^^^^^^^^
+
+- Fix caching of ``wcs.world_axis_object_components`` and ``world_axis_object_classes`` in cases where the equinox was NaN [#19898]
+
+
 Version 7.2.1 (2026-06-16)
 ==========================
 

{astropy-7.2.1 → astropy-7.2.2}/CITATION.cff

@@ -685,6 +685,7 @@ preferred-citation:
   issue: 2
   pages: 20
   year: 2022
+  doi: 10.3847/1538-4357/ac7c74
   identifiers:
     - description: ADS bibcode
       type: url

{astropy-7.2.1 → astropy-7.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astropy
-Version: 7.2.1
+Version: 7.2.2
 Summary: Astronomy and astrophysics core library
 Author-email: The Astropy Developers <astropy.team@gmail.com>
 License-Expression: BSD-3-Clause
@@ -37,7 +37,7 @@ License-File: licenses/PYFITS.rst
 License-File: licenses/PYTHON.rst
 License-File: licenses/README.rst
 License-File: licenses/WCSLIB_LICENSE.rst
-Requires-Dist: astropy-iers-data>=0.2026.6.1.17.39.59
+Requires-Dist: astropy-iers-data>=0.2026.6.22.1.23.34
 Requires-Dist: numpy<2.7,>=1.24
 Requires-Dist: packaging>=22.0.0
 Requires-Dist: pyerfa>=2.0.1.1

{astropy-7.2.1 → astropy-7.2.2}/astropy/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '7.2.1'
-__version_tuple__ = version_tuple = (7, 2, 1)
+__version__ = version = '7.2.2'
+__version_tuple__ = version_tuple = (7, 2, 2)
 
-__commit_id__ = commit_id = 'g6754556ce'
+__commit_id__ = commit_id = 'gf58189fde'

{astropy-7.2.1 → astropy-7.2.2}/astropy/io/fits/hdu/compressed/tests/test_compressed.py

@@ -306,7 +306,7 @@ class TestCompressedImage(FitsTestCase):
 
         # Try reshaping the data, then closing and reopening the file; let's
         # see if all the changes are preserved properly
-        hdul[1].data.shape = (42, 10)
+        hdul[1].data = hdul[1].data.reshape(42, 10)
         hdul.close()
 
         hdul = fits.open(self.temp("scale.fits"))

{astropy-7.2.1 → astropy-7.2.2}/astropy/modeling/functional_models.py

@@ -383,8 +383,10 @@ class Gaussian2D(Fittable2DModel):
             eig_vals, eig_vecs = np.linalg.eig(cov_matrix)
             if not NUMPY_LT_2_5 or eig_vals.dtype.kind == "c":
                 # in numpy 2.5+, return values are *always* complex
-                assert np.all(eig_vals.imag == 0)
-                assert np.all(eig_vecs.imag == 0)
+                if np.any(eig_vals.imag != 0) or np.any(eig_vecs.imag != 0):
+                    raise TypeError(
+                        "Expected cov_matrix's eigen values to be real. Complex values were found."
+                    )
                 eig_vals = eig_vals.real
                 eig_vecs = eig_vecs.real
 

{astropy-7.2.1 → astropy-7.2.2}/astropy/modeling/parameters.py

@@ -242,6 +242,7 @@ class Parameter:
         # use this to convert to and from the public unit defined for the
         # parameter.
         self._internal_unit = None
+        self._internal_value = None
         if not self._model_required:
             if self._default is not None:
                 self.value = self._default
@@ -780,6 +781,12 @@ def _wrap_ufunc(ufunc):
             orig_unit is the value after the ufunc has been applied
             it is assumed ufunc(raw_unit) == orig_unit
         """
+        # Make sure value is ufunc compatible
+        #   parameters are expected to be real floats
+        # If the value is `None` this will result in a NaN
+        if not isinstance(value, Quantity):
+            value = np.float64(value)
+
         if orig_unit is not None:
             return ufunc(value) * orig_unit
         elif raw_unit is not None:

{astropy-7.2.1 → astropy-7.2.2}/astropy/modeling/tests/test_parameters.py

@@ -743,6 +743,10 @@ class TestParameters:
         assert not isinstance(param.value, np.ndarray)
         assert param.value == 1
 
+        param = Parameter(name="test", setter=setter1, getter=getter1)
+        assert not isinstance(param.value, np.ndarray)
+        assert np.isnan(param.value)
+
     def test_raw_value(self):
         param = Parameter(name="test", default=[1, 2, 3, 4])
 
@@ -848,6 +852,11 @@ class TestParameters:
         param = Parameter(name="test", default=[1, 2, 3, 4] * u.m)
         assert param_repr_oneline(param) == "[1., 2., 3., 4.] m"
 
+    def test_param_repr_getter_no_value(self):
+        """Regression test for #19963"""
+        param = Parameter(name="test", getter=np.deg2rad, setter=np.rad2deg)
+        assert repr(param) == "Parameter('test', value=nan)"
+
     def test_getter_setter(self):
         msg = "setter and getter must both be input"
         with pytest.raises(ValueError, match=msg):

{astropy-7.2.1 → astropy-7.2.2}/astropy/table/bst.py

@@ -451,22 +451,26 @@ class BST:
         return [x for node in nodes for x in node.data]
 
     def _range(self, lower, upper, op1, op2, node, lst):
+        # In-order traversal (left, node, right) so that matching nodes
+        # are collected in ascending key order.
+        if lower < node.key and node.left is not None:
+            self._range(lower, upper, op1, op2, node.left, lst)
         if op1(lower, node.key) and op2(upper, node.key):
             lst.append(node)
         if upper > node.key and node.right is not None:
             self._range(lower, upper, op1, op2, node.right, lst)
-        if lower < node.key and node.left is not None:
-            self._range(lower, upper, op1, op2, node.left, lst)
         return lst
 
     def _same_prefix(self, val, node, lst):
+        # In-order traversal (left, node, right) so that matching nodes
+        # are collected in ascending key order.
         prefix = node.key[: len(val)]
+        if prefix >= val and node.left is not None:
+            self._same_prefix(val, node.left, lst)
         if prefix == val:
             lst.append(node)
         if prefix <= val and node.right is not None:
             self._same_prefix(val, node.right, lst)
-        if prefix >= val and node.left is not None:
-            self._same_prefix(val, node.left, lst)
         return lst
 
     def __repr__(self):

{astropy-7.2.1 → astropy-7.2.2}/astropy/table/sorted_array.py

@@ -93,7 +93,7 @@ class SortedArray:
 
     def find_pos(self, key, data, exact=False):
         """
-        Return the index of the largest key in data greater than or
+        Return the index of the first key in data greater than or
         equal to the given key, data pair.
 
         Parameters
@@ -190,27 +190,40 @@ class SortedArray:
             argument corresponds to an inclusive lower bound,
             and the second argument to an inclusive upper bound.
         """
-        # Find initial positions for lower and upper bounds. Just like a slice object,
-        # None values for `lower` or `upper` correspond to no bound in that direction.
-        lower_pos = 0 if lower is None else self.find_pos(lower, 0)
-        upper_pos = len(self.row_index) if upper is None else self.find_pos(upper, 0)
-
-        if lower_pos == len(self.row_index):
-            return []
-
-        lower_bound = tuple(col[lower_pos] for col in self.cols)
-        if not bounds[0] and lower_bound == lower:
-            lower_pos += 1  # data[lower_pos] > lower
-
-        # data[lower_pos] >= lower
-        # data[upper_pos] >= upper
-        if upper_pos < len(self.row_index):
-            upper_bound = tuple(col[upper_pos] for col in self.cols)
-            if not bounds[1] and upper_bound == upper:
-                upper_pos -= 1  # data[upper_pos] < upper
-            elif upper_bound > upper:
-                upper_pos -= 1  # data[upper_pos] <= upper
-        return self.row_index[lower_pos : upper_pos + 1]
+        n = len(self.row_index)
+
+        def bisect_left(key):
+            # Position of the first entry whose key is >= ``key``.
+            return self.find_pos(key, 0)
+
+        def bisect_right(key):
+            # Position of the first entry whose key is > ``key`` (i.e. just
+            # past the last entry equal to ``key``).
+            if self.unique:
+                pos = self.find_pos(key, 0)
+                if pos < n and tuple(col[pos] for col in self.cols) == key:
+                    pos += 1
+                return pos
+            # For a non-unique index the stored keys include the row number, so
+            # searching with a row number larger than any real row lands just
+            # past the last entry equal to ``key`` (and thus past all duplicates).
+            return self.find_pos(key, n)
+
+        # Compute a half-open range [lower_pos, upper_pos). Just like a slice
+        # object, a None value for `lower` or `upper` means no bound in that
+        # direction. Using bisect_left/bisect_right ensures all entries that
+        # share a value with an inclusive bound are included, even duplicates.
+        if lower is None:
+            lower_pos = 0
+        else:
+            lower_pos = bisect_left(lower) if bounds[0] else bisect_right(lower)
+
+        if upper is None:
+            upper_pos = n
+        else:
+            upper_pos = bisect_right(upper) if bounds[1] else bisect_left(upper)
+
+        return self.row_index[lower_pos:upper_pos]
 
     def remove(self, key: tuple, data: int) -> bool:
         """

{astropy-7.2.1 → astropy-7.2.2}/astropy/table/tests/test_index.py

@@ -883,3 +883,21 @@ def test_index_not_corrupted_on_failed_row_assignment(engine):
     # No ghost entry for the attempted new value
     with pytest.raises(KeyError):
         t.loc[99]
+
+
+def test_loc_range_sorted_after_add_row(engine):
+    """Regression test: a range query must return rows in ascending key order,
+    also for rows added after the index was created.
+
+    The ``BST`` engine previously collected nodes in node-right-left order,
+    so after ``add_row`` the tree was no longer a degenerate chain and
+    ``t.loc[lower:upper]`` returned rows in scrambled order.
+    """
+    t = Table([[1, 5, 9], [10, 50, 90]], names=("a", "b"))
+    t.add_index("a", engine=engine)
+    for a, b in [(7, 70), (3, 30), (8, 80), (2, 20), (6, 60), (4, 40)]:
+        t.add_row((a, b))
+
+    assert t.loc[2:8]["a"].tolist() == [2, 3, 4, 5, 6, 7, 8]
+    assert t.loc[2:8]["b"].tolist() == [20, 30, 40, 50, 60, 70, 80]
+    assert t.loc[:]["a"].tolist() == [1, 2, 3, 4, 5, 6, 7, 8, 9]

{astropy-7.2.1 → astropy-7.2.2}/astropy/units/quantity_helper/function_helpers.py

@@ -1601,7 +1601,11 @@ def structured_to_unstructured(arr, *args, **kwargs):
     """
     from astropy.units import StructuredUnit
 
-    target_unit = arr.unit.values()[0]
+    if isinstance(arr.unit, StructuredUnit) and len(arr.unit) > 0:
+        target_unit = next(iter(arr.unit.values()))
+    else:
+        # Fallback if the unit isn't structured or is empty
+        target_unit = arr.unit
 
     def replace_unit(x):
         if isinstance(x, StructuredUnit):
@@ -1609,7 +1613,8 @@ def structured_to_unstructured(arr, *args, **kwargs):
         else:
             return target_unit
 
-    to_unit = arr.unit._recursively_apply(replace_unit)
+    to_unit = replace_unit(arr.unit)
+
     return (arr.to_value(to_unit),) + args, kwargs, target_unit, None
 
 

{astropy-7.2.1 → astropy-7.2.2}/astropy/units/tests/test_quantity_non_ufuncs.py

@@ -2852,6 +2852,25 @@ class TestRecFunctions:
         ):
             rfn.merge_arrays((self.q_pv, np.array(["a", "b", "c"])), flatten=flatten)
 
+    def test_structured_to_unstructured_success(self):
+        """
+        Test that structured_to_unstructured correctly extracts
+        the target unit for structured quantities where all fields
+        share the same compatible unit initialized as a standard unit.
+        """
+        # Using a standard unit (not StructuredUnit) triggers the bug
+        # where `unit` (a standard unit) has no `values()` method.
+        dtype = np.dtype([("a", "f8"), ("b", "f8")])
+        data = np.array([(100.0, 2.0), (300.0, 4.0)], dtype=dtype)
+        unit = u.m
+        q = u.Quantity(data, unit=unit)
+
+        result = rfn.structured_to_unstructured(q)
+
+        assert isinstance(result, u.Quantity)
+        assert result.unit == u.m
+        assert_array_equal(result.value, np.array([[100.0, 2.0], [300.0, 4.0]]))
+
 
 all_wrapped_functions = get_wrapped_functions(
     np, np.fft, np.linalg, np.lib.recfunctions

{astropy-7.2.1 → astropy-7.2.2}/astropy/units/tests/test_structured.py

@@ -659,7 +659,7 @@ class TestStructuredQuantityFunctions(StructuredTestBaseWithUnits):
         # ``test_quantity_non_ufuncs.TestRecFunctions.test_structured_to_unstructured``
 
     def test_unstructured_to_structured(self):
-        # can't structure something that's already structured
+        # can't structure something with incompatible shape
         dtype = np.dtype([("f1", float), ("f2", float)])
         with pytest.raises(ValueError, match="The length of the last dimension"):
             rfn.unstructured_to_structured(self.q_pv, dtype=self.q_pv.dtype)

{astropy-7.2.1 → astropy-7.2.2}/astropy/utils/iers/iers.py

@@ -783,20 +783,19 @@ class IERS_Auto(IERS_A):
 
     @classmethod
     def open(cls):
-        """If the configuration setting ``astropy.utils.iers.conf.auto_download``
-        is set to True (default), then open a recent version of the IERS-A
-        table with predictions for UT1-UTC and polar motion out to
-        approximately one year from now.  If the available version of this file
-        is older than ``astropy.utils.iers.conf.auto_max_age`` days old
-        (or non-existent) then it will be downloaded over the network and cached.
+        """
+        This reads in the bundled IERS_A table (or the version of the file in
+        the current working directory, if present - see `IERS_A.read`).
 
-        If the configuration setting ``astropy.utils.iers.conf.auto_download``
-        is set to False then the bundled IERS-A table will be used rather than
-        any downloaded version of the IERS-A table.
+        Subsequently, if values are requested which are more recent than the
+        range of validity of the bundled table, an updated version of the table
+        will be downloaded if the configuration setting
+        ``astropy.utils.iers.conf.auto_download`` is set to True (default) and
+        if the available version of this file is older than
+        ``astropy.utils.iers.conf.auto_max_age`` days old.
 
-        On the first call in a session, the table will be memoized (in the
-        ``iers_table`` class attribute), and further calls to ``open`` will
-        return this stored table.
+        If the configuration setting ``astropy.utils.iers.conf.auto_download``
+        is set to False then the bundled IERS-A table will always be used.
 
         Returns
         -------
@@ -804,47 +803,8 @@ class IERS_Auto(IERS_A):
             With IERS (Earth rotation) data columns
 
         """
-        if not conf.auto_download:
-            # If auto_download is changed to False mid-session, iers_table may have already been
-            # made from non-bundled files, so it should be remade from bundled files
-            if not hasattr(cls, "_iers_table_bundled"):
-                cls._iers_table_bundled = cls.read()
-            cls.iers_table = cls._iers_table_bundled
-            return cls.iers_table
-
-        all_urls = (conf.iers_auto_url, conf.iers_auto_url_mirror)
-
-        if cls.iers_table is not None:
-            # If the URL has changed, we need to redownload the file, so we
-            # should ignore the internally cached version.
-
-            if cls.iers_table.meta.get("data_url") in all_urls:
-                return cls.iers_table
-
-        for url in all_urls:
-            try:
-                filename = download_file(url, cache=True)
-            except Exception as err:
-                warn(f"failed to download {url}: {err}", IERSWarning)
-                continue
-
-            try:
-                cls.iers_table = cls.read(file=filename)
-            except Exception as err:
-                warn(f"malformed IERS table from {url}: {err}", IERSWarning)
-                continue
-            cls.iers_table.meta["data_url"] = url
-            break
-
-        else:
-            # Issue a warning here, perhaps user is offline.  An exception
-            # will be raised downstream if actually trying to interpolate
-            # predictive values.
-            warn(
-                "unable to download valid IERS file, using bundled IERS-A", IERSWarning
-            )
+        if cls.iers_table is None:
             cls.iers_table = cls.read()
-
         return cls.iers_table
 
     def _check_interpolate_indices(self, indices_orig, indices_clipped, max_input_mjd):
@@ -924,7 +884,26 @@ class IERS_Auto(IERS_A):
                 )
                 return
 
-            new_table = self.__class__.read(file=filename)
+            try:
+                new_table = self.__class__.read(file=filename)
+            except Exception as err:
+                # The download succeeded but the content could not be parsed as
+                # an IERS table (e.g. the server returned an error page).  Keep
+                # using the existing table; an exception will be raised
+                # downstream when actually trying to interpolate predictive
+                # values.
+                warn(
+                    AstropyWarning(
+                        "malformed IERS table downloaded from"
+                        f" {' and '.join(all_urls)}: {err}.\nA coordinate or"
+                        " time-related calculation might be compromised or fail"
+                        " because the dates are not covered by the available IERS"
+                        ' file.  See the "IERS data access" section of the astropy'
+                        " documentation for additional information on working"
+                        " offline."
+                    )
+                )
+                return
             new_table.meta["data_url"] = str(all_urls[0])
 
             # New table has new values?

{astropy-7.2.1 → astropy-7.2.2}/astropy/utils/iers/tests/test_iers.py

@@ -20,7 +20,7 @@ from astropy.table import QTable
 from astropy.tests.helper import CI, assert_quantity_allclose
 from astropy.time import Time, TimeDelta
 from astropy.utils.data import get_pkg_data_filename
-from astropy.utils.exceptions import AstropyDeprecationWarning
+from astropy.utils.exceptions import AstropyDeprecationWarning, AstropyWarning
 from astropy.utils.iers import iers
 
 FILE_NOT_FOUND_ERROR = getattr(__builtins__, "FileNotFoundError", OSError)
@@ -247,6 +247,12 @@ class TestIERS_Auto:
         self._auto_download = iers.conf.auto_download
         iers.conf.auto_download = True
 
+        # Ensure no IERS_Auto table is cached from an earlier test, so that the
+        # first test's open() re-reads the (possibly monkeypatched) bundled file
+        # rather than returning a stale memoized table; teardown_method keeps it
+        # clean for the remaining tests.
+        iers.IERS_Auto.close()
+
         # auto_download = False is tested in test_IERS_B_parameters_loading_into_IERS_Auto()
 
     def teardown_class(self):
@@ -257,10 +263,11 @@ class TestIERS_Auto:
         """Run this after every test."""
         iers.IERS_Auto.close()
 
-    def test_interpolate_error_formatting(self):
+    def test_interpolate_error_formatting(self, monkeypatch):
         """Regression test: make sure the error message in
         IERS_Auto._check_interpolate_indices() is formatted correctly.
         """
+        monkeypatch.setattr(iers, "IERS_A_FILE", self.iers_a_file_1)
         with iers.conf.set_temp("iers_auto_url", self.iers_a_url_1):
             with iers.conf.set_temp("iers_auto_url_mirror", self.iers_a_url_1):
                 with iers.conf.set_temp("auto_max_age", self.ame):
@@ -276,10 +283,11 @@ class TestIERS_Auto:
                             warnings.simplefilter("ignore", iers.IERSStaleWarning)
                             iers_table.ut1_utc(self.t.jd1, self.t.jd2)
 
-    def test_auto_max_age_none(self):
+    def test_auto_max_age_none(self, monkeypatch):
         """Make sure that iers.INTERPOLATE_ERROR's advice about setting
         auto_max_age = None actually works.
         """
+        monkeypatch.setattr(iers, "IERS_A_FILE", self.iers_a_file_1)
         with iers.conf.set_temp("iers_auto_url", self.iers_a_url_1):
             with iers.conf.set_temp("auto_max_age", None):
                 iers_table = iers.IERS_Auto.open()
@@ -302,7 +310,8 @@ class TestIERS_Auto:
                     iers_table = iers.IERS_Auto.open()
                     _ = iers_table.ut1_utc(self.t.jd1, self.t.jd2)
 
-    def test_simple(self):
+    def test_simple(self, monkeypatch):
+        monkeypatch.setattr(iers, "IERS_A_FILE", self.iers_a_file_1)
         with iers.conf.set_temp("iers_auto_url", self.iers_a_url_1):
             dat = iers.IERS_Auto.open()
             assert dat["MJD"][0] == 57359.0 * u.d
@@ -482,33 +491,58 @@ def test_iers_b_out_of_range_handling():
             (now + 100 * u.day).ut1
 
 
+@pytest.fixture
+def reset_iers_auto_cache():
+    """Clear the IERS_A/IERS_Auto/IERS caches around a test.
+
+    IERS_Auto.open() memoizes its table in a class attribute, so a test that
+    loads a non-default bundled table (e.g. a truncated fixture) would otherwise
+    leak that table into later tests through earth_orientation_table.  close()
+    only nulls the cached table, so this is safe regardless of the current
+    IERS_A_FILE value.
+    """
+    for cls in (iers.IERS_A, iers.IERS_Auto, iers.IERS):
+        cls.close()
+    yield
+    for cls in (iers.IERS_A, iers.IERS_Auto, iers.IERS):
+        cls.close()
+
+
 @pytest.mark.remote_data
-def test_iers_download_error_handling(tmp_path):
-    # Make sure an IERS-A table isn't already loaded
+def test_iers_download_error_handling(tmp_path, monkeypatch, reset_iers_auto_cache):
+    # IERS_Auto.open() now reads the bundled table and only attempts a download
+    # later, when predictive values beyond the table range are requested while
+    # the table is older than auto_max_age.  Point at an old bundled table so
+    # that requesting a recent date triggers a download attempt.  The truncated
+    # fixture it loads is cleared afterwards by reset_iers_auto_cache.
+    monkeypatch.setattr(
+        iers,
+        "IERS_A_FILE",
+        get_pkg_data_filename(os.path.join("data", "finals2000A-2016-02-30-test")),
+    )
     with set_temp_cache(tmp_path), iers.conf.set_temp("auto_download", True):
-        iers.IERS_A.close()
-        iers.IERS_Auto.close()
-        iers.IERS.close()
         now = Time.now()
 
-        # bad site name
-        with iers.conf.set_temp("iers_auto_url", "FAIL FAIL"):
-            # site that exists but doesn't have IERS data
-            with iers.conf.set_temp("iers_auto_url_mirror", "https://google.com"):
-                with pytest.warns(iers.IERSWarning) as record:
-                    with iers.conf.set_temp("iers_degraded_accuracy", "ignore"):
-                        (now + 400 * u.day).ut1
-
-                assert len(record) == 3
-                assert str(record[0].message).startswith(
-                    "failed to download FAIL FAIL: Malformed URL"
-                )
-                assert str(record[1].message).startswith(
-                    "malformed IERS table from https://google.com"
-                )
-                assert str(record[2].message).startswith(
-                    "unable to download valid IERS file, using bundled IERS-A"
-                )
+        # Primary URL is a bad site name and the mirror is a site that exists
+        # but does not provide a valid IERS table, so the refresh cannot find
+        # usable data.
+        with (
+            iers.conf.set_temp("iers_auto_url", "FAIL FAIL"),
+            iers.conf.set_temp("iers_auto_url_mirror", "https://google.com"),
+            iers.conf.set_temp("iers_degraded_accuracy", "ignore"),
+        ):
+            # The failed refresh is reported with a warning (the download fails
+            # or the downloaded content cannot be parsed), and since the bundled
+            # table is too old to cover the requested predictive date the
+            # interpolation then raises.
+            with pytest.warns(
+                AstropyWarning, match="failed to download|malformed IERS table"
+            ):
+                with pytest.raises(
+                    ValueError,
+                    match="interpolating from IERS_Auto using predictive values",
+                ):
+                    (now + 400 * u.day).ut1
 
 
 OLD_DATA_FILES = {

{astropy-7.2.1 → astropy-7.2.2}/astropy/wcs/wcsapi/fitswcs.py

@@ -397,13 +397,16 @@ class FITSWCSAPIMixin(BaseLowLevelWCS, HighLevelWCSMixin):
         # it. We start off by defining a hash based on the attributes of the
         # WCS that matter here (we can't just use the WCS object as a hash since
         # it is mutable)
+        # NaN values must be normalized since NaN != NaN would otherwise
+        # defeat the cache comparison below.
+        equinox = self.wcs.equinox
         wcs_hash = (
             self.naxis,
             list(self.wcs.ctype),
             list(self.wcs.cunit),
             self.wcs.radesys,
             self.wcs.specsys,
-            self.wcs.equinox,
+            None if np.isnan(equinox) else equinox,
             self.wcs.dateobs,
             self.wcs.lng,
             self.wcs.lat,

{astropy-7.2.1 → astropy-7.2.2}/astropy/wcs/wcsapi/tests/test_fitswcs.py

@@ -1663,3 +1663,13 @@ def test_array_index_conversions_scalars_2d():
     x, y = wcs.world_to_pixel(scoord)
     assert isinstance(x, np.ndarray) and x.ndim == 0
     assert isinstance(y, np.ndarray) and y.ndim == 0
+
+
+def test_components_and_classes_cache():
+    # Regression test for the components and classes cache never hitting
+    # when the equinox was undefined, because the NaN it contributed to the
+    # cache key compares unequal to itself
+    wcs = WCS(naxis=2)
+    wcs.wcs.ctype = ["RA---TAN", "DEC--TAN"]
+    wcs.wcs.set()
+    assert wcs.world_axis_object_components is wcs.world_axis_object_components