Merge remote-tracking branch 'upstream/master'

Author: vilhelmp

astroquery/alma/__init__.py

@@ -16,7 +16,7 @@ class Conf(_config.ConfigNamespace):
                                       'http://almascience.eso.org',
                                       'http://almascience.nrao.edu',
                                       'http://almascience.nao.ac.jp',
-                                      'http://beta.cadc-ccda.hia-iha.nrc-cnrc.gc.ca/aq', # the beta server (for testing)
+                                      'http://beta.cadc-ccda.hia-iha.nrc-cnrc.gc.ca', # the beta server (for testing)
                                      ],
                                      'The ALMA Archive mirror to use')
 

astroquery/alma/core.py

@@ -11,6 +11,7 @@
 import re
 import tarfile
 import string
+import requests
 from pkg_resources import resource_filename
 from bs4 import BeautifulSoup
 
@@ -545,7 +546,7 @@ def get_files_from_tarballs(self, downloaded_files, regex='.*\.fits$',
                         log.info("Extracting {0} to {1}".format(member.name,
                                                                 path))
                     tf.extract(member, path)
-                    filelist.append(urljoin(path, member.name))
+                    filelist.append(os.path.join(path, member.name))
 
         return filelist
 
@@ -596,8 +597,16 @@ def download_and_extract_files(self, urls, delete=True, regex='.*\.fits$',
                     log.info("ASDM tarballs do not contain FITS files; skipping.")
                     continue
 
-            tarball_name = self._request('GET', url, save=True,
-                                         timeout=self.TIMEOUT)
+            try:
+                tarball_name = self._request('GET', url, save=True,
+                                             timeout=self.TIMEOUT)
+            except requests.ConnectionError as ex:
+                self.partial_file_list = all_files
+                log.error("There was an error downloading the file. "
+                          "A partially completed download list is "
+                          "in Alma.partial_file_list")
+                raise ex
+                
             fitsfilelist = self.get_files_from_tarballs([tarball_name],
                                                         regex=regex, path=path,
                                                         verbose=verbose)

astroquery/alma/tests/test_alma_remote.py

@@ -12,6 +12,10 @@
 
 @remote_data
 class TestAlma:
+
+    def setup_class(cls):
+        Alma.archive_url = 'http://beta.cadc-ccda.hia-iha.nrc-cnrc.gc.ca'
+
     @pytest.fixture()
     def temp_dir(self, request):
         my_temp_dir = tempfile.mkdtemp()

astroquery/splatalogue/utils.py

@@ -5,9 +5,22 @@
 import numpy as np
 import astropy
 
-column_headings_map = {'Log<sub>10</sub> (A<sub>ij</sub>)': 'log10(Aij)',
-                       'E_U (K)': 'EU_K',
-                       'Resolved QNs': 'QNs'}
+# Remap column headings to something IPAC-compatible
+column_headings_map = {'Log<sub>10</sub> (A<sub>ij</sub>)': 'log10_Aij',
+                       'Resolved QNs': 'QNs',
+                       'CDMS/JPL Intensity':'CDMSJPL_Intensity',
+                       'S<sub>ij</sub>':'Sij',
+                       'Freq-GHz':'FreqGHz',
+                       'Meas Freq-GHz':'MeasFreqGHz',
+                       'Lovas/AST Intensity':'LovasAST_Intensity',
+                       'E_L (cm^-1)':'EL_percm',
+                       'E_L (K)':'EL_K',
+                       'E_U (cm^-1)':'EU_percm',
+                       'E_U (K)':'EU_K',
+                       'Chemical Name':'ChemicalName',
+                       'Freq Err':'FreqErr',
+                       'Meas Freq Err':'MeasFreqErr',
+                      }
 
 
 def clean_column_headings(table, renaming_dict=column_headings_map):

astroquery/template_module/core.py

@@ -13,35 +13,58 @@
 
 # 3. local imports - use relative imports
 # commonly required local imports shown below as example
-from ..query import BaseQuery # all Query classes should inherit from this.
-from ..utils import commons # has common functions required by most modules
-from ..utils import prepend_docstr_noreturns # automatically generate docs for similar functions
-from ..utils import async_to_sync # all class methods must be callable as static as well as instance methods.
-from . import conf # import configurable items declared in __init__.py
+# all Query classes should inherit from BaseQuery.
+from ..query import BaseQuery
+# has common functions required by most modules
+from ..utils import commons
+# prepend_docstr is a way to copy docstrings between methods
+from ..utils import prepend_docstr_noreturns
+# async_to_sync generates the relevant query tools from _async methods
+from ..utils import async_to_sync
+# import configurable items declared in __init__.py
+from . import conf
 
 
 # export all the public classes and methods
-__all__ = ['Dummy', 'DummyClass']
+__all__ = ['Template', 'TemplateClass']
 
 # declare global variables and constants if any
 
 
 # Now begin your main class
 # should be decorated with the async_to_sync imported previously
 @async_to_sync
-class DummyClass(BaseQuery):
+class TemplateClass(BaseQuery):
 
     """
-    Not all the methods below are necessary but these cover most of the common cases, new methods may be added if necessary, follow the guidelines at <http://astroquery.readthedocs.org/en/latest/api.html>
+    Not all the methods below are necessary but these cover most of the common
+    cases, new methods may be added if necessary, follow the guidelines at
+    <http://astroquery.readthedocs.org/en/latest/api.html>
     """
-    # use the Configuration Items imported from __init__.py to set the URL, TIMEOUT, etc.
+    # use the Configuration Items imported from __init__.py to set the URL,
+    # TIMEOUT, etc.
     URL = conf.server
     TIMEOUT = conf.timeout
 
-    def query_object(self, object_name, get_query_payload=False, verbose=False):
+    # all query methods are implemented with an "async" method that handles
+    # making the actual HTTP request and returns the raw HTTP response, which
+    # should be parsed by a separate _parse_result method.   The query_object
+    # method is created by async_to_sync automatically.  It would look like
+    # this:
+    """
+    def query_object(object_name, get_query_payload=False)
+        response = self.query_object_async(object_name,
+                                           get_query_payload=get_query_payload)
+        if get_query_payload:
+            return response
+        result = self._parse_result(response, verbose=verbose)
+        return result
+    """
+
+    def query_object_async(self, object_name, get_query_payload=False):
         """
         This method is for services that can parse object names. Otherwise
-        use :meth:`astroquery.template_module.DummyClass.query_region`.
+        use :meth:`astroquery.template_module.TemplateClass.query_region`.
         Put a brief description of what the class does here.
 
         Parameters
@@ -59,52 +82,16 @@ def query_object(self, object_name, get_query_payload=False, verbose=False):
 
         Returns
         -------
-        result : `~astropy.table.Table`
-            The result of the query as a `~astropy.table.Table` object.
-            All queries other than image queries should typically return
-            results like this.
+        response : `requests.Response`
+            The HTTP response returned from the service.
+            All async methods should return the raw HTTP response.
 
         Examples
         --------
         While this section is optional you may put in some examples that
         show how to use the method. The examples are written similar to
         standard doctests in python.
-        """
 
-        # typically query_object should have the following steps:
-        # 1. call the corresponding query_object_async method, and
-        #    get the HTTP response of the query
-        # 2. check if 'get_query_payload' is set to True, then
-        #    simply return the dict of HTTP request parameters.
-        # 3. otherwise call the parse_result method on the
-        #    HTTP response returned by query_object_async and
-        #    return the result parsed as astropy.Table
-        # These steps are filled in below, but may be replaced
-        # or modified as required.
-
-        response = self.query_object_async(object_name, get_query_payload=get_query_payload)
-        if get_query_payload:
-            return response
-        result = self._parse_result(response, verbose=verbose)
-        return result
-
-    # all query methods usually have a corresponding async method
-    # that handles making the actual HTTP request and returns the
-    # raw HTTP response, which should be parsed by a separate
-    # parse_result method. Since these async counterparts take in
-    # the same parameters as the corresponding query methods, but
-    # differ only in the return value, they should be decorated with
-    # prepend_docstr_noreturns which will automatically generate
-    # the common docs. See below for an example.
-
-    @prepend_docstr_noreturns(query_object.__doc__)
-    def query_object_async(self, object_name, get_query_payload=False):
-        """
-        Returns
-        -------
-        response : `requests.Response`
-            The HTTP response returned from the service.
-            All async methods should return the raw HTTP response.
         """
         # the async method should typically have the following steps:
         # 1. First construct the dictionary of the HTTP request params.
@@ -132,24 +119,25 @@ def query_object_async(self, object_name, get_query_payload=False):
 
         if get_query_payload:
             return request_payload
-        # commons.send_request takes 4 parameters - the URL to query, the dict of
-        # HTTP request parameters we constructed above, the TIMEOUT which we imported
-        # from __init__.py and the type of HTTP request - either 'GET' or 'POST', which
-        # defaults to 'GET'.
-        response = commons.send_request(self.URL,
-                                        request_payload,
-                                        self.TIMEOUT,
-                                        request_type='GET')
+        # BaseQuery classes come with a _request method that includes a
+        # built-in caching system
+        response = self._request('GET', self.URL, params=request_payload,
+                                 timeout=self.TIMEOUT, cache=cache)
         return response
 
     # For services that can query coordinates, use the query_region method.
     # The pattern is similar to the query_object method. The query_region
     # method also has a 'radius' keyword for specifying the radius around
     # the coordinates in which to search. If the region is a box, then
     # the keywords 'width' and 'height' should be used instead. The coordinates
-    # may be accepted as an `astropy.coordinates` object or as a
-    # string, which may be further parsed.
-    def query_region(self, coordinates, radius, width, height, get_query_payload=False, verbose=False):
+    # may be accepted as an `astropy.coordinates` object or as a string, which
+    # may be further parsed.
+
+    # similarly we write a query_region_async method that makes the
+    # actual HTTP request and returns the HTTP response
+
+    def query_region_async(self, coordinates, radius, height, width,
+                           get_query_payload=False, cache=True):
         """
         Queries a region around the specified coordinates.
 
@@ -168,40 +156,18 @@ def query_region(self, coordinates, radius, width, height, get_query_payload=Fal
         verbose : bool, optional
             Display VOTable warnings or not.
 
-        Returns
-        -------
-        result : `~astropy.table.Table`
-            The result of the query as a `~astropy.table.Table` object.
-            All queries other than image queries should typically return
-            results like this.
-        """
-        # the documentation and code are similar to the steps outlined in the
-        # `query_object` method, but a rough sketch is provided below
-
-        response = self.query_region_async(coordinates, radius, height, width,
-                                           get_query_payload=get_query_payload)
-        result = self._parse_result(response, verbose=verbose)
-        return result
-
-    # similarly we write a query_region_async method that makes the
-    # actual HTTP request and returns the HTTP response
-
-    @prepend_docstr_noreturns(query_region.__doc__)
-    def query_region_async(self, coordinates, radius, height, width, get_query_payload=False):
-        """
         Returns
         -------
         response : `requests.Response`
             The HTTP response returned from the service.
             All async methods should return the raw HTTP response.
         """
-        request_payload = self._args_to_payload(coordinates, radius, height, width)
+        request_payload = self._args_to_payload(coordinates, radius, height,
+                                                width)
         if get_query_payload:
             return request_payload
-        response = commons.send_request(self.URL,
-                                        request_payload,
-                                        self.TIMEOUT,
-                                        request_type='GET')
+        response = self._request('GET', self.URL, params=request_payload,
+                                 timeout=self.TIMEOUT, cache=cache)
         return response
 
     # as we mentioned earlier use various python regular expressions, etc
@@ -233,7 +199,12 @@ def _parse_result(self, response, verbose=False):
             # return raw result/ handle in some way
             pass
 
-    # for image queries, the results should be returned as a
+    # Image queries do not use the async_to_sync approach: the "synchronous"
+    # version must be defined explicitly.  The example below therefore presents
+    # a complete example of how to write your own synchronous query tools if
+    # you prefer to avoid the automatic approach.
+    #
+    # For image queries, the results should be returned as a
     # list of `astropy.fits.HDUList` objects. Typically image queries
     # have the following method family:
     # 1. get_images - this is the high level method that interacts with
@@ -328,7 +299,9 @@ def get_image_list(self, coordinates, radius, get_query_payload=False):
 
     def extract_image_urls(self, html_str):
         """
-        Helper function that uses regex to extract the image urls from the given HTML.
+        Helper function that uses regex to extract the image urls from the
+        given HTML.
+
         Parameters
         ----------
         html_str : str
@@ -343,7 +316,7 @@ def extract_image_urls(self, html_str):
         pass
 
 # the default tool for users to interact with is an instance of the Class
-Dummy = DummyClass()
+Template = TemplateClass()
 
 # once your class is done, tests should be written
 # See ./tests for examples on this

docs/alma/alma.rst

@@ -6,6 +6,15 @@
 ALMA Queries (`astroquery.alma`)
 ********************************
 
+Example Notebooks
+=================
+A series of example notebooks can be found here:
+
+ * `What has ALMA observed toward all Messier objects? (an example of querying many sources) <http://nbviewer.ipython.org/gist/keflavich/e798e10e3bf9a93d1453>`_
+ * `ALMA finder chart of the Cartwheel galaxy and public Cycle 1 data quicklooks <http://nbviewer.ipython.org/gist/keflavich/d5af22578094853e2d24>`_
+ * `Finder charts toward many sources with different backgrounds <http://nbviewer.ipython.org/gist/keflavich/2ef877ec90d774645fee>`_
+ * `Finder chart and downloaded data from Cycle 0 observations of Sombrero Galaxy <http://nbviewer.ipython.org/gist/keflavich/9934c9412d8f58299962>`_
+
 Getting started
 ===============