oc-cdtapi 3.9.1__py2-none-any.whl → 3.9.4__py2-none-any.whl

oc_cdtapi/API.py

@@ -13,6 +13,7 @@ if sys.version_info.major == 2:
 elif sys.version_info.major == 3:
     strtype = str
 
+
 class HttpAPIError(Exception):
 
     def __init__(self, code=0, url='', resp=None, text=''):
@@ -21,7 +22,6 @@ class HttpAPIError(Exception):
         self.resp = resp
         self.text = text
 
-
     def __str__(self):
         return self.text + ': Code ' + str(self.code) + ' ' + self.url
 
@@ -40,11 +40,11 @@ class HttpAPI(object):
 
     def __init__(self, root=None, user=None, auth=None, readonly=False, anonymous=False):
         """
-        :param root: Root URL (uses *_URL by default)
-        :param user: Username (uses *_USER by default)
-        :param auth: Password (uses *_PASSWORD by default)
-        :param readonly: sets readonly property, should be explictly supported by child 
-        :param anonymous: ignore username/password provided and use anonymous requests
+        :param str root: Root URL (uses *_URL by default)
+        :param str user: Username (uses *_USER by default)
+        :param str auth: Password (uses *_PASSWORD by default)
+        :param bool readonly: sets readonly property, should be explictly supported by child 
+        :param bool anonymous: ignore username/password provided and use anonymous requests
 
         >>> import os
         >>> from oc_cdtapi.API import HttpAPI
@@ -67,30 +67,58 @@ class HttpAPI(object):
         """
 
         self.readonly = readonly
-        if self._env_prefix != None:
-            if not root: root = os.getenv(self._env_prefix + self._env_url)
-            if not user: user = os.getenv(self._env_prefix + self._env_user)
-            if not auth: auth = os.getenv(self._env_prefix + self._env_auth)
-        if not root: raise ValueError('Server URL for service [%s] not set' % self._env_prefix)
+
+        if self._env_prefix is not None:
+            if not root:
+                root = os.getenv(self._env_prefix + self._env_url)
+
+            if not user:
+                user = os.getenv(self._env_prefix + self._env_user)
+
+            if not auth:
+                auth = os.getenv(self._env_prefix + self._env_auth)
+
+        if not root:
+            raise ValueError('Server URL for service [%s] not set' % self._env_prefix)
+
         self.root = root
         self.web = requests.Session()
-        if user != None and not anonymous: self.web.auth = (user, auth)
 
-        if self.root.startswith( "https:" ):
-            self.web.verify = False;
+        if user and not anonymous:
+            self.web.auth = (user, auth)
 
+        if self.root.startswith("https:"):
+            # ignore self-signed certificates warning
+            self.web.verify = False
 
     def set_readonly(self, readonly=True):
+        """
+        Set instance as read-only
+        :param bool readonly: foo
+        """
         self.readonly = readonly
 
-
     def re(self, req):
-        """ Constructs request URL from request name """
-        return posixpath.join(self.root, req)
+        """ 
+        Constructs request URL from request name
+        :param str req: string or list of strings for the request
+        """
+        # do not use 'urlparse.urljoin' here because it gives wrong result if 'root'
+        # contains sub-path. Example:
+        # urlparse.urljoin("https://exapmle.com:5400/c1/c2/c3", "c4/c5/c6")
+        # gives 'https://exapmle.com:5400/c1/c2/c4/c5/c6'
+        # while 'https://exapmle.com:5400/c1/c2/c3/c4/c5/c6' expected ('c3' missing)
+        if isinstance(req, list):
+            req = posixpath.sep.join(req)
 
+        return posixpath.join(self.root, req)
 
     def pp(self, resp, write_to=None, stream=False, **kvarg):
         """ Post-processes response
+        :param requests.Response resp: the response object
+        :param fileObj write_to: file object to write result to
+        :param bool stream: use stream mode (useful for large objects)
+        :param kvarg: another keyword arguments, not actually used
 
         New feature! If write_to parameter is given to any method, that returns response
         object, request result will be written to fd or filename specified in write_to.
@@ -147,29 +175,50 @@ class HttpAPI(object):
 
         if resp.status_code < self.raise_exception_low or resp.status_code > self.raise_exception_high:
             raise self._error(resp.status_code, resp.url, resp, 'Error making request to server')
-        if write_to != None:
-            if isinstance (write_to, strtype):
+
+        if write_to is not None:
+
+            if isinstance(write_to, strtype):
                 fd = open(write_to, 'wb')
             else:
                 fd = write_to
+
             if not stream:
                 fd.write(resp.content)
             else:
                 shutil.copyfileobj(resp.raw, fd)
+
             fd.flush()
-            if isinstance (write_to, strtype): fd.close()
+
+            if isinstance(write_to, strtype):
+                fd.close()
+
             del fd
-        return resp
 
+        return resp
 
     def __kvarg(self, kvarg):
+        """
+        Omit 'write_to' argument
+        :param dict kvarg: keyword arguments
+        :return dict: ditionary without 'write_to' key
+        """
+
         kvarg = kvarg.copy()
-        if 'write_to' in kvarg: del kvarg['write_to']
-        return kvarg
+        if 'write_to' in kvarg:
+            del kvarg['write_to']
 
+        return kvarg
 
     def get(self, req, params=None, files=None, data=None, headers=None, **kvarg):
         """Sends GET request
+        :param str req: request sub-URL
+        :param dict params: additional GET parameters
+        :param files: files to append to the request
+        :param data: additional data to append to the request
+        :param dict headers: additional headers for the request
+        :param kvarg: additional keyword arguments
+        :return requests.Response: postprocessed the response object
 
         >>> def test(port):
         ...     api = HttpAPI('http://127.0.0.1:' + str(port))
@@ -193,18 +242,36 @@ class HttpAPI(object):
 
         """
 
-        resp = self.web.get(self.re(req), params=params, data=data, files=files, headers=headers, **self.__kvarg(kvarg))
-        return self.pp(resp, **kvarg)
+        resp = self.web.get(self.re(req), params=params, data=data,
+                            files=files, headers=headers, **self.__kvarg(kvarg))
 
+        return self.pp(resp, **kvarg)
 
     def post(self, req, params=None, files=None, data=None, headers=None, **kvarg):
-        """Sends POST request"""
-        resp = self.web.post(self.re(req), params=params, data=data, files=files, headers=headers, **kvarg)
+        """
+        Sends POST request
+        :param str req: request sub-URL
+        :param dict params: additional GET parameters
+        :param files: files to append to the request
+        :param data: additional data to append to the request
+        :param dict headers: additional headers for the request
+        :param kvarg: additional keyword arguments
+        :return requests.Response: postprocessed the response object
+        """
+        resp = self.web.post(self.re(req), params=params,
+                             data=data, files=files, headers=headers, **kvarg)
         return self.pp(resp, **kvarg)
 
-
     def put(self, req, params=None, files=None, data=None, headers=None, **kvarg):
         """Sends PUT request
+        :param str req: request sub-URL
+        :param dict params: additional GET parameters
+        :param files: files to append to the request
+        :param data: additional data to append to the request
+        :param dict headers: additional headers for the request
+        :param kvarg: additional keyword arguments
+        :return requests.Response: postprocessed the response object
+
         >>> def test(port):
         ...     api = HttpAPI('http://127.0.0.1:' + str(port))
         ...     api.put('getrequest')
@@ -215,35 +282,64 @@ class HttpAPI(object):
 
         """
 
-        resp = self.web.put(self.re(req), params=params, data=data, files=files, headers=headers, **kvarg)
+        resp = self.web.put(self.re(req), params=params,
+                            data=data, files=files, headers=headers, **kvarg)
         return self.pp(resp, **kvarg)
 
-
     def delete(self, req, params=None, files=None, data=None, headers=None, **kvarg):
-        """Sends DELETE request"""
-        resp = self.web.delete(self.re(req), params=params, data=data, files=files, headers=headers, **kvarg)
+        """
+        Sends DELETE request
+        :param str req: request sub-URL
+        :param dict params: additional GET parameters
+        :param files: files to append to the request
+        :param data: additional data to append to the request
+        :param dict headers: additional headers for the request
+        :param kvarg: additional keyword arguments
+        :return requests.Response: postprocessed the response object
+        """
+        resp = self.web.delete(self.re(req), params=params,
+                               data=data, files=files, headers=headers, **kvarg)
         return self.pp(resp, **kvarg)
 
     def head(self, req, params=None, files=None, data=None, headers=None, **kvarg):
-        """Sends HEAD request"""
-        resp = self.web.head(self.re(req), params=params, data=data, files=files, headers=headers, **kvarg)
+        """
+        Sends HEAD request
+        :param str req: request sub-URL
+        :param dict params: additional GET parameters
+        :param files: files to append to the request
+        :param data: additional data to append to the request
+        :param dict headers: additional headers for the request
+        :param kvarg: additional keyword arguments
+        :return requests.Response: postprocessed the response object
+        """
+        resp = self.web.head(self.re(req), params=params,
+                             data=data, files=files, headers=headers, **kvarg)
         return self.pp(resp, **kvarg)
 
 
 # Two shortcuts to deal with XML without having full XML support
 def get_xml_tag(config, tag):
-    """Gets tag value from xml config"""
+    """
+    Gets tag value from xml config
+    Warning: this method ignores XML-comments and returns the first inclusion only
+    :param str config: xml string
+    :param str tag: tag to get
+    :return str: first tag value found
+    """
     return ((config.split('<' + tag + '>')[1]).split('</' + tag + '>')[0])
 
 
 def edit_xml_tag(config, tag, value):
-    """Sets tag value in xml config. Works fine if there is only single such tag in XML"""
+    """
+    Sets tag value in xml config. Works fine if there is only single such tag in XML
+    Warning: this method ignores XML-comments and returns the first inclusion only
+    :param str config: xml string
+    :param str tag: tag to edit
+    :param str value: value to set
+    :return str: str with replaced tag value
+    """
     config = config.split('<' + tag + '>')[0] + '<' + tag + '>' + value + '</' + tag + '>' + \
-             config.split('</' + tag + '>')[1]
-    return config
+        config.split('</' + tag + '>')[1]
 
+    return config
 
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod()

oc_cdtapi/DevPIAPI.py

@@ -4,54 +4,54 @@
 Additional HTTP API for Python Package Index based on DevPI
 """
 
-from .API import HttpAPI;
-import re;
-import xml.etree.ElementTree as ET;
-import posixpath;
+from .API import HttpAPI
+import re
+import xml.etree.ElementTree as ET
+import posixpath
 
-class DevPIAPI( HttpAPI ):
+
+class DevPIAPI(HttpAPI):
     """
     Class for providing some simple Http requests to PyPI based on DevPI 
     """
-    _env_prefix = "PYPI_PRODUCTION";
+    _env_prefix = "PYPI_PRODUCTION"
 
-    def _split_pkg_string( r_self, str_name ):
+    def _split_pkg_string(self, name):
         """
         Split string for package name into components following PyPI standard
-        :param r_self: self reference
-        :type r_self: DevPIApi object
-        :param str_name: python package name
-        :type str_name: string, unicode
-        :return: dictionary with components: distribution, version, build_tag, python_tag, abi_tag, platform_tag. Some of them may be absent
+        :param str name: python package name
+        :return dict: components: distribution, version, build_tag, python_tag, abi_tag, platform_tag.
+                      Some of them may be absent
         """
 
-        obj_match = re.match( r'^(?P<distribution>[^\.]*)-(?P<version>[\d\.]+)(-(?P<build_tag>[^\-]+))?-(?P<python_tag>[^\-]+)-(?P<abi_tag>[^\-]+)-(?P<platform_tag>[^\-\.]+)\.whl$', str_name );
+        _match = re.match(
+            r'^(?P<distribution>[^\.]*)-(?P<version>[\d\.]+)(-(?P<build_tag>[^\-]+))?-(?P<python_tag>[^\-]+)-(?P<abi_tag>[^\-]+)-(?P<platform_tag>[^\-\.]+)\.whl$', name)
 
-        if obj_match is None:
-            obj_match = re.match( r'^(?P<distribution>[^\.]*)-(?P<version>[\d\.]+)\.tar\.gz$', str_name );
+        if _match is None:
+            _match = re.match(r'^(?P<distribution>[^\.]*)-(?P<version>[\d\.]+)\.tar\.gz$', name)
 
-        if obj_match is None:
-            raise ValueError( 'DevPI answer is wrong: package name ' + str_name + " does not match any known pattern" );
+        if _match is None:
+            raise ValueError('DevPI answer is wrong: package name [%s] does not match any known pattern' % name)
 
-        return obj_match.groupdict();
+        return _match.groupdict()
 
-    def get_package_versions( r_self, str_name ):
+    def get_package_versions(self, name):
         """
         Get package version list from server
-        :param r_self: self reference
-        :type r_self: DevPIApi object
-        :param str_name: python package name
-        :type str_name: string, unicode
+        :param self: self reference
+        :type self: DevPIApi object
+        :param name: python package name
+        :type name: string, unicode
         :return: list of versions on the server, or None if nothing found
         """
 
-        str_name = str_name.strip();
-        str_request = posixpath.join( "+simple", str_name );
-        obj_resp = r_self.get( str_request );
+        name = name.strip()
+        _request = posixpath.join("+simple", name)
+        _resp = self.get(_request)
 
-        if ( obj_resp.status_code != 200 ):
-            return None;
+        if (_resp.status_code != 200):
+            return None
 
-        xml_resp = ET.fromstring( obj_resp.text );
+        xml_resp = ET.fromstring(_resp.text)
 
-        return list( set( [r_self._split_pkg_string( x.text )[ 'version' ] for x in xml_resp.findall( 'body/a' )] ) )
+        return list(set([self._split_pkg_string(x.text)['version'] for x in xml_resp.findall('body/a')]))

oc_cdtapi/DmsAPI.py

@@ -1,57 +1,101 @@
 import logging
 import os
 import re
+import posixpath
+
+from . import API
 
-from oc_cdtapi import API
 
 class DmsAPIError(API.HttpAPIError):
     pass
 
-class DmsAPI(API.HttpAPI):   # we use HttpAPI as a base class - the idea of HttpAPI is to use it as a skelet for new API clients
+
+# we use HttpAPI as a base class - the idea of HttpAPI is to use it as a skelet for new API clients
+class DmsAPI(API.HttpAPI):   
     """
     DmsAPI implementation
     """
     # do not forget about docstrings
 
-    _env_prefix = 'DMS' # this automatically allows usage of DMS_* environment variables - everything is done in HttpAPI for you
+    # this automatically allows usage of DMS_* environment variables - everything is done in HttpAPI for you
+    _env_prefix = 'DMS'  
     _env_token = '_TOKEN'
-    _env_crs = '_CRS_URL' # now we have a separate Components Registry Service for components info obtaining
+    # for now we have a separate Components Registry Service for components info obtaining
+    # TODO: refactor when it will be joined with base DMS API on the server-side
+    _env_crs = '_CRS_URL'
 
     def __init__(self, *args, **argv):
         """
         Initialiazing the parent class then loading the DMS API's bearer token
         """
-        API.HttpAPI.__init__(self)
+
+        # TODO: re-factor when Python2 support will be deprecated
+        super(DmsAPI, self).__init__(*args, **argv)
         self.crs_root = os.getenv(self._env_prefix + self._env_crs)
         token = os.getenv(self._env_prefix + self._env_token)
+
         if not self.crs_root:
-            raise DmsAPIError("DMS API initialization failed. The components request url is not set")
+            raise DmsAPIError("DMS API initialization failed. The components request URL [%s] is not set" % (
+                self._env_prefix + self._env_crs))
+
         if token:
             self.headers = {"Authorization": "Bearer {}".format(token)}
         else:
-            self.headers = {} # Empty headers dict is added for backwards-compatibility with bearer token functional
+            # Empty headers dict is added for backwards-compatibility with bearer token functional
+            self.headers = {}
+
+    def __req(self, req):
+        """
+        Joining an URL to one posixpath-compatible
+        :param str req: request, may be list of str
+        :return str: joined req
+        """
+        if not req:
+            return req
+
+        if isinstance(req, list):
+            logging.log(5, "re-formatting requested list [%s] URL to string" % ', '.join(req))
+            req = posixpath.sep.join(req)
+
+        return req
 
-        if self.crs_root[-1] != '/': self.crs_root += '/'
 
     def re(self, req):
         """
         Re-defines default request formater, not to be called directly
-        This forms request URL separated by / from string array
+        This forms request URL separated by slash from string array
+        :param req: list of str or str for sub-url
+        :return str: full joined URL
         """
-        if len(req) == 0: return self.root
-        return self.root + 'dms-service/rest/api/' + '/'.join(req)
 
-        # directly accessing class variables outside the class itself is possible, but should be avoided
-        # consider using setters/getters or storing state outside the class
-    
+        if not req:
+            return self.root
+
+        # do not use 'urlparse.urljoin' here because it gives wrong result if 'root'
+        # contains sub-path. Example:
+        # urlparse.urljoin("https://exapmle.com:5400/c1/c2/c3", "c4/c5/c6")
+        # gives 'https://exapmle.com:5400/c1/c2/c4/c5/c6'
+        # while 'https://exapmle.com:5400/c1/c2/c3/c4/c5/c6' expected ('c3' missing)
+
+        return posixpath.join(self.root, "dms-service", "rest", "api", self.__req(req))
+
+    # directly accessing class variables outside the class itself is possible, but should be avoided
+    # consider using setters/getters or storing state outside the class
+
     def crs_re(self, req):
         """
         Forming the correct URL for the DMS Components Registry Service
+        :param req: list of str or str for sub-url
+        :return str: full joined URL
         """
-        if len(req) == 0: return self.crs_root
-        return self.crs_root + 'rest/api/' + '/'.join(req)
+        if not req:
+            return self.crs_root
+
+        # see the note about 'urljoin' in 're' method - the same is applicable here
 
-    def get_artifacts(self, component, version, ctype = None):
+        return posixpath.join(self.crs_root, 'rest', 'api', self.__req(req))
+
+    def get_artifacts(self, component, version, ctype=None):
         """
         Gets list of artifacts of given component, version and type
         :param component: dms component name
@@ -59,25 +103,32 @@ class DmsAPI(API.HttpAPI):   # we use HttpAPI as a base class - the idea of Http
         :param ctype:     type of artifact. if not specified - query all known types
         :returns:         list of artifacts
         """
-        assert bool(re.match('^[a-zA-Z0-9_-]*$', component)), "Component name must contain only latin letters, numbers, underscores and hyphens"
-        assert bool(re.match('^[a-zA-Z0-9._-]*$', version)), "Version must contain only latin letters, numbers, underscores, hyphens and dots"
+        assert bool(re.match('^[a-zA-Z0-9_-]*$', component)
+                    ), "Component name must contain only latin letters, numbers, underscores and hyphens"
+        assert bool(re.match('^[a-zA-Z0-9._-]*$', version)
+                    ), "Version must contain only latin letters, numbers, underscores, hyphens and dots"
         logging.debug('Reached %s.get_artifacts', self.__class__.__name__)
+
         if ctype is None:
             types = self.get_types()
         else:
-            assert bool(re.match('^[a-zA-Z0-9_-]*$', ctype)), "Component type must contain only latin letters, numbers, underscores and hyphens"
-            types = [ ctype ]
+            assert bool(re.match('^[a-zA-Z0-9_-]*$', ctype)
+                        ), "Component type must contain only latin letters, numbers, underscores and hyphens"
+            types = [ctype]
 
         artifacts = []
 
         for t in types:
             req = ['2', 'component', component, 'version', version, t, 'list']
-            artifacts += self.get(req, headers=self.headers, verify=False).json() # Why do you use write_to parameter instead of just using response object ?
+
+            # Why do you use write_to parameter instead of just using response object ?
             # also, requests has json parser, no need to re-invent it
+            artifacts += self.get(req, headers=self.headers, verify=False).json()
 
-        logging.debug('About to return an array of %d elements', len(artifacts)) # logging has its own format-string engine
-        return artifacts
+        # logging has its own format-string engine
+        logging.debug('About to return an array of %d elements', len(artifacts))
 
+        return artifacts
 
     def get_components(self):
         """
@@ -88,71 +139,86 @@ class DmsAPI(API.HttpAPI):   # we use HttpAPI as a base class - the idea of Http
         req = ['1', 'components']
 
         crs_request_url = self.crs_re(req)
-        components = self.web.get(crs_request_url, verify=False).json()['components']
+        components = self.web.get(crs_request_url, verify=False).json().get('components', list())
         logging.debug('About to return an array of %d elements', len(components))
+
         return components
 
     def get_gav(self, component, version, ctype, artifact, classifier=None):
         """
         Requests and forms gav for specified artifact
-        :param component: component name
-        :param version: version
-        :param ctype:
-        :param artifact:
-        :param classifier:
-        :returns: gav
-        """
-        assert bool(re.match('^[a-zA-Z0-9_-]+$', component)), "Component name have not to be empty and must contain only latin letters, numbers, underscores and hyphens"
-        assert bool(re.match('^[a-zA-Z0-9\._-]+$', version)), "Version have not to be empty and must contain only latin letters, numbers, underscores, hyphens and dots"
-        assert bool(re.match('^[a-zA-Z0-9_-]+$', ctype)), "Component type have not to be empty and must contain only latin letters, numbers, underscores and hyphens"
-        assert bool(re.match('^[a-zA-Z0-9_-]+$', artifact)), "Artifact type have not to be empty and must contain only latin letters, numbers, underscores and hyphens"
+        :param str component: component name
+        :param str version: version
+        :param str ctype:
+        :param str artifact:
+        :param str classifier:
+        :returns str: gav
+        """
+        assert bool(re.match('^[a-zA-Z0-9_-]+$', component)
+                    ), "Component name have not to be empty and must contain only latin letters, numbers, underscores and hyphens"
+        assert bool(re.match('^[a-zA-Z0-9\._-]+$', version)
+                    ), "Version have not to be empty and must contain only latin letters, numbers, underscores, hyphens and dots"
+        assert bool(re.match('^[a-zA-Z0-9_-]+$', ctype)
+                    ), "Component type have not to be empty and must contain only latin letters, numbers, underscores and hyphens"
+        assert bool(re.match('^[a-zA-Z0-9_-]+$', artifact)
+                    ), "Artifact type have not to be empty and must contain only latin letters, numbers, underscores and hyphens"
         logging.debug('Reached %s.get_gav', self.__class__.__name__)
         logging.debug('component: {0}'.format(component))
         logging.debug('version: {0}'.format(version))
         logging.debug('artifact: {0}'.format(artifact))
         logging.debug('classifier: {0}'.format(classifier))
         req = ['1', 'component', component, 'version', version, ctype, artifact, 'gav']
+
+        params = None
+
         if classifier:
-            assert bool(re.match('^[a-zA-Z0-9_-]+$', classifier)), "Non-empty classifier must contain only latin letters, hyphens and underscores"
+            assert bool(re.match('^[a-zA-Z0-9_-]+$', classifier)
+                        ), "Non-empty classifier must contain only latin letters, hyphens and underscores"
             params = {'classifier': classifier}
-        else:
-            params = None
 
         gav = self.get(req, params, headers=self.headers).json()
 
-        assert bool(re.match('^[a-zA-Z0-9\._-]+$', gav['groupId'])), "groupId have not to be empty and must contain only latin letters, numbers, underscores, hyphens and dots"
-        assert bool(re.match('^[a-zA-Z0-9_-]+$', gav['artifactId'])), "artifactId have not to be empty and must contain only latin letters, numbers, underscores and hyphens"
-        assert bool(re.match('^[a-zA-Z0-9\._-]+$', gav['version'])), "version have not to be empty and must contain only latin letters, numbers, underscores, hyphens and dots"
-        assert bool(re.match('^[a-zA-Z0-9_-]+$', gav['packaging'])), "packaging have not to be empty and must contain only latin letters, hyphens and underscores"
+        assert bool(re.match('^[a-zA-Z0-9\._-]+$', gav['groupId'])
+                    ), "groupId have not to be empty and must contain only latin letters, numbers, underscores, hyphens and dots"
+        assert bool(re.match('^[a-zA-Z0-9_-]+$', gav['artifactId'])
+                    ), "artifactId have not to be empty and must contain only latin letters, numbers, underscores and hyphens"
+        assert bool(re.match('^[a-zA-Z0-9\._-]+$', gav['version'])
+                    ), "version have not to be empty and must contain only latin letters, numbers, underscores, hyphens and dots"
+        assert bool(re.match('^[a-zA-Z0-9_-]+$', gav['packaging'])
+                    ), "packaging have not to be empty and must contain only latin letters, hyphens and underscores"
+
+        _gav = ':'.join(list(map(lambda x: gav[x], ['groupId', 'artifactId', 'version', 'packaging'])))
 
-        _gav = ':'.join( [gav['groupId'], gav['artifactId'], gav['version'], gav['packaging']] )
         if gav.get('classifier'):
-            assert bool(re.match('^[a-zA-Z0-9_-]+$', gav['classifier'])), "non-empty classifier must contain only latin letters, hyphens and underscores"
+            assert bool(re.match('^[a-zA-Z0-9_-]+$', gav['classifier'])
+                        ), "non-empty classifier must contain only latin letters, hyphens and underscores"
             _gav = ':'.join([_gav, gav['classifier']])
 
         logging.debug('Formed gav: %s', _gav)
 
         return _gav
 
-
-    def get_types(self): return ['notes', 'distribution', 'report', 'static', 'documentation']
-
+    def get_types(self): 
+        return ['notes', 'distribution', 'report', 'static', 'documentation']
 
     def get_versions(self, component):
         """
         fetches list of versions for specified component
-        :param component: component name
-        :returns: array of versions
+        :param str component: component name
+        :returns list: versions
         """
-        assert bool(re.match('^[a-zA-Z0-9_-]*$', component)), "Component name must contain only latin letters, numbers, underscores and hyphens"
+
+        assert bool(re.match('^[a-zA-Z0-9_-]*$', component)
+                    ), "Component name must contain only latin letters, numbers, underscores and hyphens"
+
         logging.debug('Reached %s.get_versions', self.__class__.__name__)
 
         req = ['2', 'component', component, 'versions']
 
         versions = list(map(lambda x: x.get('version'), self.get(req, headers=self.headers).json().get('versions')))
-        logging.debug('About to return an array of %d elements',len(versions))
-        return versions
+        logging.debug('About to return an array of %d elements', len(versions))
 
+        return versions
 
     def ping_dms(self):
         """
@@ -160,5 +226,5 @@ class DmsAPI(API.HttpAPI):   # we use HttpAPI as a base class - the idea of Http
         :returns: server response
         """
         logging.debug('Reached %s.ping_dms', self.__class__.__name__)
-        return self.get([], headers=self.headers).content
 
+        return self.get([], headers=self.headers).content