supervisely 6.73.311__tar.gz → 6.73.312__tar.gz

{supervisely-6.73.311/supervisely.egg-info → supervisely-6.73.312}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: supervisely
-Version: 6.73.311
+Version: 6.73.312
 Summary: Supervisely Python SDK.
 Home-page: https://github.com/supervisely/supervisely
 Author: Supervisely

{supervisely-6.73.311 → supervisely-6.73.312}/supervisely/__init__.py

@@ -311,4 +311,4 @@ except Exception as e:
 # If new changes in Supervisely Python SDK require upgrade of the Supervisely instance
 # set a new value for the environment variable MINIMUM_INSTANCE_VERSION_FOR_SDK, otherwise
 # users can face compatibility issues, if the instance version is lower than the SDK version.
-os.environ["MINIMUM_INSTANCE_VERSION_FOR_SDK"] = "6.12.28"
+os.environ["MINIMUM_INSTANCE_VERSION_FOR_SDK"] = "6.12.30"

{supervisely-6.73.311 → supervisely-6.73.312}/supervisely/annotation/tag.py

@@ -3,14 +3,13 @@
 
 # docs
 from __future__ import annotations
-from typing import List, Optional, Dict, Union
-from supervisely.annotation.tag_meta import TagMeta
-from supervisely.annotation.tag_meta_collection import TagMetaCollection
 
+from typing import Dict, List, Optional, Union
 
-from supervisely.annotation.tag_meta import TagValueType
-from supervisely.collection.key_indexed_collection import KeyObject
 from supervisely._utils import take_with_default
+from supervisely.annotation.tag_meta import TagMeta, TagValueType
+from supervisely.annotation.tag_meta_collection import TagMetaCollection
+from supervisely.collection.key_indexed_collection import KeyObject
 
 
 class TagJsonFields:
@@ -83,6 +82,8 @@ class Tag(KeyObject):
         # Output: ValueError: Tag coat color can not have value yellow
     """
 
+    _SUPPORT_UNFINISHED_TAGS = False
+
     def __init__(
         self,
         meta: TagMeta,
@@ -97,7 +98,8 @@ class Tag(KeyObject):
         self._meta = meta
         self._value = value
         if not self._meta.is_valid_value(value):
-            raise ValueError("Tag {} can not have value {}".format(self.meta.name, value))
+            if not (self._SUPPORT_UNFINISHED_TAGS and value is None):
+                raise ValueError(f"Tag {self.meta.name} can not have value {value}")
         self.labeler_login = labeler_login
         self.updated_at = updated_at
         self.created_at = created_at
@@ -219,9 +221,7 @@ class Tag(KeyObject):
             #  "createdAt": "2021-01-22T18:00:00.000Z"
             # }
         """
-        res = {
-            TagJsonFields.TAG_NAME: self.meta.name
-        }
+        res = {TagJsonFields.TAG_NAME: self.meta.name}
         if self.meta.value_type != TagValueType.NONE:
             res[TagJsonFields.VALUE] = self.value
         if self.labeler_login is not None:

{supervisely-6.73.311 → supervisely-6.73.312}/supervisely/api/module_api.py

@@ -621,6 +621,10 @@ class ApiField:
     """"""
     EXPERIMENT = "experiment"
     """"""
+    IS_FINISHED = "isFinished"
+    """"""
+    NON_FINAL_VALUE = "nonFinalValue"
+    """"""
 
 
 def _get_single_item(items):

{supervisely-6.73.311 → supervisely-6.73.312}/supervisely/api/video/video_tag_api.py

@@ -6,7 +6,9 @@ from typing import List, Optional, Union
 from supervisely.annotation.tag_meta import TagMeta
 from supervisely.api.entity_annotation.tag_api import TagApi
 from supervisely.api.module_api import ApiField
+from supervisely.collection.key_indexed_collection import KeyIndexedCollection
 from supervisely.project.project_meta import ProjectMeta
+from supervisely.video_annotation.key_id_map import KeyIdMap
 from supervisely.video_annotation.video_tag import VideoTag
 from supervisely.video_annotation.video_tag_collection import VideoTagCollection
 
@@ -102,6 +104,8 @@ class VideoTagApi(TagApi):
         video_id: int,
         value: Optional[Union[str, int]] = None,
         frame_range: Optional[List[int]] = None,
+        is_finished: Optional[bool] = True,
+        non_final_value: Optional[bool] = False,
     ) -> int:
         """
         Add VideoTag to video.
@@ -114,6 +118,10 @@ class VideoTagApi(TagApi):
         :type value: str or int
         :param frame_range: New VideoTag frame range.
         :type frame_range: List[int]
+        :param is_finished: Specify if the tag is finished.
+        :type is_finished: bool
+        :param non_final_value: Specify if the tag value is non-final.
+        :type non_final_value: bool
         :return: None
         :rtype: dict
         :Usage example:
@@ -133,11 +141,17 @@ class VideoTagApi(TagApi):
         request_data = {ApiField.TAG_ID: project_meta_tag_id, ApiField.VIDEO_ID: video_id}
         if value:
             request_data[ApiField.VALUE] = value
+        if non_final_value is True:
+            is_finished = False
         if frame_range:
+            if is_finished is False and frame_range[0] != frame_range[1]:
+                raise ValueError("Start frame and end frame must be equal for unfinished tags")
             request_data[ApiField.FRAME_RANGE] = frame_range
+        request_data[ApiField.IS_FINISHED] = is_finished
+        request_data[ApiField.NON_FINAL_VALUE] = non_final_value
 
         resp = self._api.post("videos.tags.add", request_data)
-        # {'imageId': 3267369, 'tagId': 368985, 'id': 2296676, 'createdAt': '2022-09-20T11:52:33.829Z', 'updatedAt': '2022-09-20T11:52:33.829Z', 'labelerLogin': 'max'}
+        # {'imageId': 3267369, 'tagId': 368985, 'id': 2296676, 'createdAt': '2022-09-20T11:52:33.829Z', 'updatedAt': '2022-09-20T11:52:33.829Z', 'labelerLogin': 'max', isFinished: true, nonFinalValue: false}
         return resp.json()
 
     def add(self, video_id: int, tag: VideoTag, update_id_inplace=True) -> int:
@@ -186,7 +200,14 @@ class VideoTagApi(TagApi):
             else:
                 raise ValueError("tag_meta.sly_id is None, get updated project meta from server")
 
-        resp_json = self.add_tag(tag.meta.sly_id, video_id, tag.value, tag.frame_range)
+        resp_json = self.add_tag(
+            tag.meta.sly_id,
+            video_id,
+            tag.value,
+            tag.frame_range,
+            tag.is_finished,
+            tag.non_final_value,
+        )
         tag_id = resp_json.get("id")
         created_at = resp_json.get("createdAt")
         updated_at = resp_json.get("updatedAt")
@@ -275,7 +296,7 @@ class VideoTagApi(TagApi):
 
 
 class VideoObjectTagApi(TagApi):
-    _entity_id_field = ApiField.OBJECT_ID
+    _entity_id_field = ApiField.ENTITY_ID
     _method_bulk_add = "annotation-objects.tags.bulk.add"
 
     def add(
@@ -284,6 +305,8 @@ class VideoObjectTagApi(TagApi):
         object_id: int,
         value: Optional[Union[str, int]] = None,
         frame_range: Optional[List[int]] = None,
+        is_finished: Optional[bool] = True,
+        non_final_value: Optional[bool] = False,
     ) -> int:
         """Add a tag to an annotation object.
 
@@ -304,8 +327,14 @@ class VideoObjectTagApi(TagApi):
         }
         if value is not None:
             request_body[ApiField.VALUE] = value
+        if non_final_value is True:
+            is_finished = False
         if frame_range is not None:
+            if is_finished is False and frame_range[0] != frame_range[1]:
+                raise ValueError("Start frame and end frame must be equal for unfinished tags")
             request_body[ApiField.FRAME_RANGE] = frame_range
+        request_body[ApiField.IS_FINISHED] = is_finished
+        request_body[ApiField.NON_FINAL_VALUE] = non_final_value
 
         response = self._api.post("annotation-objects.tags.add", request_body)
         id = response.json()[ApiField.ID]
@@ -349,3 +378,40 @@ class VideoObjectTagApi(TagApi):
             ApiField.FRAME_RANGE: frame_range,
         }
         self._api.post("annotation-objects.tags.update", request_body)
+
+    def append_to_entity(
+        self,
+        entity_id: int,
+        project_id: int,
+        tags: KeyIndexedCollection,
+        object_id: int,
+        key_id_map: KeyIdMap = None,
+    ):
+        """
+        Add tags to entity in project with given ID.
+
+        :param entity_id: ID of the entity in Supervisely to add a tag to
+        :type entity_id: int
+        :param project_id: Project ID in Supervisely.
+        :type project_id: int
+        :param tags: Collection of tags
+        :type tags: KeyIndexedCollection
+        :param object_id: ID of the object in Supervisely to add a tag to
+        :type object_id: int, optional
+        :param key_id_map: KeyIdMap object.
+        :type key_id_map: KeyIdMap, optional
+        :return: List of tags IDs
+        :rtype: list
+        """
+
+        if len(tags) == 0:
+            return []
+        tags_json, tags_keys = self._tags_to_json(tags, project_id=project_id)
+        tags_to_add = []
+        for tag in tags_json:
+            if object_id is not None:
+                tag[ApiField.OBJECT_ID] = object_id
+            tags_to_add.append(tag)
+        ids = self._append_json(entity_id, tags_to_add)
+        KeyIdMap.add_tags_to(key_id_map, tags_keys, ids)
+        return ids

{supervisely-6.73.311 → supervisely-6.73.312}/supervisely/pointcloud_annotation/pointcloud_episode_tag.py

@@ -1,6 +1,9 @@
 from __future__ import annotations
+
 import uuid
-from typing import Optional, Dict, Union, Tuple
+from typing import Dict, Optional, Tuple, Union
+
+from supervisely._utils import take_with_default
 from supervisely.annotation.tag_meta import TagMeta
 from supervisely.annotation.tag_meta_collection import TagMetaCollection
 from supervisely.video_annotation.key_id_map import KeyIdMap
@@ -57,6 +60,30 @@ class PointcloudEpisodeTag(VideoTag):
         # Output: ValueError: Tag car color can not have value yellow
     """
 
+    _SUPPORT_UNFINISHED_TAGS = False
+
+    def __init__(
+        self,
+        meta,
+        value=None,
+        frame_range=None,
+        key=None,
+        sly_id=None,
+        labeler_login=None,
+        updated_at=None,
+        created_at=None,
+    ):
+        super().__init__(
+            meta,
+            value,
+            frame_range,
+            key,
+            sly_id,
+            labeler_login,
+            updated_at,
+            created_at,
+        )
+
     @classmethod
     def from_json(
         cls,
@@ -95,7 +122,18 @@ class PointcloudEpisodeTag(VideoTag):
             tag_car_color = sly.PointcloudEpisodeTag.from_json(tag_car_color_json, meta_car_collection)
         """
 
-        return super().from_json(data, tag_meta_collection, key_id_map=key_id_map)
+        temp = super(PointcloudEpisodeTag, cls).from_json(data, tag_meta_collection, key_id_map)
+
+        return cls(
+            meta=temp.meta,
+            value=temp.value,
+            frame_range=temp.frame_range,
+            key=temp.key(),
+            sly_id=temp.sly_id,
+            labeler_login=temp.labeler_login,
+            updated_at=temp.updated_at,
+            created_at=temp.created_at,
+        )
 
     def __eq__(self, other: PointcloudEpisodeTag) -> bool:
         return super().__eq__(other)
@@ -154,13 +192,13 @@ class PointcloudEpisodeTag(VideoTag):
             # }
         """
 
-        return super().clone(
-            meta=meta,
-            value=value,
-            frame_range=frame_range,
-            key=key,
-            sly_id=sly_id,
-            labeler_login=labeler_login,
-            updated_at=updated_at,
-            created_at=created_at,
+        return self.__class__(
+            meta=take_with_default(meta, self.meta),
+            value=take_with_default(value, self.value),
+            frame_range=take_with_default(frame_range, self.frame_range),
+            key=take_with_default(key, self.key()),
+            sly_id=take_with_default(sly_id, self.sly_id),
+            labeler_login=take_with_default(labeler_login, self.labeler_login),
+            updated_at=take_with_default(updated_at, self.updated_at),
+            created_at=take_with_default(created_at, self.created_at),
         )

{supervisely-6.73.311 → supervisely-6.73.312}/supervisely/video_annotation/video_tag.py

@@ -2,15 +2,17 @@
 
 # docs
 from __future__ import annotations
-from typing import List, Tuple, Dict, Optional, Union
-from supervisely.annotation.tag_meta_collection import TagMetaCollection
-from supervisely.annotation.tag_meta import TagMeta
-
 
 import uuid
-from supervisely.annotation.tag import Tag, TagJsonFields
+from typing import Dict, List, Optional, Tuple, Union
+
 from supervisely._utils import take_with_default
-from supervisely.video_annotation.constants import KEY, ID, FRAME_RANGE
+from supervisely.annotation.tag import Tag, TagJsonFields
+from supervisely.annotation.tag_meta import TagMeta, TagTargetType
+from supervisely.annotation.tag_meta_collection import TagMetaCollection
+from supervisely.api.module_api import ApiField
+from supervisely.sly_logger import logger
+from supervisely.video_annotation.constants import FRAME_RANGE, ID, KEY
 from supervisely.video_annotation.key_id_map import KeyIdMap
 
 
@@ -34,6 +36,10 @@ class VideoTag(Tag):
     :type updated_at: str, optional
     :param created_at: Date and Time when VideoTag was created. Date Format is the same as in "updated_at" parameter.
     :type created_at: str, optional
+    :param is_finished: Video Tag is finished or not (applicable for range tags).
+    :type is_finished: bool, optional
+    :param non_final_value: Video Tag value is final or not. Can be useful to create tag without value.
+    :type non_final_value: bool, optional
     :Usage example:
 
      .. code-block:: python
@@ -64,22 +70,52 @@ class VideoTag(Tag):
         tag_coat_color = VideoTag(meta_coat_color, value="yellow")
         # Output: ValueError: Tag coat color can not have value yellow
     """
-    def __init__(self, meta: TagMeta, value: Optional[Union[str, int, float]]=None, frame_range: Optional[Tuple[int, int]]=None,
-                 key: Optional[uuid.UUID]=None, sly_id: Optional[int]=None, labeler_login: Optional[str]=None,
-                 updated_at: Optional[str]=None, created_at: Optional[str]=None):
-        super(VideoTag, self).__init__(meta, value=value, sly_id=sly_id, labeler_login=labeler_login, updated_at=updated_at, created_at=created_at)
-        
+
+    _SUPPORT_UNFINISHED_TAGS = True
+
+    def __init__(
+        self,
+        meta: TagMeta,
+        value: Optional[Union[str, int, float]] = None,
+        frame_range: Optional[Tuple[int, int]] = None,
+        key: Optional[uuid.UUID] = None,
+        sly_id: Optional[int] = None,
+        labeler_login: Optional[str] = None,
+        updated_at: Optional[str] = None,
+        created_at: Optional[str] = None,
+        is_finished: Optional[bool] = None,
+        non_final_value: Optional[bool] = None,
+    ):
+        super(VideoTag, self).__init__(
+            meta,
+            value=value,
+            sly_id=sly_id,
+            labeler_login=labeler_login,
+            updated_at=updated_at,
+            created_at=created_at,
+        )
+
         self._frame_range = None
         if frame_range is not None:
-            if not isinstance(frame_range, (tuple, list)):
-                raise TypeError('frame_range has to be a tuple or a list. Given type "{}".'.format(type(frame_range)))
-
-            if len(frame_range) != 2 or not isinstance(frame_range[0], int) or not isinstance(frame_range[1], int):
-                raise ValueError("frame_range has to be a tuple or a list with 2 int values.") 
-            self._frame_range = list(frame_range)
+            self._frame_range = self._validate_frame_range(frame_range)
 
         self._key = take_with_default(key, uuid.uuid4())
 
+        self._is_finished = None
+        self._non_final_value = None
+
+        if self._SUPPORT_UNFINISHED_TAGS is True:
+            self._is_finished = take_with_default(is_finished, True)
+            if self._is_finished is False:
+                if self._frame_range is None:
+                    raise ValueError("Cannot set is_finished=False for a tag without frame range")
+                self._frame_range = [self._frame_range[0], self._frame_range[0]]
+            if not self.meta.is_valid_value(self.value) and self.value is None:
+                non_final_value = True
+            self._non_final_value = take_with_default(non_final_value, False)
+            if self._non_final_value is True:
+                self._is_finished = False
+
     @property
     def frame_range(self) -> Tuple[int, int]:
         """
@@ -95,9 +131,53 @@ class VideoTag(Tag):
         """
         return self._frame_range
 
+    @property
+    def is_finished(self) -> bool:
+        """
+        VideoTag is finished or not (applicable for range tags).
+
+        :return: True if VideoTag is finished, otherwise False
+        :rtype: :class:`bool`
+        :Usage example:
+
+         .. code-block:: python
+
+            is_finished = tag_cat.is_finished
+        """
+        return self._is_finished
+
+    @property
+    def non_final_value(self) -> bool:
+        """
+        VideoTag value is final or not.
+
+        :return: True if VideoTag value is final, otherwise False
+        :rtype: :class:`bool`
+        :Usage example:
+
+         .. code-block:: python
+
+            non_final_value = tag_cat.non_final_value
+        """
+        return self._non_final_value
+
     def key(self) -> uuid.UUID:
         return self._key
 
+    def _validate_frame_range(self, frame_range: Tuple[int, int]) -> Tuple[int, int]:
+        if not isinstance(frame_range, (tuple, list)):
+            raise TypeError(
+                f'frame_range has to be a tuple or a list. Given type "{type(frame_range)}".'
+            )
+
+        if (
+            len(frame_range) != 2
+            or not isinstance(frame_range[0], int)
+            or not isinstance(frame_range[1], int)
+        ):
+            raise ValueError("frame_range has to be a tuple or a list with 2 int values.")
+        return list(frame_range)
+
     def to_json(self, key_id_map: Optional[KeyIdMap] = None) -> Dict:
         """
         Convert the VideoTag to a json dict. Read more about `Supervisely format <https://docs.supervise.ly/data-organization/00_ann_format_navi>`_.
@@ -127,6 +207,11 @@ class VideoTag(Tag):
             data_json = {TagJsonFields.TAG_NAME: data_json}
         if self.frame_range is not None:
             data_json[FRAME_RANGE] = self.frame_range
+
+        if self.is_finished is not None:
+            data_json[ApiField.IS_FINISHED] = self.is_finished
+        if self.non_final_value is not None:
+            data_json[ApiField.NON_FINAL_VALUE] = self.non_final_value
         data_json[KEY] = self.key().hex
 
         if key_id_map is not None:
@@ -137,7 +222,12 @@ class VideoTag(Tag):
         return data_json
 
     @classmethod
-    def from_json(cls, data: Dict, tag_meta_collection: TagMetaCollection, key_id_map: Optional[KeyIdMap] = None) -> VideoTag:
+    def from_json(
+        cls,
+        data: Dict,
+        tag_meta_collection: TagMetaCollection,
+        key_id_map: Optional[KeyIdMap] = None,
+    ) -> VideoTag:
         """
         Convert a json dict to VideoTag. Read more about `Supervisely format <https://docs.supervise.ly/data-organization/00_ann_format_navi>`_.
 
@@ -171,13 +261,25 @@ class VideoTag(Tag):
         """
         temp = super(VideoTag, cls).from_json(data, tag_meta_collection)
         frame_range = data.get(FRAME_RANGE, None)
+        is_finished = data.get(ApiField.IS_FINISHED, True)
+        non_final_value = data.get(ApiField.NON_FINAL_VALUE, False)
         key = uuid.UUID(data[KEY]) if KEY in data else uuid.uuid4()
 
         if key_id_map is not None:
             key_id_map.add_tag(key, data.get(ID, None))
 
-        return cls(meta=temp.meta, value=temp.value, frame_range=frame_range, key=key,
-                   sly_id=temp.sly_id, labeler_login=temp.labeler_login, updated_at=temp.updated_at, created_at=temp.created_at)
+        return cls(
+            meta=temp.meta,
+            value=temp.value,
+            frame_range=frame_range,
+            key=key,
+            sly_id=temp.sly_id,
+            labeler_login=temp.labeler_login,
+            updated_at=temp.updated_at,
+            created_at=temp.created_at,
+            is_finished=is_finished,
+            non_final_value=non_final_value,
+        )
 
     def get_compact_str(self) -> str:
         """
@@ -199,6 +301,10 @@ class VideoTag(Tag):
         res = super(VideoTag, self).get_compact_str()
         if self.frame_range is not None:
             res = "{}[{} - {}]".format(res, self.frame_range[0], self.frame_range[1])
+        if self.is_finished is False:
+            res += " (unfinished)"
+        if self.non_final_value is True:
+            res += " (non-final value)"
         return res
 
     def __eq__(self, other: VideoTag) -> bool:
@@ -233,14 +339,33 @@ class VideoTag(Tag):
             # Compare unidentical Tags
             print(tag_lemon_1 == tag_cucumber)     # False
         """
-        return isinstance(other, VideoTag) and \
-               self.meta == other.meta and \
-               self.value == other.value and \
-               self.frame_range == other.frame_range
-
-    def clone(self, meta: Optional[TagMeta] = None, value: Optional[Union[str, int, float]] = None, frame_range: Optional[Tuple[int, int]] = None,
-              key: Optional[uuid.UUID] = None, sly_id: Optional[int] = None, labeler_login: Optional[str] = None,
-              updated_at: Optional[str] = None, created_at: Optional[str] = None) -> VideoTag:
+        unfinished_tag_comparison = True
+        if self._SUPPORT_UNFINISHED_TAGS:
+            unfinished_tag_comparison = (
+                self.is_finished == other.is_finished
+                and self.non_final_value == other.non_final_value
+            )
+        return (
+            isinstance(other, VideoTag)
+            and self.meta == other.meta
+            and self.value == other.value
+            and self.frame_range == other.frame_range
+            and unfinished_tag_comparison
+        )
+
+    def clone(
+        self,
+        meta: Optional[TagMeta] = None,
+        value: Optional[Union[str, int, float]] = None,
+        frame_range: Optional[Tuple[int, int]] = None,
+        key: Optional[uuid.UUID] = None,
+        sly_id: Optional[int] = None,
+        labeler_login: Optional[str] = None,
+        updated_at: Optional[str] = None,
+        created_at: Optional[str] = None,
+        is_finished: Optional[bool] = None,
+        non_final_value: Optional[bool] = None,
+    ) -> VideoTag:
         """
         Makes a copy of VideoTag with new fields, if fields are given, otherwise it will use fields of the original VideoTag.
 
@@ -260,6 +385,10 @@ class VideoTag(Tag):
         :type updated_at: str, optional
         :param created_at: Date and Time when VideoTag was created. Date Format is the same as in "updated_at" parameter.
         :type created_at: str, optional
+        :param is_finished: Video Tag is finished or not (applicable for range tags).
+        :type is_finished: bool, optional
+        :param non_final_value: Video Tag value is final or not (applicable for range tags).
+        :type non_final_value: bool, optional
         :Usage example:
 
          .. code-block:: python
@@ -292,19 +421,48 @@ class VideoTag(Tag):
             sly_id=take_with_default(sly_id, self.sly_id),
             labeler_login=take_with_default(labeler_login, self.labeler_login),
             updated_at=take_with_default(updated_at, self.updated_at),
-            created_at=take_with_default(created_at, self.created_at)
+            created_at=take_with_default(created_at, self.created_at),
+            is_finished=take_with_default(is_finished, self.is_finished),
+            non_final_value=take_with_default(non_final_value, self.non_final_value),
         )
 
     def __str__(self):
         # pylint: disable=too-many-format-args
-        return '{:<7s}{:<10}{:<7s} {:<13}{:<7s} {:<10} {:<12}'.format('Name:', self._meta.name,
-                                                               'Value type:', self._meta.value_type,
-                                                               'Value:', str(self.value),
-                                                               'FrameRange', str(self.frame_range))
+        s = "{:<7s}{:<10}{:<7s} {:<13}{:<7s} {:<10} {:<12}".format(
+            "Name:",
+            self._meta.name,
+            "Value type:",
+            self._meta.value_type,
+            "Value:",
+            str(self.value),
+            "FrameRange",
+            str(self.frame_range),
+        )
+        if self._SUPPORT_UNFINISHED_TAGS:
+            s += "{:<7s} {:<10} {:<12}".format(
+                "Is finished:",
+                str(self.is_finished),
+                "Non final value:",
+                str(self.non_final_value),
+            )
+
+        return s
 
     @classmethod
     def get_header_ptable(cls) -> List[str]:
-        return ['Name', 'Value type', 'Value', 'Frame range']
+        header = ["Name", "Value type", "Value", "Frame range"]
+        if cls._SUPPORT_UNFINISHED_TAGS:
+            header += ["Is finished", "Non final value"]
+        return header
 
     def get_row_ptable(self) -> List[str]:
-        return [self._meta.name, self._meta.value_type, self.value, self.frame_range]
+        row = [
+            self._meta.name,
+            self._meta.value_type,
+            self.value,
+            self.frame_range,
+        ]
+        if self._SUPPORT_UNFINISHED_TAGS:
+            row += [self.is_finished, self.non_final_value]
+
+        return row

{supervisely-6.73.311 → supervisely-6.73.312/supervisely.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: supervisely
-Version: 6.73.311
+Version: 6.73.312
 Summary: Supervisely Python SDK.
 Home-page: https://github.com/supervisely/supervisely
 Author: Supervisely