dtlpy 1.92.19__py3-none-any.whl → 1.93.11__py3-none-any.whl

dtlpy/entities/prompt_item.py

@@ -1,11 +1,14 @@
+import requests
 import logging
+import base64
 import enum
 import json
-import os.path
-from dtlpy import entities, repositories
+import io
+import os
+
+from concurrent.futures import ThreadPoolExecutor
+from .. import entities, repositories
 from dtlpy.services.api_client import client as client_api
-import base64
-import requests
 
 logger = logging.getLogger(name='dtlpy')
 
@@ -26,6 +29,8 @@ class Prompt:
         """
         self.key = key
         self.elements = list()
+        # to avoid broken stream of json files - DAT-75653
+        client_api.default_headers['x-dl-sanitize'] = '0'
         self._items = repositories.Items(client_api=client_api)
         self.metadata = {'role': role}
 
@@ -39,8 +44,6 @@ class Prompt:
         allowed_prompt_types = [prompt_type for prompt_type in PromptType]
         if mimetype not in allowed_prompt_types:
             raise ValueError(f'Invalid mimetype: {mimetype}. Allowed values: {allowed_prompt_types}')
-        if not isinstance(value, str) and mimetype != PromptType.METADATA:
-            raise ValueError(f'Expected str for Prompt element value, got {type(value)} instead')
         if mimetype == PromptType.METADATA and isinstance(value, dict):
             self.metadata.update(value)
         else:
@@ -57,7 +60,7 @@ class Prompt:
             {
                 "mimetype": e['mimetype'],
                 "value": e['value'],
-            } for e in self.elements
+            } for e in self.elements if not e['mimetype'] == PromptType.METADATA
         ]
         elements_json.append({
             "mimetype": PromptType.METADATA,
@@ -135,15 +138,34 @@ class Prompt:
 
 
 class PromptItem:
-    def __init__(self, name, item: entities.Item = None):
+    def __init__(self, name, item: entities.Item = None, role_mapping=None):
+        if role_mapping is None:
+            role_mapping = {'user': 'item',
+                            'assistant': 'annotation'}
+        if not isinstance(role_mapping, dict):
+            raise ValueError(f'input role_mapping must be dict. type: {type(role_mapping)}')
+        self.role_mapping = role_mapping
         # prompt item name
         self.name = name
         # list of user prompts in the prompt item
         self.prompts = list()
+        self.assistant_prompts = list()
         # list of assistant (annotations) prompts in the prompt item
-        self.assistant_prompts = dict()
         # Dataloop Item
-        self._item = None
+        self._messages = []
+        self._item: entities.Item = item
+        self._annotations: entities.AnnotationCollection = None
+        if item is not None:
+            self._items = item.items
+            self.fetch()
+        else:
+            self._items = repositories.Items(client_api=client_api)
+        # to avoid broken stream of json files - DAT-75653
+        self._items._client_api.default_headers['x-dl-sanitize'] = '0'
+
+    @classmethod
+    def from_messages(cls, messages: list):
+        ...
 
     @classmethod
     def from_item(cls, item: entities.Item):
@@ -154,68 +176,67 @@ class PromptItem:
         """
         if 'json' not in item.mimetype or item.system.get('shebang', dict()).get('dltype') != 'prompt':
             raise ValueError('Expecting a json item with system.shebang.dltype = prompt')
-        # Not using `save_locally=False` to use the from_local_file method
-        item_file_path = item.download()
-        prompt_item = cls.from_local_file(file_path=item_file_path)
-        if os.path.exists(item_file_path):
-            os.remove(item_file_path)
-        prompt_item._item = item
-        return prompt_item
+        return cls(name=item.name, item=item)
 
     @classmethod
-    def from_local_file(cls, file_path):
+    def from_local_file(cls, filepath):
         """
         Create a new prompt item from a file
-        :param file_path: path to the file
+        :param filepath: path to the file
         :return: PromptItem object
         """
-        if os.path.exists(file_path) is False:
-            raise FileNotFoundError(f'File does not exists: {file_path}')
-        if 'json' not in os.path.splitext(file_path)[-1]:
-            raise ValueError(f'Expected path to json item, got {os.path.splitext(file_path)[-1]}')
-        prompt_item = cls(name=file_path)
-        with open(file_path, 'r') as f:
+        if os.path.exists(filepath) is False:
+            raise FileNotFoundError(f'File does not exists: {filepath}')
+        if 'json' not in os.path.splitext(filepath)[-1]:
+            raise ValueError(f'Expected path to json item, got {os.path.splitext(filepath)[-1]}')
+        prompt_item = cls(name=filepath)
+        with open(filepath, 'r', encoding='utf-8') as f:
             data = json.load(f)
-        for prompt_key, prompt_values in data.get('prompts', dict()).items():
-            prompt = Prompt(key=prompt_key)
-            for val in prompt_values:
-                if val['mimetype'] == PromptType.METADATA:
-                    _ = val.pop('mimetype')
-                    prompt.add_element(value=val, mimetype=PromptType.METADATA)
-                else:
-                    prompt.add_element(mimetype=val['mimetype'], value=val['value'])
-            prompt_item.add_prompt(prompt=prompt, update_item=False)
+        prompt_item.prompts = prompt_item._load_item_prompts(data=data)
         return prompt_item
 
-    def get_assistant_messages(self, annotations: entities.AnnotationCollection):
+    @staticmethod
+    def _load_item_prompts(data):
+        prompts = list()
+        for prompt_key, prompt_elements in data.get('prompts', dict()).items():
+            content = list()
+            for element in prompt_elements:
+                content.append({'value': element.get('value', dict()),
+                                'mimetype': element['mimetype']})
+            prompt = Prompt(key=prompt_key, role="user")
+            for element in content:
+                prompt.add_element(value=element.get('value', ''),
+                                   mimetype=element.get('mimetype', PromptType.TEXT))
+            prompts.append(prompt)
+        return prompts
+
+    @staticmethod
+    def _load_annotations_prompts(annotations: entities.AnnotationCollection):
         """
         Get all the annotations in the item for the assistant messages
         """
         # clearing the assistant prompts from previous annotations that might not belong
-        self.assistant_prompts = dict()
+        assistant_prompts = list()
         for annotation in annotations:
             prompt_id = annotation.metadata.get('system', dict()).get('promptId', None)
+            model_info = annotation.metadata.get('user', dict()).get('model', dict())
+            annotation_id = annotation.id
             if annotation.type == 'ref_image':
-                prompt = Prompt(key=prompt_id)
-                prompt.add_element(value=annotation.coordinates.get('ref'), mimetype=PromptType.IMAGE)
-                self.assistant_prompts[annotation.id] = prompt
+                prompt = Prompt(key=prompt_id, role='assistant')
+                prompt.add_element(value=annotation.annotation_definition.coordinates.get('ref'),
+                                   mimetype=PromptType.IMAGE)
             elif annotation.type == 'text':
-                prompt = Prompt(key=prompt_id)
-                prompt.add_element(value=annotation.coordinates, mimetype=PromptType.TEXT)
-                self.assistant_prompts[annotation.id] = prompt
+                prompt = Prompt(key=prompt_id, role='assistant')
+                prompt.add_element(value=annotation.annotation_definition.coordinates,
+                                   mimetype=PromptType.TEXT)
+            else:
+                raise ValueError(f"Unsupported annotation type: {annotation.type}")
 
-    def get_assistant_prompts(self, model_name):
-        """
-        Get assistant prompts
-        :return:
-        """
-        if self._item is None:
-            logger.warning('Item is not loaded, skipping annotations context')
-            return
-        filters = entities.Filters(resource=entities.FiltersResource.ANNOTATION)
-        filters.add(field='metadata.user.model.name', values=model_name)
-        annotations = self._item.annotations.list(filters=filters)
-        self.get_assistant_messages(annotations=annotations)
+            prompt.add_element(value={'id': annotation_id,
+                                      'model_info': model_info},
+                               mimetype=PromptType.METADATA)
+            assistant_prompts.append(prompt)
+        return assistant_prompts
 
     def to_json(self):
         """
@@ -233,33 +254,9 @@ class PromptItem:
         for prompt in self.prompts:
             for prompt_key, prompt_values in prompt.to_json().items():
                 prompts_json["prompts"][prompt_key] = prompt_values
-                prompts_json["prompts"][prompt_key].append({'metadata'})
-
         return prompts_json
 
-    def add_prompt(self, prompt: Prompt, update_item=True):
-        """
-            add a prompt to the prompt item
-            prompt: a dictionary. keys are prompt message id, values are prompt messages
-            responses: a list of annotations representing responses to the prompt
-        """
-        self.prompts.append(prompt)
-        if update_item is True:
-            if self._item is not None:
-                self._item._Item__update_item_binary(_json=self.to_json())
-            else:
-                logger.warning('Item is not loaded, skipping upload')
-
-    def messages(self, model_name=None):
-        """
-        return a list of messages in the prompt item
-        messages are returned following the openai SDK format
-        """
-        if model_name is not None:
-            self.get_assistant_prompts(model_name=model_name)
-        else:
-            logger.warning('Model name is not provided, skipping assistant prompts')
-
+    def to_messages(self, model_name=None, include_assistant=True):
         all_prompts_messages = dict()
         for prompt in self.prompts:
             if prompt.key not in all_prompts_messages:
@@ -270,38 +267,191 @@ class PromptItem:
                 'content': prompt_messages
             }
             all_prompts_messages[prompt.key].append(messages)
-
-        for ann_id, prompt in self.assistant_prompts.items():
-            if prompt.key not in all_prompts_messages:
-                logger.warning(f'Prompt key {prompt.key} is not found in the user prompts, skipping Assistant prompt')
-                continue
-            prompt_messages, prompt_key = prompt.messages()
-            assistant_messages = {
-                'role': 'assistant',
-                'content': prompt_messages
-            }
-            all_prompts_messages[prompt.key].append(assistant_messages)
+        if include_assistant is True:
+            # reload to filer model annotations
+            for prompt in self.assistant_prompts:
+                prompt_model_name = prompt.metadata.get('model_info', dict()).get('name')
+                if model_name is not None and prompt_model_name != model_name:
+                    continue
+                if prompt.key not in all_prompts_messages:
+                    logger.warning(
+                        f'Prompt key {prompt.key} is not found in the user prompts, skipping Assistant prompt')
+                    continue
+                prompt_messages, prompt_key = prompt.messages()
+                assistant_messages = {
+                    'role': 'assistant',
+                    'content': prompt_messages
+                }
+                all_prompts_messages[prompt.key].append(assistant_messages)
         res = list()
         for prompts in all_prompts_messages.values():
             for prompt in prompts:
                 res.append(prompt)
-        return res
+        self._messages = res
+        return self._messages
+
+    def to_bytes_io(self):
+        # Used for item upload, do not delete
+        byte_io = io.BytesIO()
+        byte_io.name = self.name
+        byte_io.write(json.dumps(self.to_json()).encode())
+        byte_io.seek(0)
+        return byte_io
 
-    def add_responses(self, annotation: entities.BaseAnnotationDefinition, model: entities.Model):
+    def fetch(self):
+        if self._item is None:
+            raise ValueError('Missing item, nothing to fetch..')
+        self._item = self._items.get(item_id=self._item.id)
+        self._annotations = self._item.annotations.list()
+        self.prompts = self._load_item_prompts(data=json.load(self._item.download(save_locally=False)))
+        self.assistant_prompts = self._load_annotations_prompts(self._annotations)
+
+    def build_context(self, nearest_items, add_metadata=None) -> str:
+        """
+        Create a context stream from nearest items list.
+        add_metadata is a list of location in the item.metadata to add to the context, for instance ['system.document.source']
+        :param nearest_items: list of item ids
+        :param add_metadata: list of metadata location to add metadata to context
+        :return:
         """
-        Add an annotation to the prompt item
-        :param annotation: Annotation object
-        :param model: Model object
+        if add_metadata is None:
+            add_metadata = list()
+
+        def stream_single(w_id):
+            context_item = self._items.get(item_id=w_id)
+            buf = context_item.download(save_locally=False)
+            text = buf.read().decode(encoding='utf-8')
+            m = ""
+            for path in add_metadata:
+                parts = path.split('.')
+                value = context_item.metadata
+                part = ""
+                for part in parts:
+                    if isinstance(value, dict):
+                        value = value.get(part)
+                    else:
+                        value = ""
+
+                m += f"{part}:{value}\n"
+            return text, m
+
+        pool = ThreadPoolExecutor(max_workers=32)
+        context = ""
+        if len(nearest_items) > 0:
+            # build context
+            results = pool.map(stream_single, nearest_items)
+            for res in results:
+                context += f"\n<source>\n{res[1]}\n</source>\n<text>\n{res[0]}\n</text>"
+        return context
+
+    def add(self,
+            message: dict,
+            prompt_key: str = None,
+            stream: bool = True,
+            model_info: dict = None):
         """
-        if self._item is None:
-            raise ValueError('Item is not loaded, cannot add annotation')
-        annotation_collection = entities.AnnotationCollection()
-        annotation_collection.add(annotation_definition=annotation,
-                                  prompt_id=self.prompts[-1].key,
-                                  model_info={
-                                      'name': model.name,
-                                      'model_id': model.id,
-                                      'confidence': 1.0
-                                  })
-        annotations = self._item.annotations.upload(annotations=annotation_collection)
-        self.get_assistant_messages(annotations=annotations)
+        add a prompt to the prompt item
+        prompt: a dictionary. keys are prompt message id, values are prompt messages
+        responses: a list of annotations representing responses to the prompt
+
+        :param message:
+        :param prompt_key:
+        :param stream:
+        :param model_info:
+        :return:
+        """
+        if prompt_key is None:
+            prompt_key = len(self.prompts) + 1
+        role = message.get('role', 'user')
+        content = message.get('content', list())
+
+        if self.role_mapping.get(role, 'item') == 'item':
+            # for new prompt we need a new key
+            prompt = Prompt(key=str(prompt_key), role=role)
+            for element in content:
+                prompt.add_element(value=element.get('value', ''),
+                                   mimetype=element.get('mimetype', PromptType.TEXT))
+
+            # create new prompt and add to prompts
+            self.prompts.append(prompt)
+            if self._item is not None and stream is True:
+                self._item._Item__update_item_binary(_json=self.to_json())
+        else:
+            # for response - we need to assign to previous key
+            prompt_key = str(prompt_key - 1)
+            assistant_message = content[0]
+            assistant_mimetype = assistant_message.get('mimetype', PromptType.TEXT)
+            uploaded_annotation = None
+
+            # find if prompt
+            if model_info is None:
+                # dont search for existing if there's no model information
+                existing_prompt = None
+            else:
+                existing_prompts = list()
+                for prompt in self.assistant_prompts:
+                    prompt_id = prompt.key
+                    model_name = prompt.metadata.get('model_info', dict()).get('name')
+                    if prompt_id == prompt_key and model_name == model_info.get('name'):
+                        # TODO how to handle multiple annotations
+                        existing_prompts.append(prompt)
+                if len(existing_prompts) > 1:
+                    assert False, "shouldn't be here! more than 1 annotation for a single model"
+                elif len(existing_prompts) == 1:
+                    # found model annotation to upload
+                    existing_prompt = existing_prompts[0]
+                else:
+                    # no annotation found
+                    existing_prompt = None
+
+            if existing_prompt is None:
+                prompt = Prompt(key=prompt_key)
+                if assistant_mimetype == PromptType.TEXT:
+                    annotation_definition = entities.FreeText(text=assistant_message.get('value'))
+                    prompt.add_element(value=annotation_definition.to_coordinates(None),
+                                       mimetype=PromptType.TEXT)
+                elif assistant_mimetype == PromptType.IMAGE:
+                    annotation_definition = entities.RefImage(ref=assistant_message.get('value'))
+                    prompt.add_element(value=annotation_definition.to_coordinates(None).get('ref'),
+                                       mimetype=PromptType.IMAGE)
+                else:
+                    raise NotImplementedError('Only images of mimetype image and text are supported')
+                metadata = {'system': {'promptId': prompt_key},
+                            'user': {'model': model_info}}
+                prompt.add_element(mimetype=PromptType.METADATA,
+                                   value={"model_info": model_info})
+
+                if stream:
+                    existing_annotation = entities.Annotation.new(item=self._item,
+                                                                  metadata=metadata,
+                                                                  annotation_definition=annotation_definition)
+                    uploaded_annotation = existing_annotation.upload()
+                    prompt.add_element(mimetype=PromptType.METADATA,
+                                       value={"id": uploaded_annotation.id})
+                existing_prompt = prompt
+                self.assistant_prompts.append(prompt)
+
+            # TODO Shadi fix
+            existing_prompt_element = [element for element in existing_prompt.elements if
+                                       element['mimetype'] != PromptType.METADATA][-1]
+            existing_prompt_element['value'] = assistant_message.get('value')
+            if stream is True and uploaded_annotation is None:
+                # Creating annotation with old dict to match platform dict
+                annotation_definition = entities.FreeText(text='')
+                metadata = {'system': {'promptId': prompt_key},
+                            'user': {'model': existing_prompt.metadata.get('model_info')}}
+                annotation = entities.Annotation.new(item=self._item,
+                                                     metadata=metadata,
+                                                     annotation_definition=annotation_definition
+                                                     )
+                annotation.id = existing_prompt.metadata['id']
+                # set the platform dict to match the old annotation for the dict difference check, otherwise it won't
+                # update
+                annotation._platform_dict = annotation.to_json()
+                # update the annotation with the new text
+                annotation.annotation_definition.text = existing_prompt_element['value']
+                self._item.annotations.update(annotation)
+
+    def update(self):
+        if self._item is not None:
+            self._item._Item__update_item_binary(_json=self.to_json())

dtlpy/ml/base_model_adapter.py

@@ -1,3 +1,4 @@
+import dataclasses
 import tempfile
 import datetime
 import logging
@@ -19,10 +20,41 @@ from ..services.api_client import ApiClient
 logger = logging.getLogger('ModelAdapter')
 
 
+@dataclasses.dataclass
+class AdapterDefaults(dict):
+    # for predict items, dataset, evaluate
+    upload_annotations: bool = dataclasses.field(default=True)
+    clean_annotations: bool = dataclasses.field(default=True)
+    # for embeddings
+    upload_features: bool = dataclasses.field(default=True)
+    # for training
+    root_path: str = dataclasses.field(default=None)
+    data_path: str = dataclasses.field(default=None)
+    output_path: str = dataclasses.field(default=None)
+
+    def __post_init__(self):
+        # Initialize the internal dictionary with the dataclass fields
+        self.update(**dataclasses.asdict(self))
+
+    def update(self, **kwargs):
+        for f in dataclasses.fields(AdapterDefaults):
+            if f.name in kwargs:
+                setattr(self, f.name, kwargs[f.name])
+        super().update(**kwargs)
+
+    def resolve(self, key, *args):
+
+        for arg in args:
+            if arg is not None:
+                return arg
+        return self.get(key, None)
+
+
 class BaseModelAdapter(utilities.BaseServiceRunner):
     _client_api = attr.ib(type=ApiClient, repr=False)
 
     def __init__(self, model_entity: entities.Model = None):
+        self.adapter_defaults = AdapterDefaults()
         self.logger = logger
         # entities
         self._model_entity = None
@@ -222,14 +254,18 @@ class BaseModelAdapter(utilities.BaseServiceRunner):
         download the specific subset selected to data_path and preforms `self.convert` to the data_path dir
 
         :param dataset: dl.Dataset
-        :param root_path: `str` root directory for training. default is "tmp"
-        :param data_path: `str` dataset directory. default <root_path>/"data"
-        :param output_path: `str` save everything to this folder. default <root_path>/"output"
+        :param root_path: `str` root directory for training. default is "tmp". Can be set using self.adapter_defaults.root_path
+        :param data_path: `str` dataset directory. default <root_path>/"data". Can be set using self.adapter_defaults.data_path
+        :param output_path: `str` save everything to this folder. default <root_path>/"output". Can be set using self.adapter_defaults.output_path
 
         :param bool overwrite: overwrite the data path (download again). default is False
         """
         # define paths
         dataloop_path = os.path.join(os.path.expanduser('~'), '.dataloop')
+        root_path = self.adapter_defaults.resolve("root_path", root_path)
+        data_path = self.adapter_defaults.resolve("data_path", data_path)
+        output_path = self.adapter_defaults.resolve("output_path", output_path)
+
         if root_path is None:
             now = datetime.datetime.now()
             root_path = os.path.join(dataloop_path,
@@ -311,6 +347,8 @@ class BaseModelAdapter(utilities.BaseServiceRunner):
             local_path = os.path.join(service_defaults.DATALOOP_PATH, "models", self.model_entity.name)
         # Load configuration
         self.configuration = self.model_entity.configuration
+        # Update the adapter config with the model config to run over defaults if needed
+        self.adapter_defaults.update(**self.configuration)
         # Download
         self.model_entity.artifacts.download(
             local_path=local_path,
@@ -331,6 +369,7 @@ class BaseModelAdapter(utilities.BaseServiceRunner):
         :param cleanup: `bool` if True (default) remove the data from local FileSystem after upload
         :return:
         """
+
         if local_path is None:
             local_path = tempfile.mkdtemp(prefix="model_{}".format(self.model_entity.name))
             self.logger.debug("Using temporary dir at {}".format(local_path))
@@ -354,7 +393,7 @@ class BaseModelAdapter(utilities.BaseServiceRunner):
     @entities.Package.decorators.function(display_name='Predict Items',
                                           inputs={'items': 'Item[]'},
                                           outputs={'items': 'Item[]', 'annotations': 'Annotation[]'})
-    def predict_items(self, items: list, upload_annotations=True, clean_annotations=True, batch_size=None, **kwargs):
+    def predict_items(self, items: list, upload_annotations=None, clean_annotations=None, batch_size=None, **kwargs):
         """
         Run the predict function on the input list of items (or single) and return the items and the predictions.
         Each prediction is by the model output type (package.output_type) and model_info in the metadata
@@ -368,6 +407,8 @@ class BaseModelAdapter(utilities.BaseServiceRunner):
         """
         if batch_size is None:
             batch_size = self.configuration.get('batch_size', 4)
+        upload_annotations = self.adapter_defaults.resolve("upload_annotations", upload_annotations)
+        clean_annotations = self.adapter_defaults.resolve("clean_annotations", clean_annotations)
         input_type = self.model_entity.input_type
         self.logger.debug(
             "Predicting {} items, using batch size {}. input type: {}".format(len(items), batch_size, input_type))
@@ -410,8 +451,8 @@ class BaseModelAdapter(utilities.BaseServiceRunner):
 
     @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):
+                                          outputs={'items': 'Item[]', 'features': 'Json[]'})
+    def embed_items(self, items: list, upload_features=None, batch_size=None, **kwargs):
         """
         Extract feature from an input list of items (or single) and return the items and the feature vector.
 
@@ -423,6 +464,7 @@ class BaseModelAdapter(utilities.BaseServiceRunner):
         """
         if batch_size is None:
             batch_size = self.configuration.get('batch_size', 4)
+        upload_features = self.adapter_defaults.resolve("upload_features", upload_features)
         input_type = self.model_entity.input_type
         self.logger.debug(
             "Predicting {} items, using batch size {}. input type: {}".format(len(items), batch_size, input_type))
@@ -486,7 +528,7 @@ class BaseModelAdapter(utilities.BaseServiceRunner):
     def embed_dataset(self,
                       dataset: entities.Dataset,
                       filters: entities.Filters = None,
-                      upload_features=True,
+                      upload_features=None,
                       batch_size=None,
                       **kwargs):
         """
@@ -501,8 +543,9 @@ class BaseModelAdapter(utilities.BaseServiceRunner):
         """
         if batch_size is None:
             batch_size = self.configuration.get('batch_size', 4)
+        upload_features = self.adapter_defaults.resolve("upload_features", upload_features)
 
-        self.logger.debug("Creating embedings for dataset (name:{}, id:{}, using batch size {}".format(dataset.name,
+        self.logger.debug("Creating embeddings for dataset (name:{}, id:{}, using batch size {}".format(dataset.name,
                                                                                                        dataset.id,
                                                                                                        batch_size))
         if not filters:
@@ -524,8 +567,8 @@ class BaseModelAdapter(utilities.BaseServiceRunner):
     def predict_dataset(self,
                         dataset: entities.Dataset,
                         filters: entities.Filters = None,
-                        with_upload=True,
-                        cleanup=False,
+                        upload_annotations=None,
+                        clean_annotations=None,
                         batch_size=None,
                         **kwargs):
         """
@@ -533,8 +576,8 @@ class BaseModelAdapter(utilities.BaseServiceRunner):
 
         :param dataset: Dataset entity to predict
         :param filters: Filters entity for a filtering before predicting
-        :param with_upload: `bool` uploads the predictions back to the given items
-        :param cleanup: `bool` if set removes existing predictions with the same package-model name (default: False)
+        :param upload_annotations: `bool` uploads the predictions back to the given items
+        :param clean_annotations: `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: `bool` indicating if the prediction process completed successfully
@@ -554,8 +597,8 @@ class BaseModelAdapter(utilities.BaseServiceRunner):
         # Item type is 'file' only, can be deleted if default filters are added to custom filters
         items = [item for page in pages for item in page if item.type == 'file']
         self.predict_items(items=items,
-                           upload_annotations=with_upload,
-                           cleanup=cleanup,
+                           upload_annotations=upload_annotations,
+                           clean_annotations=clean_annotations,
                            batch_size=batch_size,
                            **kwargs)
         return True

dtlpy/repositories/__init__.py

@@ -51,3 +51,4 @@ from .dpks import Dpks
 from .messages import Messages
 from .compositions import Compositions
 from .schema import Schema
+from .computes import Computes, ServiceDrivers

dtlpy/repositories/apps.py

@@ -210,7 +210,8 @@ class Apps:
                 organization_id: str = None,
                 custom_installation: dict = None,
                 scope: entities.AppScope = None,
-                wait: bool = True
+                wait: bool = True,
+                integrations: list = None
                 ) -> entities.App:
         """
         Install the specified app in the project.
@@ -222,6 +223,7 @@ class Apps:
         :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.
+        :param list integrations: list of integrations to install with the app.
 
         :return the installed app.
         :rtype entities.App
@@ -243,7 +245,8 @@ class Apps:
                                             'dpkName': dpk.name,
                                             "customInstallation": custom_installation,
                                             'dpkVersion': dpk.version,
-                                            'scope': scope
+                                            'scope': scope,
+                                            'integrations': integrations
                                             },
                                      client_api=self._client_api,
                                      project=self.project)