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

dtlpy/entities/base_entity.py

@@ -98,22 +98,6 @@ class DlEntity(object):
         """
         return miscellaneous.List([self]).to_df(show_all=show_all, columns=columns)
 
-    # def __repr__(self):
-    #     string = '{}('.format(self.__class__.__name__)
-    #     for prop in dir(self):
-    #         if isinstance(prop, DlProperty) and prop.repr is True:
-    #             string += '{}={}'.format()
-    #     params = json.dumps(self._dict, indent=4)
-    #     return "{}({})".format(self.__class__.__name__, params)
-
-    # def __repr__(self):
-    #     self.print()
-
-    # def __getattribute__(self, attr):
-    #     if super(BaseEntity, self).__getattribute__(attr) is None:
-    #         pass
-    #     return super(BaseEntity, self).__getattribute__(attr)
-
 
 class DlProperty:
     def __init__(self, location=None, default='NODEFAULT', _type=None, _kls=None):
@@ -206,16 +190,9 @@ class DlProperty:
 
         # instantiate dictionary to the type
         value = self._to_instance(_dict=value)
-
-        # isinstance(value, typing_extensions.get_args(self._type))
         return value
 
     def __set__(self, instance, value):
-        # TODO still not working properly. need to fix this validation
-        # if not isinstance(value, typing_extensions.get_args(self._type)):
-        #     logger.warning(
-        #         f'Incorrect typing for type: {type(instance)}. {self.location} must be of type {self._type}. Received: {type(value)}')
-        _client_api = getattr(instance, 'client_api', None)
 
         # validate - if validator is set
         if self._validator is not None:

dtlpy/entities/command.py

@@ -141,7 +141,7 @@ class Command(entities.BaseEntity):
                                entities.CommandsStatus.FINALIZING,
                                entities.CommandsStatus.IN_PROGRESS]
 
-    def wait(self, timeout=0, step=None,  backoff_factor=1):
+    def wait(self, timeout=0, step=None, backoff_factor=1):
         """
         Wait for Command to finish
 
@@ -157,4 +157,5 @@ class Command(entities.BaseEntity):
                                   timeout=timeout,
                                   step=step,
                                   url=self.url,
-                                  backoff_factor=backoff_factor)
+                                  backoff_factor=backoff_factor
+                                  )

dtlpy/entities/dataset.py

@@ -18,6 +18,11 @@ class IndexDriver(str, Enum):
     V2 = "v2"
 
 
+class ExportType(str, Enum):
+    JSON = "json"
+    ZIP = "zip"
+
+
 class ExpirationOptions:
     """
     ExpirationOptions object
@@ -58,7 +63,6 @@ class Dataset(entities.BaseEntity):
     items_count = attr.ib()
     metadata = attr.ib(repr=False)
     directoryTree = attr.ib(repr=False)
-    export = attr.ib(repr=False)
     expiration_options = attr.ib()
     index_driver = attr.ib()
     enable_sync_with_cloned = attr.ib(repr=False)
@@ -165,7 +169,6 @@ class Dataset(entities.BaseEntity):
                    projects=projects,
                    creator=_json.get('creator', None),
                    items_url=_json.get('items', None),
-                   export=_json.get('export', None),
                    driver=_json.get('driver', None),
                    name=_json.get('name', None),
                    url=_json.get('url', None),
@@ -240,7 +243,7 @@ class Dataset(entities.BaseEntity):
 
     @property
     def platform_url(self):
-        return self._client_api._get_resource_url("projects/{}/datasets/{}".format(self.project.id, self.id))
+        return self._client_api._get_resource_url("projects/{}/datasets/{}/items".format(self.project.id, self.id))
 
     @readonly.setter
     def readonly(self, state):
@@ -653,6 +656,53 @@ class Dataset(entities.BaseEntity):
             export_version=export_version
         )
 
+    def export(self,
+               local_path=None,
+               filters=None,
+               annotation_filters=None,
+               feature_vector_filters=None,
+               include_feature_vectors: bool = False,
+               include_annotations: bool = False,
+               export_type: ExportType = ExportType.JSON,
+               timeout: int = 0):
+        """
+        Export dataset items and annotations.
+
+        **Prerequisites**: You must be an *owner* or *developer* to use this method.
+
+        You must provide at least ONE of the following params: dataset, dataset_name, dataset_id.
+
+        :param str local_path: The local path to save the exported dataset
+        :param Union[dict, dtlpy.entities.filters.Filters] filters: Filters entity or a query dictionary
+        :param dtlpy.entities.filters.Filters annotation_filters: Filters entity
+        :param dtlpy.entities.filters.Filters feature_vector_filters: Filters entity
+        :param bool include_feature_vectors: Include item feature vectors in the export
+        :param bool include_annotations: Include item annotations in the export
+        :param entities.ExportType export_type: Type of export ('json' or 'zip')
+        :param int timeout: Maximum time in seconds to wait for the export to complete
+        :return: Exported item
+        :rtype: dtlpy.entities.item.Item
+
+        **Example**:
+
+        .. code-block:: python
+
+            export_item = dataset.export(filters=filters,
+                                         include_feature_vectors=True,
+                                         include_annotations=True,
+                                         export_type=dl.ExportType.JSON)
+        """
+
+        return self.datasets.export(dataset=self,
+                                    local_path=local_path,
+                                    filters=filters,
+                                    annotation_filters=annotation_filters,
+                                    feature_vector_filters=feature_vector_filters,
+                                    include_feature_vectors=include_feature_vectors,
+                                    include_annotations=include_annotations,
+                                    export_type=export_type,
+                                    timeout=timeout)
+
     def upload_annotations(self,
                            local_path,
                            filters=None,

dtlpy/entities/dpk.py

@@ -126,6 +126,7 @@ class DpkComputeConfig(entities.DlEntity):
     driver_id: str = entities.DlProperty(location=['driverId'], _type=str)
     versions: dict = entities.DlProperty(location=['versions'], _type=dict)
     name: str = entities.DlProperty(location=['name'], _type=str)
+    integrations: List[dict] = entities.DlProperty(location=['integrations'], _type=list)
 
     def to_json(self) -> dict:
         return self._dict.copy()
@@ -226,6 +227,7 @@ class Components(entities.DlEntity):
 class Dpk(entities.DlEntity):
     # name change
     id: str = entities.DlProperty(location=['id'], _type=str)
+    base_id: str = entities.DlProperty(location=['baseId'], _type=str)
     name: str = entities.DlProperty(location=['name'], _type=str)
     version: str = entities.DlProperty(location=['version'], _type=str)
     attributes: list = entities.DlProperty(location=['attributes'], _type=dict)
@@ -388,6 +390,19 @@ class Dpk(entities.DlEntity):
             self._revisions = self._get_revision_pages()
         return self._revisions
 
+    def get_revisions(self, version: str):
+        """
+        Get the dpk with the specified version.
+
+        :param str version: the version of the dpk to get.
+        :return: Dpk
+
+        ** Example **
+        ..code-block:: python
+        dpk = dpk.get_revisions(version='1.0.0')
+        """
+        return self.dpks.get_revisions(dpk_id=self.base_id, version=version)
+
     @staticmethod
     def _protected_from_json(_json, client_api, project, is_fetched=True):
         """

dtlpy/entities/execution.py

@@ -13,8 +13,12 @@ logger = logging.getLogger(name='dtlpy')
 class ExecutionStatus(str, Enum):
     SUCCESS = "success"
     FAILED = "failed"
-    IN_PROGRESS = "inProgress"
+    IN_PROGRESS = "in-progress"
     CREATED = "created"
+    TERMINATED = 'terminated',
+    ABORTED = 'aborted'
+    CANCELED = 'canceled'
+    SYSTEM_FAILURE = 'system-failure'
 
 
 @attr.s
@@ -377,3 +381,11 @@ class Execution(entities.BaseEntity):
         :return: Service execution object
         """
         return self.executions.wait(execution_id=self.id)
+
+    def in_progress(self):
+        return self.latest_status['status'] not in [ExecutionStatus.FAILED,
+                                                    ExecutionStatus.SUCCESS,
+                                                    ExecutionStatus.TERMINATED,
+                                                    ExecutionStatus.ABORTED,
+                                                    ExecutionStatus.CANCELED,
+                                                    ExecutionStatus.SYSTEM_FAILURE]

dtlpy/entities/feature_set.py

@@ -31,6 +31,7 @@ class FeatureSet(entities.BaseEntity):
     set_type = attr.ib()
     entity_type = attr.ib()
     project_id = attr.ib()
+    model_id = attr.ib()
     org_id = attr.ib()
 
     # sdk
@@ -100,6 +101,7 @@ class FeatureSet(entities.BaseEntity):
             size=_json.get('size', None),
             url=_json.get('url', None),
             project_id=_json.get('project', None),
+            model_id=_json.get('modelId', None),
             created_at=_json.get('createdAt', None),
             creator=_json.get('creator', None),
             updated_by=_json.get('updatedBy', None),
@@ -121,6 +123,7 @@ class FeatureSet(entities.BaseEntity):
                  'type': self.set_type,
                  'entityType': self.entity_type,
                  'project': self.project_id,
+                 'modelId': self.model_id,
                  'creator': self.creator,
                  'createdAt': self.created_at,
                  'updatedBy': self.updated_by,

dtlpy/entities/filters.py

@@ -2,6 +2,7 @@ import urllib.parse
 import logging
 import json
 import os
+import io
 from enum import Enum
 
 from .. import exceptions, entities
@@ -139,7 +140,7 @@ class Filters:
 
     @property
     def resource(self):
-        return self._resource
+        return f'{self._resource.value}' if isinstance(self._resource, FiltersResource) else f'{self._resource}'
 
     @resource.setter
     def resource(self, resource):
@@ -295,9 +296,9 @@ class Filters:
             self.join = dict()
         if 'on' not in self.join:
             if self.resource == FiltersResource.ITEM:
-                self.join['on'] = {'resource': FiltersResource.ANNOTATION, 'local': 'itemId', 'forigen': 'id'}
+                self.join['on'] = {'resource': FiltersResource.ANNOTATION.value, 'local': 'itemId', 'forigen': 'id'}
             else:
-                self.join['on'] = {'resource': FiltersResource.ITEM, 'local': 'id', 'forigen': 'itemId'}
+                self.join['on'] = {'resource': FiltersResource.ITEM.value, 'local': 'id', 'forigen': 'itemId'}
         if 'filter' not in self.join:
             self.join['filter'] = dict()
         join_method = '$' + method
@@ -474,7 +475,7 @@ class Filters:
         """
         if value not in [FiltersOrderByDirection.ASCENDING, FiltersOrderByDirection.DESCENDING]:
             raise exceptions.PlatformException(error='400', message='Sort can be by ascending or descending order only')
-        self.sort[field] = value
+        self.sort[field] = value.value if isinstance(value, FiltersOrderByDirection) else value
 
     def platform_url(self, resource) -> str:
         """
@@ -488,14 +489,17 @@ class Filters:
         # add the view option
         _json['view'] = 'icons'
         # convert from enum to string
-        _json["resource"] = '{}'.format(_json['resource'])
+        _json["resource"] = f'{_json["resource"]}'
         # convert the dictionary to a json string
-        _json['dqlFilter'] = json.dumps({'filter': _json.pop('filter')})
+        _json['dqlFilter'] = json.dumps({'filter': _json.pop('filter'),
+                                         'join': _json.pop('join'),
+                                         'sort': _json.get('sort')})
         # set the page size as the UI default
         _json['pageSize'] = 100
+        _json['page'] = _json['page']
         # build the url for the dataset data browser
         if isinstance(resource, entities.Dataset):
-            url = resource.platform_url + '/items?{}'.format(urllib.parse.urlencode(_json))
+            url = resource.platform_url + f'?{urllib.parse.urlencode(_json)}'
         else:
             raise NotImplementedError('Not implemented for resource type: {}'.format(type(resource)))
         return url
@@ -511,6 +515,81 @@ class Filters:
         else:
             raise NotImplementedError('Not implemented for resource type: {}'.format(type(resource)))
 
+    def save(self, project: entities.Project, filter_name: str):
+        """
+        Save the current DQL filter to the project
+
+        :param project: dl.Project
+        :param filter_name: the saved filter's name
+        :return: True if success
+        """
+        _json_filter = self.prepare()
+        shebang_dict = {"type": "dql",
+                        "shebang": "dataloop",
+                        "metadata": {
+                            "version": "1.0.0",
+                            "system": {
+                                "mimetype": "dql"
+                            },
+                            "dltype": "filter",
+                            "filterFieldsState": [],
+                            "resource": "items",
+                            "filter": _json_filter.pop('filter'),
+                            "join": _json_filter.pop('join')
+                        }
+                        }
+        b_dataset = project.datasets._get_binaries_dataset()
+        byte_io = io.BytesIO()
+        byte_io.name = filter_name
+        byte_io.write(json.dumps(shebang_dict).encode())
+        byte_io.seek(0)
+        b_dataset.items.upload(local_path=byte_io,
+                               remote_path='/.dataloop/dqlfilters/items',
+                               remote_name=filter_name)
+        return True
+
+    @classmethod
+    def load(cls, project: entities.Project, filter_name: str) -> 'Filters':
+        """
+        Load a saved filter from the project by name
+
+        :param project: dl.Project entity
+        :param filter_name: filter name
+        :return: dl.Filters
+        """
+        b_dataset = project.datasets._get_binaries_dataset()
+        f = entities.Filters(custom_filter={
+            'filter': {'$and': [{'filename': f'/.dataloop/dqlfilters/items/{filter_name}'}]},
+            'page': 0,
+            'pageSize': 1000,
+            'resource': 'items'
+        })
+        pages = b_dataset.items.list(filters=f)
+        if pages.items_count == 0:
+            raise exceptions.NotFound(
+                f'Saved filter not found: {filter_name}. Run `Filters.list()` to list existing filters')
+        with open(pages.items[0].download()) as f:
+            data = json.load(f)
+            custom_filter = data['metadata']['filter']
+            custom_filter['join'] = data['metadata']['join']
+        return cls(custom_filter=custom_filter)
+
+    @staticmethod
+    def list(project: entities.Project) -> list:
+        """
+        List all saved filters for a project
+        :param project: dl.Project entity
+        :return: a list of all the saved filters' names
+        """
+        b_dataset = project.datasets._get_binaries_dataset()
+        f = entities.Filters(use_defaults=False,
+                             field='dir',
+                             values='/.dataloop/dqlfilters/items')
+        pages = b_dataset.items.list(filters=f)
+        all_filter_items = list(pages.all())
+        names = [i.name for i in all_filter_items]
+        return names
+
 
 class SingleFilter:
     def __init__(self, field, values, operator: FiltersOperations = None):
@@ -552,6 +631,6 @@ class SingleFilter:
             _json[self.field] = value
 
         return _json
-    
+
     def print(self, indent=2):
         print(json.dumps(self.prepare(), indent=indent))

dtlpy/entities/integration.py

@@ -79,7 +79,7 @@ class Integration(entities.BaseEntity):
                    name=_json.get('name', None),
                    creator=_json.get('creator', None),
                    created_at=_json.get('createdAt', None),
-                   update_at=_json.get('updateAt', None),
+                   update_at=_json.get('updatedAt', None),
                    type=_json.get('type', None),
                    org=_json.get('org', None),
                    client_api=client_api,

dtlpy/entities/item.py

@@ -6,11 +6,13 @@ import logging
 import attr
 import copy
 import os
-
+import io
 from .. import repositories, entities, exceptions
 from .annotation import ViewAnnotationOptions, ExportVersion
 from ..services.api_client import ApiClient
 from ..services.api_client import client as client_api
+import json
+import requests
 
 logger = logging.getLogger(name='dtlpy')
 
@@ -182,6 +184,18 @@ class Item(entities.BaseEntity):
     def model(self):
         return self._model
 
+    def __update_item_binary(self, _json):
+        binary = io.BytesIO()
+        binary.write(json.dumps(_json).encode())
+        binary.seek(0)
+        binary.name = self.name
+        resp = requests.post(url=client_api.environment + f'/items/{self.id}/revisions',
+                             headers=client_api.auth,
+                             files={'file': (binary.name, binary)}
+                             )
+        if not resp.ok:
+            raise ValueError(resp.text)
+
     @property
     def project(self):
         if self._project is None:
@@ -661,6 +675,32 @@ class Item(entities.BaseEntity):
         else:
             raise exceptions.PlatformException('400', 'must provide assignment_id or task_id')
 
+    def status(self, assignment_id: str = None, task_id: str = None):
+        """
+        Get item status
+
+        :param str assignment_id: assignment id
+        :param str task_id: task id
+
+        :return: status
+        :rtype: str
+
+        **Example**:
+
+        .. code-block:: python
+
+            status = item.status(task_id='task_id')
+        """
+        if not assignment_id and not task_id:
+            raise exceptions.PlatformException('400', 'must provide assignment_id or task_id')
+        status = None
+        resource_id = assignment_id if assignment_id else task_id
+        for ref in self.metadata.get('system', dict()).get('refs', []):
+            if ref.get('id') == resource_id:
+                status = ref.get('metadata', {}).get('status', None)
+                break
+        return status
+
     def set_description(self, text: str):
         """
         Update Item description

dtlpy/entities/node.py

@@ -120,7 +120,7 @@ class PipelineNodeIO:
         self.description = description
 
         if action is not None:
-            warnings.warn('action param has been deprecated in version 1.80', DeprecationWarning)
+            warnings.warn('action param has been deprecated in version 1.95', DeprecationWarning)
             if actions is None:
                 actions = []
             actions.append(action)
@@ -128,7 +128,7 @@ class PipelineNodeIO:
 
     @property
     def action(self):
-        warnings.warn('action attribute has been deprecated in version 1.80', DeprecationWarning)
+        warnings.warn('action attribute has been deprecated in version 1.95', DeprecationWarning)
         return None
 
     @staticmethod
@@ -221,6 +221,8 @@ class PipelineNode:
                  config: dict = None,
                  position: tuple = (1, 1),
                  app_id: str = None,
+                 dpk_name: str = None,
+                 app_name: str = None,
                  ):
         """
         :param str name: node name
@@ -234,6 +236,8 @@ class PipelineNode:
         :param dict config: for the code node dict in format { package: {code : the_code}}
         :param tuple position: tuple of the node place
         :param str app_id: app id
+        :param str dpk_name: dpk name
+        :param str app_name: app name
         """
         self.name = name
         self.node_id = node_id
@@ -246,6 +250,8 @@ class PipelineNode:
         self.config = config
         self.position = position
         self.app_id = app_id
+        self.dpk_name = dpk_name
+        self.app_name = app_name
         self._pipeline = None
 
     @property
@@ -297,7 +303,9 @@ class PipelineNode:
             project_id=_json.get('projectId', None),
             config=_json.get('config', None),
             position=position,
-            app_id=_json.get('appId', None)
+            app_id=_json.get('appId', None),
+            dpk_name=_json.get('dpkName', None),
+            app_name=_json.get('appName', None),
         )
 
     def to_json(self):
@@ -310,6 +318,8 @@ class PipelineNode:
             'type': self.node_type,
             'namespace': self.namespace.to_json(),
             'projectId': self.project_id,
+            'dpkName': self.dpk_name,
+            'appName': self.app_name,
         }
         if self.config is not None:
             _json['config'] = self.config
@@ -921,12 +931,20 @@ class DatasetNode(PipelineNode):
                  project_id: str,
                  dataset_id: str,
                  dataset_folder: str = None,
+                 load_existing_data: bool = False,
+                 data_filters: entities.Filters = None,
                  position: tuple = (1, 1)):
         """
         :param str name: node name
         :param str project_id: project id
         :param str dataset_id: dataset id
         :param str dataset_folder: folder in dataset to work in it
+        :param bool load_existing_data: optional - enable to automatically load existing data into the
+                                        pipeline (executions) upon activation, based on the defined dataset,
+                                        folder, and data_filters.
+        :param entities.Filters data_filters: optional - filters entity or a dictionary containing filters parameters.
+                                              Use to filter the data items to be loaded when load_existing_data
+                                              is enabled.
         :param tuple position: tuple of the node place
         """
         inputs = [self._default_io()]
@@ -944,6 +962,8 @@ class DatasetNode(PipelineNode):
                          position=position)
         self.dataset_id = dataset_id
         self.dataset_folder = dataset_folder
+        self.load_existing_data = load_existing_data
+        self.data_filters = data_filters
 
     @property
     def dataset_id(self):
@@ -964,6 +984,32 @@ class DatasetNode(PipelineNode):
                 dataset_folder = '/' + dataset_folder
             self.metadata['dir'] = dataset_folder
 
+    @property
+    def load_existing_data(self):
+        return self.metadata.get('triggerToPipeline', {}).get('active', False)
+
+    @load_existing_data.setter
+    def load_existing_data(self, load_existing_data: bool):
+        if load_existing_data:
+            self.metadata.setdefault('triggerToPipeline', {})['active'] = True
+        else:
+            self.metadata.pop('triggerToPipeline', None)
+
+    @property
+    def data_filters(self):
+        data_filters = self.metadata.get('triggerToPipeline', {}).get('filter', None)
+        if data_filters:
+            data_filters = entities.Filters(custom_filter=json.loads(data_filters))
+        return data_filters
+
+    @data_filters.setter
+    def data_filters(self, data_filters: entities.Filters):
+        if data_filters is None:
+            filters = None
+        else:
+            filters = json.dumps(data_filters.prepare(query_only=True).get('filter'))
+        self.metadata.setdefault('triggerToPipeline', {})['filter'] = filters
+
     @staticmethod
     def from_json(_json: dict):
         parent = PipelineNode.from_json(_json)

dtlpy/entities/ontology.py

@@ -207,7 +207,14 @@ class Ontology(entities.BaseEntity):
 
     @property
     def _use_attributes_2(self):
-        return os.environ.get("USE_ATTRIBUTE_2", 'false') == 'true'
+        if isinstance(self.metadata, dict):
+            attributes = self.metadata.get("attributes", None)
+            if attributes is not None:
+                return True
+            else:
+                if isinstance(self.attributes, list) and len(self.attributes) > 0:
+                    return False
+        return True
 
     @classmethod
     def from_json(cls, _json, client_api, recipe, dataset=None, project=None, is_fetched=True):
@@ -223,10 +230,9 @@ class Ontology(entities.BaseEntity):
         :return: Ontology object
         :rtype: dtlpy.entities.ontology.Ontology
         """
-        if not os.environ.get("USE_ATTRIBUTE_2", 'false') == 'true':
-            attributes = _json.get("attributes", [])
-        else:
-            attributes = _json.get('metadata', {}).get("attributes", [])
+        attributes_v2 = _json.get('metadata', {}).get("attributes", [])
+        attributes_v1 = _json.get("attributes", [])
+        attributes = attributes_v2 if attributes_v2 else attributes_v1
 
         labels = list()
         for root in _json["roots"]:
@@ -741,3 +747,54 @@ class Ontology(entities.BaseEntity):
         """
 
         return self.ontologies.delete_attributes(ontology_id=self.id, keys=keys)
+
+    def copy_from(self, ontology_json: dict):
+        """
+        Import ontology to the platform.\n
+        Notice: only the following fields will be updated: `labels`, `attributes`, `instance_map` and `color_map`.
+
+        :param dict ontology_json: The source ontology json to copy from
+        :return: Ontology object: The updated ontology entity
+        :rtype: dtlpy.entities.ontology.Ontology
+
+        **Example**:
+
+        .. code-block:: python
+
+            ontology = ontology.import_ontology(ontology_json=ontology_json)
+        """
+        # TODO: Add support for import from ontology entity in the Future
+        if not self._use_attributes_2:
+            raise ValueError("This method is only supported for attributes 2 mode!")
+        new_ontology = self.from_json(_json=ontology_json, client_api=self._client_api, recipe=self.recipe)
+
+        # Update 'labels' and 'attributes'
+        self.labels = new_ontology.labels
+        new_attributes = new_ontology.attributes
+        if isinstance(new_attributes, list):
+            for new_attribute in new_attributes:
+                attribute_range = new_attribute.get("range", None)
+                if attribute_range is not None:
+                    attribute_range = entities.AttributesRange(
+                        min_range=attribute_range.get("min", None),
+                        max_range=attribute_range.get("max", None),
+                        step=attribute_range.get("step", None)
+                    )
+                script_data = new_attribute.get("scriptData", None)
+                if script_data is None:
+                    new_attribute_key = new_attribute.get("key", None)
+                    raise Exception(f"Attribute '{new_attribute_key}' scriptData is missing in the ontology json!")
+                self.update_attributes(
+                    title=script_data.get("title", None),
+                    key=new_attribute.get("key", None),
+                    attribute_type=new_attribute.get("type", None),
+                    scope=new_attribute.get("scope", None),
+                    optional=script_data.get("optional", None),
+                    values=new_attribute.get("values", None),
+                    attribute_range=attribute_range
+                )
+
+        # Update 'instance map' and 'color map'
+        self._instance_map = new_ontology.instance_map
+        self._color_map = new_ontology.color_map
+        return self.update(system_metadata=True)

dtlpy/entities/package_function.py

@@ -97,6 +97,8 @@ class FunctionIO(entities.DlEntity):
     name = entities.DlProperty(location=['name'], _type=str)
     actions = entities.DlProperty(location=['actions'], _type=list)
     description = entities.DlProperty(location=['description'], _type=str)
+    integration = entities.DlProperty(location=['integration'], _type=dict)
+    mandatory = entities.DlProperty(location=['mandatory'], _type=bool)
 
     def __repr__(self):
         # TODO need to move to DlEntity