oc-cdtapi 3.9.2__py3-none-any.whl → 3.9.5__py3-none-any.whl

oc_cdtapi/JenkinsAPI.py

@@ -1,11 +1,12 @@
 # requires python-requests rpm package
+from enum import Enum
 import requests
 from .API import HttpAPI, HttpAPIError
 from string import Template
 import json
 from collections import namedtuple, OrderedDict
 import re
-import xml.etree.ElementTree as ET;
+import xml.etree.ElementTree as ET
 import posixpath
 import sys
 
@@ -42,10 +43,11 @@ class Jenkins(HttpAPI):
     _env_prefix = 'JENKINS'
 
     def re(self, req):
-        if req and req[0] == '!':
-            req = req[1:]
-            return posixpath.join( self.root, req );
-        return posixpath.join( self.root, req, 'api', 'json' );
+        if req and req.startswith('!'):
+            req = req.lstrip('!')
+            return posixpath.join(self.root, req)
+
+        return posixpath.join(self.root, req, 'api', 'json')
 
     def post(self, req, *vargs, **kvargs):
         # We need all post requests to be processed in a different way in re(),
@@ -57,127 +59,133 @@ class Jenkins(HttpAPI):
         jobs = self.get('', params={'tree': 'jobs[name]'})
         return filter(lambda x: (not prefix or x.startswith(prefix)) and (not suffix or x.endswith(suffix)),
                       map(lambda x: x['name'], jobs.json().get('jobs', [])))
+
     def get_node(self, node):
         """Gets config.xml for specific slave"""
-        config = self.get( posixpath.join( 'computer', node, 'config.xml') );
+        config = self.get(posixpath.join('computer', node, 'config.xml'))
         return config.text
 
     def put_node(self, node, config):
         """Saves config.xml for a node (or creates new node)"""
-        request = posixpath.join( 'computer', node, 'config.xml' );
+        request = posixpath.join('computer', node, 'config.xml')
         params = None
-        headers = {'content-type' : 'application/xml'}
+        headers = {'content-type': 'application/xml'}
 
         try:
             self.get_node(node)
         except JenkinsError as e:
-            if e.code == 404: request = posixpath.join( 'computer', 'doCreateItem' );
+            if e.code == 404:
+                request = posixpath.join('computer', 'doCreateItem')
             params = {'name': node}
 
-        if self.readonly: return None
+        if self.readonly:
+            return None
+
         put = self.post(request, data=config, params=params, headers=headers)
         return put
 
-    def delete_node( self, node ):
+    def delete_node(self, node):
         """Deletes node from CI"""
-        if self.readonly: return None
-        return self.post( posixpath.join( 'computer', node, 'doDelete' ) );
+        if self.readonly:
+            return None
+        return self.post(posixpath.join('computer', node, 'doDelete'))
 
-    def get_node_label_from_config( self, config ):
+    def get_node_label_from_config(self, config):
         """
         Get the exact XML tag value with XPATH: label
         :param self: self reference
         :param config: xml string with a configuration of node
         :return: <label> tag text
         """
-        obj_xml = ET.fromstring( config );
-        xml_tag = obj_xml.find( 'label' );
+        obj_xml = ET.fromstring(config)
+        xml_tag = obj_xml.find('label')
 
-        if ( xml_tag is None ) or ( xml_tag.text is None ) or ( len( xml_tag.text.strip() ) == 0 ):
-            return "";
+        if (xml_tag is None) or (xml_tag.text is None) or (len(xml_tag.text.strip()) == 0):
+            return ""
 
-        return xml_tag.text;
+        return xml_tag.text
 
     def get_node_label(self, node, config=None):
-        if not config: config = self.get_node(node)
-        return self.get_node_label_from_config( config ).split(' ')
+        if not config:
+            config = self.get_node(node)
+        return self.get_node_label_from_config(config).split(' ')
 
-    def set_node_label_in_config( self, config, label ):
+    def set_node_label_in_config(self, config, label):
         """
         set <label> tag in XML config
         :param self: self reference
         :param config: string with XML node configuration
         :return: string with edited 'config' with <lable> tag content set to 'label'
         """
-        obj_xml = ET.fromstring( config );
-        xml_tag = obj_xml.find( 'label' );
+        obj_xml = ET.fromstring(config)
+        xml_tag = obj_xml.find('label')
 
-        if ( xml_tag is None ):
-            xml_tag = ET.SubElement( obj_xml, 'label' );
+        if (xml_tag is None):
+            xml_tag = ET.SubElement(obj_xml, 'label')
 
-        xml_tag.text = label;
+        xml_tag.text = label
 
-        return ET.tostring( obj_xml, encoding='utf8' );
+        return ET.tostring(obj_xml, encoding='utf8')
 
     def set_node_label(self, node, label):
         config = self.get_node(node)
-        config = self.set_node_label_in_config( config, ' '.join(label))
+        config = self.set_node_label_in_config(config, ' '.join(label))
         return self.put_node(node, config)
 
     def enable_node(self, job):
-        if self.readonly: return None
-        return self.post( posixpath.join( 'computer', job, 'enable') );
+        if self.readonly:
+            return None
+        return self.post(posixpath.join('computer', job, 'enable'))
 
     def disable_node(self, job):
-        if self.readonly: return None
-        return self.post( posixpath.join( 'computer', job, 'disable') )
+        if self.readonly:
+            return None
+        return self.post(posixpath.join('computer', job, 'disable'))
 
     def is_node_idle(self, node):
         """Retrieve 'idle' attribute of a node via newer JSON API (may require Jenkins 2.x)."""
-        return json.loads(
-            self.get("computer/{}/api/json".format(node)).content
-        )['idle']
+        return self.get(posixpath.join("computer", node, "api", "json")).json().get('idle')
 
-    def list_nodes( self ):
+    def list_nodes(self):
         """
         List all active nodes (except master one)
         :return: List of strings with node names, possible empty
         """
-        raw_data = self.get( "computer", params = { "tree" : "computer[displayName]" } )
+        raw_data = self.get("computer", params={"tree": "computer[displayName]"})
         str_data = raw_data.text
 
 #        return map( lambda x: x[ "displayName" ], json.loads( self.get( "computer", params = { "tree" : "computer[displayName]" } ).text )[ "computer" ] );
-        return [x[ "displayName" ] for x in json.loads( str_data )[ "computer" ]];
-
+        return [x["displayName"] for x in json.loads(str_data)["computer"]]
 
-    def job_xml_enable( self, config ):
+    def job_xml_enable(self, config):
         """
         Enables jenkins job by modifying XML tag (XPATH=) in the configuration
         :param self: self reference
         :param config: xml string from a config
         :return: xml string with <disabled> tag value modified to 'true'
         """
-        obj_xml = ET.fromstring( config );
-        xml_tag = obj_xml.find( 'disabled' );
+        obj_xml = ET.fromstring(config)
+        xml_tag = obj_xml.find('disabled')
 
         if xml_tag is None:
-            return config;
+            return config
 
-        xml_tag.text = "false";
+        xml_tag.text = "false"
 
-        return ET.tostring( obj_xml, encoding='utf8' );
+        return ET.tostring(obj_xml, encoding='utf8')
 
     def copy_job(self, config, j_name, parameters={}, enabled=True, use_template=False):
         """Create or update job by template"""
 
-        if config[0] != '<':    config = self.get_job(config)
+        if config[0] != '<':
+            config = self.get_job(config)
         parameters['name'] = j_name
         if enabled:
-            config = self.job_xml_enable( config );
+            config = self.job_xml_enable(config)
 
-        cfg_type = str (type (config) )
+        cfg_type = str(type(config))
         if cfg_type.find('byte') != -1:
-            config = str (config, 'UTF-8')
+            config = str(config, 'UTF-8')
 
         if use_template:
             config = Template(config).safe_substitute(parameters)
@@ -190,142 +198,149 @@ class Jenkins(HttpAPI):
 
     def get_job(self, job):
         """Gets config.xml for a job"""
-        config = self.get( posixpath.join( 'job', job, 'config.xml') );
+        config = self.get(posixpath.join('job', job, 'config.xml'))
         return config.text
 
     def put_job(self, job, config):
         """Saves config.xml for a job (or creates new job)"""
-        request = posixpath.join( 'job', job, 'config.xml' )
+        request = posixpath.join('job', job, 'config.xml')
         params = None
-        headers = {'content-type' : 'application/xml'}
+        headers = {'content-type': 'application/xml'}
         try:
             self.get_job(job)
         except JenkinsError as e:
-            if e.code == 404: request = 'createItem'
+            if e.code == 404:
+                request = 'createItem'
             params = {'name': job}
 
-        if self.readonly: return None
+        if self.readonly:
+            return None
         put = self.post(request, data=config, params=params, headers=headers)
         return put
 
     def enable_job(self, job):
-        if self.readonly: return None
-        return self.post( posixpath.join( 'job', job, 'enable' ) );
+        if self.readonly:
+            return None
+        return self.post(posixpath.join('job', job, 'enable'))
 
     def disable_job(self, job):
-        if self.readonly: return None
-        return self.post( posixpath.join ( 'job', job, 'disable' ) );
+        if self.readonly:
+            return None
+        return self.post(posixpath.join('job', job, 'disable'))
 
     def delete_job(self, job):
-        if self.readonly: return None
-        return self.post( posixpath.join( 'job', job, 'doDelete' ) );
+        if self.readonly:
+            return None
+        return self.post(posixpath.join('job', job, 'doDelete'))
 
     def run_job(self, job, params=None):
-        if self.readonly: return None
+        if self.readonly:
+            return None
         if params == None:
-            response=self.post( posixpath.join( 'job', job, 'build') );
+            response = self.post(posixpath.join('job', job, 'build'))
         else:
-            response=self.post( posixpath.join( 'job', job, 'buildWithParameters' ), data=params)
+            response = self.post(posixpath.join('job', job, 'buildWithParameters'), data=params)
 
-        queue_item=QueueItem.from_jenkins_response(response, self)
+        queue_item = QueueItem.from_jenkins_response(response, self)
         return queue_item
 
-    def list_builds( self, node = None ):
+    def list_builds(self, node=None):
         """
         Get list of Builds which are currently build on the node given
         :param node: list only jobs building on the node specified
         :type node: string
         :return: dictionary with node_names as a key and list of jobs dictionaries building on the node as { "job_name": ... , "build_number" : ... }, list may be None
         """
-        str_request = "";
-        dict_parms = { "tree" : "jobs[name,lastBuild[building,fullDisplayName,number,url,builtOn]]" };
+        str_request = ""
+        dict_parms = {"tree": "jobs[name,lastBuild[building,fullDisplayName,number,url,builtOn]]"}
 
         if node is not None:
-            str_request = posixpath.join( "computer", node );
-            dict_parms[ "tree" ] = "executors[idle,currentExecutable[idle,building,builtOn,number,fullDisplayName,url]]";
+            str_request = posixpath.join("computer", node)
+            dict_parms["tree"] = "executors[idle,currentExecutable[idle,building,builtOn,number,fullDisplayName,url]]"
 
-        response = self.get( str_request, params = dict_parms );
-        dict_resp = json.loads( response.text );
+        response = self.get(str_request, params=dict_parms)
+        dict_resp = json.loads(response.text)
 
         if node is not None:
-            if len( dict_resp[ "executors" ] ) == 0:
-                return { node: list() };
+            if len(dict_resp["executors"]) == 0:
+                return {node: list()}
 
-            ls_jobs = map( lambda x: { "name" : None, "lastBuild" : ( None if x[ "idle" ] else x[ "currentExecutable" ] ) }, dict_resp[ "executors" ] );
-
-        else :
-            ls_jobs = dict_resp[ "jobs" ];
+            ls_jobs = map(lambda x: {"name": None, "lastBuild": (
+                None if x["idle"] else x["currentExecutable"])}, dict_resp["executors"])
 
+        else:
+            ls_jobs = dict_resp["jobs"]
 
-        dict_result = dict();
+        dict_result = dict()
 
         for dict_job in ls_jobs:
-            if "lastBuild" not in dict_job or dict_job[ "lastBuild" ] is None or not dict_job[ "lastBuild" ][ "building" ]:
-                continue; # inactive build, out of interes
+            if "lastBuild" not in dict_job or dict_job["lastBuild"] is None or not dict_job["lastBuild"]["building"]:
+                continue  # inactive build, out of interes
 
-            str_job_name = dict_job[ "name" ];
+            str_job_name = dict_job["name"]
 
             if not str_job_name:
-                str_job_name = dict_job[ "lastBuild" ][ "url" ].split( posixpath.sep + "job" + posixpath.sep, 1 )[1].split( posixpath.sep, 1 )[0];
+                str_job_name = dict_job["lastBuild"]["url"].split(
+                    posixpath.sep + "job" + posixpath.sep, 1)[1].split(posixpath.sep, 1)[0]
 
-            str_builder_node = dict_job[ "lastBuild" ][ "builtOn" ];
+            str_builder_node = dict_job["lastBuild"]["builtOn"]
 
             if str_builder_node not in dict_result:
-                dict_result[ str_builder_node ] = list();
+                dict_result[str_builder_node] = list()
 
-            dict_result[ str_builder_node ].append( { "job_name" : str_job_name, "build_nubmer" : dict_job[ "lastBuild" ][ "number" ] } );
+            dict_result[str_builder_node].append(
+                {"job_name": str_job_name, "build_nubmer": dict_job["lastBuild"]["number"]})
 
-        return dict_result;
+        return dict_result
 
-    def list_queue( self ):
+    def list_queue(self):
         """
         Get queue items, perhaps empty if no jobs queued
         :return: list of QueueItems, possible empty
         """
-        ls_result = list();
-        obj_resp = self.get( "queue" );
-        dict_resp = json.loads( obj_resp.text or {} );
+        ls_result = list()
+        obj_resp = self.get("queue")
+        dict_resp = json.loads(obj_resp.text or {})
 
         if not 'items' in dict_resp:
-            return ls_result;
+            return ls_result
 
-        for dict_task in dict_resp[ 'items' ]:
+        for dict_task in dict_resp['items']:
             if not 'task' in dict_task:
-                continue;
+                continue
 
-            if not 'name' in dict_task[ 'task' ]:
-                continue;
+            if not 'name' in dict_task['task']:
+                continue
 
             if not 'id' in dict_task:
-                continue;
+                continue
 
-            ls_result.append( QueueItem( dict_task[ 'id' ], self, dict_task ) );
-        
-        return ls_result;
+            ls_result.append(QueueItem(dict_task['id'], self, dict_task))
+
+        return ls_result
 
-    def unqueue_item( self, int_id ):
+    def unqueue_item(self, int_id):
         """
         remove item with ID given from queue
         :param int_id: id
         :type int_id: integer
         """
-        if int_id is None or not isinstance( int_id, int ):
-            raise TypeError( "Wrong type of arguments: int_id is not integer" );
+        if int_id is None or not isinstance(int_id, int):
+            raise TypeError("Wrong type of arguments: int_id is not integer")
 
         try:
-            self.post( posixpath.join( 'queue','cancelItem'), data = {}, params = { "id": int_id } );
+            self.post(posixpath.join('queue', 'cancelItem'), data={}, params={"id": int_id})
         except:
-            pass; # since jenkins returns 404 code for this type of operation and it is normal
+            pass  # since jenkins returns 404 code for this type of operation and it is normal
 
 
-from enum import Enum
 class BuildStatus(Enum):
-    BUILDING=0
-    SUCCESS=1
-    FAILURE=2
-    ABORTED=3
-    UNSTABLE=4
-    NOT_BUILD=5
+    BUILDING = 0
+    SUCCESS = 1
+    FAILURE = 2
+    ABORTED = 3
+    UNSTABLE = 4
+    NOT_BUILD = 5
 
 
 class Build(object):
@@ -334,31 +349,31 @@ class Build(object):
     """
 
     def __init__(self, job_name, build_number, jenkins_client):
-        self.job_name=job_name
-        self.build_number=build_number
-        self.jenkins_client=jenkins_client
-        self._build_status=BuildStatus.BUILDING
+        self.job_name = job_name
+        self.build_number = build_number
+        self.jenkins_client = jenkins_client
+        self._build_status = BuildStatus.BUILDING
 
     def get_status(self):
         self._update_build_status()
         return self._build_status
 
     def _update_build_status(self):
-        if self._build_status!=BuildStatus.BUILDING:
+        if self._build_status != BuildStatus.BUILDING:
             return self._build_status
-        build_path = posixpath.join( "job", self.job_name, str( self.build_number ), 'api', 'json' )
-        response=self.jenkins_client.get(build_path)
-        if response.status_code==404:
+        build_path = posixpath.join("job", self.job_name, str(self.build_number), 'api', 'json')
+        response = self.jenkins_client.get(build_path)
+        if response.status_code == 404:
             raise JenkinsError("No build exist at %s" % build_path)
-        parsed_response=json.loads(response.text or "{}")
-        status_value=parsed_response["result"]
+        parsed_response = json.loads(response.text or "{}")
+        status_value = parsed_response["result"]
         if not status_value:
-            self._build_status=BuildStatus.BUILDING
+            self._build_status = BuildStatus.BUILDING
         else:
             if sys.version_info.major == 2:
                 self._build_status = getattr(BuildStatus, status_value)
             else:
-                self._build_status=BuildStatus[status_value]
+                self._build_status = BuildStatus[status_value]
 
 
 class QueueItem(object):
@@ -369,55 +384,55 @@ class QueueItem(object):
 
     @classmethod
     def from_jenkins_response(cls, response, jenkins_client):
-        location_url=response.headers["Location"]
-        search_result=re.search( r'' + posixpath.join( "queue", "item", "(?P<queue_id>\d+)" ), location_url)
-        queue_id=int(search_result.group("queue_id"))
+        location_url = response.headers["Location"]
+        search_result = re.search(r'' + posixpath.join("queue", "item", "(?P<queue_id>\d+)"), location_url)
+        queue_id = int(search_result.group("queue_id"))
         return QueueItem(queue_id, jenkins_client)
-    
-    def __init__(self, queue_id, jenkins_client, dict_details = None):
+
+    def __init__(self, queue_id, jenkins_client, dict_details=None):
         """
         :param resource: id in build queue (assigned at build launch request)
         :param required: jenkins.Jenkins instance
         """
-        self.queue_id=queue_id
-        self.jenkins_client=jenkins_client
-        self._build=None
-        self._task=None;
+        self.queue_id = queue_id
+        self.jenkins_client = jenkins_client
+        self._build = None
+        self._task = None
 
         if not dict_details:
-            return;
+            return
 
         if "task" in dict_details:
-            self._task = dict_details[ "task" ];
+            self._task = dict_details["task"]
 
     @property
-    def task( self ):
+    def task(self):
         """
         :return: dictionary with task parameters - job name, url, color - as it returned by Jenkins
         """
         if not self._task:
-            self._try_update_queue_status();
-        return self._task;
+            self._try_update_queue_status()
+        return self._task
 
     @property
-    def job_name( self ):
+    def job_name(self):
         """
         :return: job name of the queue item
         """
 
         if not self._task:
-            self._try_update_queue_status();
+            self._try_update_queue_status()
 
         if not self._task:
-            return None;
+            return None
 
         if "url" not in self._task:
-            self._try_update_queue_status();
+            self._try_update_queue_status()
 
         if "url" not in self._task:
-            return None;
+            return None
 
-        return self._task[ "url" ].split( posixpath.sep + "job" + posixpath.sep, 1 )[1].split( posixpath.sep, 1 )[0];
+        return self._task["url"].split(posixpath.sep + "job" + posixpath.sep, 1).pop().split(posixpath.sep, 1).pop(0)
 
     def is_running(self):
         self._try_update_queue_status()
@@ -425,33 +440,29 @@ class QueueItem(object):
 
     def get_build(self):
         self._try_update_queue_status()
+
         if self._build:
             return self._build
-        else:
-            raise BuildStatusException("Build is not started yet")
+        
+        raise BuildStatusException("Build is not started yet")
 
     def _try_update_queue_status(self):
         if self._build:
             return
-        item_path= posixpath.join( "queue", "item", str( self.queue_id ), "api", "json" );
-        response=self.jenkins_client.get(item_path)
-        if response.status_code==404:
+        item_path = posixpath.join("queue", "item", str(self.queue_id), "api", "json")
+        response = self.jenkins_client.get(item_path)
+        if response.status_code == 404:
             raise JenkinsError("No queue item exist at %s" % item_path)
-        parsed_response=json.loads(response.text or "{}")
+        parsed_response = json.loads(response.text or "{}")
         if "executable" in parsed_response:
-            self._build=Build(parsed_response["task"]["name"],
-                              parsed_response["executable"]["number"],
-                              self.jenkins_client)
+            self._build = Build(parsed_response["task"]["name"],
+                                parsed_response["executable"]["number"],
+                                self.jenkins_client)
 
         if not self._task and "task" in parsed_response:
-            self._task = parsed_response[ "task" ];
-    
+            self._task = parsed_response["task"]
+
 
 class BuildStatusException(Exception):
     pass
 
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod()

oc_cdtapi/NexusAPI.py

@@ -246,8 +246,7 @@ class NexusAPI(HttpAPI):
         :param repo: repo
         :type repo: str
         """
-        # here is nice place to use 'urllib.urljoin'
-        # but implemented ugly via 'posixpath' to get rid of extra dependencies
+        #urllib.urlparse.urljoin is not suitable for us since it joins only host part + relative part
         if not gav:
             raise ValueError("GAV is mandatory")
 

{oc_cdtapi-3.9.2.dist-info → oc_cdtapi-3.9.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: oc-cdtapi
-Version: 3.9.2
+Version: 3.9.5
 Summary: Custom Development python API libraries
 License: Apache2.0
 Requires-Python: >=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*

oc_cdtapi-3.9.5.dist-info/RECORD

@@ -0,0 +1,15 @@
+oc_cdtapi/API.py,sha256=hpdnzyirYT_wISeznRmoqr-umYRT6uqKVwhmCXyj8Nk,12398
+oc_cdtapi/DevPIAPI.py,sha256=Nn63Ob0kA5XXuRZ3OIWG2rcnSsztKq9yPI6Lu2zX3Gk,1836
+oc_cdtapi/DmsAPI.py,sha256=j2Bx4Sryc4R1knyNjQmZshVuCePeD2q4W-fxv7zOMFc,9481
+oc_cdtapi/DmsGetverAPI.py,sha256=NIhWq2MDWaIBFLYJqkPCV9jZqM1HSZum6gIHquGHdQg,16085
+oc_cdtapi/ForemanAPI.py,sha256=w6MN86vJxYtHIZQ5gCehghV0D-EisGpCcBXEvfuUk3M,39986
+oc_cdtapi/JenkinsAPI.py,sha256=lZ8pe3a4eb_6h53JE7QLuzOSlu7Sqatc9PQwWhio9Vg,15748
+oc_cdtapi/NexusAPI.py,sha256=uU12GtHvKlWorFaPAnFcQ5AGEc94MZ5SdmfM2Pw3F7A,26122
+oc_cdtapi/TestServer.py,sha256=HV97UWg2IK4gOYAp9yaMdwFUWsw9v66MxyZdI3qQctA,2715
+oc_cdtapi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+oc_cdtapi-3.9.5.data/scripts/nexus.py,sha256=4teqZ_KtCSrwHDJVgA7lkreteod4Xt5XJFZNbwb7E6E,6858
+oc_cdtapi-3.9.5.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+oc_cdtapi-3.9.5.dist-info/METADATA,sha256=S64Fcjm0kP3W3bg7C5ENxYYtLdkQDKuyi0RVXqrswx8,276
+oc_cdtapi-3.9.5.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+oc_cdtapi-3.9.5.dist-info/top_level.txt,sha256=d4-5-D-0CSeSXYuLCP7-nIFCpjkfmJr-Y_muzds8iVU,10
+oc_cdtapi-3.9.5.dist-info/RECORD,,

oc_cdtapi-3.9.2.dist-info/RECORD

@@ -1,15 +0,0 @@
-oc_cdtapi/API.py,sha256=ScjpCC6bdEzJBc1Qgp6ODH8bfxwccBr3hI9I96UYmQk,8680
-oc_cdtapi/DevPIAPI.py,sha256=SvQWSpsgZEsxJmm-edTPqZ25fi8KyvxQ0X27vjhU3cI,2054
-oc_cdtapi/DmsAPI.py,sha256=NzXfJ9k1srTOWZYCwOhxzLN1deNGnPtJoUy22qjiGmQ,7841
-oc_cdtapi/DmsGetverAPI.py,sha256=SOFLSl8DOCblR-swdHeufRLMPKahf1rDbILfz-4_zbk,13948
-oc_cdtapi/ForemanAPI.py,sha256=wGYPEPYgeNUSp2SATk_pZ4FRIwX9lmkcAgZyIzM47_4,39979
-oc_cdtapi/JenkinsAPI.py,sha256=ZBMDRmR4K7rlpGzqaWL7vPjlwweP4AGi2bom31v5T8s,15862
-oc_cdtapi/NexusAPI.py,sha256=PsE6Lzh3WcmZkqlIo0zqi_VvpHjYciUYvCLEQtH4bzw,26153
-oc_cdtapi/TestServer.py,sha256=HV97UWg2IK4gOYAp9yaMdwFUWsw9v66MxyZdI3qQctA,2715
-oc_cdtapi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-oc_cdtapi-3.9.2.data/scripts/nexus.py,sha256=4teqZ_KtCSrwHDJVgA7lkreteod4Xt5XJFZNbwb7E6E,6858
-oc_cdtapi-3.9.2.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-oc_cdtapi-3.9.2.dist-info/METADATA,sha256=vvaNt2GXOnNYqCH8Pc6sHtIBI_XVCqZo34pk43zB9nQ,276
-oc_cdtapi-3.9.2.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-oc_cdtapi-3.9.2.dist-info/top_level.txt,sha256=d4-5-D-0CSeSXYuLCP7-nIFCpjkfmJr-Y_muzds8iVU,10
-oc_cdtapi-3.9.2.dist-info/RECORD,,