changelog, check for catalog matches

Author: snbianco

CHANGES.rst

@@ -43,6 +43,14 @@ utils.tap
 - The method ``upload_table`` accepts file formats accepted by astropy's
   ``Table.read()``. [#3295]
 
+mast
+^^^^
+
+- Added ``resolver`` parameter to query methods to specify the resolver to use when resolving object names to coordinates. [#3292]
+
+- Added ``resolve_all`` parameter to ``MastClass.resolve_object`` to resolve object names and return 
+  coordinates for all available resolvers. [#3292]
+
 
 Infrastructure, Utility and Other Changes and Additions
 -------------------------------------------------------

astroquery/mast/tests/data/README.rst

@@ -48,3 +48,16 @@ To generate `~astroquery.mast.tests.data.mast_relative_path.json`, use the follo
     ...                              {'uri': ['mast:HST/product/u9o40504m_c3m.fits', 'mast:HST/product/does_not_exist.fits']})
     >>> with open('mast_relative_path.json', 'w') as file:
     ...     json.dump(resp.json(), file, indent=4)  # doctest: +SKIP
+
+
+To generate `~astroquery.mast.tests.data.resolver.json`, use the following:
+
+.. doctest-remote-data::
+
+    >>> import json
+    >>> from astroquery.mast import utils
+    ...
+    >>> resp = utils._simple_request('http://mastresolver.stsci.edu/Santa-war/query',
+    ...                              {'name': 'TIC 307210830', 'outputFormat': 'json', 'resolveAll': 'true'})
+    >>> with open('resolver.json', 'w') as file:
+    ...     json.dump(resp.json(), file, indent=4)  # doctest: +SKIP

astroquery/mast/tests/data/resolver.json

@@ -1 +1,39 @@
-{"resolvedCoordinate":[{"searchString":"m103","resolver":"NED","cached":true,"resolverTime":114,"cacheDate":"Apr 19, 2017 2:32:38 PM","searchRadius":-1.0,"canonicalName":"MESSIER 103","ra":23.34086,"decl":60.658,"objectType":"*Cl"}],"status":""}
+{
+    "resolvedCoordinate": [
+        {
+            "searchString": "tic 307210830",
+            "resolver": "TIC",
+            "cached": false,
+            "resolverTime": 3,
+            "searchRadius": 0.000333,
+            "canonicalName": "TIC 307210830",
+            "ra": 124.531756290083,
+            "decl": -68.3129998725044
+        },
+        {
+            "searchString": "tic 307210830",
+            "resolver": "SIMBADCFA",
+            "cached": true,
+            "resolverTime": 289,
+            "cacheDate": "Mar 19, 2025, 4:36:27 PM",
+            "searchRadius": -1.0,
+            "canonicalName": "L   98-59",
+            "ra": 124.5317560026638,
+            "decl": -68.3130014904408,
+            "objectType": "HighPM*"
+        },
+        {
+            "searchString": "tic 307210830",
+            "resolver": "SIMBAD",
+            "cached": true,
+            "resolverTime": 299,
+            "cacheDate": "Apr 17, 2025, 3:47:59 PM",
+            "searchRadius": -1.0,
+            "canonicalName": "L   98-59",
+            "ra": 124.5317560026638,
+            "decl": -68.3130014904408,
+            "objectType": "HighPM*"
+        }
+    ],
+    "status": ""
+}

astroquery/mast/tests/test_mast.py

@@ -492,26 +492,32 @@ def test_mast_query(patch_post):
 
 
 def test_resolve_object(patch_post):
-    coord = SkyCoord(23.34086, 60.658, unit='deg')
-    m103_loc = mast.Mast.resolve_object("M103")
-    assert round(m103_loc.separation(coord).value, 10) == 0
+    obj = "TIC 307210830"
+    tic_coord = SkyCoord(124.531756290083, -68.3129998725044, unit="deg")
+    simbad_coord = SkyCoord(124.5317560026638, -68.3130014904408, unit="deg")
+    obj_loc = mast.Mast.resolve_object(obj)
+    assert round(obj_loc.separation(tic_coord).value, 10) == 0
 
-    # resolve using a specific resolver
-    m103_loc_ned = mast.Mast.resolve_object("M103", resolver="NED")
-    assert round(m103_loc_ned.separation(coord).value, 10) == 0
+    # resolve using a specific resolver and an object that belongs to a MAST catalog
+    obj_loc_simbad = mast.Mast.resolve_object(obj, resolver="SIMBAD")
+    assert round(obj_loc_simbad.separation(simbad_coord).value, 10) == 0
+
+    # resolve using a specific resolver and an object that does not belong to a MAST catalog
+    obj_loc_simbad = mast.Mast.resolve_object("M101", resolver="SIMBAD")
+    assert round(obj_loc_simbad.separation(simbad_coord).value, 10) == 0
 
     # resolve using all resolvers
-    m103_loc_dict = mast.Mast.resolve_object("M103", resolve_all=True)
-    assert isinstance(m103_loc_dict, dict)
-    assert round(m103_loc_dict['NED'].separation(coord).value, 10) == 0
+    obj_loc_dict = mast.Mast.resolve_object(obj, resolve_all=True)
+    assert isinstance(obj_loc_dict, dict)
+    assert round(obj_loc_dict["SIMBAD"].separation(simbad_coord).value, 10) == 0
 
     # error with invalid resolver
     with pytest.raises(ResolverError, match="Invalid resolver"):
-        mast.Mast.resolve_object("M103", resolver="invalid")
+        mast.Mast.resolve_object(obj, resolver="invalid")
 
     # warn if specifying both resolver and resolve_all
     with pytest.warns(InputWarning, match="The resolver parameter is ignored when resolve_all is True"):
-        loc = mast.Mast.resolve_object("m103", resolver="NED", resolve_all=True)
+        loc = mast.Mast.resolve_object(obj, resolver="NED", resolve_all=True)
         assert isinstance(loc, dict)
 
 

astroquery/mast/tests/test_mast_remote.py

@@ -60,6 +60,10 @@ def test_resolve_object(self):
         simbad_loc = utils.resolve_object("jw100", resolver="simbad")
         assert round(simbad_loc.separation(SkyCoord("83.70341477 -5.55918309", unit="deg")).value, 4) == 0
 
+        # Try an object from a MAST catalog with a resolver
+        catalog_loc = utils.resolve_object("TIC 307210830", resolver="SIMBAD")
+        assert round(catalog_loc.separation(SkyCoord("124.5317560 -68.31300149", unit="deg")).value, 4) == 0
+
         # Use resolve_all to get all resolvers
         loc_dict = utils.resolve_object("jw100", resolve_all=True)
         assert isinstance(loc_dict, dict)

astroquery/mast/utils.py

@@ -12,8 +12,9 @@
 import requests
 import platform
 
-import astropy.coordinates as coord
+from astropy.coordinates import SkyCoord
 from astropy.table import unique, Table
+from astropy import units as u
 
 from .. import log
 from ..version import version
@@ -111,49 +112,82 @@ def resolve_object(objectname, resolver=None, resolve_all=False):
     response : `~astropy.coordinates.SkyCoord`
         The sky position of the given object.
     """
+    is_catalog = False  # Flag to check if object name belongs to a MAST catalog
+    catalog = None  # Variable to store the catalog name
+    objectname = objectname.strip()
+    catalog_prefixes = {
+        'TIC ': 'TIC',
+        'KIC ': 'KEPLER',
+        'EPIC ': 'K2'
+    }
 
-    # Check that resolver is valid
-    valid_resolvers = ['ned', 'simbad']
     if resolver:
-        if resolver.lower() not in valid_resolvers:
+        # Check that resolver is valid
+        resolver = resolver.upper()
+        if resolver not in ('NED', 'SIMBAD'):
             raise ResolverError('Invalid resolver. Must be "NED" or "SIMBAD".')
 
         if resolve_all:
+            # Warn if user is trying to use a resolver with resolve_all
             warnings.warn('The resolver parameter is ignored when resolve_all is True. '
                           'Coordinates will be resolved using all available resolvers.', InputWarning)
-            resolver = None
+
+        # Check if object belongs to a MAST catalog
+        for prefix, name in catalog_prefixes.items():
+            if objectname.startswith(prefix):
+                is_catalog = True
+                catalog = name
+                break
+
+    # Whether to set resolveAll to True when making the HTTP request
+    # Should be True when resolve_all = True or when object name belongs to a MAST catalog (TIC, KIC, EPIC, K2)
+    use_resolve_all = resolve_all or is_catalog
 
     # Send request to STScI Archive Name Translation Application (SANTA)
-    params = {'name': objectname, 'outputFormat': 'json', 'resolveAll': str(resolve_all).lower()}
-    if resolver:
+    params = {'name': objectname,
+              'outputFormat': 'json',
+              'resolveAll': use_resolve_all}
+    if resolver and not use_resolve_all:
         params['resolver'] = resolver
     response = _simple_request('http://mastresolver.stsci.edu/Santa-war/query', params)
     response.raise_for_status()  # Raise any errors
-    result = response.json()
-
-    if len(result['resolvedCoordinate']) == 0:
-        if resolver:
-            raise ResolverError("Could not resolve {} to a sky position using {}. "
-                                "Please try another resolver or set ``resolver=None`` to use the first "
-                                "compatible resolver.".format(objectname, resolver))
-        else:
-            raise ResolverError("Could not resolve {} to a sky position.".format(objectname))
-
+    result = response.json().get('resolvedCoordinate', [])
+
+    # If a resolver is specified and resolve_all is False, find and return the result for that resolver
+    if resolver and not resolve_all:
+        resolver_result = next((res for res in result if res.get('resolver') == resolver), None)
+        if not resolver_result:
+            raise ResolverError(f'Could not resolve {objectname} to a sky position using {resolver}. '
+                                'Please try another resolver or set ``resolver=None`` to use the first '
+                                'compatible resolver.')
+        resolver_coord = SkyCoord(resolver_result['ra'], resolver_result['decl'], unit='deg')
+
+        # If object belongs to a MAST catalog, check the separation between the coordinates from the
+        # resolver and the catalog
+        if is_catalog:
+            catalog_result = next((res for res in result if res.get('resolver') == catalog), None)
+            if catalog_result:
+                catalog_coord = SkyCoord(catalog_result['ra'], catalog_result['decl'], unit='deg')
+                if resolver_coord.separation(catalog_coord) > 1 * u.arcsec:
+                    # Warn user if the coordinates differ by more than 1 arcsec
+                    warnings.warn(f'Resolver {resolver} returned coordinates that differ from MAST {catalog} catalog '
+                                  'by more than 0.1 arcsec. ', InputWarning)
+
+        return resolver_coord
+
+    if not result:
+        raise ResolverError('Could not resolve {} to a sky position.'.format(objectname))
+
+    # Return results for all compatible resolvers
     if resolve_all:
-        # Return results for all compatible resolvers
-        coordinates = {}
-        for res in result['resolvedCoordinate']:
-            ra = res['ra']
-            dec = res['decl']
-            coordinates[res['resolver']] = coord.SkyCoord(ra, dec, unit="deg")
-        return coordinates
-
-    # Return coordinates for a single resolver
-    ra = result['resolvedCoordinate'][0]['ra']
-    dec = result['resolvedCoordinate'][0]['decl']
-    coordinates = coord.SkyCoord(ra, dec, unit="deg")
-
-    return coordinates
+        return {
+            res['resolver']: SkyCoord(res['ra'], res['decl'], unit='deg')
+            for res in result
+        }
+
+    # Case when resolve_all is False and no resolver is specified
+    # SANTA returns result from first compatible resolver
+    return SkyCoord(result[0]['ra'], result[0]['decl'], unit='deg')
 
 
 def parse_input_location(coordinates=None, objectname=None, resolver=None):