dtlpy 1.90.37__py3-none-any.whl → 1.91.37__py3-none-any.whl

dtlpy/ml/base_model_adapter.py

@@ -145,6 +145,16 @@ class BaseModelAdapter(utilities.BaseServiceRunner):
         """
         raise NotImplementedError("Please implement 'predict' method in {}".format(self.__class__.__name__))
 
+    def extract_features(self, batch, **kwargs):
+        """ Extract model features on batch of images
+
+            Virtual method - need to implement
+
+        :param batch: `np.ndarray`
+        :return: `list[list]` each feature is per each image / item in the batch
+        """
+        raise NotImplementedError("Please implement 'extract_features' method in {}".format(self.__class__.__name__))
+
     def evaluate(self, model: entities.Model, dataset: entities.Dataset, filters: entities.Filters) -> entities.Model:
         """
         This function evaluates the model prediction on a dataset (with GT annotations).
@@ -263,7 +273,7 @@ class BaseModelAdapter(utilities.BaseServiceRunner):
                         values=False,
                         operator=entities.FiltersOperations.EXISTS,
                         resource=entities.FiltersResource.ANNOTATION
-                        )
+                    )
 
                 ret_list = dataset.items.download(filters=filters,
                                                   local_path=data_subset_base_path,
@@ -352,7 +362,8 @@ class BaseModelAdapter(utilities.BaseServiceRunner):
         pool = ThreadPoolExecutor(max_workers=16)
 
         annotations = list()
-        for i_batch in tqdm.tqdm(range(0, len(items), batch_size), desc='predicting', unit='bt', leave=None, file=sys.stdout):
+        for i_batch in tqdm.tqdm(range(0, len(items), batch_size), desc='predicting', unit='bt', leave=None,
+                                 file=sys.stdout):
             batch_items = items[i_batch: i_batch + batch_size]
             batch = list(pool.map(self.prepare_item_func, batch_items))
             batch_collections = self.predict(batch, **kwargs)
@@ -385,6 +396,72 @@ class BaseModelAdapter(utilities.BaseServiceRunner):
         pool.shutdown()
         return items, annotations
 
+    @entities.Package.decorators.function(display_name='Extract Feature',
+                                          inputs={'items': 'Item[]'},
+                                          outputs={'items': 'Item[]', 'features': '[]'})
+    def extract_item_features(self, items: list, upload_features=True, batch_size=None, **kwargs):
+        """
+        Extract feature from an input list of items (or single) and return the items and the feature vector.
+
+        :param items: `List[dl.Item]` list of items to predict
+        :param upload_features: `bool` uploads the features on the given items
+        :param batch_size: `int` size of batch to run a single inference
+
+        :return: `List[dl.Item]`, `List[List[vector]]`
+        """
+        if batch_size is None:
+            batch_size = self.configuration.get('batch_size', 4)
+        input_type = self.model_entity.input_type
+        self.logger.debug(
+            "Predicting {} items, using batch size {}. input type: {}".format(len(items), batch_size, input_type))
+        pool = ThreadPoolExecutor(max_workers=16)
+
+        vectors = list()
+        feature_set_name = self.configuration.get('featureSetName', self.model_entity.name)
+        try:
+            feature_set = self.model_entity.project.feature_sets.get(feature_set_name)
+            logger.info(f'Feature Set found! name: {feature_set_name}')
+        except exceptions.NotFound as e:
+            logger.info('Feature Set not found. creating... ')
+            feature_set = self.model_entity.project.feature_sets.create(name=feature_set_name,
+                                                                        entity_type=entities.FeatureEntityType.ITEM,
+                                                                        project_id=self.model_entity.project_id,
+                                                                        set_type=self.model_entity.name,
+                                                                        size=self.configuration.get('embeddings_size',
+                                                                                                    256))
+            if 'featureSetName' not in self.model_entity.configuration:
+                self.model_entity.configuration['featureSetName'] = feature_set_name
+                self.model_entity.update()
+            logger.info(f'Feature Set created! name: {feature_set.name}, id: {feature_set.id}')
+
+        feature_set_id = feature_set.id
+        project_id = self.model_entity.project_id
+
+        for i_batch in tqdm.tqdm(range(0, len(items), batch_size),
+                                 desc='predicting',
+                                 unit='bt',
+                                 leave=None,
+                                 file=sys.stdout):
+            batch_items = items[i_batch: i_batch + batch_size]
+            batch = list(pool.map(self.prepare_item_func, batch_items))
+            batch_vectors = self.extract_features(batch, **kwargs)
+            batch_features = list()
+            if upload_features is True:
+                self.logger.debug(
+                    "Uploading items' feature vectors for model {!r}.".format(self.model_entity.name))
+                try:
+                    batch_features = list(pool.map(partial(self._upload_model_features,
+                                                           feature_set_id,
+                                                           project_id),
+                                                   batch_items,
+                                                   batch_vectors))
+                except Exception as err:
+                    self.logger.exception("Failed to upload feature vectors to items.")
+
+            vectors.extend(batch_features)
+        pool.shutdown()
+        return items, vectors
+
     @entities.Package.decorators.function(display_name='Predict Dataset with DQL',
                                           inputs={'dataset': 'Dataset',
                                                   'filters': 'Json'})
@@ -571,6 +648,19 @@ class BaseModelAdapter(utilities.BaseServiceRunner):
     # =============
     # INNER METHODS
     # =============
+
+    @staticmethod
+    def _upload_model_features(feature_set_id, project_id, item: entities.Item, vector):
+        try:
+            feature = item.features.create(value=vector,
+                                           project_id=project_id,
+                                           feature_set_id=feature_set_id,
+                                           entity=item)
+            return feature
+        except Exception as e:
+            logger.error(f'Failed to upload feature vector if length {len(vector)} to item {item.id}, Error: {e}')
+            return []
+
     def _upload_model_annotations(self, item: entities.Item, predictions, clean_annotations):
         """
         Utility function that upload prediction to dlp platform based on the package.output_type

dtlpy/repositories/apps.py

@@ -280,15 +280,15 @@ class Apps:
         """
         if app_id is not None and app is None:
             app = self.get(app_id=app_id)
+
+            if app and app.status == entities.CompositionStatus.INSTALLED:
+                raise exceptions.PlatformException(
+                    error='400',
+                    message='Application is already active'
+                )
         if app is None:
             raise exceptions.PlatformException(error='400', message='You must provide app or app_id')
 
-        if app and app.status == entities.CompositionStatus.INSTALLED:
-            raise exceptions.PlatformException(
-                error='400',
-                message='Application is already active'
-            )
-
         success, response = self._client_api.gen_request(req_type='post', path='/apps/{}/activate'.format(app.id))
         if not success:
             raise exceptions.PlatformException(response)
@@ -313,15 +313,15 @@ class Apps:
         """
         if app_id is not None and app is None:
             app = self.get(app_id=app_id)
+
+            if app and app.status == entities.CompositionStatus.UNINSTALLED:
+                raise exceptions.PlatformException(
+                    error='400',
+                    message='Application is already inactive'
+                )
         if app is None:
             raise exceptions.PlatformException(error='400', message='You must provide app or app_id')
 
-        if app and app.status == entities.CompositionStatus.UNINSTALLED:
-            raise exceptions.PlatformException(
-                error='400',
-                message='Application is already inactive'
-            )
-
         success, response = self._client_api.gen_request(req_type='post', path='/apps/{}/deactivate'.format(app.id))
         if not success:
             raise exceptions.PlatformException(response)

dtlpy/repositories/assignments.py

@@ -117,7 +117,7 @@ class Assignments:
         elif self._project is not None:
             project_ids = [self._project.id]
         else:
-            raise ('400', 'Must provide project')
+            raise exceptions.PlatformException(error='400', message='Must provide project')
 
         project_ids = ','.join(project_ids)
         query.append('projects={}'.format(project_ids))

dtlpy/repositories/datasets.py

@@ -139,7 +139,7 @@ class Datasets:
         if dataset is not None:
             dataset.open_in_web()
         elif dataset_id is not None:
-            self._client_api._open_in_web(url=self.platform_url + '/' + str(dataset_id))
+            self._client_api._open_in_web(url=f'{self.platform_url}/{dataset_id}/items')
         else:
             self._client_api._open_in_web(url=self.platform_url)
 

dtlpy/repositories/dpks.py

@@ -309,6 +309,35 @@ class Dpks:
             raise exceptions.PlatformException(response)
         return response.json()
 
+    def get_revisions(self, dpk_id: str, version: str):
+        """
+        Get the revision of a specific dpk.
+
+        :param str dpk_id: the id of the dpk.
+        :param str version: the version of the dpk.
+        :return the entity of the dpk
+        :rtype entities.Dpk
+
+        ** Example **
+        ..coed-block:: python
+            dpk = dl.dpks.get_revisions(dpk_id='id', version='1.0.0')
+        """
+        if dpk_id is None or version is None:
+            raise ValueError('You must provide both dpk_id and version')
+        url = '/app-registry/{}/revisions/{}'.format(dpk_id, version)
+
+        # request
+        success, response = self._client_api.gen_request(req_type='get',
+                                                         path=url)
+        if not success:
+            raise exceptions.PlatformException(response)
+
+        dpk = entities.Dpk.from_json(_json=response.json(),
+                                     client_api=self._client_api,
+                                     project=self._project,
+                                     is_fetched=False)
+        return dpk
+
     def get(self, dpk_name: str = None, dpk_version: str = None, dpk_id: str = None) -> entities.Dpk:
         """
         Get a specific dpk from the platform.

dtlpy/repositories/executions.py

@@ -7,6 +7,7 @@ from .. import exceptions, entities, repositories, miscellaneous, _api_reference
 from ..services.api_client import ApiClient
 
 logger = logging.getLogger(name='dtlpy')
+MAX_SLEEP_TIME = 30
 
 
 class Executions:
@@ -562,15 +563,19 @@ class Executions:
         return execution
 
     def wait(self,
-             execution_id: str,
-             timeout: int = None):
+             execution_id: str = None,
+             execution: entities.Execution = None,
+             timeout: int = None,
+             backoff_factor=1):
         """
         Get Service execution object.
 
         **Prerequisites**: You must be in the role of an *owner* or *developer*. You must have a service.
 
         :param str execution_id: execution id
+        :param str execution: dl.Execution, optional. must input one of execution or execution_id
         :param int timeout: seconds to wait until TimeoutError is raised. if <=0 - wait until done - by default wait take the service timeout
+        :param float backoff_factor: A backoff factor to apply between attempts after the second try
         :return: Service execution object
         :rtype: dtlpy.entities.execution.Execution
 
@@ -580,40 +585,32 @@ class Executions:
 
             service.executions.wait(execution_id='execution_id')
         """
-        url_path = "/executions/{}".format(execution_id)
+        if execution is None:
+            if execution_id is None:
+                raise ValueError('Must input at least one: [execution, execution_id]')
+            else:
+                execution = self.get(execution_id=execution_id)
         elapsed = 0
         start = int(time.time())
-        if timeout is not None and timeout <= 0:
+        if timeout is None or timeout <= 0:
             timeout = np.inf
 
-        i = 1
-        while True:
-            success, response = self._client_api.gen_request(req_type="get",
-                                                             path=url_path,
-                                                             log_error=False)
-            if not success:
-                raise exceptions.PlatformException(response)
-            # return entity
-            execution = entities.Execution.from_json(client_api=self._client_api,
-                                                     _json=response.json(),
-                                                     project=self._project,
-                                                     service=self._service)
-            if timeout is None:
-                timeout = execution.service.execution_timeout + 60
-            if execution.latest_status['status'] in ['failed', 'success', 'terminated', 'aborted', 'canceled',
-                                                     'system-failure']:
+        num_tries = 1
+        while elapsed < timeout:
+            execution = self.get(execution_id=execution.id)
+            if not execution.in_progress():
                 break
-            elapsed = int(time.time()) - start
-            i += 1
-            if i > 18 or elapsed > timeout:
-                break
-            sleep_time = np.minimum(timeout - elapsed, 2 ** i)
+            elapsed = time.time() - start
+            if elapsed >= timeout:
+                raise TimeoutError(
+                    f"execution wait() got timeout. id: {execution.id!r}, status: {execution.latest_status}")
+            sleep_time = np.min([timeout - elapsed, backoff_factor * (2 ** num_tries), MAX_SLEEP_TIME])
+            num_tries += 1
+            logger.debug("Execution {!r} is running for {:.2f}[s] and now Going to sleep {:.2f}[s]".format(execution.id,
+                                                                                                           elapsed,
+                                                                                                           sleep_time))
             time.sleep(sleep_time)
-        if execution is None:
-            raise ValueError('Nothing to wait for')
-        if elapsed >= timeout:
-            raise TimeoutError("execution wait() got timeout. id: {!r}, status: {}".format(
-                execution.id, execution.latest_status))
+
         return execution
 
     @_api_reference.add(path='/executions/{id}/terminate', method='post')

dtlpy/repositories/features.py

@@ -89,6 +89,9 @@ class Features:
         if filters is None:
             filters = entities.Filters(resource=entities.FiltersResource.FEATURE)
             filters._user_query = 'false'
+        # default sorting
+        if filters.sort == dict():
+            filters.sort_by(field='id')
         # assert type filters
         if not isinstance(filters, entities.Filters):
             raise exceptions.PlatformException(error='400',
@@ -149,7 +152,7 @@ class Features:
         :param immutable value: actual vector - immutable (list of floats [1,2,3])
         :param str project_id: the id of the project where feature will be created
         :param str feature_set_id: ref to a featureSet this vector is a part of
-        :param entity: the entity the featureVector is linked to (item.id, annotation.id etc)
+        :param entity: the entity the featureVector is linked to (item, annotation, etc)
         :param str version: version of the featureSet generator
         :param str parent_id: optional: parent FeatureSet id - used when FeatureVector is a subFeature
         :param str org_id: the id of the org where featureVector will be created

dtlpy/repositories/packages.py

@@ -664,9 +664,12 @@ class Packages:
         :return: Package object
         :rtype: dtlpy.entities.package.Package
         """
-        # if is dtlpy entity convert to dict
-        if modules and isinstance(modules[0], entities.PackageModule):
-            modules = [module.to_json() for module in modules]
+        if modules is not None:
+            if not isinstance(modules, list):
+                modules = [modules]
+
+            if isinstance(modules[0], entities.PackageModule):
+                modules = [module.to_json() for module in modules]
 
         if slots and isinstance(slots[0], entities.PackageSlot):
             slots = [slot.to_json() for slot in slots]

dtlpy/repositories/pipeline_executions.py

@@ -81,7 +81,7 @@ class PipelineExecutions:
         if pipeline_id is None and self._pipeline is None:
             raise exceptions.PlatformException('400', 'Must provide param pipeline_id')
         elif pipeline_id is None:
-            pipeline_id = self.pipeline.id
+            pipeline_id = self._pipeline.id
 
         success, response = self._client_api.gen_request(
             req_type="get",
@@ -93,13 +93,13 @@ class PipelineExecutions:
         if not success:
             raise exceptions.PlatformException(response)
 
-        pipeline = entities.PipelineExecution.from_json(
+        pipeline_execution = entities.PipelineExecution.from_json(
             client_api=self._client_api,
             _json=response.json(),
             pipeline=self._pipeline
         )
 
-        return pipeline
+        return pipeline_execution
 
     def _build_entities_from_response(self, response_items) -> miscellaneous.List[entities.PipelineExecution]:
         pool = self._client_api.thread_pools(pool_name='entity.create')
@@ -175,7 +175,7 @@ class PipelineExecutions:
         #     filters.add(field='projectId', values=self.project.id)
 
         if self._pipeline is not None:
-            filters.add(field='pipelineId', values=self.pipeline.id)
+            filters.add(field='pipelineId', values=self._pipeline.id)
 
         paged = entities.PagedEntities(
             items_repository=self,
@@ -344,7 +344,7 @@ class PipelineExecutions:
         if pipeline_id is None and self._pipeline is None:
             raise exceptions.PlatformException('400', 'Must provide param pipeline_id')
         elif pipeline_id is None:
-            pipeline_id = self.pipeline.id
+            pipeline_id = self._pipeline.id
 
         if filters is None:
             filters = entities.Filters(resource=entities.FiltersResource.PIPELINE_EXECUTION)

dtlpy/repositories/services.py

@@ -25,7 +25,7 @@ class Services:
     def __init__(self,
                  client_api: ApiClient,
                  project: entities.Project = None,
-                 package: entities.Package = None,
+                 package: Union[entities.Package, entities.Dpk] = None,
                  project_id=None,
                  model_id=None,
                  model: entities.Model = None):
@@ -52,12 +52,12 @@ class Services:
             raise exceptions.PlatformException(
                 error='2001',
                 message='Cannot perform action WITHOUT package entity in services repository. Please set a package')
-        assert isinstance(self._package, entities.Package)
+        assert (isinstance(self._package, entities.Package) or isinstance(self._package, entities.Dpk))
         return self._package
 
     @package.setter
-    def package(self, package: entities.Package):
-        if not isinstance(package, entities.Package):
+    def package(self, package: Union[entities.Package, entities.Dpk]):
+        if not isinstance(package, entities.Package) and not isinstance(package, entities.Dpk):
             raise ValueError('Must input a valid package entity')
         self._package = package
 
@@ -605,6 +605,7 @@ class Services:
                 on_reset: str = None,
                 max_attempts: int = None,
                 secrets=None,
+                integrations=None,
                 **kwargs
                 ) -> entities.Service:
         """
@@ -631,6 +632,7 @@ class Services:
         :param int max_attempts: Maximum execution retries in-case of a service reset
         :param bool force: optional - terminate old replicas immediately
         :param list secrets: list of the integrations ids
+        :param list integrations: list of the integrations
         :param kwargs:
         :return: Service object
         :rtype: dtlpy.entities.service.Service
@@ -691,6 +693,11 @@ class Services:
                 secrets = [secrets]
             payload['secrets'] = secrets
 
+        if integrations is not None:
+            if not isinstance(integrations, list):
+                integrations = [integrations]
+            payload['integrations'] = integrations
+
         if runtime is not None:
             if isinstance(runtime, entities.KubernetesRuntime):
                 runtime = runtime.to_json()
@@ -748,7 +755,7 @@ class Services:
         )
 
     @_api_reference.add(path='/services/{id}', method='delete')
-    def delete(self, service_name: str = None, service_id: str = None):
+    def delete(self, service_name: str = None, service_id: str = None, force=False):
         """
         Delete Service object
 
@@ -756,6 +763,7 @@ class Services:
 
         You must provide at least ONE of the following params: service_id, service_name.
 
+        :param force:
         :param str service_name: by name
         :param str service_id: by id
         :return: True
@@ -774,10 +782,14 @@ class Services:
             else:
                 service_id = self.get(service_name=service_name).id
 
+        path = "/services/{}".format(service_id)
+        if force:
+            path = '{}?force=true'.format(path)
+
         # request
         success, response = self._client_api.gen_request(
             req_type="delete",
-            path="/services/{}".format(service_id)
+            path=path
         )
         if not success:
             raise exceptions.PlatformException(response)
@@ -1168,6 +1180,7 @@ class Services:
                on_reset: str = None,
                force: bool = False,
                secrets: list = None,
+               integrations: list = None,
                **kwargs) -> entities.Service:
         """
         Deploy service.
@@ -1196,6 +1209,7 @@ class Services:
         :param str on_reset: what happens on reset
         :param bool force: optional - if true, terminate old replicas immediately
         :param list secrets: list of the integrations ids
+        :param list integrations: list of the integrations
         :param kwargs: list of additional arguments
         :return: Service object
         :rtype: dtlpy.entities.service.Service
@@ -1218,6 +1232,8 @@ class Services:
                                     )
                                 )
         """
+        if package is None and isinstance(package, entities.Dpk):
+            raise exceptions.PlatformException('400', 'cannot deploy dpk package. Please install the app')
         package = package if package is not None else self._package
         if service_name is None:
             get_name = False
@@ -1290,6 +1306,10 @@ class Services:
                 if not isinstance(secrets, list):
                     secrets = [secrets]
                 service.secrets = secrets
+            if integrations is not None:
+                if not isinstance(integrations, list):
+                    integrations = [integrations]
+                service.integrations = integrations
             service = self.update(service=service, force=force)
         else:
             service = self._create(service_name=service_name,
@@ -1312,7 +1332,8 @@ class Services:
                                    drain_time=drain_time,
                                    max_attempts=max_attempts,
                                    on_reset=on_reset,
-                                   secrets=secrets
+                                   secrets=secrets,
+                                   integrations=integrations,
                                    )
         if checkout:
             self.checkout(service=service)

dtlpy/repositories/tasks.py

@@ -585,7 +585,8 @@ class Tasks:
                consensus_task_type=None,
                consensus_percentage=None,
                consensus_assignees=None,
-               scoring=True
+               scoring=True,
+               enforce_video_conversion=True,
                ) -> entities.Task:
         """
         Create a new Task (Annotation or QA).
@@ -619,6 +620,7 @@ class Tasks:
         :param int consensus_percentage: percentage of items to be copied to multiple annotators (consensus items)
         :param int consensus_assignees: the number of different annotators per item (number of copies per item)
         :param bool scoring: create a scoring app in project
+        :param bool enforce_video_conversion: Enforce WEBM conversion on video items for frame-accurate annotations. WEBM Conversion will be executed as a project service and incurs compute costs. Service compute resources can be set according to planned workload.
         :return: Task object
         :rtype: dtlpy.entities.task.Task
 
@@ -628,7 +630,8 @@ class Tasks:
 
             dataset.tasks.create(task= 'task_entity',
                                 due_date = datetime.datetime(day= 1, month= 1, year= 2029).timestamp(),
-                                assignee_ids =[ 'annotator1@dataloop.ai', 'annotator2@dataloop.ai'])
+                                assignee_ids =[ 'annotator1@dataloop.ai', 'annotator2@dataloop.ai'],
+                                available_actions=[dl.ItemAction("discard"), dl.ItemAction("to-check")])
         """
 
         if dataset is None and self._dataset is None:
@@ -706,6 +709,9 @@ class Tasks:
         if task_parent_id is not None:
             payload['spec']['parentTaskId'] = task_parent_id
 
+        if not enforce_video_conversion:
+            payload['disableWebm'] = not enforce_video_conversion
+
         is_pulling = any([batch_size, max_batch_workload])
         is_consensus = any([consensus_percentage, consensus_assignees, consensus_task_type])
         if is_pulling and is_consensus:

dtlpy/repositories/uploader.py

@@ -480,8 +480,8 @@ class Uploader:
                             element.item_metadata = {}
                             with open(element.annotations_filepath) as ann_f:
                                 item_metadata = json.load(ann_f)
-                            if 'metadata' in item_metadata and 'user' in item_metadata['metadata']:
-                                element.item_metadata['user'] = item_metadata['metadata']['user']
+                            if 'metadata' in item_metadata:
+                                element.item_metadata = item_metadata['metadata']
                         item, action = await self.__single_async_upload(filepath=element.buffer,
                                                                         mode=mode,
                                                                         item_metadata=element.item_metadata,

dtlpy/services/api_client.py

@@ -43,6 +43,12 @@ logger = logging.getLogger(name='dtlpy')
 threadLock = threading.Lock()
 
 
+def format_message(message):
+    if message:
+        return message.replace('\\n', '\n')
+    return message
+
+
 class VerboseLoggingLevel:
     DEBUG = "debug"
     INFO = "info"
@@ -61,9 +67,9 @@ class PlatformError(Exception):
         if hasattr(resp, 'status_code'):
             msg += '<Response [{}]>'.format(resp.status_code)
         if hasattr(resp, 'reason'):
-            msg += '<Reason [{}]>'.format(resp.reason)
+            msg += '<Reason [{}]>'.format(format_message(resp.reason))
         elif hasattr(resp, 'text'):
-            msg += '<Reason [{}]>'.format(resp.text)
+            msg += '<Reason [{}]>'.format(format_message(resp.text))
         super().__init__(msg)
 
 
@@ -777,7 +783,7 @@ class ApiClient:
         return information
 
     @property
-    def __base_gate_url(self):
+    def base_gate_url(self):
         if self.__gate_url_for_requests is None:
             self.__gate_url_for_requests = self.environment
             internal_requests_url = os.environ.get('INTERNAL_REQUESTS_URL', None)
@@ -801,7 +807,7 @@ class ApiClient:
 
         # prepare request
         req = requests.Request(method=req_type,
-                               url=self.__base_gate_url + path,
+                               url=self.base_gate_url + path,
                                json=json_req,
                                files=files,
                                data=data,
@@ -981,7 +987,7 @@ class ApiClient:
 
         # prepare request
         if is_dataloop:
-            full_url = self.environment + path
+            full_url = self.base_gate_url + path
             headers_req = self._build_request_headers(headers=headers)
         else:
             full_url = path
@@ -1018,7 +1024,7 @@ class ApiClient:
                                    timeout=timeout) as session:
                 try:
                     async with session._request(request=session._client.request,
-                                                url=self.environment + path,
+                                                url=self.base_gate_url + path,
                                                 method=req_type,
                                                 json=json_req,
                                                 data=data,
@@ -1135,7 +1141,7 @@ class ApiClient:
                 form.add_field('file', AsyncUploadStream(buffer=to_upload,
                                                          callback=callback,
                                                          name=uploaded_filename))
-                url = '{}?mode={}'.format(self.environment + remote_url, mode)
+                url = '{}?mode={}'.format(self.base_gate_url + remote_url, mode)
 
                 # use SSL context
                 ssl_context = None
@@ -1218,7 +1224,7 @@ class ApiClient:
                                   pool_connections=np.sum(list(self._thread_pools_names.values())))
             self.session.mount('http://', adapter)
             self.session.mount('https://', adapter)
-        resp = self.session.send(request=prepared, stream=stream, verify=self.verify, timeout=None)
+        resp = self.session.send(request=prepared, stream=stream, verify=self.verify, timeout=120)
 
         with threadLock:
             self.calls_counter.add()
@@ -1337,7 +1343,7 @@ class ApiClient:
         if hasattr(resp, 'reason'):
             msg += '[Reason: {val}]'.format(val=resp.reason)
         if hasattr(resp, 'text'):
-            msg += '[Text: {val}]'.format(val=resp.text)
+            msg += '[Text: {val}]'.format(val=format_message(resp.text))
 
         request_id = resp.headers.get('x-request-id', 'na')
         logger.debug('--- [Request] Start ---')