move some functionallity to mixins

pyvo/dal/datalink.py

@@ -5,17 +5,8 @@
 from __future__ import (
     absolute_import, division, print_function, unicode_literals)
 
-from functools import partial
-from datetime import datetime
-from time import sleep
-from distutils.version import LooseVersion
-import requests
-from astropy.io.votable import parse as votableparse
-
-from .query import (
-    DALResults, DALQuery, DALService, Record, UploadList,
-    DALServiceError, DALQueryError)
-from ..tools import vosi
+from .query import DALResults, DALQuery, DALService, Record, DALServiceError
+from .mixin import AvailabilityMixin, CapabilityMixin
 
 __all__ = [
     "search", "DatalinkService", "DatalinkQuery", "DatalinkResults"]
@@ -50,15 +41,11 @@ def search(url, id, responseformat=None, **keywords):
     service = DatalinkService(url)
     return service.search(id, responseformat, **keywords)
 
-class DatalinkService(DALService):
+class DatalinkService(DALService, AvailabilityMixin, CapabilityMixin):
     """
     a representation of a Datalink service
     """
 
-    _availability = (None, None)
-    _capabilities = None
-    _tables = None
-
     def __init__(self, baseurl):
         """
         instantiate a Datalink service
@@ -70,78 +57,6 @@ def __init__(self, baseurl):
         """
         super(DatalinkService, self).__init__(baseurl)
 
-    @property
-    def availability(self):
-        """
-        returns availability as a tuple in the following form:
-
-        Returns
-        -------
-        [0] : bool
-            whether the service is available or not
-        [1] : datetime
-            the time since the server is running
-        """
-        if self._availability == (None, None):
-            avail_url = '{0}/availability'.format(self.baseurl)
-
-            response = requests.get(avail_url, stream=True)
-
-            try:
-                response.raise_for_status()
-            except requests.RequestException as ex:
-                raise DALServiceError.from_except(ex, avail_url)
-
-            # requests doesn't decode the content by default
-            response.raw.read = partial(response.raw.read, decode_content=True)
-
-            self._availability = vosi.parse_availability(response.raw)
-        return self._availability
-
-    @property
-    def available(self):
-        """
-        True if the service is available, False otherwise
-        """
-        return self.availability[0]
-
-    @property
-    def up_since(self):
-        """
-        datetime the service was started
-        """
-        return self.availability[1]
-
-    @property
-    def capabilities(self):
-        """returns capabilities as a nested dictionary
-
-        Known keys include:
-
-            * outputs_formats
-            * languages: {
-                'ADQL-2.0': {
-                    'features':
-                        'ivo://ivoa.net/std/TAPRegExt#features-adqlgeo': [],
-                        'ivo://ivoa.net/std/TAPRegExt#features-udf': [],
-                }
-        """
-        if self._capabilities is None:
-            capa_url = '{0}/capabilities'.format(self.baseurl)
-            response = requests.get(capa_url, stream=True)
-
-            try:
-                response.raise_for_status()
-            except requests.RequestException as ex:
-                raise DALServiceError.from_except(ex, capa_url)
-
-            # requests doesn't decode the content by default
-            response.raw.read = partial(response.raw.read, decode_content=True)
-
-            self._capabilities = vosi.parse_capabilities(response.raw)
-        return self._capabilities
-
-
     def run_sync(self, id, responseformat=None, **keywords):
         """
         runs sync query and returns its result

pyvo/dal/mixin.py

@@ -0,0 +1,87 @@
+# Licensed under a 3-clause BSD style license - see LICENSE.rst
+"""
+Various mixins
+"""
+from __future__ import (
+    absolute_import, division, print_function, unicode_literals)
+
+from functools import partial
+import requests
+
+from .query import DALServiceError
+from ..tools import vosi
+
+class AvailabilityMixin(object):
+    """
+    Mixing for VOSI availability
+    """
+    _availability = (None, None)
+
+    @property
+    def availability(self):
+        """
+        returns availability as a tuple in the following form:
+
+        Returns
+        -------
+        [0] : bool
+            whether the service is available or not
+        [1] : datetime
+            the time since the server is running
+        """
+        if self._availability == (None, None):
+            avail_url = '{0}/availability'.format(self.baseurl)
+
+            response = requests.get(avail_url, stream=True)
+
+            try:
+                response.raise_for_status()
+            except requests.RequestException as ex:
+                raise DALServiceError.from_except(ex, avail_url)
+
+            # requests doesn't decode the content by default
+            response.raw.read = partial(response.raw.read, decode_content=True)
+
+            self._availability = vosi.parse_availability(response.raw)
+        return self._availability
+
+    @property
+    def available(self):
+        """
+        True if the service is available, False otherwise
+        """
+        return self.availability[0]
+
+    @property
+    def up_since(self):
+        """
+        datetime the service was started
+        """
+        return self.availability[1]
+
+
+class CapabilityMixin(object):
+    """
+    Mixing for VOSI capability
+    """
+    _capabilities = None
+
+    @property
+    def capabilities(self):
+        """
+        Returns capabilities as a nested dictionary
+        """
+        if self._capabilities is None:
+            capa_url = '{0}/capabilities'.format(self.baseurl)
+            response = requests.get(capa_url, stream=True)
+
+            try:
+                response.raise_for_status()
+            except requests.RequestException as ex:
+                raise DALServiceError.from_except(ex, capa_url)
+
+            # requests doesn't decode the content by default
+            response.raw.read = partial(response.raw.read, decode_content=True)
+
+            self._capabilities = vosi.parse_capabilities(response.raw)
+        return self._capabilities

pyvo/dal/tap.py

@@ -15,6 +15,7 @@
 from .query import (
     DALResults, DALQuery, DALService, Record, UploadList,
     DALServiceError, DALQueryError)
+from .mixin import AvailabilityMixin, CapabilityMixin
 from ..tools import vosi, uws
 
 __all__ = [
@@ -61,13 +62,11 @@ def search(url, query, language="ADQL", maxrec=None, uploads=None, **keywords):
     service = TAPService(url)
     return service.search(query, language, maxrec, uploads, **keywords)
 
-class TAPService(DALService):
+class TAPService(DALService, AvailabilityMixin, CapabilityMixin):
     """
     a representation of a Table Access Protocol service
     """
 
-    _availability = (None, None)
-    _capabilities = None
     _tables = None
 
     def __init__(self, baseurl):
@@ -81,77 +80,6 @@ def __init__(self, baseurl):
         """
         super(TAPService, self).__init__(baseurl)
 
-    @property
-    def availability(self):
-        """
-        returns availability as a tuple in the following form:
-
-        Returns
-        -------
-        [0] : bool
-            whether the service is available or not
-        [1] : datetime
-            the time since the server is running
-        """
-        if self._availability == (None, None):
-            avail_url = '{0}/availability'.format(self.baseurl)
-
-            response = requests.get(avail_url, stream=True)
-
-            try:
-                response.raise_for_status()
-            except requests.RequestException as ex:
-                raise DALServiceError.from_except(ex, avail_url)
-
-            # requests doesn't decode the content by default
-            response.raw.read = partial(response.raw.read, decode_content=True)
-
-            self._availability = vosi.parse_availability(response.raw)
-        return self._availability
-
-    @property
-    def available(self):
-        """
-        True if the service is available, False otherwise
-        """
-        return self.availability[0]
-
-    @property
-    def up_since(self):
-        """
-        datetime the service was started
-        """
-        return self.availability[1]
-
-    @property
-    def capabilities(self):
-        """returns capabilities as a nested dictionary
-
-        Known keys include:
-
-            * outputs_formats
-            * languages: {
-                'ADQL-2.0': {
-                    'features':
-                        'ivo://ivoa.net/std/TAPRegExt#features-adqlgeo': [],
-                        'ivo://ivoa.net/std/TAPRegExt#features-udf': [],
-                }
-        """
-        if self._capabilities is None:
-            capa_url = '{0}/capabilities'.format(self.baseurl)
-            response = requests.get(capa_url, stream=True)
-
-            try:
-                response.raise_for_status()
-            except requests.RequestException as ex:
-                raise DALServiceError.from_except(ex, capa_url)
-
-            # requests doesn't decode the content by default
-            response.raw.read = partial(response.raw.read, decode_content=True)
-
-            self._capabilities = vosi.parse_capabilities(response.raw)
-        return self._capabilities
-
     @property
     def tables(self):
         """