Modifications to get LCOGT support

Author: zemogle

astroquery/lcogt/core.py

@@ -41,7 +41,9 @@
                                   '00 42 44.3 -41 16 08'
                                   '00h42m44.3s -41d16m08s'
 
-catalog     Required    Catalog name in the IRSA database management system.
+catalog     Required    Catalog name in the LCOGT Archive. The database of photometry
+                        can be found using lco_cat and the database of image metadata is
+                        found using lco_img.
 
 outfmt      Optional    Defines query's output format.
                         6 - returns a program interface in XML
@@ -80,12 +82,11 @@
 from . import conf
 from ..exceptions import TableParseError
 
-__all__ = ['Irsa', 'IrsaClass']
+__all__ = ['Lcogt', 'LcogtClass']
 
 
-class IrsaClass(BaseQuery):
-    IRSA_URL = conf.server
-    GATOR_LIST_URL = conf.gator_list_catalogs
+class LcogtClass(BaseQuery):
+    LCOGT_URL = conf.server
     TIMEOUT = conf.timeout
     ROW_LIMIT = conf.row_limit
 
@@ -94,8 +95,8 @@ def query_region(self, coordinates=None, catalog=None, spatial='Cone',
                      get_query_payload=False, verbose=False):
         """
         This function can be used to perform either cone, box, polygon or
-        all-sky search in the catalogs hosted by the NASA/IPAC Infrared
-        Science Archive (IRSA).
+        all-sky search in the LCOGT public archive hosted by the NASA/IPAC Infrared
+        Science Archive.
 
         Parameters
         ----------
@@ -108,7 +109,8 @@ def query_region(self, coordinates=None, catalog=None, spatial='Cone',
             details). Required if spatial is ``'Cone'`` or ``'Box'``. Optional
             if spatial is ``'Polygon'``.
         catalog : str
-            The catalog to be used (see the *Notes* section below).
+            The catalog to be used. Either ``lco_img`` for image metadata or ``lco_cat``
+            for photometry.
         spatial : str
             Type of spatial query: ``'Cone'``, ``'Box'``, ``'Polygon'``, and
             ``'All-Sky'``. If missing then defaults to ``'Cone'``.
@@ -151,7 +153,7 @@ def query_region_async(self, coordinates=None, catalog=None,
                            polygon=None, get_query_payload=False):
         """
         This function serves the same purpose as
-        :meth:`~astroquery.irsa.IrsaClass.query_region`, but returns the raw
+        :meth:`~astroquery.irsa.LcogtClass.query_region`, but returns the raw
         HTTP response rather than the results in a `~astropy.table.Table`.
 
         Parameters
@@ -165,7 +167,8 @@ def query_region_async(self, coordinates=None, catalog=None,
             details). Required if spatial is ``'Cone'`` or ``'Box'``. Optional
             if spatial is ``'Polygon'``.
         catalog : str
-            The catalog to be used (see the *Notes* section below).
+            The catalog to be used. Either ``lco_img`` for image metadata or ``lco_cat``
+            for photometry.
         spatial : str
             Type of spatial query: ``'Cone'``, ``'Box'``, ``'Polygon'``, and
             ``'All-Sky'``. If missing then defaults to ``'Cone'``.
@@ -202,8 +205,8 @@ def query_region_async(self, coordinates=None, catalog=None,
 
         if get_query_payload:
             return request_payload
-        response = commons.send_request(Irsa.IRSA_URL, request_payload,
-                                        Irsa.TIMEOUT, request_type='GET')
+        response = commons.send_request(Lcogt.LCOGT_URL, request_payload,
+                                        Lcogt.TIMEOUT, request_type='GET')
         return response
 
     def _parse_spatial(self, spatial, coordinates, radius=None, width=None,
@@ -228,11 +231,11 @@ def _parse_spatial(self, spatial, coordinates, radius=None, width=None,
             The string must be parsable by `~astropy.coordinates.Angle`. The
             appropriate `~astropy.units.Quantity` object from `astropy.units`
             may also be used. Defaults to 10 arcsec.
-      width : str, `~astropy.units.Quantity` object [Required for spatial is ``'Polygon'``.]
+        width : str, `~astropy.units.Quantity` object [Required for spatial is ``'Polygon'``.]
             The string must be parsable by `~astropy.coordinates.Angle`. The
             appropriate `~astropy.units.Quantity` object from `astropy.units`
             may also be used.
-      polygon : list, [Required for spatial is ``'Polygon'``]
+        polygon : list, [Required for spatial is ``'Polygon'``]
             A list of ``(ra, dec)`` pairs as tuples of
             `astropy.coordinates.Angle`s outlinining the polygon to search in.
             It can also be a list of `astropy.coordinates` object or strings
@@ -290,7 +293,7 @@ def _args_to_payload(self, catalog):
         """
         request_payload = dict(catalog=catalog,
                                outfmt=3,
-                               outrows=Irsa.ROW_LIMIT)
+                               outrows=Lcogt.ROW_LIMIT)
         return request_payload
 
     def _parse_result(self, response, verbose=False):
@@ -325,7 +328,7 @@ def _parse_result(self, response, verbose=False):
 
         # Check that the results are not of length zero
         if len(content) == 0:
-            raise Exception("The IRSA server sent back an empty reply")
+            raise Exception("The LCOGT server sent back an empty reply")
 
         # Read it in using the astropy VO table reader
         try:
@@ -334,7 +337,7 @@ def _parse_result(self, response, verbose=False):
         except Exception as ex:
             self.response = response
             self.table_parse_error = ex
-            raise TableParseError("Failed to parse IRSA votable! The raw response can be found "
+            raise TableParseError("Failed to parse LCOGT votable! The raw response can be found "
                                   "in self.response, and the error in self.table_parse_error.")
 
         # Convert to astropy.table.Table instance
@@ -348,7 +351,7 @@ def _parse_result(self, response, verbose=False):
 
     def list_catalogs(self):
         """
-        Return a dictionary of the catalogs in the IRSA Gator tool.
+        Return a dictionary of the catalogs in the LCOGT Gator tool.
 
         Returns
         -------
@@ -357,24 +360,19 @@ def list_catalogs(self):
             be used in query functions, and the value is the verbose description
             of the catalog.
         """
-        response = commons.send_request(Irsa.GATOR_LIST_URL, dict(mode='xml'), Irsa.TIMEOUT, request_type="GET")
-        root = tree.fromstring(response.content)
-        catalogs = {}
-        for catalog in root.findall('catalog'):
-            catname = catalog.find('catname').text
-            desc = catalog.find('desc').text
-            catalogs[catname] = desc
+        catalogs = {'lco_cat' : 'Photometry archive from LCOGT',
+                    'lco_img' : 'Image metadata archive from LCOGT'}
         return catalogs
 
     def print_catalogs(self):
         """
-        Display a table of the catalogs in the IRSA Gator tool.
+        Display a table of the catalogs in the LCOGT Gator tool.
         """
         catalogs = self.list_catalogs()
         for catname in catalogs:
             print("{:30s}  {:s}".format(catname, catalogs[catname]))
 
-Irsa = IrsaClass()
+Lcogt = LcogtClass()
 
 
 def _parse_coordinates(coordinates):

astroquery/lcogt/tests/setup_package.py

@@ -5,4 +5,4 @@
 def get_package_data():
     paths = [os.path.join('data', '*.xml'),
              ]
-    return {'astroquery.irsa.tests': paths}
+    return {'astroquery.lcogt.tests': paths}

astroquery/lcogt/tests/test_lcogt.py

@@ -12,8 +12,8 @@
 
 from ...utils.testing_tools import MockResponse
 from ...utils import commons
-from ... import irsa
-from ...irsa import conf
+from ... import lcogt
+from ...lcogt import conf
 
 DATA_FILES = {'Cone': 'Cone.xml',
               'Box': 'Box.xml',
@@ -44,7 +44,7 @@ def get_mockreturn(url, params=None, timeout=10, **kwargs):
 @pytest.mark.parametrize(('dim'), ['5d0m0s', 0.3 * u.rad, '5h0m0s', 2 * u.arcmin])
 def test_parse_dimension(dim):
     # check that the returned dimension is always in units of 'arcsec', 'arcmin' or 'deg'
-    new_dim = irsa.core._parse_dimension(dim)
+    new_dim = lcogt.core._parse_dimension(dim)
     assert new_dim.unit in ['arcsec', 'arcmin', 'deg']
 
 
@@ -53,15 +53,15 @@ def test_parse_dimension(dim):
                           (10.0, -11, '10.0 -11')
                           ])
 def test_format_decimal_coords(ra, dec, expected):
-    out = irsa.core._format_decimal_coords(ra, dec)
+    out = lcogt.core._format_decimal_coords(ra, dec)
     assert out == expected
 
 
 @pytest.mark.parametrize(('coordinates', 'expected'),
                          [("5h0m0s 0d0m0s", "75.0 +0.0")
                           ])
 def test_parse_coordinates(coordinates, expected):
-    out = irsa.core._parse_coordinates(coordinates)
+    out = lcogt.core._parse_coordinates(coordinates)
     for a, b in zip(out.split(), expected.split()):
         try:
             a = float(a)
@@ -72,41 +72,41 @@ def test_parse_coordinates(coordinates, expected):
 
 
 def test_args_to_payload():
-    out = irsa.core.Irsa._args_to_payload("fp_psc")
+    out = lcogt.core.Lcogt._args_to_payload("fp_psc")
     assert out == dict(catalog='fp_psc', outfmt=3, outrows=conf.row_limit)
 
 
 @pytest.mark.parametrize(("coordinates"), OBJ_LIST)
 def test_query_region_cone_async(coordinates, patch_get):
-    response = irsa.core.Irsa.query_region_async(coordinates, catalog='fp_psc', spatial='Cone',
+    response = lcogt.core.Lcogt.query_region_async(coordinates, catalog='fp_psc', spatial='Cone',
                                                  radius=2 * u.arcmin, get_query_payload=True)
     assert response['radius'] == 2
     assert response['radunits'] == 'arcmin'
-    response = irsa.core.Irsa.query_region_async(coordinates, catalog='fp_psc', spatial='Cone',
+    response = lcogt.core.Lcogt.query_region_async(coordinates, catalog='fp_psc', spatial='Cone',
                                                  radius=2 * u.arcmin)
     assert response is not None
 
 
 @pytest.mark.parametrize(("coordinates"), OBJ_LIST)
 def test_query_region_cone(coordinates, patch_get):
-    result = irsa.core.Irsa.query_region(coordinates, catalog='fp_psc', spatial='Cone',
+    result = lcogt.core.Lcogt.query_region(coordinates, catalog='fp_psc', spatial='Cone',
                                          radius=2 * u.arcmin)
     assert isinstance(result, Table)
 
 
 @pytest.mark.parametrize(("coordinates"), OBJ_LIST)
 def test_query_region_box_async(coordinates, patch_get):
-    response = irsa.core.Irsa.query_region_async(coordinates, catalog='fp_psc', spatial='Box',
+    response = lcogt.core.Lcogt.query_region_async(coordinates, catalog='fp_psc', spatial='Box',
                                                  width=2 * u.arcmin, get_query_payload=True)
     assert response['size'] == 120
-    response = irsa.core.Irsa.query_region_async(coordinates, catalog='fp_psc', spatial='Box',
+    response = lcogt.core.Lcogt.query_region_async(coordinates, catalog='fp_psc', spatial='Box',
                                                  width=2 * u.arcmin)
     assert response is not None
 
 
 @pytest.mark.parametrize(("coordinates"), OBJ_LIST)
 def test_query_region_box(coordinates, patch_get):
-    result = irsa.core.Irsa.query_region(coordinates, catalog='fp_psc', spatial='Box',
+    result = lcogt.core.Lcogt.query_region(coordinates, catalog='fp_psc', spatial='Box',
                                          width=2 * u.arcmin)
     assert isinstance(result, Table)
 
@@ -121,7 +121,7 @@ def test_query_region_box(coordinates, patch_get):
                           poly2
                           ])
 def test_query_region_async_polygon(polygon, patch_get):
-    response = irsa.core.Irsa.query_region_async("m31", catalog="fp_psc", spatial="Polygon",
+    response = lcogt.core.Lcogt.query_region_async("m31", catalog="fp_psc", spatial="Polygon",
                                                  polygon=polygon, get_query_payload=True)
 
     for a, b in zip(re.split("[ ,]", response["polygon"]),
@@ -131,7 +131,7 @@ def test_query_region_async_polygon(polygon, patch_get):
             b1 = float(b1)
             np.testing.assert_almost_equal(a1, b1)
 
-    response = irsa.core.Irsa.query_region_async("m31", catalog="fp_psc", spatial="Polygon",
+    response = lcogt.core.Lcogt.query_region_async("m31", catalog="fp_psc", spatial="Polygon",
                                                  polygon=polygon)
     assert response is not None
 
@@ -141,19 +141,19 @@ def test_query_region_async_polygon(polygon, patch_get):
                           poly2,
                           ])
 def test_query_region_polygon(polygon, patch_get):
-    result = irsa.core.Irsa.query_region("m31", catalog="fp_psc", spatial="Polygon",
+    result = lcogt.core.Lcogt.query_region("m31", catalog="fp_psc", spatial="Polygon",
                                          polygon=polygon)
     assert isinstance(result, Table)
 
 
 @pytest.mark.parametrize(('spatial', 'result'), zip(('Cone', 'Box', 'Polygon', 'All-Sky'), ('Cone', 'Box', 'Polygon', 'NONE')))
 def test_spatial_valdi(spatial, result):
-    out = irsa.core.Irsa._parse_spatial(spatial, coordinates='m31', radius=5 * u.deg, width=5 * u.deg, polygon=[(5 * u.hour, 5 * u.deg)] * 3)
+    out = lcogt.core.Lcogt._parse_spatial(spatial, coordinates='m31', radius=5 * u.deg, width=5 * u.deg, polygon=[(5 * u.hour, 5 * u.deg)] * 3)
     assert out['spatial'] == result
 
 
 @pytest.mark.parametrize(('spatial'), [('cone', 'box', 'polygon', 'all-Sky', 'All-sky', 'invalid', 'blah')])
 def test_spatial_invalid(spatial):
     with pytest.raises(ValueError):
-        irsa.core.Irsa._parse_spatial(spatial, coordinates='m31')
+        lcogt.core.Lcogt._parse_spatial(spatial, coordinates='m31')