dtlpy 1.113.10__py3-none-any.whl → 1.114.13__py3-none-any.whl

dtlpy/services/events.py

@@ -1,84 +1,84 @@
-import threading
-import time
-import traceback
-import logging
-import queue
-import os
-
-logger = logging.getLogger(name='dtlpy')
-
-
-class Events(threading.Thread):
-    def __init__(self, client_api, *args, **kwargs):
-        super(Events, self).__init__(*args, **kwargs)
-        self.client_api = client_api
-        self.q = queue.Queue()
-        self.mapping_events_dict = {
-            'project': {'method': ['create', 'delete'], 'route': '/projects'},
-            'task': {'method': ['create'], 'route': '/annotationtasks'},
-        }
-
-    def track(self, event):
-        try:
-            return_type, resp = self.client_api.gen_request(req_type='POST',
-                                                            path='/analytics/metric/pendo',
-                                                            json_req=event,
-                                                            log_error=False)
-            if not resp.ok:
-                logger.debug('failed send event to analytics: {}'.format(resp.text))
-        except Exception:
-            logger.debug('failed send track event: {}'.format(traceback.format_exc()))
-
-    def run(self):
-        while True:
-            try:
-                event = self.q.get()
-                self.track([event])
-                self.q.task_done()
-            except Exception:
-                logger.exception('failed in loop')
-
-    def _valid_events(self, path):
-        for route in self.mapping_events_dict.values():
-            if path.startswith(route['route']) and 'sdk' not in path:
-                return True
-        return False
-
-    def _add_info(self, event_payload, function, resp):
-        if function in ['create']:
-            event_source = event_payload.get('event', None)
-            resp_json = resp.json()
-            if event_source == 'dtlpy:project':
-                event_payload['properties'].update({'project_id': resp_json['id'],
-                                                    'project_name': resp_json['name']})
-            if event_source == 'dtlpy:task' and function in ['create']:
-                if 'createTaskPayload' in resp_json.get('spec', {}):
-                    task_payload = resp_json.get('spec', {}).get('createTaskPayload', {})
-                else:
-                    task_payload = resp_json
-                metadata = task_payload.get('metadata', {}).get('system', {})
-                task_type = task_payload.get('spec', {}).get('type', {})
-                allocation_method = 'Distribution'
-                if 'batchSize' in metadata and 'maxBatchWorkload' in metadata and 'allowedAssignees' in metadata:
-                    allocation_method = 'Pulling'
-                event_payload['properties'].update({'task_type': task_type,
-                                                    'allocation_method': allocation_method})
-
-    def put(self, event, resp=None, path=None):
-        send_event = True
-        if path is not None and not self._valid_events(path=path):
-            send_event = False
-
-        if resp is not None and send_event:
-            event_source = os.path.normpath(event.filename).split('\\')[-1][:-4]
-            event_payload = {'event': 'dtlpy:' + event_source,
-                             'properties': {'sdk_event': event.function + '_' + event_source}}
-            if event_source in self.mapping_events_dict and \
-                    event.function in self.mapping_events_dict[event_source]['method']:
-                self._add_info(event_payload=event_payload, function=event.function, resp=resp)
-            else:
-                send_event = False
-        else:
-            event_payload = event
-        if send_event:
-            self.q.put(event_payload)
+import threading
+import time
+import traceback
+import logging
+import queue
+import os
+
+logger = logging.getLogger(name='dtlpy')
+
+
+class Events(threading.Thread):
+    def __init__(self, client_api, *args, **kwargs):
+        super(Events, self).__init__(*args, **kwargs)
+        self.client_api = client_api
+        self.q = queue.Queue()
+        self.mapping_events_dict = {
+            'project': {'method': ['create', 'delete'], 'route': '/projects'},
+            'task': {'method': ['create'], 'route': '/annotationtasks'},
+        }
+
+    def track(self, event):
+        try:
+            return_type, resp = self.client_api.gen_request(req_type='POST',
+                                                            path='/analytics/metric/pendo',
+                                                            json_req=event,
+                                                            log_error=False)
+            if not resp.ok:
+                logger.debug('failed send event to analytics: {}'.format(resp.text))
+        except Exception:
+            logger.debug('failed send track event: {}'.format(traceback.format_exc()))
+
+    def run(self):
+        while True:
+            try:
+                event = self.q.get()
+                self.track([event])
+                self.q.task_done()
+            except Exception:
+                logger.exception('failed in loop')
+
+    def _valid_events(self, path):
+        for route in self.mapping_events_dict.values():
+            if path.startswith(route['route']) and 'sdk' not in path:
+                return True
+        return False
+
+    def _add_info(self, event_payload, function, resp):
+        if function in ['create']:
+            event_source = event_payload.get('event', None)
+            resp_json = resp.json()
+            if event_source == 'dtlpy:project':
+                event_payload['properties'].update({'project_id': resp_json['id'],
+                                                    'project_name': resp_json['name']})
+            if event_source == 'dtlpy:task' and function in ['create']:
+                if 'createTaskPayload' in resp_json.get('spec', {}):
+                    task_payload = resp_json.get('spec', {}).get('createTaskPayload', {})
+                else:
+                    task_payload = resp_json
+                metadata = task_payload.get('metadata', {}).get('system', {})
+                task_type = task_payload.get('spec', {}).get('type', {})
+                allocation_method = 'Distribution'
+                if 'batchSize' in metadata and 'maxBatchWorkload' in metadata and 'allowedAssignees' in metadata:
+                    allocation_method = 'Pulling'
+                event_payload['properties'].update({'task_type': task_type,
+                                                    'allocation_method': allocation_method})
+
+    def put(self, event, resp=None, path=None):
+        send_event = True
+        if path is not None and not self._valid_events(path=path):
+            send_event = False
+
+        if resp is not None and send_event:
+            event_source = os.path.normpath(event.filename).split('\\')[-1][:-4]
+            event_payload = {'event': 'dtlpy:' + event_source,
+                             'properties': {'sdk_event': event.function + '_' + event_source}}
+            if event_source in self.mapping_events_dict and \
+                    event.function in self.mapping_events_dict[event_source]['method']:
+                self._add_info(event_payload=event_payload, function=event.function, resp=resp)
+            else:
+                send_event = False
+        else:
+            event_payload = event
+        if send_event:
+            self.q.put(event_payload)

dtlpy/services/logins.py

@@ -1,235 +1,235 @@
-from urllib.parse import urlsplit, urlunsplit
-import base64
-import requests
-import logging
-import json
-import jwt
-import os
-
-logger = logging.getLogger(name='dtlpy')
-
-
-def login_m2m(api_client, email, password, client_id=None, client_secret=None, force=False):
-    return login_secret(api_client=api_client,
-                        email=email,
-                        password=password,
-                        client_id=client_id,
-                        client_secret=client_secret,
-                        force=force)
-
-
-def login_secret(api_client, email, password, client_id, client_secret=None, force=False):
-    """
-    Login with email and password from environment variables
-    :param api_client: ApiClient instance
-    :param email: user email. if already logged in with same user - login will NOT happen. see "force"
-    :param password: user password
-    :param client_id: DEPRECATED
-    :param client_secret: DEPRECATED
-    :param force: force login. in case login with same user but want to get a new JWT
-    :return:
-    """
-    # TODO add deprecation warning to client_id
-    # check if already logged in with SAME email
-    if api_client.token is not None or api_client.token == '':
-        try:
-            payload = jwt.decode(api_client.token, algorithms=['HS256'],
-                                 options={'verify_signature': False}, verify=False)
-            if 'email' in payload and \
-                    payload['email'] == email and \
-                    not api_client.token_expired() and \
-                    not force:
-                return True
-        except jwt.exceptions.DecodeError:
-            logger.debug('{}'.format('Cant decode token. Force login is used'))
-
-    logger.info('[Start] Login Secret')
-    env_params = api_client.environments[api_client.environment]
-    # need to login
-    payload = {'username': email,
-               'password': password,
-               'type': 'user_credentials'
-               }
-    headers = {'content-type': 'application/json'}
-    if 'gate_url' not in env_params:
-        env_params['gate_url'] = gate_url_from_host(environment=api_client.environment)
-        api_client.environments[api_client.environment] = env_params
-    token_url = env_params['gate_url'] + "/token?default"
-    resp = requests.request("POST",
-                            token_url,
-                            data=json.dumps(payload),
-                            headers=headers,
-                            verify=env_params.get('verify_ssl', True))
-    if not resp.ok:
-        logout(api_client=api_client)
-        api_client.print_bad_response(resp)
-        return False
-    else:
-        response_dict = resp.json()
-        api_client.token = response_dict['id_token']  # this will also set the refresh_token to None
-        if 'refresh_token' in response_dict:
-            api_client.refresh_token = response_dict['refresh_token']
-
-        # set new client id for refresh
-        payload = jwt.decode(api_client.token, algorithms=['HS256'],
-                             options={'verify_signature': False}, verify=False)
-        if 'email' in payload:
-            logger.info('[Done] Login Secret. User: {}'.format(payload['email']))
-        else:
-            logger.info('[Done] Login Secret. User: {}'.format(email))
-            logger.info(payload)
-    return True
-
-
-def logout(api_client):
-    """
-    remove JWT from cookie
-    """
-    api_client.token = None
-    api_client.refresh_token = None
-    return True
-
-
-def login_html():
-    try:
-        location = os.path.dirname(os.path.realpath(__file__))
-    except NameError:
-        location = './dtlpy/services'
-    filename = os.path.join(location, '..', 'assets', 'lock_open.png')
-
-    if os.path.isfile(filename):
-
-        with open(filename, 'rb') as f:
-            image = f.read()
-
-        html = (
-            "        <!doctype html>\n"
-            "        <html>\n"
-            "        <head>\n"
-            "            <style>\n"
-            "                body {{\n"
-            "                    background-color: #F7F7F9 !important;\n"
-            "                    display: flex;\n"
-            "                    justify-content: center;\n"
-            "                    align-items: center;\n"
-            "                    height: 100vh;\n"
-            "                    width: 100vw;\n"
-            "                    margin: 0;\n"
-            "                }}\n"
-            "                img {{\n"
-            "                    display: block;\n"
-            "                    max-width: 100%;\n"
-            "                    max-height: 100%;\n"
-            "                    margin: auto;\n"
-            "                }}\n"
-            "            </style>\n"
-            "        </head>\n"
-            "        <body>\n"
-            "            <img src='data:image/png;base64,{image}'>\n"
-            "        </body>\n"
-            "        </html>\n"
-        ).format(image=base64.b64encode(image).decode())
-    else:
-        html = "<!doctype html><html><body>Logged in successfully</body></html>"
-
-    return html.encode('utf-8')
-
-
-def login(api_client, auth0_url=None, audience=None, client_id=None, login_domain=None, callback_port=None):
-    import webbrowser
-    from http.server import BaseHTTPRequestHandler, HTTPServer
-    from urllib.parse import urlparse, parse_qs
-    logger.info('Logging in to Dataloop...')
-
-    class LocalServer:
-
-        class Handler(BaseHTTPRequestHandler):
-
-            tokens_obtained = False
-            id_token = None
-            access_token = None
-            refresh_token = None
-
-            def log_message(self, format, *args):
-                return
-
-            def do_GET(self):
-                parsed_path = urlparse(self.path)
-                query = parse_qs(parsed_path.query)
-                self.send_response(200)
-                self.send_header('Content-type', 'text/html')
-                self.end_headers()
-                self.wfile.write(login_html())
-                self.__class__.id_token = query['id_token'][0]
-                self.__class__.access_token = query['access_token'][0]
-                self.__class__.refresh_token = query['refresh_token'][0]
-                self.__class__.tokens_obtained = True
-
-        def __init__(self):
-            self.port = callback_port if callback_port is not None else 3001
-            self.server = HTTPServer(('', self.port), self.Handler)
-            self.server.timeout = 60
-
-        def process_request(self):
-            self.server.handle_request()
-
-            if self.Handler.tokens_obtained:
-                return True, {
-                    "id": self.Handler.id_token,
-                    "access": self.Handler.access_token,
-                    "refresh": self.Handler.refresh_token
-                }
-            else:
-                return False, {}
-
-        def local_endpoint(self):
-            return "http://localhost:{}".format(self.port)
-
-        def close(self):
-            self.server.server_close()
-
-    server = LocalServer()
-
-    try:
-        local_ep = server.local_endpoint()
-        env_params = api_client.environments[api_client.environment]
-        if 'gate_url' not in env_params:
-            env_params['gate_url'] = gate_url_from_host(environment=api_client.environment)
-            api_client.environments[api_client.environment] = env_params
-        remote_ep = env_params['gate_url']
-        login_page_url = "{}/login?callback={}".format(remote_ep, local_ep)
-        if login_domain is not None:
-            login_page_url = "{}&domain={}".format(login_page_url, login_domain)
-        logger.info("Launching interactive login via {}".format(remote_ep))
-        webbrowser.open(url=login_page_url, new=2, autoraise=True)
-
-        success, tokens = server.process_request()
-
-        if success:
-            decoded_jwt = jwt.decode(tokens['id'], verify=False,
-                                     options={'verify_signature': False})
-
-            if 'email' in decoded_jwt:
-                logger.info('Logged in: {}'.format(decoded_jwt['email']))
-            else:
-                logger.info('Logged in: unknown user')
-
-            api_client.token = tokens['id']
-            api_client.refresh_token = tokens['refresh']
-
-            return True
-        else:
-            logout(api_client=api_client)
-            logger.error('Login failed: no tokens obtained')
-            return False
-    except Exception as err:
-        logout(api_client=api_client)
-        logger.exception('Login failed: error while getting token', err)
-        return False
-    finally:
-        server.close()
-
-
-def gate_url_from_host(environment):
-    parsed = urlsplit(environment)
-    return urlunsplit((parsed.scheme, parsed.netloc, '', '', ''))
+from urllib.parse import urlsplit, urlunsplit
+import base64
+import requests
+import logging
+import json
+import jwt
+import os
+
+logger = logging.getLogger(name='dtlpy')
+
+
+def login_m2m(api_client, email, password, client_id=None, client_secret=None, force=False):
+    return login_secret(api_client=api_client,
+                        email=email,
+                        password=password,
+                        client_id=client_id,
+                        client_secret=client_secret,
+                        force=force)
+
+
+def login_secret(api_client, email, password, client_id, client_secret=None, force=False):
+    """
+    Login with email and password from environment variables
+    :param api_client: ApiClient instance
+    :param email: user email. if already logged in with same user - login will NOT happen. see "force"
+    :param password: user password
+    :param client_id: DEPRECATED
+    :param client_secret: DEPRECATED
+    :param force: force login. in case login with same user but want to get a new JWT
+    :return:
+    """
+    # TODO add deprecation warning to client_id
+    # check if already logged in with SAME email
+    if api_client.token is not None or api_client.token == '':
+        try:
+            payload = jwt.decode(api_client.token, algorithms=['HS256'],
+                                 options={'verify_signature': False}, verify=False)
+            if 'email' in payload and \
+                    payload['email'] == email and \
+                    not api_client.token_expired() and \
+                    not force:
+                return True
+        except jwt.exceptions.DecodeError:
+            logger.debug('{}'.format('Cant decode token. Force login is used'))
+
+    logger.info('[Start] Login Secret')
+    env_params = api_client.environments[api_client.environment]
+    # need to login
+    payload = {'username': email,
+               'password': password,
+               'type': 'user_credentials'
+               }
+    headers = {'content-type': 'application/json'}
+    if 'gate_url' not in env_params:
+        env_params['gate_url'] = gate_url_from_host(environment=api_client.environment)
+        api_client.environments[api_client.environment] = env_params
+    token_url = env_params['gate_url'] + "/token?default"
+    resp = requests.request("POST",
+                            token_url,
+                            data=json.dumps(payload),
+                            headers=headers,
+                            verify=env_params.get('verify_ssl', True))
+    if not resp.ok:
+        logout(api_client=api_client)
+        api_client.print_bad_response(resp)
+        return False
+    else:
+        response_dict = resp.json()
+        api_client.token = response_dict['id_token']  # this will also set the refresh_token to None
+        if 'refresh_token' in response_dict:
+            api_client.refresh_token = response_dict['refresh_token']
+
+        # set new client id for refresh
+        payload = jwt.decode(api_client.token, algorithms=['HS256'],
+                             options={'verify_signature': False}, verify=False)
+        if 'email' in payload:
+            logger.info('[Done] Login Secret. User: {}'.format(payload['email']))
+        else:
+            logger.info('[Done] Login Secret. User: {}'.format(email))
+            logger.info(payload)
+    return True
+
+
+def logout(api_client):
+    """
+    remove JWT from cookie
+    """
+    api_client.token = None
+    api_client.refresh_token = None
+    return True
+
+
+def login_html():
+    try:
+        location = os.path.dirname(os.path.realpath(__file__))
+    except NameError:
+        location = './dtlpy/services'
+    filename = os.path.join(location, '..', 'assets', 'lock_open.png')
+
+    if os.path.isfile(filename):
+
+        with open(filename, 'rb') as f:
+            image = f.read()
+
+        html = (
+            "        <!doctype html>\n"
+            "        <html>\n"
+            "        <head>\n"
+            "            <style>\n"
+            "                body {{\n"
+            "                    background-color: #F7F7F9 !important;\n"
+            "                    display: flex;\n"
+            "                    justify-content: center;\n"
+            "                    align-items: center;\n"
+            "                    height: 100vh;\n"
+            "                    width: 100vw;\n"
+            "                    margin: 0;\n"
+            "                }}\n"
+            "                img {{\n"
+            "                    display: block;\n"
+            "                    max-width: 100%;\n"
+            "                    max-height: 100%;\n"
+            "                    margin: auto;\n"
+            "                }}\n"
+            "            </style>\n"
+            "        </head>\n"
+            "        <body>\n"
+            "            <img src='data:image/png;base64,{image}'>\n"
+            "        </body>\n"
+            "        </html>\n"
+        ).format(image=base64.b64encode(image).decode())
+    else:
+        html = "<!doctype html><html><body>Logged in successfully</body></html>"
+
+    return html.encode('utf-8')
+
+
+def login(api_client, auth0_url=None, audience=None, client_id=None, login_domain=None, callback_port=None):
+    import webbrowser
+    from http.server import BaseHTTPRequestHandler, HTTPServer
+    from urllib.parse import urlparse, parse_qs
+    logger.info('Logging in to Dataloop...')
+
+    class LocalServer:
+
+        class Handler(BaseHTTPRequestHandler):
+
+            tokens_obtained = False
+            id_token = None
+            access_token = None
+            refresh_token = None
+
+            def log_message(self, format, *args):
+                return
+
+            def do_GET(self):
+                parsed_path = urlparse(self.path)
+                query = parse_qs(parsed_path.query)
+                self.send_response(200)
+                self.send_header('Content-type', 'text/html')
+                self.end_headers()
+                self.wfile.write(login_html())
+                self.__class__.id_token = query['id_token'][0]
+                self.__class__.access_token = query['access_token'][0]
+                self.__class__.refresh_token = query['refresh_token'][0]
+                self.__class__.tokens_obtained = True
+
+        def __init__(self):
+            self.port = callback_port if callback_port is not None else 3001
+            self.server = HTTPServer(('', self.port), self.Handler)
+            self.server.timeout = 60
+
+        def process_request(self):
+            self.server.handle_request()
+
+            if self.Handler.tokens_obtained:
+                return True, {
+                    "id": self.Handler.id_token,
+                    "access": self.Handler.access_token,
+                    "refresh": self.Handler.refresh_token
+                }
+            else:
+                return False, {}
+
+        def local_endpoint(self):
+            return "http://localhost:{}".format(self.port)
+
+        def close(self):
+            self.server.server_close()
+
+    server = LocalServer()
+
+    try:
+        local_ep = server.local_endpoint()
+        env_params = api_client.environments[api_client.environment]
+        if 'gate_url' not in env_params:
+            env_params['gate_url'] = gate_url_from_host(environment=api_client.environment)
+            api_client.environments[api_client.environment] = env_params
+        remote_ep = env_params['gate_url']
+        login_page_url = "{}/login?callback={}".format(remote_ep, local_ep)
+        if login_domain is not None:
+            login_page_url = "{}&domain={}".format(login_page_url, login_domain)
+        logger.info("Launching interactive login via {}".format(remote_ep))
+        webbrowser.open(url=login_page_url, new=2, autoraise=True)
+
+        success, tokens = server.process_request()
+
+        if success:
+            decoded_jwt = jwt.decode(tokens['id'], verify=False,
+                                     options={'verify_signature': False})
+
+            if 'email' in decoded_jwt:
+                logger.info('Logged in: {}'.format(decoded_jwt['email']))
+            else:
+                logger.info('Logged in: unknown user')
+
+            api_client.token = tokens['id']
+            api_client.refresh_token = tokens['refresh']
+
+            return True
+        else:
+            logout(api_client=api_client)
+            logger.error('Login failed: no tokens obtained')
+            return False
+    except Exception as err:
+        logout(api_client=api_client)
+        logger.exception('Login failed: error while getting token', err)
+        return False
+    finally:
+        server.close()
+
+
+def gate_url_from_host(environment):
+    parsed = urlsplit(environment)
+    return urlunsplit((parsed.scheme, parsed.netloc, '', '', ''))