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

dtlpy/__version__.py

@@ -1 +1 @@
-version = '1.90.39'
+version = '1.91.37'

dtlpy/entities/analytic.py

@@ -14,6 +14,7 @@ class BaseSample:
                  event_type,
                  action,
                  status,
+                 other_keys: dict = None
                  ):
         self.start_time = start_time
         self.end_time = end_time
@@ -23,6 +24,31 @@ class BaseSample:
         self.event_type = event_type
         self.action = action
         self.status = status
+        self.other_keys = other_keys
+
+    def to_json(self):
+        _json = {
+            'startTime': self.start_time,
+            'endTime': self.end_time,
+            'context': {
+                'projectId': self.project_id,
+                'projectOrgId': self.org_id,
+                'pipelineId': self.pipeline_id
+            },
+            'eventType': self.event_type,
+            'action': self.action,
+            'data': {
+                'status': self.status
+            }
+        }
+        if self.other_keys is not None:
+            if 'context' in self.other_keys:
+                _json['context'].update(self.other_keys['context'])
+            if 'data' in self.other_keys:
+                _json['data'].update(self.other_keys['data'])
+            _json.update({k: v for k, v in self.other_keys.items() if k not in ['context', 'data']})
+
+        return _json
 
 
 class ServiceSample(BaseSample):
@@ -47,16 +73,21 @@ class ServiceSample(BaseSample):
                  queue_size=None,
                  num_executions=None,
                  service_type: entities.ServiceType = None,
-                 interval: int = None
+                 interval: int = None,
+                 driver_id: str = None,
+                 other_keys: dict = None
                  ):
-        super().__init__(start_time=start_time,
-                         end_time=end_time,
-                         project_id=project_id,
-                         org_id=org_id,
-                         pipeline_id=pipeline_id,
-                         event_type=event_type,
-                         action=action,
-                         status=status)
+        super().__init__(
+            start_time=start_time,
+            end_time=end_time,
+            project_id=project_id,
+            org_id=org_id,
+            pipeline_id=pipeline_id,
+            event_type=event_type,
+            action=action,
+            status=status,
+            other_keys=other_keys
+        )
         self.user_id = user_id
         self.pipeline_node_id = pipeline_node_id
         self.service_id = service_id
@@ -70,38 +101,32 @@ class ServiceSample(BaseSample):
         self.num_executions = num_executions
         self.service_type = service_type if service_type is not None else entities.ServiceType.REGULAR
         self.interval = interval
+        self.driver_id = driver_id
 
     def to_json(self):
-        _json = {
-            'startTime': self.start_time,
-            'endTime': self.end_time,
-            'context': {
-                'userId': self.user_id,
-                'projectId': self.project_id,
-                'projectOrgId': self.org_id,
-                'pipelineId': self.pipeline_id,
-                'pipelineNodeId': self.pipeline_node_id,
-                'serviceId': self.service_id,
-                'podId': self.pod_id,
-                'podType': self.pod_type,
-                'serviceType': self.service_type
-            },
-            'eventType': self.event_type,
-            'entityType': self.entity_type,
-            'action': self.action,
-            'data': {
-                'status': self.status,
-                'numRestarts': self.num_restarts,
-                'cpu': self.cpu,
-                'ram': self.ram,
-                'queueSize': self.queue_size,
-                'numExecutions': self.num_executions,
-                'interval': self.interval
-            }
-        }
+        _json = super().to_json()
+        _json['context'].update({
+            'userId': self.user_id,
+            'pipelineNodeId': self.pipeline_node_id,
+            'serviceId': self.service_id,
+            'podId': self.pod_id,
+            'podType': self.pod_type,
+            'serviceType': self.service_type
+        })
+        _json['data'].update({
+            'numRestarts': self.num_restarts,
+            'cpu': self.cpu,
+            'ram': self.ram,
+            'queueSize': self.queue_size,
+            'numExecutions': self.num_executions,
+            'interval': self.interval,
+            'driverId': self.driver_id
+        })
+        _json.update({
+            'entityType': self.entity_type
+        })
         _json['context'] = {k: v for k, v in _json['context'].items() if v is not None}
         _json['data'] = {k: v for k, v in _json['data'].items() if v is not None}
-
         return {k: v for k, v in _json.items() if v is not None}
 
     @classmethod
@@ -127,6 +152,8 @@ class ServiceSample(BaseSample):
             queue_size=_json.get('data', {}).get('queueSize', None),
             num_executions=_json.get('data', {}).get('numExecutions', None),
             service_type=_json.get('type', entities.ServiceType.REGULAR),
+            interval=_json.get('data', {}).get('interval', None),
+            driver_id=_json.get('data', {}).get('driverId', None)
         )
         return inst
 
@@ -149,16 +176,20 @@ class ExecutionSample(BaseSample):
                  execution_id=None,
                  trigger_id=None,
                  function_name=None,
-                 duration=None
+                 duration=None,
+                 other_keys: dict = None
                  ):
-        super().__init__(start_time=start_time,
-                         end_time=end_time,
-                         project_id=project_id,
-                         org_id=org_id,
-                         pipeline_id=pipeline_id,
-                         event_type=event_type,
-                         action=action,
-                         status=status)
+        super().__init__(
+            start_time=start_time,
+            end_time=end_time,
+            project_id=project_id,
+            org_id=org_id,
+            pipeline_id=pipeline_id,
+            event_type=event_type,
+            action=action,
+            status=status,
+            other_keys=other_keys
+        )
         self.user_id = user_id
         self.account_id = account_id
         self.pipeline_node_id = pipeline_node_id
@@ -170,30 +201,22 @@ class ExecutionSample(BaseSample):
         self.duration = duration
 
     def to_json(self):
-        _json = {
-            'startTime': self.start_time,
-            'endTime': self.end_time,
-            'context': {
-                'userId': self.user_id,
-                'projectId': self.project_id,
-                'projectOrgId': self.org_id,
-                'accountId': self.account_id,
-                'pipelineId': self.pipeline_id,
-                'pipelineNodeId': self.pipeline_node_id,
-                'pipelineExecutionId': self.pipeline_execution_id,
-                'serviceId': self.service_id,
-                'executionId': self.execution_id,
-                'triggerId': self.trigger_id,
-            },
-            'eventType': self.event_type,
-            'action': self.action,
-            'data': {
-                'status': self.status,
-                'functionName': self.function_name,
-                'duration': self.duration
-            }
-        }
-        return _json
+        _json = super().to_json()
+        _json['context'].update({
+            'userId': self.user_id,
+            'accountId': self.account_id,
+            'pipelineNodeId': self.pipeline_node_id,
+            'pipelineExecutionId': self.pipeline_execution_id,
+            'serviceId': self.service_id,
+            'triggerId': self.trigger_id
+        })
+        _json['data'].update({
+            'functionName': self.function_name,
+            'duration': self.duration
+        })
+        _json['context'] = {k: v for k, v in _json['context'].items() if v is not None}
+        _json['data'] = {k: v for k, v in _json['data'].items() if v is not None}
+        return {k: v for k, v in _json.items() if v is not None}
 
     @classmethod
     def from_json(cls, _json):
@@ -234,15 +257,19 @@ class PipelineExecutionSample(BaseSample):
                  pipeline_execution_id=None,
                  trigger_id=None,
                  node_status=None,
+                 other_keys: dict = None
                  ):
-        super().__init__(start_time=start_time,
-                         end_time=end_time,
-                         project_id=project_id,
-                         org_id=org_id,
-                         pipeline_id=pipeline_id,
-                         event_type=event_type,
-                         action=action,
-                         status=status)
+        super().__init__(
+            start_time=start_time,
+            end_time=end_time,
+            project_id=project_id,
+            org_id=org_id,
+            pipeline_id=pipeline_id,
+            event_type=event_type,
+            action=action,
+            status=status,
+            other_keys=other_keys
+        )
         self.account_id = account_id
         self.pipeline_node_id = pipeline_node_id
         self.pipeline_execution_id = pipeline_execution_id
@@ -250,26 +277,19 @@ class PipelineExecutionSample(BaseSample):
         self.node_status = node_status
 
     def to_json(self):
-        _json = {
-            'startTime': self.start_time,
-            'endTime': self.end_time,
-            'context': {
-                'projectId': self.project_id,
-                'projectOrgId': self.org_id,
-                'accountId': self.account_id,
-                'pipelineId': self.pipeline_id,
-                'pipelineExecutionId': self.pipeline_execution_id,
-                'triggerId': self.trigger_id,
-            },
-            'eventType': self.event_type,
-            'action': self.action,
-            'data': {
-                'status': self.status,
-                'nodeId': self.pipeline_node_id,
-                'nodeStatus': self.node_status
-            }
-        }
-        return _json
+        _json = super().to_json()
+        _json['context'].update({
+            'accountId': self.account_id,
+            'pipelineNodeId': self.pipeline_node_id,
+            'pipelineExecutionId': self.pipeline_execution_id,
+            'triggerId': self.trigger_id
+        })
+        _json['data'].update({
+            'nodeStatus': self.node_status
+        })
+        _json['context'] = {k: v for k, v in _json['context'].items() if v is not None}
+        _json['data'] = {k: v for k, v in _json['data'].items() if v is not None}
+        return {k: v for k, v in _json.items() if v is not None}
 
     @classmethod
     def from_json(cls, _json):

dtlpy/entities/annotation.py

@@ -418,28 +418,25 @@ class Annotation(entities.BaseEntity):
     def label(self, label):
         self.annotation_definition.label = label
 
-    @property
-    def _use_attributes_2(self):
-        if self.__client_api is None and self._item is None:
-            return os.environ.get("USE_ATTRIBUTE_2", 'false') == 'true'
-        return self._client_api.attributes_mode.use_attributes_2
-
     @property
     def attributes(self):
-        return self._recipe_2_attributes if self._use_attributes_2 else self.annotation_definition.attributes
+        if self._recipe_2_attributes or not self.annotation_definition.attributes:
+            return self._recipe_2_attributes
+        return self.annotation_definition.attributes
 
     @attributes.setter
     def attributes(self, attributes):
-        if self._use_attributes_2:
-            if not isinstance(attributes, dict):
-                raise ValueError(
-                    'Attributes must be a dict. If you are using v1 attributes please use dl.use_attributes_2(False)')
+        if isinstance(attributes, dict):
             self._recipe_2_attributes = attributes
-        else:
-            if not isinstance(attributes, list):
-                raise ValueError(
-                    'Attributes must be a list. If you are using v2 attributes please use dl.use_attributes_2(True)')
+        elif isinstance(attributes, list):
             self.annotation_definition.attributes = attributes
+        elif attributes is None:
+            if self._recipe_2_attributes:
+                self._recipe_2_attributes = {}
+            if self.annotation_definition.attributes:
+                self.annotation_definition.attributes = []
+        else:
+            raise ValueError('Attributes must be a dictionary or a list')
 
     @property
     def color(self):
@@ -1362,12 +1359,8 @@ class Annotation(entities.BaseEntity):
             object_id = _json['metadata']['system'].get('objectId', object_id)
             status = _json['metadata']['system'].get('status', status)
 
-        if client_api is not None:
-            recipe_2_attributes = client_api.attributes_mode.use_attributes_2
-        else:
-            recipe_2_attributes = False
         named_attributes = metadata.get('system', dict()).get('attributes', None)
-        attributes = named_attributes if recipe_2_attributes else _json.get('attributes', None)
+        attributes = named_attributes if named_attributes else _json.get('attributes', None)
 
         first_frame_attributes = attributes
         first_frame_coordinates = list()
@@ -1598,7 +1591,7 @@ class Annotation(entities.BaseEntity):
         if isinstance(self.annotation_definition, entities.Description):
             _json['metadata']['system']['system'] = True
 
-        if self._use_attributes_2:
+        if self._recipe_2_attributes is not None:
             _json['metadata']['system']['attributes'] = self._recipe_2_attributes
             if 'attributes' in self._platform_dict:
                 _json['attributes'] = self._platform_dict['attributes']
@@ -1685,20 +1678,18 @@ class FrameAnnotation(entities.BaseEntity):
 
     @property
     def attributes(self):
-        return self._recipe_2_attributes if self.annotation._use_attributes_2 else self.annotation_definition.attributes
+        if self._recipe_2_attributes or not self.annotation_definition.attributes:
+            return self._recipe_2_attributes
+        return self.annotation_definition.attributes
 
     @attributes.setter
     def attributes(self, attributes):
-        if self.annotation._use_attributes_2:
-            if not isinstance(attributes, dict):
-                raise ValueError(
-                    'Attributes must be a dict. If you are using v1 attributes please use dl.use_attributes_2(False)')
+        if isinstance(attributes, dict):
             self._recipe_2_attributes = attributes
-        else:
-            if not isinstance(attributes, list):
-                raise ValueError(
-                    'Attributes must be a list. If you are using v2 attributes please use dl.use_attributes_2(True)')
+        elif isinstance(attributes, list):
             self.annotation_definition.attributes = attributes
+        else:
+            raise ValueError('Attributes must be a dictionary or a list')
 
     @property
     def geo(self):
@@ -1879,7 +1870,7 @@ class FrameAnnotation(entities.BaseEntity):
             'data': self.coordinates
         }
 
-        if self.annotation._use_attributes_2:
+        if self.annotation._recipe_2_attributes:
             snapshot_dict['namedAttributes'] = self._recipe_2_attributes
         else:
             snapshot_dict['attributes'] = self.attributes

dtlpy/entities/annotation_collection.py

@@ -63,7 +63,7 @@ class AnnotationCollection(entities.BaseEntity):
         """
         Add annotations to collection
 
-        :param annotation_definition: dl.Polygon, dl.Segmentation, dl.Point, dl.Box etc
+        :param annotation_definition: dl.Polygon, dl.Segmentation, dl.Point, dl.Box etc.
         :param object_id: Object id (any id given by user). If video - must input to match annotations between frames
         :param frame_num: video only, number of frame
         :param end_frame_num: video only, the end frame of the annotation
@@ -72,12 +72,12 @@ class AnnotationCollection(entities.BaseEntity):
         :param automated:
         :param fixed: video only, mark frame as fixed
         :param object_visible: video only, does the annotated object is visible
-        :param metadata: optional- metadata dictionary for annotation
+        :param metadata: optional, metadata dictionary for annotation
         :param parent_id: set a parent for this annotation (parent annotation ID)
         :param prompt_id: Connect the annotation with a specific prompt in a dl.PromptItem
-        :param model_info: optional - set model on annotation {'confidence':0 [Mandatory], (Float between 0-1)
-                                                               'name',:'' [Optional], ('name' refers to 'model_name')
-                                                               'model_id':''[Optional]}
+        :param model_info: optional - set model on annotation {'confidence': 0, # [Mandatory], (Float between 0-1)
+                                                               'name': '', # [Optional], ('name' refers to 'model_name')
+                                                               'model_id': ''} # [Optional]
         :return:
         """
         if model_info is not None:
@@ -163,7 +163,7 @@ class AnnotationCollection(entities.BaseEntity):
              annotation_format: entities.ViewAnnotationOptions = entities.ViewAnnotationOptions.MASK,
              label_instance_dict=None,
              color=None,
-             alpha=1,
+             alpha=1.,
              frame_num=None):
         """
         Show annotations according to annotation_format
@@ -188,8 +188,7 @@ class AnnotationCollection(entities.BaseEntity):
 
             image = builder.show(image='ndarray',
                         thickness=1,
-                        annotation_format=dl.VIEW_ANNOTATION_OPTIONS_MASK,
-                        )
+                        annotation_format=dl.VIEW_ANNOTATION_OPTIONS_MASK)
         """
         # if 'video' in self.item.mimetype and (annotation_format != 'json' or annotation_format != ['json']):
         #     raise PlatformException('400', 'Cannot show mask or instance of video item')
@@ -210,7 +209,7 @@ class AnnotationCollection(entities.BaseEntity):
             else:
                 rest_annotations.append(annotation)
         all_annotations = segment_annotations + rest_annotations
-        # gor over all annotations and put the id where the annotations is
+        # gor over all annotations and put the id where the annotations are
         for annotation in all_annotations:
             # get the mask of the annotation
             image = annotation.show(thickness=thickness,
@@ -231,7 +230,7 @@ class AnnotationCollection(entities.BaseEntity):
                      thickness=1,
                      annotation_format=entities.ViewAnnotationOptions.ANNOTATION_ON_IMAGE,
                      with_text=False,
-                     alpha=1):
+                     alpha=1.):
         """
         create a video from frames
 
@@ -240,6 +239,8 @@ class AnnotationCollection(entities.BaseEntity):
         :param thickness: int - thickness of the annotations
         :param annotation_format: str - ViewAnnotationOptions - annotations format
         :param with_text: bool - if True show the label in the output
+        :param float alpha: opacity value [0 1], default 1
+
         """
         try:
             import cv2
@@ -288,7 +289,8 @@ class AnnotationCollection(entities.BaseEntity):
         if reader is not None:
             reader.release()
 
-    def _set_flip_args(self, orientation):
+    @staticmethod
+    def _set_flip_args(orientation):
         try:
             import cv2
         except (ImportError, ModuleNotFoundError):
@@ -329,10 +331,10 @@ class AnnotationCollection(entities.BaseEntity):
         :param int height: height
         :param int width: width
         :param int thickness: thickness
-        :param bool with_text: add a text to the image
+        :param bool with_text: add a text to an image
         :param int orientation: the image orientation
         :param float alpha: opacity value [0 1], default 1
-        :return: file path of the downlaod annotation
+        :return: file path of the download annotation
         :rtype: str
 
         **Example**:
@@ -521,8 +523,8 @@ class AnnotationCollection(entities.BaseEntity):
         :param dict _json: platform json
         :param dtlpy.entities.item.Item item: item
         :param client_api: ApiClient entity
-        :param bool is_video: is video
-        :param fps: video fps
+        :param bool is_video: whether the item is video
+        :param fps: frame rate of the video
         :param float height: height
         :param float width: width
         :param bool is_audio: is audio
@@ -614,19 +616,15 @@ class AnnotationCollection(entities.BaseEntity):
             start_time = datetime.timedelta(hours=float(h), minutes=float(m), seconds=float(s)).total_seconds()
             h, m, s = caption.end.split(':')
             end_time = datetime.timedelta(hours=float(h), minutes=float(m), seconds=float(s)).total_seconds()
-            if self.item.fps is not None:
-                start_frame = round(start_time * self.item.fps)
-            else:
-                raise ValueError('Item do not have fps, please wait for video-preprocess to complete')
             annotation_definition = entities.Subtitle(text=caption.text, label='Text')
             annotation = entities.Annotation.new(
                 annotation_definition=annotation_definition,
-                frame_num=start_frame,
                 item=self.item,
                 start_time=start_time)
 
             annotation.add_frames(annotation_definition=annotation_definition,
-                                  frame_num=start_frame, end_time=end_time)
+                                  start_time=start_time,
+                                  end_time=end_time)
 
             self.annotations.append(annotation)
 

dtlpy/entities/app.py

@@ -47,6 +47,7 @@ class App(entities.BaseEntity):
     custom_installation = attr.ib(type=dict)
     metadata = attr.ib(type=dict)
     status = attr.ib(type=entities.CompositionStatus)
+    settings = attr.ib(type=dict)
 
     # sdk
     _project = attr.ib(type=entities.Project, repr=False)
@@ -55,10 +56,11 @@ class App(entities.BaseEntity):
 
     @_repositories.default
     def set_repositories(self):
-        reps = namedtuple('repositories', field_names=['projects', 'apps'])
+        reps = namedtuple('repositories', field_names=['projects', 'apps', 'compositions'])
         return reps(
             projects=repositories.Projects(client_api=self._client_api),
-            apps=repositories.Apps(client_api=self._client_api, project=self._project)
+            apps=repositories.Apps(client_api=self._client_api, project=self._project),
+            compositions=repositories.Compositions(client_api=self._client_api, project=self._project)
         )
 
     @property
@@ -77,6 +79,11 @@ class App(entities.BaseEntity):
         assert isinstance(self._repositories.apps, repositories.Apps)
         return self._repositories.apps
 
+    @property
+    def compositions(self):
+        assert isinstance(self._repositories.compositions, repositories.Compositions)
+        return self._repositories.compositions
+
     def uninstall(self):
         """
         Uninstall an app installed app from the project.
@@ -177,6 +184,8 @@ class App(entities.BaseEntity):
             _json['metadata'] = self.metadata
         if self.status is not None:
             _json['status'] = self.status
+        if self.settings != {}:
+            _json['settings'] = self.settings
 
         return _json
 
@@ -200,7 +209,8 @@ class App(entities.BaseEntity):
             client_api=client_api,
             project=project,
             metadata=_json.get('metadata', None),
-            status=_json.get('status', None)
+            status=_json.get('status', None),
+            settings=_json.get('settings', {})
         )
         app.is_fetched = is_fetched
         return app

dtlpy/entities/assignment.py

@@ -19,6 +19,8 @@ class Assignment(entities.BaseEntity):
     metadata = attr.ib(repr=False)
     id = attr.ib()
     url = attr.ib(repr=False)
+    updated_at = attr.ib(repr=False)
+    updated_by = attr.ib(repr=False)
     task_id = attr.ib(repr=False)
     dataset_id = attr.ib(repr=False)
     annotation_status = attr.ib(repr=False)
@@ -62,6 +64,8 @@ class Assignment(entities.BaseEntity):
             metadata=metadata,
             url=_json.get('url', None),
             id=_json['id'],
+            updated_by=_json.get('updatedBy', None),
+            updated_at=_json.get('updatedAt', None),
             client_api=client_api,
             project=project,
             dataset=dataset,
@@ -143,6 +147,8 @@ class Assignment(entities.BaseEntity):
                                                               attr.fields(Assignment)._dataset,
                                                               attr.fields(Assignment)._task,
                                                               attr.fields(Assignment).annotation_status,
+                                                              attr.fields(Assignment).updated_at,
+                                                              attr.fields(Assignment).updated_by,
                                                               attr.fields(Assignment).item_status,
                                                               attr.fields(Assignment).total_items,
                                                               attr.fields(Assignment).for_review,

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/dataset.py

@@ -240,7 +240,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):