dtlpy 1.90.39__py3-none-any.whl → 1.92.18__py3-none-any.whl

dtlpy/ml/base_model_adapter.py

@@ -110,7 +110,7 @@ class BaseModelAdapter(utilities.BaseServiceRunner):
 
         :param local_path: `str` directory path in local FileSystem
         """
-        raise NotImplementedError("Please implement 'load' method in {}".format(self.__class__.__name__))
+        raise NotImplementedError("Please implement `load` method in {}".format(self.__class__.__name__))
 
     def save(self, local_path, **kwargs):
         """ saves configuration and weights locally
@@ -121,7 +121,7 @@ class BaseModelAdapter(utilities.BaseServiceRunner):
 
         :param local_path: `str` directory path in local FileSystem
         """
-        raise NotImplementedError("Please implement 'save' method in {}".format(self.__class__.__name__))
+        raise NotImplementedError("Please implement `save` method in {}".format(self.__class__.__name__))
 
     def train(self, data_path, output_path, **kwargs):
         """
@@ -133,17 +133,27 @@ class BaseModelAdapter(utilities.BaseServiceRunner):
         :param data_path: `str` local File System path to where the data was downloaded and converted at
         :param output_path: `str` local File System path where to dump training mid-results (checkpoints, logs...)
         """
-        raise NotImplementedError("Please implement 'train' method in {}".format(self.__class__.__name__))
+        raise NotImplementedError("Please implement `train` method in {}".format(self.__class__.__name__))
 
     def predict(self, batch, **kwargs):
-        """ Model inference (predictions) on batch of images
+        """ Model inference (predictions) on batch of items
 
             Virtual method - need to implement
 
-        :param batch: `np.ndarray`
+        :param batch: output of the `prepare_item_func` func
         :return: `list[dl.AnnotationCollection]` each collection is per each image / item in the batch
         """
-        raise NotImplementedError("Please implement 'predict' method in {}".format(self.__class__.__name__))
+        raise NotImplementedError("Please implement `predict` method in {}".format(self.__class__.__name__))
+
+    def embed(self, batch, **kwargs):
+        """ Extract model embeddings on batch of items
+
+            Virtual method - need to implement
+
+        :param batch: output of the `prepare_item_func` func
+        :return: `list[list]` a feature vector per each item in the batch
+        """
+        raise NotImplementedError("Please implement `embed` method in {}".format(self.__class__.__name__))
 
     def evaluate(self, model: entities.Model, dataset: entities.Dataset, filters: entities.Filters) -> entities.Model:
         """
@@ -177,7 +187,7 @@ class BaseModelAdapter(utilities.BaseServiceRunner):
         :param data_path: `str` local File System directory path where we already downloaded the data from dataloop platform
         :return:
         """
-        raise NotImplementedError("Please implement 'convert_from_dtlpy' method in {}".format(self.__class__.__name__))
+        raise NotImplementedError("Please implement `convert_from_dtlpy` method in {}".format(self.__class__.__name__))
 
     #################
     # DTLPY METHODS #
@@ -255,15 +265,27 @@ class BaseModelAdapter(utilities.BaseServiceRunner):
                 self.logger.debug("Downloading subset {!r} of {}".format(subset,
                                                                          self.model_entity.dataset.name))
 
-                if self.configuration.get("include_model_annotations", False):
-                    annotation_filters = None
-                else:
+                if self.model_entity.output_type is not None:
+                    if self.model_entity.output_type in [entities.AnnotationType.SEGMENTATION,
+                                                         entities.AnnotationType.POLYGON]:
+                        model_output_types = [entities.AnnotationType.SEGMENTATION, entities.AnnotationType.POLYGON]
+                    else:
+                        model_output_types = [self.model_entity.output_type]
                     annotation_filters = entities.Filters(
+                        field=entities.FiltersKnownFields.TYPE,
+                        values=model_output_types,
+                        resource=entities.FiltersResource.ANNOTATION,
+                        operator=entities.FiltersOperations.IN
+                    )
+                else:
+                    annotation_filters = entities.Filters(resource=entities.FiltersResource.ANNOTATION)
+
+                if not self.configuration.get("include_model_annotations", False):
+                    annotation_filters.add(
                         field="metadata.system.model.name",
                         values=False,
-                        operator=entities.FiltersOperations.EXISTS,
-                        resource=entities.FiltersResource.ANNOTATION
-                        )
+                        operator=entities.FiltersOperations.EXISTS
+                    )
 
                 ret_list = dataset.items.download(filters=filters,
                                                   local_path=data_subset_base_path,
@@ -352,7 +374,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 +408,115 @@ class BaseModelAdapter(utilities.BaseServiceRunner):
         pool.shutdown()
         return items, annotations
 
+    @entities.Package.decorators.function(display_name='Embed Items',
+                                          inputs={'items': 'Item[]'},
+                                          outputs={'items': 'Item[]', 'features': '[]'})
+    def embed_items(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))
+
+        # Search for existing feature set for this model id
+        filters = entities.Filters(field='modelId',
+                                   values=self.model_entity.id,
+                                   resource=entities.FiltersResource.FEATURE_SET)
+        pages = self.model_entity.project.feature_sets.list(filters)
+        if pages.items_count == 0:
+            feature_set_name = self.configuration.get('featureSetName', self.model_entity.name)
+            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,
+                                                                        model_id=self.model_entity.id,
+                                                                        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}')
+        elif pages.items_count > 1:
+            raise ValueError(
+                f'More than one feature set for model. model_id: {self.model_entity.id}, feature_sets_ids: {[f.id for f in pages.all()]}')
+        else:
+            feature_set = pages.items[0]
+            logger.info(f'Feature Set found! name: {feature_set.name}, id: {feature_set.id}')
+
+        # upload the feature vectors
+        pool = ThreadPoolExecutor(max_workers=16)
+        vectors = list()
+        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.embed(batch, **kwargs)
+            vectors.extend(batch_vectors)
+            if upload_features is True:
+                self.logger.debug(
+                    "Uploading items' feature vectors for model {!r}.".format(self.model_entity.name))
+                try:
+                    _ = list(pool.map(partial(self._upload_model_features,
+                                              feature_set.id,
+                                              self.model_entity.project_id),
+                                      batch_items,
+                                      batch_vectors))
+                except Exception as err:
+                    self.logger.exception("Failed to upload feature vectors to items.")
+
+        pool.shutdown()
+        return items, vectors
+
+    @entities.Package.decorators.function(display_name='Embed Dataset with DQL',
+                                          inputs={'dataset': 'Dataset',
+                                                  'filters': 'Json'})
+    def embed_dataset(self,
+                      dataset: entities.Dataset,
+                      filters: entities.Filters = None,
+                      upload_features=True,
+                      batch_size=None,
+                      **kwargs):
+        """
+        Extract feature from all items given
+
+        :param dataset: Dataset entity to predict
+        :param filters: Filters entity for a filtering before predicting
+        :param upload_features: `bool` uploads the features back to the given items
+        :param batch_size: `int` size of batch to run a single inference
+
+        :return: `bool` indicating if the prediction process completed successfully
+        """
+        if batch_size is None:
+            batch_size = self.configuration.get('batch_size', 4)
+
+        self.logger.debug("Creating embedings for dataset (name:{}, id:{}, using batch size {}".format(dataset.name,
+                                                                                                       dataset.id,
+                                                                                                       batch_size))
+        if not filters:
+            filters = entities.Filters()
+        if filters is not None and isinstance(filters, dict):
+            filters = entities.Filters(custom_filter=filters)
+        pages = dataset.items.list(filters=filters, page_size=batch_size)
+        items = [item for page in pages for item in page]
+        self.embed_items(items=items,
+                         upload_features=upload_features,
+                         batch_size=batch_size,
+                         **kwargs)
+        return True
+
     @entities.Package.decorators.function(display_name='Predict Dataset with DQL',
                                           inputs={'dataset': 'Dataset',
                                                   'filters': 'Json'})
@@ -404,9 +536,12 @@ class BaseModelAdapter(utilities.BaseServiceRunner):
         :param cleanup: `bool` if set removes existing predictions with the same package-model name (default: False)
         :param batch_size: `int` size of batch to run a single inference
 
-        :return: `List[dl.AnnotationCollection]` where all annotation in the collection are of type package.output_type
-                                                 and has prediction fields (model_info)
+        :return: `bool` indicating if the prediction process completed successfully
         """
+
+        if batch_size is None:
+            batch_size = self.configuration.get('batch_size', 4)
+
         self.logger.debug("Predicting dataset (name:{}, id:{}, using batch size {}".format(dataset.name,
                                                                                            dataset.id,
                                                                                            batch_size))
@@ -415,9 +550,9 @@ class BaseModelAdapter(utilities.BaseServiceRunner):
         if filters is not None and isinstance(filters, dict):
             filters = entities.Filters(custom_filter=filters)
         pages = dataset.items.list(filters=filters, page_size=batch_size)
-        items = [item for item in pages.all() if item.type == 'file']
+        items = [item for page in pages for item in page]
         self.predict_items(items=items,
-                           with_upload=with_upload,
+                           upload_annotations=with_upload,
                            cleanup=cleanup,
                            batch_size=batch_size,
                            **kwargs)
@@ -571,6 +706,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/new_instance.py

@@ -1,14 +1,61 @@
 class Dtlpy:
+    from .services.api_client import client as client_api
+    from .services.api_client import VerboseLoggingLevel, ApiClient
+    from .services import DataloopLogger, DtlpyFilter, check_sdk, Reporter, service_defaults
+    from .services.api_reference import api_reference as _api_reference
+    from .caches.cache import CacheConfig, CacheType
     from .exceptions import PlatformException
     from . import repositories, exceptions, entities, examples
-    from .__version__ import version as __version__
-    from .entities import Box, Text, Point, Segmentation, Polygon, Ellipse, Classification, Subtitle, Polyline, \
-        Filters, Trigger, Description, \
-        AnnotationCollection, Annotation, Item, Codebase, Filters, Execution, Recipe, Ontology, Label, \
-        ItemLink, UrlLink, PackageModule, PackageFunction, FunctionIO, Modality, Workload, WorkloadUnit
-    from .utilities import Converter, BaseServiceRunner, Progress
-    from .services.api_client import ApiClient
-    from .services import check_sdk
+    from .entities import (
+        # main entities
+        Project, Dataset, ExpirationOptions, ExportVersion, Trigger, Item, Execution, AnnotationCollection, Annotation,
+        Recipe, IndexDriver, AttributesTypes, AttributesRange, Dpk, App, AppModule, AppScope,
+        Ontology, Label, Task, TaskPriority, ConsensusTaskType, Assignment, Service, Package, Codebase, Model,
+        PackageModule, PackageFunction,
+        # annotations
+        Box, Cube, Cube3d, Point, Note, Message, Segmentation, Ellipse, Classification, Subtitle, Polyline, Pose,
+        Description,
+        Polygon, Text, FreeText, RefImage,
+        # filters
+        Filters, FiltersKnownFields, FiltersResource, FiltersOperations, FiltersMethod, FiltersOrderByDirection,
+        FiltersKnownFields as KnownFields,
+        # triggers
+        TriggerResource, TriggerAction, TriggerExecutionMode, TriggerType,
+        # faas
+        FunctionIO, KubernetesAutuscalerType, KubernetesRabbitmqAutoscaler, KubernetesAutoscaler, KubernetesRuntime,
+        InstanceCatalog, PackageInputType, ServiceType, ServiceModeType,
+        PackageSlot, SlotPostAction, SlotPostActionType, SlotDisplayScope, SlotDisplayScopeResource, UiBindingPanel,
+        # roberto
+        DatasetSubsetType, ModelStatus, PlotSample, ArtifactType, Artifact, ItemArtifact, LinkArtifact, LocalArtifact,
+        EntityScopeLevel,
+        # features
+        FeatureEntityType, Feature, FeatureSet,
+        #
+        RequirementOperator, PackageRequirement,
+        Command, CommandsStatus,
+        LocalCodebase, GitCodebase, ItemCodebase, FilesystemCodebase, PackageCodebaseType,
+        MemberRole, MemberOrgRole,
+        Webhook, HttpMethod,
+        ViewAnnotationOptions, AnnotationStatus, AnnotationType,
+        ItemStatus, ExecutionStatus, ExportMetadata,
+        PromptItem, Prompt, PromptType,
+        ItemLink, UrlLink, LinkTypeEnum,
+        Modality, ModalityTypeEnum, ModalityRefTypeEnum,
+        Workload, WorkloadUnit, ItemAction,
+        PipelineExecution, CycleRerunMethod, PipelineExecutionNode, Pipeline, PipelineConnection,
+        PipelineNode, TaskNode, CodeNode, PipelineStats, PipelineSettings,
+        PipelineNodeType, PipelineNameSpace, PipelineResumeOption, Variable, CompositionStatus,
+        FunctionNode, DatasetNode, PipelineConnectionPort, PipelineNodeIO, Organization, OrganizationsPlans,
+        Integration,
+        Driver, S3Driver, GcsDriver, AzureBlobDriver, CacheAction, PodType,
+        ExternalStorage, IntegrationType, Role, PlatformEntityType, SettingsValueTypes, SettingsTypes,
+        SettingsSectionNames,
+        SettingScope, BaseSetting, UserSetting, Setting, ServiceSample, ExecutionSample, PipelineExecutionSample,
+        ResourceExecution, Message, NotificationEventContext
+    )
+    from .ml import BaseModelAdapter
+    from .utilities import Converter, BaseServiceRunner, Progress, Context, AnnotationFormat
+    from .repositories import FUNCTION_END_LINE, PackageCatalog
 
     def __init__(self, cookie_filepath=None):
         self.client_api = self.ApiClient(cookie_filepath=cookie_filepath)
@@ -24,15 +71,40 @@ class Dtlpy:
         self.triggers = self.repositories.Triggers(client_api=self.client_api)
         self.assignments = self.repositories.Assignments(client_api=self.client_api)
         self.tasks = self.repositories.Tasks(client_api=self.client_api)
+        self.dpks = self.repositories.Dpks(client_api=self.client_api)
         self.annotations = self.repositories.Annotations(client_api=self.client_api)
+        self.models = self.repositories.Models(client_api=self.client_api)
+        self.ontologies = self.repositories.Ontologies(client_api=self.client_api)
+        self.recipes = self.repositories.Recipes(client_api=self.client_api)
+        self.pipelines = self.repositories.Pipelines(client_api=self.client_api)
+        self.pipeline_executions = self.repositories.PipelineExecutions(client_api=self.client_api)
+        self.feature_sets = self.repositories.FeatureSets(client_api=self.client_api)
+        self.features = self.repositories.Features(client_api=self.client_api)
+        self.organizations = self.repositories.Organizations(client_api=self.client_api)
+        self.analytics = self.repositories.Analytics(client_api=self.client_api)
+        self.integrations = self.repositories.Integrations(client_api=self.client_api)
+        self.drivers = self.repositories.Drivers(client_api=self.client_api)
+        self.settings = self.repositories.Settings(client_api=self.client_api)
+        self.apps = self.repositories.Apps(client_api=self.client_api)
+        self.dpks = self.repositories.Dpks(client_api=self.client_api)
+        self.messages = self.repositories.Messages(client_api=self.client_api)
+        self.compositions = self.repositories.Compositions(client_api=self.client_api)
+
         self.verbose = self.client_api.verbose
         self.login = self.client_api.login
+        self.logout = self.client_api.logout
         self.login_token = self.client_api.login_token
         self.login_secret = self.client_api.login_secret
+        self.login_api_key = self.client_api.login_api_key
+        self.login_m2m = self.client_api.login_m2m
         self.add_environment = self.client_api.add_environment
         self.setenv = self.client_api.setenv
         self.token_expired = self.client_api.token_expired
         self.info = self.client_api.info
+        self.cache_state = self.client_api.cache_state
+        self.attributes_mode = self.client_api.attributes_mode
+        self.sdk_cache = self.client_api.sdk_cache
+        self.platform_settings = self.client_api.platform_settings
 
     def __del__(self):
         for name, pool in self.client_api._thread_pools.items():
@@ -176,7 +248,6 @@ class Dtlpy:
         GPU_T4_S = "gpu-t4-s"
         GPU_T4_M = "gpu-t4-m"
 
-
     class LoggingLevel:
         DEBUG = 'debug'
         WARNING = 'warning'

dtlpy/repositories/apps.py

@@ -1,6 +1,6 @@
 import logging
 
-from .. import entities, exceptions, miscellaneous
+from .. import entities, exceptions, miscellaneous, repositories
 from ..services.api_client import ApiClient
 
 logger = logging.getLogger(name='dtlpy')
@@ -11,6 +11,7 @@ class Apps:
     def __init__(self, client_api: ApiClient, project: entities.Project = None):
         self._client_api = client_api
         self._project = project
+        self._commands = None
 
     @property
     def project(self) -> entities.Project:
@@ -21,6 +22,12 @@ class Apps:
         assert isinstance(self._project, entities.Project)
         return self._project
 
+    @property
+    def commands(self) -> repositories.Commands:
+        if self._commands is None:
+            self._commands = repositories.Commands(client_api=self._client_api)
+        return self._commands
+
     @project.setter
     def project(self, project: entities.Project):
         if not isinstance(project, entities.Project):
@@ -160,12 +167,13 @@ class Apps:
         paged.get_page()
         return paged
 
-    def update(self, app: entities.App = None, app_id: str = None) -> bool:
+    def update(self, app: entities.App = None, app_id: str = None, wait: bool = True) -> bool:
         """
         Update the current app to the new configuration
 
         :param entities.App app: The app to update.
         :param str app_id: The app id to update.
+        :param bool wait: wait for the operation to finish.
         :return bool whether the operation ran successfully or not
 
         **Example**
@@ -179,16 +187,30 @@ class Apps:
         success, response = self._client_api.gen_request(req_type='put',
                                                          path=f"/apps/{app.id}",
                                                          json_req=app.to_json())
-        if success:
-            return success
-        raise exceptions.PlatformException(response)
+        if not success:
+            raise exceptions.PlatformException(response)
+
+        app = entities.App.from_json(
+            _json=response.json(),
+            client_api=self._client_api,
+            project=self.project
+        )
+        if app.metadata:
+            command_id = app.metadata.get('system', {}).get('commands', {}).get('update', None)
+            if wait and app.status == entities.CompositionStatus.UPDATING and command_id is not None:
+                command = self.commands.get(command_id=command_id, url='api/v1/commands/faas/{}'.format(command_id))
+                command.wait()
+                app = self.get(app_id=app.id)
+
+        return success
 
     def install(self,
                 dpk: entities.Dpk,
                 app_name: str = None,
                 organization_id: str = None,
                 custom_installation: dict = None,
-                scope: entities.AppScope = None
+                scope: entities.AppScope = None,
+                wait: bool = True
                 ) -> entities.App:
         """
         Install the specified app in the project.
@@ -199,6 +221,7 @@ class Apps:
         :param str organization_id: the organization which you want to apply on the filter.
         :param dict custom_installation: partial installation.
         :param str scope: the scope of the app. default is project.
+        :param bool wait: wait for the operation to finish.
 
         :return the installed app.
         :rtype entities.App
@@ -229,11 +252,20 @@ class Apps:
                                                          json_req=app.to_json())
         if not success:
             raise exceptions.PlatformException(response)
-        return entities.App.from_json(_json=response.json(),
-                                      client_api=self._client_api,
-                                      project=self.project)
+        app = entities.App.from_json(_json=response.json(),
+                                     client_api=self._client_api,
+                                     project=self.project)
+
+        if app.metadata:
+            command_id = app.metadata.get('system', {}).get('commands', {}).get('install', None)
+            if wait and app.status == entities.CompositionStatus.INITIALIZING and command_id is not None:
+                command = self.commands.get(command_id=command_id, url='api/v1/commands/faas/{}'.format(command_id))
+                command.wait()
+                app = self.get(app_id=app.id)
 
-    def uninstall(self, app_id: str = None, app_name: str = None) -> bool:
+        return app
+
+    def uninstall(self, app_id: str = None, app_name: str = None, wait: bool = True) -> bool:
         """
         Delete an app entity.
 
@@ -241,6 +273,7 @@ class Apps:
 
         :param str app_id: optional - the id of the app.
         :param str app_name: optional - the name of the app.
+        :param bool wait: optional - wait for the operation to finish.
         :return whether we succeed uninstalling the specified app.
         :rtype bool
 
@@ -260,6 +293,19 @@ class Apps:
         if not success:
             raise exceptions.PlatformException(response)
 
+        try:
+            app = self.get(app_id=app_id)
+        except Exception as e:
+            if e.status_code == '404':
+                return success
+            else:
+                raise e
+        if app.metadata:
+            command_id = app.metadata.get('system', {}).get('commands', {}).get('uninstall', None)
+            if wait and app.status == entities.CompositionStatus.TERMINATING and command_id is not None:
+                command = self.commands.get(command_id=command_id, url='api/v1/commands/faas/{}'.format(command_id))
+                command.wait()
+
         logger.debug(f"App deleted successfully (id: {app_id}, name: {app_name}")
         return success
 
@@ -280,15 +326,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 +359,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/commands.py

@@ -87,17 +87,25 @@ class Commands:
         :param float backoff_factor: A backoff factor to apply between attempts after the second try
         :return: Command  object
         """
+
         elapsed = 0
         start = time.time()
         if timeout is None or timeout <= 0:
             timeout = np.inf
 
         command = None
-        pbar = tqdm.tqdm(total=100, disable=self._client_api.verbose.disable_progress_bar,
-                         file=sys.stdout, desc='Command Progress')
+        pbar = tqdm.tqdm(total=100,
+                         disable=self._client_api.verbose.disable_progress_bar,
+                         file=sys.stdout,
+                         desc='Command Progress')
         num_tries = 1
         while elapsed < timeout:
             command = self.get(command_id=command_id, url=url)
+            if command.type == 'ExportDatasetAsJson':
+                self._client_api.callbacks.run_on_event(event=self._client_api.callbacks.CallbackEvent.DATASET_EXPORT,
+                                                        context=command.spec,
+                                                        progress=command.progress)
+
             pbar.update(command.progress - pbar.n)
             if not command.in_progress():
                 break