dtlpy 1.115.44__py3-none-any.whl → 1.116.6__py3-none-any.whl

dtlpy/services/api_reference.py

@@ -1,40 +1,40 @@
-class ApiReference(object):
-
-    def __init__(self):
-        self.references = {'paths': dict()}
-
-    def add(self, path, method):
-        def wrapper(f):
-            if path not in self.references['paths']:
-                self.references['paths'][path] = dict()
-            if method not in self.references['paths'][path]:
-                self.references['paths'][path][method] = dict()
-
-            docstring = f.__doc__
-            docstring = docstring.split('\n')
-            in_code = False
-
-            code_list = list()
-            docs_list = list()
-            for i_line in range(len(docstring)):
-                if '.. code-block::' in docstring[i_line]:
-                    in_code = True
-                    continue
-                if '**Example**' in docstring[i_line]:
-                    continue
-                if docstring[i_line].startswith('    ') and not docstring[i_line].startswith('        '):
-                    in_code = False
-                if in_code:
-                    code_list.append('{}'.format(docstring[i_line].strip()))
-                else:
-                    docs_list.append('# {}'.format(docstring[i_line].strip()))
-                # assert False
-            docstring = '\n'.join(code_list + docs_list)
-            self.references['paths'][path][method]['x-codeSamples'] = [{"lang": "Python",
-                                                                        "source": docstring}]
-            return f
-
-        return wrapper
-
-
-api_reference = ApiReference()
+class ApiReference(object):
+
+    def __init__(self):
+        self.references = {'paths': dict()}
+
+    def add(self, path, method):
+        def wrapper(f):
+            if path not in self.references['paths']:
+                self.references['paths'][path] = dict()
+            if method not in self.references['paths'][path]:
+                self.references['paths'][path][method] = dict()
+
+            docstring = f.__doc__
+            docstring = docstring.split('\n')
+            in_code = False
+
+            code_list = list()
+            docs_list = list()
+            for i_line in range(len(docstring)):
+                if '.. code-block::' in docstring[i_line]:
+                    in_code = True
+                    continue
+                if '**Example**' in docstring[i_line]:
+                    continue
+                if docstring[i_line].startswith('    ') and not docstring[i_line].startswith('        '):
+                    in_code = False
+                if in_code:
+                    code_list.append('{}'.format(docstring[i_line].strip()))
+                else:
+                    docs_list.append('# {}'.format(docstring[i_line].strip()))
+                # assert False
+            docstring = '\n'.join(code_list + docs_list)
+            self.references['paths'][path][method]['x-codeSamples'] = [{"lang": "Python",
+                                                                        "source": docstring}]
+            return f
+
+        return wrapper
+
+
+api_reference = ApiReference()

dtlpy/services/async_utils.py

@@ -1,133 +1,133 @@
-import threading
-import asyncio
-import logging
-import io
-
-logger = logging.getLogger(name='dtlpy')
-
-
-class AsyncThreadEventLoop(threading.Thread):
-    """Thread class with a stop() method. The thread itself has to check
-    regularly for the stopped() condition."""
-
-    def __init__(self, loop, n, *args, **kwargs):
-        super(AsyncThreadEventLoop, self).__init__(*args, **kwargs)
-        self.loop = loop
-        self.n = n
-        self._count = 0
-        self._semaphores = dict()
-
-    def count_up(self):
-        self._count += 1
-
-    def count_down(self):
-        self._count -= 1
-
-    def run(self):
-        def exception_handler(loop, context):
-            logger.debug(
-                "[Asyc] EventLoop: caught the following exception: {}".format(context['message']))
-
-        self.loop.set_exception_handler(exception_handler)
-        asyncio.set_event_loop(self.loop)
-        self.loop.run_forever()
-        logger.debug('Ended event loop with bounded semaphore to {}'.format(self.n))
-
-    def semaphore(self, name, n=None):
-        if n is None:
-            n = self.n
-        else:
-            n = min(n, self.n)
-        if name not in self._semaphores:
-            self._semaphores[name] = asyncio.BoundedSemaphore(n)
-        return self._semaphores[name]
-
-    def stop(self):
-        self.loop.call_soon_threadsafe(self.loop.stop)  # here
-
-
-class AsyncResponse:
-    def __init__(self, text, _json, async_resp):
-        self.text = text
-        self._json = _json
-        self.async_resp = async_resp
-
-    def json(self):
-        return self._json
-
-    @property
-    def status_code(self):
-        return self.async_resp.status
-
-    @property
-    def reason(self):
-        return self.async_resp.reason
-
-    @property
-    def ok(self):
-        return self.async_resp.status < 400
-
-    @property
-    def request(self):
-        return self.async_resp.request_info
-
-    @property
-    def headers(self):
-        return self.async_resp.headers
-
-
-class DummyErrorResponse:
-    def __init__(self, error, trace):
-        self.status = 3001  # SDK Error
-        self.reason = trace
-        self.error = error
-        self.request_info = {}
-        self.headers = {}
-
-
-class AsyncResponseError(AsyncResponse):
-    def __init__(self, error, trace):
-        async_resp = DummyErrorResponse(error=error, trace=trace)
-        _json = {'error': error}
-        text = error
-        super().__init__(async_resp=async_resp,
-                         _json=_json,
-                         text=text)
-
-
-class AsyncUploadStream(io.IOBase):
-    def __init__(self, buffer, callback=None, name='', chunk_timeout=10, max_retries=3):
-        self.buffer = buffer
-        self.buffer.seek(0)
-        self.callback = callback
-        self._name = name
-        self.chunk_timeout = chunk_timeout
-        self.max_retries = max_retries
-
-    @property
-    def name(self):
-        return self._name
-
-    async def async_read(self, size):
-        retries = 0
-        while retries < self.max_retries:
-            try:
-                import sys
-                if sys.version_info < (3, 9):
-                    loop = asyncio.get_event_loop()
-                    data = await asyncio.wait_for(loop.run_in_executor(None, self.buffer.read, size),
-                                                  timeout=self.chunk_timeout)
-                else:
-                    data = await asyncio.wait_for(asyncio.to_thread(self.buffer.read, size), timeout=self.chunk_timeout)
-                if self.callback is not None:
-                    self.callback(size)
-                return data
-            except asyncio.TimeoutError:
-                retries += 1
-                logger.warning(
-                    f"Chunk read timed out after {self.chunk_timeout} seconds. Retrying {retries}/{self.max_retries}...")
-
-        raise Exception(f"Chunk read failed after {self.max_retries} retries due to timeouts")
-
-    def read(self, size):
-        return asyncio.run(self.async_read(size))
+import threading
+import asyncio
+import logging
+import io
+
+logger = logging.getLogger(name='dtlpy')
+
+
+class AsyncThreadEventLoop(threading.Thread):
+    """Thread class with a stop() method. The thread itself has to check
+    regularly for the stopped() condition."""
+
+    def __init__(self, loop, n, *args, **kwargs):
+        super(AsyncThreadEventLoop, self).__init__(*args, **kwargs)
+        self.loop = loop
+        self.n = n
+        self._count = 0
+        self._semaphores = dict()
+
+    def count_up(self):
+        self._count += 1
+
+    def count_down(self):
+        self._count -= 1
+
+    def run(self):
+        def exception_handler(loop, context):
+            logger.debug(
+                "[Asyc] EventLoop: caught the following exception: {}".format(context['message']))
+
+        self.loop.set_exception_handler(exception_handler)
+        asyncio.set_event_loop(self.loop)
+        self.loop.run_forever()
+        logger.debug('Ended event loop with bounded semaphore to {}'.format(self.n))
+
+    def semaphore(self, name, n=None):
+        if n is None:
+            n = self.n
+        else:
+            n = min(n, self.n)
+        if name not in self._semaphores:
+            self._semaphores[name] = asyncio.BoundedSemaphore(n)
+        return self._semaphores[name]
+
+    def stop(self):
+        self.loop.call_soon_threadsafe(self.loop.stop)  # here
+
+
+class AsyncResponse:
+    def __init__(self, text, _json, async_resp):
+        self.text = text
+        self._json = _json
+        self.async_resp = async_resp
+
+    def json(self):
+        return self._json
+
+    @property
+    def status_code(self):
+        return self.async_resp.status
+
+    @property
+    def reason(self):
+        return self.async_resp.reason
+
+    @property
+    def ok(self):
+        return self.async_resp.status < 400
+
+    @property
+    def request(self):
+        return self.async_resp.request_info
+
+    @property
+    def headers(self):
+        return self.async_resp.headers
+
+
+class DummyErrorResponse:
+    def __init__(self, error, trace):
+        self.status = 3001  # SDK Error
+        self.reason = trace
+        self.error = error
+        self.request_info = {}
+        self.headers = {}
+
+
+class AsyncResponseError(AsyncResponse):
+    def __init__(self, error, trace):
+        async_resp = DummyErrorResponse(error=error, trace=trace)
+        _json = {'error': error}
+        text = error
+        super().__init__(async_resp=async_resp,
+                         _json=_json,
+                         text=text)
+
+
+class AsyncUploadStream(io.IOBase):
+    def __init__(self, buffer, callback=None, name='', chunk_timeout=10, max_retries=3):
+        self.buffer = buffer
+        self.buffer.seek(0)
+        self.callback = callback
+        self._name = name
+        self.chunk_timeout = chunk_timeout
+        self.max_retries = max_retries
+
+    @property
+    def name(self):
+        return self._name
+
+    async def async_read(self, size):
+        retries = 0
+        while retries < self.max_retries:
+            try:
+                import sys
+                if sys.version_info < (3, 9):
+                    loop = asyncio.get_event_loop()
+                    data = await asyncio.wait_for(loop.run_in_executor(None, self.buffer.read, size),
+                                                  timeout=self.chunk_timeout)
+                else:
+                    data = await asyncio.wait_for(asyncio.to_thread(self.buffer.read, size), timeout=self.chunk_timeout)
+                if self.callback is not None:
+                    self.callback(size)
+                return data
+            except asyncio.TimeoutError:
+                retries += 1
+                logger.warning(
+                    f"Chunk read timed out after {self.chunk_timeout} seconds. Retrying {retries}/{self.max_retries}...")
+
+        raise Exception(f"Chunk read failed after {self.max_retries} retries due to timeouts")
+
+    def read(self, size):
+        return asyncio.run(self.async_read(size))

dtlpy/services/calls_counter.py

@@ -1,44 +1,44 @@
-from .cookie import CookieIO
-
-
-class CallsCounter:
-    def __init__(self, filepath):
-        self.io = CookieIO(filepath)
-        self.state = 'off'
-        self.number = 0
-        self.load()
-
-    def add(self):
-        if self.state == 'on':
-            self.load()
-            self.number += 1
-            self.save()
-
-    def reset(self):
-        self.number = 0
-        self.save()
-
-    def save(self):
-        self.io.put('calls_counter', {'state': self.state,
-                                      'number': self.number})
-
-    def on(self):
-        self.state = 'on'
-        self.save()
-
-    def off(self):
-        self.state = 'off'
-        self.save()
-
-    def on_exit(self):
-        self.save()
-
-    def load(self):
-        calls = self.io.get('calls_counter')
-        if calls is None:
-            # not set in cookie - set default
-            calls = {'state': 'off',
-                     'number': 0}
-            self.io.put('calls_counter', calls)
-        self.state = calls['state']
-        self.number = calls['number']
+from .cookie import CookieIO
+
+
+class CallsCounter:
+    def __init__(self, filepath):
+        self.io = CookieIO(filepath)
+        self.state = 'off'
+        self.number = 0
+        self.load()
+
+    def add(self):
+        if self.state == 'on':
+            self.load()
+            self.number += 1
+            self.save()
+
+    def reset(self):
+        self.number = 0
+        self.save()
+
+    def save(self):
+        self.io.put('calls_counter', {'state': self.state,
+                                      'number': self.number})
+
+    def on(self):
+        self.state = 'on'
+        self.save()
+
+    def off(self):
+        self.state = 'off'
+        self.save()
+
+    def on_exit(self):
+        self.save()
+
+    def load(self):
+        calls = self.io.get('calls_counter')
+        if calls is None:
+            # not set in cookie - set default
+            calls = {'state': 'off',
+                     'number': 0}
+            self.io.put('calls_counter', calls)
+        self.state = calls['state']
+        self.number = calls['number']

dtlpy/services/check_sdk.py

@@ -1,68 +1,68 @@
-import time
-import logging
-import threading
-import traceback
-import jwt
-
-logger = logging.getLogger(name='dtlpy')
-
-
-def check_in_thread(version, client_api):
-    try:
-        # check for a valid token
-        if client_api.token_expired():
-            # wait for user to maybe login in the next 2 minutes
-            time.sleep(120)
-        # check for a valid token again
-        if client_api.token_expired():
-            # return if cant find a valid token
-            logger.debug('Cant check_sdk without a valid token.')
-            return
-
-        # try read token for email
-        try:
-            payload = jwt.decode(client_api.token, algorithms=['HS256'],
-                                 verify=False, options={'verify_signature': False})
-            user_email = payload['email']
-        except Exception:
-            user_email = 'na'
-        logger.debug('SDK info: user: {}, version: {}'.format(user_email, version))
-        return_type, resp = client_api.gen_request(req_type='POST',
-                                                   path='/sdk/check',
-                                                   data={'version': version,
-                                                         'email': user_email},
-                                                   log_error=False)
-        if resp.ok:
-            resp = resp.json()
-            client_api.cookie_io.put(key='check_version_status',
-                                     value={'level': resp['level'],
-                                            'msg': resp['msg']})
-        else:
-            client_api.cookie_io.put(key='check_version_status',
-                                     value={'level': 'debug',
-                                            'msg': 'unknown'})
-    except Exception:
-        logger.debug(traceback.format_exc())
-        logger.debug('Error in check sdk manager.')
-
-
-def check(version, client_api):
-    worker = threading.Thread(target=check_in_thread,
-                              kwargs={'version': version,
-                                      'client_api': client_api})
-    worker.daemon = True
-    worker.start()
-    status = client_api.cookie_io.get('check_version_status')
-    if status is not None:
-        level = status['level']
-        msg = status['msg']
-        if level.lower() == 'debug':
-            logger.debug(msg=msg)
-        elif level.lower() == 'info':
-            logger.info(msg=msg)
-        elif level.lower() == 'warning':
-            logger.warning(msg=msg)
-        elif level.lower() == 'error':
-            logger.error(msg=msg)
-        else:
-            logger.debug(msg='unknown')
+import time
+import logging
+import threading
+import traceback
+import jwt
+
+logger = logging.getLogger(name='dtlpy')
+
+
+def check_in_thread(version, client_api):
+    try:
+        # check for a valid token
+        if client_api.token_expired():
+            # wait for user to maybe login in the next 2 minutes
+            time.sleep(120)
+        # check for a valid token again
+        if client_api.token_expired():
+            # return if cant find a valid token
+            logger.debug('Cant check_sdk without a valid token.')
+            return
+
+        # try read token for email
+        try:
+            payload = jwt.decode(client_api.token, algorithms=['HS256'],
+                                 verify=False, options={'verify_signature': False})
+            user_email = payload['email']
+        except Exception:
+            user_email = 'na'
+        logger.debug('SDK info: user: {}, version: {}'.format(user_email, version))
+        return_type, resp = client_api.gen_request(req_type='POST',
+                                                   path='/sdk/check',
+                                                   data={'version': version,
+                                                         'email': user_email},
+                                                   log_error=False)
+        if resp.ok:
+            resp = resp.json()
+            client_api.cookie_io.put(key='check_version_status',
+                                     value={'level': resp['level'],
+                                            'msg': resp['msg']})
+        else:
+            client_api.cookie_io.put(key='check_version_status',
+                                     value={'level': 'debug',
+                                            'msg': 'unknown'})
+    except Exception:
+        logger.debug(traceback.format_exc())
+        logger.debug('Error in check sdk manager.')
+
+
+def check(version, client_api):
+    worker = threading.Thread(target=check_in_thread,
+                              kwargs={'version': version,
+                                      'client_api': client_api})
+    worker.daemon = True
+    worker.start()
+    status = client_api.cookie_io.get('check_version_status')
+    if status is not None:
+        level = status['level']
+        msg = status['msg']
+        if level.lower() == 'debug':
+            logger.debug(msg=msg)
+        elif level.lower() == 'info':
+            logger.info(msg=msg)
+        elif level.lower() == 'warning':
+            logger.warning(msg=msg)
+        elif level.lower() == 'error':
+            logger.error(msg=msg)
+        else:
+            logger.debug(msg='unknown')