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

dtlpy/entities/package_module.py

@@ -75,7 +75,20 @@ class PackageModule(entities.DlEntity):
         for cls_name, cls_inst in inspect.getmembers(file_module, predicate=inspect.isclass):
             spec = getattr(cls_inst, '__dtlpy__', None)
             if spec is not None:
+                functions = spec['functions']
+                available_methods = [name for name in ['train', 'predict']
+                                     if 'BaseModelAdapter' not in getattr(cls_inst, name).__qualname__]
+                if "train" not in available_methods:
+                    # remove train_model from functions list if train is not available
+                    functions[:] = [d for d in functions if d.get('name') != "train_model"]
+                if "predict" not in available_methods:
+                    # remove predict_items from functions list if predict is not available
+                    functions[:] = [d for d in functions if d.get('name') != "predict_items"]
+                if "extract_features" not in available_methods:
+                    # remove extract_item_features from functions list if extract_features is not available
+                    functions[:] = [d for d in functions if d.get('name') != "extract_item_features"]
                 spec['entryPoint'] = entry_point
+                spec['functions'] = functions
                 module = cls.from_json(spec)
                 break
         if module is None:

dtlpy/entities/pipeline.py

@@ -456,7 +456,6 @@ class Pipeline(entities.BaseEntity):
         """
         return self.pipelines.update(pipeline=self)
 
-
     def delete(self):
         """
         Delete pipeline object
@@ -560,3 +559,23 @@ class Pipeline(entities.BaseEntity):
         else:
             self.start_nodes = [{"nodeId": node.node_id,
                                  "type": "root", }]
+
+    def update_variables_values(self, **kwargs):
+        """
+        Update pipeline variables values for the given keyword arguments.
+
+        **Example**:
+
+        .. code-block:: python
+            pipeline.update_variables_values(
+                dataset=dataset.id,
+                model=model.id,
+                threshold=0.9
+            )
+            pipeline.update()
+        """
+        keys = kwargs.keys()
+        for variable in self.variables:
+            if variable.name in keys:
+                variable.value = kwargs[variable.name]
+

dtlpy/entities/pipeline_execution.py

@@ -11,6 +11,16 @@ from ..services.api_client import ApiClient
 logger = logging.getLogger(name='dtlpy')
 
 
+class PipelineExecutionStatus(str, Enum):
+    PENDING = "pending"
+    IN_PROGRESS = "in-progress"
+    FAILED = "failed"
+    SUCCESS = "success"
+    QUEUE = "queue"
+    TERMINATED = "terminated"
+    RERUN = "rerun"
+
+
 class CycleRerunMethod(str, Enum):
     START_FROM_NODES = 'startFromNodes',
     START_FROM_FAILED_EXECUTIONS = 'startFromFailedExecutions',
@@ -76,6 +86,7 @@ class PipelineExecution(entities.BaseEntity):
 
     # sdk
     _pipeline = attr.ib(repr=False)
+    _project = attr.ib(repr=False)
     _client_api = attr.ib(type=ApiClient, repr=False)
     _repositories = attr.ib(repr=False)
 
@@ -103,7 +114,7 @@ class PipelineExecution(entities.BaseEntity):
         return status, pipeline
 
     @classmethod
-    def from_json(cls, _json, client_api, pipeline, is_fetched=True):
+    def from_json(cls, _json, client_api, pipeline, is_fetched=True) -> 'PipelineExecution':
         """
         Turn platform representation of pipeline_execution into a pipeline_execution entity
 
@@ -112,9 +123,11 @@ class PipelineExecution(entities.BaseEntity):
         :param dtlpy.entities.pipeline.Pipeline pipeline: Pipeline entity
         :param bool is_fetched: is Entity fetched from Platform
         :return: Pipeline entity
-        :rtype: dtlpy.entities.pipeline.Pipeline
+        :rtype: dtlpy.entities.PipelineExecution
         """
+        project = None
         if pipeline is not None:
+            project = pipeline._project
             if pipeline.id != _json.get('pipelineId', None):
                 logger.warning('Pipeline has been fetched from a project that is not belong to it')
                 pipeline = None
@@ -132,6 +145,7 @@ class PipelineExecution(entities.BaseEntity):
             nodes=nodes,
             executions=_json.get('executions', dict()),
             pipeline=pipeline,
+            project=project,
             client_api=client_api,
         )
 
@@ -183,7 +197,10 @@ class PipelineExecution(entities.BaseEntity):
 
     @property
     def project(self):
-        return self.pipeline.project
+        if self._project is None:
+            self._project = self.pipeline.project
+        assert isinstance(self._pipeline.project, entities.Project)
+        return self._pipeline.project
 
     ################
     # repositories #
@@ -195,9 +212,10 @@ class PipelineExecution(entities.BaseEntity):
 
         r = reps(
             projects=repositories.Projects(client_api=self._client_api),
-            pipelines=repositories.Pipelines(client_api=self._client_api, project=self.project),
-            pipeline_executions=repositories.PipelineExecutions(client_api=self._client_api, project=self.project,
-                                                                pipeline=self.pipeline)
+            pipelines=repositories.Pipelines(client_api=self._client_api, project=self._project),
+            pipeline_executions=repositories.PipelineExecutions(client_api=self._client_api,
+                                                                project=self._project,
+                                                                pipeline=self._pipeline)
         )
         return r
 
@@ -246,3 +264,16 @@ class PipelineExecution(entities.BaseEntity):
             filters=filters,
             wait=wait
         )
+
+    def wait(self):
+        """
+        Wait for pipeline execution
+
+        :return: Pipeline execution object
+        """
+        return self.pipeline_executions.wait(pipeline_execution_id=self.id)
+
+    def in_progress(self):
+        return self.status not in [PipelineExecutionStatus.FAILED,
+                                   PipelineExecutionStatus.SUCCESS,
+                                   PipelineExecutionStatus.TERMINATED]

dtlpy/entities/prompt_item.py

@@ -1,7 +1,11 @@
 import logging
-import io
 import enum
 import json
+import os.path
+from dtlpy import entities, repositories
+from dtlpy.services.api_client import client as client_api
+import base64
+import requests
 
 logger = logging.getLogger(name='dtlpy')
 
@@ -11,27 +15,37 @@ class PromptType(str, enum.Enum):
     IMAGE = 'image/*'
     AUDIO = 'audio/*'
     VIDEO = 'video/*'
+    METADATA = 'metadata'
 
 
 class Prompt:
-    def __init__(self, key):
+    def __init__(self, key, role='user'):
         """
         Create a single Prompt. Prompt can contain multiple mimetype elements, e.g. text sentence and an image.
-
         :param key: unique identifier of the prompt in the item
         """
         self.key = key
         self.elements = list()
+        self._items = repositories.Items(client_api=client_api)
+        self.metadata = {'role': role}
 
-    def add(self, value, mimetype='text'):
+    def add_element(self, value, mimetype='application/text'):
         """
 
         :param value: url or string of the input
         :param mimetype: mimetype of the input. options: `text`, `image/*`, `video/*`, `audio/*`
         :return:
         """
-        self.elements.append({'mimetype': mimetype,
-                              'value': value})
+        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:
+            self.elements.append({'mimetype': mimetype,
+                                  'value': value})
 
     def to_json(self):
         """
@@ -39,26 +53,169 @@ class Prompt:
 
         :return:
         """
+        elements_json = [
+            {
+                "mimetype": e['mimetype'],
+                "value": e['value'],
+            } for e in self.elements
+        ]
+        elements_json.append({
+            "mimetype": PromptType.METADATA,
+            "value": self.metadata
+        })
         return {
-            self.key: [
-                {
-                    "mimetype": e['mimetype'],
-                    "value": e['value']
-                } for e in self.elements
-            ]
+            self.key: elements_json
         }
 
-
-class PromptItem:
-    def __init__(self, name):
+    def _convert_stream_to_binary(self, image_url: str):
         """
-        Create a new Prompt Item. Single item can have multiple prompt, e.g. a conversation.
+        Convert a stream to binary
+        :param image_url: dataloop image stream url
+        :return: binary object
+        """
+        image_buffer = None
+        if '.' in image_url and 'dataloop.ai' not in image_url:
+            # URL and not DL item stream
+            try:
+                response = requests.get(image_url, stream=True)
+                response.raise_for_status()  # Raise an exception for bad status codes
+
+                # Check for valid image content type
+                if response.headers["Content-Type"].startswith("image/"):
+                    # Read the image data in chunks to avoid loading large images in memory
+                    image_buffer = b"".join(chunk for chunk in response.iter_content(1024))
+            except requests.exceptions.RequestException as e:
+                logger.error(f"Failed to download image from URL: {image_url}, error: {e}")
 
-        :param name: name of the item (filename)
+        elif '.' in image_url and 'stream' in image_url:
+            # DL Stream URL
+            item_id = image_url.split("/stream")[0].split("/items/")[-1]
+            image_buffer = self._items.get(item_id=item_id).download(save_locally=False).getvalue()
+        else:
+            # DL item ID
+            image_buffer = self._items.get(item_id=image_url).download(save_locally=False).getvalue()
+
+        if image_buffer is not None:
+            encoded_image = base64.b64encode(image_buffer).decode()
+        else:
+            logger.error(f'Invalid image url: {image_url}')
+            return None
+
+        return f'data:image/jpeg;base64,{encoded_image}'
+
+    def messages(self):
+        """
+        return a list of messages in the prompt item,
+        messages are returned following the openai SDK format https://platform.openai.com/docs/guides/vision
         """
+        messages = []
+        for element in self.elements:
+            if element['mimetype'] == PromptType.TEXT:
+                data = {
+                    "type": "text",
+                    "text": element['value']
+                }
+                messages.append(data)
+            elif element['mimetype'] == PromptType.IMAGE:
+                image_url = self._convert_stream_to_binary(element['value'])
+                data = {
+                    "type": "image_url",
+                    "image_url": {
+                        "url": image_url
+                    }
+                }
+                messages.append(data)
+            elif element['mimetype'] == PromptType.AUDIO:
+                raise NotImplementedError('Audio prompt is not supported yet')
+            elif element['mimetype'] == PromptType.VIDEO:
+                raise NotImplementedError('Video prompt is not supported yet')
+            else:
+                raise ValueError(f'Invalid mimetype: {element["mimetype"]}')
+        return messages, self.key
+
+
+class PromptItem:
+    def __init__(self, name, item: entities.Item = None):
+        # prompt item name
         self.name = name
-        self.type = "prompt"
+        # list of user prompts in the prompt item
         self.prompts = list()
+        # list of assistant (annotations) prompts in the prompt item
+        self.assistant_prompts = dict()
+        # Dataloop Item
+        self._item = None
+
+    @classmethod
+    def from_item(cls, item: entities.Item):
+        """
+        Load a prompt item from the platform
+        :param item : Item object
+        :return: PromptItem object
+        """
+        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
+
+    @classmethod
+    def from_local_file(cls, file_path):
+        """
+        Create a new prompt item from a file
+        :param file_path: 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:
+            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)
+        return prompt_item
+
+    def get_assistant_messages(self, 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()
+        for annotation in annotations:
+            prompt_id = annotation.metadata.get('system', dict()).get('promptId', None)
+            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
+            elif annotation.type == 'text':
+                prompt = Prompt(key=prompt_id)
+                prompt.add_element(value=annotation.coordinates, mimetype=PromptType.TEXT)
+                self.assistant_prompts[annotation.id] = prompt
+
+    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)
 
     def to_json(self):
         """
@@ -69,26 +226,82 @@ class PromptItem:
         prompts_json = {
             "shebang": "dataloop",
             "metadata": {
-                "dltype": self.type
+                "dltype": 'prompt'
             },
             "prompts": {}
         }
         for prompt in self.prompts:
             for prompt_key, prompt_values in prompt.to_json().items():
                 prompts_json["prompts"][prompt_key] = prompt_values
-        return prompts_json
+                prompts_json["prompts"][prompt_key].append({'metadata'})
 
-    def to_bytes_io(self):
-        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
+        return prompts_json
 
-    def add(self, prompt):
+    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')
+
+        all_prompts_messages = dict()
+        for prompt in self.prompts:
+            if prompt.key not in all_prompts_messages:
+                all_prompts_messages[prompt.key] = list()
+            prompt_messages, prompt_key = prompt.messages()
+            messages = {
+                'role': prompt.metadata.get('role', 'user'),
+                '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)
+        res = list()
+        for prompts in all_prompts_messages.values():
+            for prompt in prompts:
+                res.append(prompt)
+        return res
+
+    def add_responses(self, annotation: entities.BaseAnnotationDefinition, model: entities.Model):
+        """
+        Add an annotation to the prompt item
+        :param annotation: Annotation object
+        :param model: Model object
+        """
+        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)

dtlpy/entities/recipe.py

@@ -262,3 +262,40 @@ class Recipe(entities.BaseEntity):
                                                               'datasetId': dataset.id,
                                                               'name': instruction_item.name}
             self.update(True)
+
+    def upload_annotations_verification_file(self, local_path: str, overwrite: bool = False) -> entities.Item:
+        """
+        Add Annotations Verification js file to the recipe.
+
+        :param str local_path: file path of the annotations verification js file.
+        :param bool overwrite: overwrite exiting file if the local and the remote names are matching
+        :return: annotations verification js item.
+        """
+
+        validation_file_metadata = self.metadata.get("system", dict()).get("validationFile", None)
+        if validation_file_metadata is None:
+            validation_file_metadata = dict()
+
+        remote_name = validation_file_metadata.get("name", None)
+        local_name = os.path.basename(local_path)
+        binaries_dataset = self._project.datasets._get_binaries_dataset()
+        remote_path = f"/.dataloop/recipes/{self.id}/verification/"
+
+        if remote_name is None or overwrite or remote_name != local_name:
+            validation_item = binaries_dataset.items.upload(
+                local_path=local_path,
+                remote_path=remote_path,
+                remote_name=local_name,
+                overwrite=True
+            )
+            self.metadata["system"]["validationFile"] = {
+                "itemId": validation_item.id,
+                "datasetId": binaries_dataset.id,
+                "name": local_name
+            }
+            self.update(system_metadata=True)
+        else:
+            logger.debug(f"Existing Annotations Validation Script was found.")
+            validation_item_id = self.metadata["system"]["validationFile"]["itemId"]
+            validation_item = binaries_dataset.items.get(item_id=validation_item_id)
+        return validation_item

dtlpy/entities/service.py

@@ -1,3 +1,4 @@
+import warnings
 from collections import namedtuple
 from enum import Enum
 import traceback
@@ -219,6 +220,7 @@ class Service(entities.BaseEntity):
     on_reset = attr.ib(type=OnResetAction)
     _type = attr.ib(type=ServiceType)
     project_id = attr.ib()
+    org_id = attr.ib()
     is_global = attr.ib()
     max_attempts = attr.ib()
     mode = attr.ib(repr=False)
@@ -235,6 +237,8 @@ class Service(entities.BaseEntity):
     _project = attr.ib(default=None, repr=False)
     _repositories = attr.ib(repr=False)
     updated_by = attr.ib(default=None)
+    app = attr.ib(default=None)
+    integrations = attr.ib(default=None)
 
     @property
     def createdAt(self):
@@ -334,6 +338,9 @@ class Service(entities.BaseEntity):
             updated_by=_json.get('updatedBy', None),
             config=_json.get('config', None),
             settings=_json.get('settings', None),
+            app=_json.get('app', None),
+            integrations=_json.get('integrations', None),
+            org_id=_json.get('orgId', None)
         )
         inst.is_fetched = is_fetched
         return inst
@@ -363,13 +370,25 @@ class Service(entities.BaseEntity):
     def package(self):
         if self._package is None:
             try:
+                dpk_id = None
+                dpk_version = None
+                if self.app and isinstance(self.app, dict):
+                    dpk_id = self.app.get('dpkId', None)
+                    dpk_version = self.app.get('dpkVersion', None)
+                if dpk_id is None:
+                    self._package = repositories.Dpks(client_api=self._client_api, project=self.project).get(
+                        dpk_id=self.package_id)
+                else:
+                    self._package = repositories.Dpks(client_api=self._client_api, project=self.project).get_revisions(
+                        dpk_id=dpk_id,
+                        version=dpk_version)
+
+                assert isinstance(self._package, entities.Dpk)
+            except:
                 self._package = repositories.Packages(client_api=self._client_api).get(package_id=self.package_id,
                                                                                        fetch=None,
                                                                                        log_error=False)
                 assert isinstance(self._package, entities.Package)
-            except:
-                self._package = repositories.Dpks(client_api=self._client_api).get(dpk_id=self.package_id)
-                assert isinstance(self._package, entities.Dpk)
         return self._package
 
     @property
@@ -462,11 +481,15 @@ class Service(entities.BaseEntity):
                 attr.fields(Service).archive,
                 attr.fields(Service).updated_by,
                 attr.fields(Service).config,
-                attr.fields(Service).settings
+                attr.fields(Service).settings,
+                attr.fields(Service).app,
+                attr.fields(Service).integrations,
+                attr.fields(Service).org_id
             )
         )
 
         _json['projectId'] = self.project_id
+        _json['orgId'] = self.org_id
         _json['packageId'] = self.package_id
         _json['initParams'] = self.init_input
         _json['moduleName'] = self.module_name
@@ -518,6 +541,12 @@ class Service(entities.BaseEntity):
         if self.settings is not None:
             _json['settings'] = self.settings
 
+        if self.app is not None:
+            _json['app'] = self.app
+
+        if self.integrations is not None:
+            _json['integrations'] = self.integrations
+
         return _json
 
     def update(self, force=False):