now that the server is working again, we don't want xfails

Author: keflavich

astroquery/linelists/jplspec/core.py

@@ -156,9 +156,19 @@ def query_lines(self, min_frequency, max_frequency, *,
         by the query service.  This workaround is needed while JPLSpec's query
         tool is broken.
 
-        use_getmolecule is an option to force the query to use get_molecule.
-        It is needed if the JPL server is completely unresponsive.
+        use_getmolecule is an option to skip the query service entirely and
+        retrieve full molecule catalogs via `get_molecule`. It is needed when
+        the JPL query server is unresponsive. Frequency and strength limits
+        are not applied in this mode.
         """
+        if use_getmolecule:
+            if get_query_payload:
+                return [('Mol', tuple(self._resolve_molecules(molecule, flags=flags,
+                                                              parse_name_locally=parse_name_locally)))]
+            mols = self._resolve_molecules(molecule, flags=flags,
+                                           parse_name_locally=parse_name_locally)
+            return self._build_table_from_get_molecule(mols)
+
         response = self.query_lines_async(min_frequency=min_frequency,
                                           max_frequency=max_frequency,
                                           min_strength=min_strength,
@@ -171,13 +181,44 @@ def query_lines(self, min_frequency, max_frequency, *,
         if get_query_payload:
             return response
         else:
-            return self._parse_result(response, fallback_to_getmolecule=fallback_to_getmolecule,
-                                      use_getmolecule=use_getmolecule)
+            return self._parse_result(response, fallback_to_getmolecule=fallback_to_getmolecule)
 
     query_lines.__doc__ = process_asyncs.async_to_sync_docstr(query_lines_async.__doc__)
 
-    def _parse_result(self, response, *, verbose=False, fallback_to_getmolecule=False,
-                      use_getmolecule=True):
+    def _resolve_molecules(self, molecule, *, flags=0, parse_name_locally=False):
+        """Return a list of molecule identifiers to feed to get_molecule."""
+        if molecule is None or molecule == 'All':
+            raise InvalidQueryError("use_getmolecule requires an explicit molecule "
+                                    "or regex; 'All' is not supported.")
+        if parse_name_locally:
+            self.lookup_ids = build_lookup()
+            mols = list(self.lookup_ids.find(molecule, flags).values())
+            if len(mols) == 0:
+                raise InvalidQueryError('No matching species found.')
+            return mols
+        if isinstance(molecule, (list, tuple)):
+            return list(molecule)
+        return [molecule]
+
+    def _build_table_from_get_molecule(self, mols):
+        """Fetch full catalog tables for each molecule and combine them."""
+        self.lookup_ids = build_lookup()
+        tbs = [self.get_molecule(mol) for mol in mols]
+        if len(tbs) > 1:
+            for tb, mol in zip(tbs, mols):
+                tb['Name'] = self.lookup_ids.find(str(mol), flags=0)
+                for key in list(tb.meta.keys()):
+                    tb.meta[f'{mol}_{key}'] = tb.meta.pop(key)
+            tb = table.vstack(tbs)
+            tb.meta['molecule_list'] = list(mols)
+            return tb
+        else:
+            tb = tbs[0]
+            tb.meta['molecule_id'] = mols[0]
+            tb.meta['molecule_name'] = self.lookup_ids.find(str(mols[0]), flags=0)
+            return tb
+
+    def _parse_result(self, response, *, verbose=False, fallback_to_getmolecule=False):
         """
         Parse a response into an `~astropy.table.Table`
 
@@ -208,28 +249,11 @@ def _parse_result(self, response, *, verbose=False, fallback_to_getmolecule=Fals
         QN":   Quantum numbers for the lower state.
         """
 
-        if 'Zero lines were found' in response.text or use_getmolecule:
+        if 'Zero lines were found' in response.text:
             if fallback_to_getmolecule:
-                self.lookup_ids = build_lookup()
                 payload = parse_qs(response.request.body)
-                tbs = [self.get_molecule(mol) for mol in payload['Mol']]
-                if len(tbs) > 1:
-                    mols = []
-                    for tb, mol in zip(tbs, payload['Mol']):
-                        tb['Name'] = self.lookup_ids.find(mol, flags=0)
-                        for key in list(tb.meta.keys()):
-                            tb.meta[f'{mol}_{key}'] = tb.meta.pop(key)
-                        mols.append(mol)
-                    tb = table.vstack(tbs)
-                    tb.meta['molecule_list'] = mols
-                else:
-                    tb = tbs[0]
-                    tb.meta['molecule_id'] = payload['Mol'][0]
-                    tb.meta['molecule_name'] = self.lookup_ids.find(payload['Mol'][0], flags=0)
-
-                return tb
-            else:
-                raise EmptyResponseError(f"Response was empty; message was '{response.text}'.")
+                return self._build_table_from_get_molecule(payload['Mol'])
+            raise EmptyResponseError(f"Response was empty; message was '{response.text}'.")
 
         # data starts at 0 since regex was applied
         # Warning for a result with more than 1000 lines:

astroquery/linelists/jplspec/tests/test_jplspec.py

@@ -290,6 +290,7 @@ def test_query_lines_with_fallback():
                                 max_frequency=200 * u.GHz,
                                 min_strength=-500,
                                 molecule="28001 CO",
+                                use_getmolecule=False,
                                 fallback_to_getmolecule=False)
 
     # Test with fallback enabled - should call get_molecule
@@ -320,6 +321,7 @@ def test_query_lines_with_fallback():
             max_frequency=200 * u.GHz,
             min_strength=-500,
             molecule="28001 CO",
+            use_getmolecule=False,
             fallback_to_getmolecule=True)
 
         mock_get_molecule.assert_called_once_with('28001')

astroquery/linelists/jplspec/tests/test_jplspec_remote.py

@@ -6,13 +6,18 @@
 from astroquery.exceptions import EmptyResponseError
 
 
-@pytest.mark.xfail(reason="2025 server problems", raises=EmptyResponseError)
 @pytest.mark.remote_data
 def test_remote():
+    """
+    In 2025-2026, the JPLSpec server went down and this was marked 'xfail' for a while.
+
+    As of late April 2026, it's back online again.
+    """
     tbl = JPLSpec.query_lines(min_frequency=500 * u.GHz,
                               max_frequency=1000 * u.GHz,
                               min_strength=-500,
                               molecule="18003 H2O",
+                              use_getmolecule=False,
                               fallback_to_getmolecule=False)
     assert isinstance(tbl, Table)
     assert len(tbl) == 36
@@ -36,7 +41,7 @@ def test_remote_regex_fallback():
                               max_frequency=1000 * u.GHz,
                               min_strength=-500,
                               molecule=("28001", "28002", "28003"),
-                              fallback_to_getmolecule=True)
+                              use_getmolecule=True)
     assert isinstance(tbl, Table)
     tbl = tbl[((tbl['FREQ'].quantity > 500*u.GHz) & (tbl['FREQ'].quantity < 1*u.THz))]
     assert len(tbl) == 16
@@ -54,14 +59,13 @@ def test_remote_regex_fallback():
     assert tbl['FREQ'][15] == 946175.3151
 
 
-# Starting in 2025, the JPL CGI server that did search queries broke totally.  See #3363
-@pytest.mark.xfail(reason="2025 server problems", raises=EmptyResponseError)
 @pytest.mark.remote_data
 def test_remote_regex():
     tbl = JPLSpec.query_lines(min_frequency=500 * u.GHz,
                               max_frequency=1000 * u.GHz,
                               min_strength=-500,
                               molecule=("28001", "28002", "28003"),
+                              use_getmolecule=False,
                               fallback_to_getmolecule=False)
     assert isinstance(tbl, Table)
     assert len(tbl) == 16
@@ -130,7 +134,7 @@ def test_remote_fallback():
                               max_frequency=1000 * u.GHz,
                               min_strength=-500,
                               molecule="18003 H2O",
-                              fallback_to_getmolecule=True)
+                              use_getmolecule=True)
     assert isinstance(tbl, Table)
     tbl = tbl[((tbl['FREQ'].quantity > 500*u.GHz) & (tbl['FREQ'].quantity < 1*u.THz))]
     assert len(tbl) == 36