supervisely 6.73.438__py3-none-any.whl → 6.73.513__py3-none-any.whl

supervisely/api/project_api.py

@@ -52,6 +52,7 @@ from supervisely.io.json import dump_json_file, load_json_file
 from supervisely.project.project_meta import ProjectMeta
 from supervisely.project.project_meta import ProjectMetaJsonFields as MetaJsonF
 from supervisely.project.project_settings import (
+    LabelingInterface,
     ProjectSettings,
     ProjectSettingsJsonFields,
 )
@@ -691,6 +692,7 @@ class ProjectApi(CloneableModuleApi, UpdateableModule, RemoveableModuleApi):
         type: ProjectType = ProjectType.IMAGES,
         description: Optional[str] = "",
         change_name_if_conflict: Optional[bool] = False,
+        readme: Optional[str] = None,
     ) -> ProjectInfo:
         """
         Create Project with given name in the given Workspace ID.
@@ -705,6 +707,8 @@ class ProjectApi(CloneableModuleApi, UpdateableModule, RemoveableModuleApi):
         :type description: str
         :param change_name_if_conflict: Checks if given name already exists and adds suffix to the end of the name.
         :type change_name_if_conflict: bool, optional
+        :param readme: Project readme.
+        :type readme: str, optional
         :return: Information about Project. See :class:`info_sequence<info_sequence>`
         :rtype: :class:`ProjectInfo`
         :Usage example:
@@ -745,15 +749,15 @@ class ProjectApi(CloneableModuleApi, UpdateableModule, RemoveableModuleApi):
             name=name,
             change_name_if_conflict=change_name_if_conflict,
         )
-        response = self._api.post(
-            "projects.add",
-            {
-                ApiField.WORKSPACE_ID: workspace_id,
-                ApiField.NAME: effective_name,
-                ApiField.DESCRIPTION: description,
-                ApiField.TYPE: str(type),
-            },
-        )
+        payload = {
+            ApiField.NAME: effective_name,
+            ApiField.WORKSPACE_ID: workspace_id,
+            ApiField.DESCRIPTION: description,
+            ApiField.TYPE: str(type),
+        }
+        if readme is not None:
+            payload[ApiField.README] = readme
+        response = self._api.post("projects.add", payload)
         return self._convert_json_info(response.json())
 
     def _get_update_method(self):
@@ -1368,6 +1372,8 @@ class ProjectApi(CloneableModuleApi, UpdateableModule, RemoveableModuleApi):
 
     def get_settings(self, id: int) -> Dict[str, str]:
         info = self._get_info_by_id(id, "projects.info")
+        if info is None:
+            raise ProjectNotFound(f"Project with id={id} not found")
         return info.settings
 
     def update_settings(self, id: int, settings: Dict[str, str]) -> None:
@@ -1993,8 +1999,11 @@ class ProjectApi(CloneableModuleApi, UpdateableModule, RemoveableModuleApi):
         )
 
     def set_multiview_settings(self, project_id: int) -> None:
-        """Sets the project settings for multiview images.
-        Images will be grouped by tag and have synchronized view and labeling.
+        """Sets the project settings for multiview mode.
+        Automatically detects project type and applies appropriate settings:
+
+        - For IMAGE projects: Images are grouped by tag with synchronized view and labeling.
+        - For VIDEO projects: Videos are grouped by datasets (each dataset = one group).
 
         :param project_id: Project ID to set multiview settings.
         :type project_id: int
@@ -2015,17 +2024,51 @@ class ProjectApi(CloneableModuleApi, UpdateableModule, RemoveableModuleApi):
             load_dotenv(os.path.expanduser("~/supervisely.env"))
             api = sly.Api.from_env()
 
-            api.project.set_multiview_settings(project_id=123)
+            # For images project - will enable grouping by tags
+            api.project.set_multiview_settings(image_project_id)
+
+            # For videos project - will enable grouping by datasets
+            api.project.set_multiview_settings(video_project_id)
         """
+        project_info = self.get_info_by_id(project_id)
+        if project_info.type == ProjectType.IMAGES.value:
+            self._set_custom_grouping_settings(
+                id=project_id,
+                group_images=True,
+                tag_name=_MULTIVIEW_TAG_NAME,
+                sync=False,
+                label_group_tag_name=_LABEL_GROUP_TAG_NAME,
+            )
+        elif project_info.type == ProjectType.VIDEOS.value:
+            self._set_custom_grouping_settings_video(project_id, sync=True)
+        else:
+            raise ValueError("Multiview settings can only be set for image or video projects")
 
-        self._set_custom_grouping_settings(
-            id=project_id,
-            group_images=True,
-            tag_name=_MULTIVIEW_TAG_NAME,
-            sync=False,
-            label_group_tag_name=_LABEL_GROUP_TAG_NAME,
+    def _set_custom_grouping_settings_video(self, project_id: int, sync: bool = True) -> None:
+        """Sets the project settings for multiview videos (private method).
+        For video projects, videos are grouped by datasets (not by tags).
+        Each dataset represents a group of videos that will be displayed together in multiview mode.
+
+        :param project_id: Project ID to set video multiview settings.
+        :type project_id: int
+        :param sync: If True, enables synchronized playback across video views.
+        :type sync: bool
+        :return: None
+        :rtype: :class:`NoneType`
+        """
+        meta = ProjectMeta.from_json(self.get_meta(project_id, with_settings=True))
+
+        new_settings = ProjectSettings(
+            multiview_enabled=True,
+            multiview_tag_name=None,  # Not used for videos
+            multiview_tag_id=None,  # Not used for videos
+            multiview_is_synced=sync,
+            labeling_interface=LabelingInterface.MULTIVIEW,
         )
 
+        meta = meta.clone(project_settings=new_settings)
+        self.update_meta(id=project_id, meta=meta)
+
     def remove_permanently(
         self, ids: Union[int, List], batch_size: int = 50, progress_cb=None
     ) -> List[dict]:
@@ -2327,7 +2370,7 @@ class ProjectApi(CloneableModuleApi, UpdateableModule, RemoveableModuleApi):
         """
         info = self.get_info_by_id(id, extra_fields=[ApiField.EMBEDDINGS_IN_PROGRESS])
         if info is None:
-            raise RuntimeError(f"Project with ID {id} not found.")
+            raise ProjectNotFound(f"Project with ID {id} not found.")
         if not hasattr(info, "embeddings_in_progress"):
             raise RuntimeError(
                 f"Project with ID {id} does not have 'embeddings_in_progress' field in its info."
@@ -2392,7 +2435,7 @@ class ProjectApi(CloneableModuleApi, UpdateableModule, RemoveableModuleApi):
         """
         info = self.get_info_by_id(id, extra_fields=[ApiField.EMBEDDINGS_UPDATED_AT])
         if info is None:
-            raise RuntimeError(f"Project with ID {id} not found.")
+            raise ProjectNotFound(f"Project with ID {id} not found.")
         if not hasattr(info, "embeddings_updated_at"):
             raise RuntimeError(
                 f"Project with ID {id} does not have 'embeddings_updated_at' field in its info."
@@ -2606,7 +2649,9 @@ class ProjectApi(CloneableModuleApi, UpdateableModule, RemoveableModuleApi):
             )
             dst_project_id = dst_project_info.id
 
-        datasets = self._api.dataset.get_list(src_project_id, recursive=True, include_custom_data=True)
+        datasets = self._api.dataset.get_list(
+            src_project_id, recursive=True, include_custom_data=True
+        )
         src_to_dst_ids = {}
 
         for src_dataset_info in datasets:
@@ -2626,7 +2671,7 @@ class ProjectApi(CloneableModuleApi, UpdateableModule, RemoveableModuleApi):
         src_project_id: int,
         dst_project_id: Optional[int] = None,
         dst_project_name: Optional[str] = None,
-    ) -> Tuple[List[DatasetInfo], List[DatasetInfo]]:
+    ) -> List[Tuple[DatasetInfo, DatasetInfo]]:
         """This method can be used to recreate a project with hierarchial datasets (without the data itself).
 
         :param src_project_id: Source project ID
@@ -2636,8 +2681,8 @@ class ProjectApi(CloneableModuleApi, UpdateableModule, RemoveableModuleApi):
         :param dst_project_name: Name of the destination project. If `dst_project_id` is None, a new project will be created with this name. If `dst_project_id` is provided, this parameter will be ignored.
         :type dst_project_name: str, optional
 
-        :return: Destination project ID
-        :rtype: int
+        :return: List of tuples of source and destination DatasetInfo objects
+        :rtype: List[Tuple[DatasetInfo, DatasetInfo]]
 
         :Usage example:
 
@@ -2650,8 +2695,8 @@ class ProjectApi(CloneableModuleApi, UpdateableModule, RemoveableModuleApi):
             src_project_id = 123
             dst_project_name = "New Project"
 
-            dst_project_id = api.project.recreate_structure(src_project_id, dst_project_name=dst_project_name)
-            print(f"Recreated project {src_project_id} -> {dst_project_id}")
+            infos = api.project.recreate_structure(src_project_id, dst_project_name=dst_project_name)
+            print(f"Recreated project {src_project_id}")
         """
         infos = []
         for src_info, dst_info in self.recreate_structure_generator(

supervisely/api/storage_api.py

@@ -228,7 +228,9 @@ class StorageApi(FileApi):
         path_infos = self.list(team_id, parent_dir, recursive=False, return_type="dict")
         for info in path_infos:
             if info["type"] == path_type:
-                if info["path"].rstrip("/") == remote_path.rstrip("/"):
+                if path_type == "file" and info["path"] == remote_path:
+                    return True
+                elif path_type == "folder" and info["path"].rstrip("/") == remote_path.rstrip("/"):
                     return True
         return False
 

supervisely/api/task_api.py

@@ -390,6 +390,7 @@ class TaskApi(ModuleApiBase, ModuleWithStatus):
         redirect_requests: Optional[Dict[str, int]] = {},
         limit_by_workspace: bool = False,
         kubernetes_settings: Optional[Union[KubernetesSettings, Dict[str, Any]]] = None,
+        multi_user_session: bool = False,
     ) -> Dict[str, Any]:
         """Starts the application task on the agent.
 
@@ -428,6 +429,11 @@ class TaskApi(ModuleApiBase, ModuleWithStatus):
         :type limit_by_workspace: bool, optional
         :param kubernetes_settings: Kubernetes settings for the application.
         :type kubernetes_settings: Union[KubernetesSettings, Dict[str, Any]], optional
+        :param multi_user_session: If True, the application session will be created as multi-user.
+                                   In this case, multiple users will be able to connect to the same application session.
+                                   All users will have separate application states.
+                                   Available only for applications that support multi-user sessions.
+        :type multi_user_session: bool, default is False
         :return: Task information in JSON format.
         :rtype: Dict[str, Any]
 
@@ -497,6 +503,11 @@ class TaskApi(ModuleApiBase, ModuleWithStatus):
             data[ApiField.APP_ID] = app_id
         if module_id is not None:
             data[ApiField.MODULE_ID] = module_id
+        if multi_user_session:
+            # * Enables single multi-user session mode for all users in the users_ids list.
+            # * Otherwise, if users_ids contains multiple IDs, separate single-user sessions will be created for each.
+            # * If users_ids is empty, a session is created only for the current user.
+            data[ApiField.SINGLE_SESSION_MODE] = multi_user_session
         resp = self._api.post(method="tasks.run.app", data=data)
         task = resp.json()[0]
         if "id" not in task:
@@ -805,8 +816,8 @@ class TaskApi(ModuleApiBase, ModuleWithStatus):
     ):
         """
         Update given task metadata
-        :param id: int — task id
-        :param data: dict — meta data to update
+        :param id: int - task id
+        :param data: dict - meta data to update
         """
         if type(data) == dict:
             data.update({"id": id})

supervisely/api/team_api.py

@@ -132,7 +132,7 @@ class ActivityAction:
 class UsageInfo(NamedTuple):
     """ """
 
-    plan: str
+    plan: Optional[str]
 
 
 class TeamInfo(NamedTuple):
@@ -144,7 +144,7 @@ class TeamInfo(NamedTuple):
     role: str
     created_at: str
     updated_at: str
-    usage: UsageInfo
+    usage: Optional[UsageInfo]
 
 
 class TeamApi(ModuleNoParent, UpdateableModule):
@@ -565,5 +565,6 @@ class TeamApi(ModuleNoParent, UpdateableModule):
         res = super()._convert_json_info(info, skip_missing=skip_missing)
         res_dict = res._asdict()
         if isinstance(res_dict.get("usage"), dict):
-            res_dict["usage"] = UsageInfo(**res_dict["usage"])
+            usage_dict = {f: res_dict["usage"].get(f) for f in UsageInfo._fields}
+            res_dict["usage"] = UsageInfo(**usage_dict)
         return TeamInfo(**res_dict)

supervisely/api/video/video_annotation_api.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import asyncio
+from collections import defaultdict
 from typing import Callable, Dict, List, Optional, Union
 
 from tqdm import tqdm
@@ -13,6 +14,7 @@ from supervisely.io.json import load_json_file
 from supervisely.project.project_meta import ProjectMeta
 from supervisely.video_annotation.key_id_map import KeyIdMap
 from supervisely.video_annotation.video_annotation import VideoAnnotation
+from supervisely.video_annotation.video_tag_collection import VideoTagCollection
 
 
 class VideoAnnotationAPI(EntityAnnotationAPI):
@@ -173,7 +175,6 @@ class VideoAnnotationAPI(EntityAnnotationAPI):
             api.video.annotation.upload_paths(video_ids, ann_paths, meta)
         """
         # video_ids from the same dataset
-
         for video_id, ann_path in zip(video_ids, ann_paths):
             ann_json = load_json_file(ann_path)
             ann = VideoAnnotation.from_json(ann_json, project_meta)
@@ -183,6 +184,119 @@ class VideoAnnotationAPI(EntityAnnotationAPI):
             if progress_cb is not None:
                 progress_cb(1)
 
+    def upload_paths_multiview(
+        self,
+        video_ids: List[int],
+        ann_paths: List[str],
+        project_meta: ProjectMeta,
+        progress_cb: Optional[Union[tqdm, Callable]] = None,
+    ) -> None:
+        """
+        Upload VideoAnnotations for multi-view video project.
+        All provided video ids must belong to the same project and dataset.
+
+        Objects with the same key are created only once and shared between videos.
+        In this mode annotation objects are created without binding to a specific entityId.
+
+        :param video_ids: Video IDs in Supervisely.
+        :type video_ids: List[int]
+        :param ann_paths: Paths to annotations on local machine.
+        :type ann_paths: List[str]
+        :param project_meta: Input :class:`ProjectMeta<supervisely.project.project_meta.ProjectMeta>` for VideoAnnotations.
+        :type project_meta: ProjectMeta
+        :param progress_cb: Function for tracking upload progress.
+        :type progress_cb: tqdm or callable, optional
+        :return: None
+        :rtype: :class:`NoneType`
+        """
+        if len(video_ids) != len(ann_paths):
+            raise RuntimeError(
+                f'Can not match "video_ids" and "ann_paths" lists, len(video_ids) != len(ann_paths): {len(video_ids)} != {len(ann_paths)}'
+            )
+        if len(video_ids) == 0:
+            return
+
+        anns = []
+        for ann_path in ann_paths:
+            ann_json = load_json_file(ann_path)
+            ann = VideoAnnotation.from_json(ann_json, project_meta)
+            anns.append(ann)
+
+        self.upload_anns_multiview(video_ids, anns, progress_cb)
+
+    def upload_anns_multiview(
+        self,
+        video_ids: List[int],
+        anns: List[VideoAnnotation],
+        progress_cb: Optional[Union[tqdm, Callable]] = None,
+    ) -> None:
+        """
+        Upload already constructed VideoAnnotation objects for multi-view video project.
+        All provided video ids must belong to the same project and dataset.
+
+        Objects with the same key are created only once and shared between videos.
+        In this mode annotation objects are created without binding to a specific entityId.
+
+        :param video_ids: Video IDs in Supervisely.
+        :type video_ids: List[int]
+        :param anns: List of VideoAnnotation objects corresponding to the video_ids.
+        :type anns: List[VideoAnnotation]
+        :param progress_cb: Function for tracking upload progress (by number of figures).
+        :type progress_cb: tqdm or callable, optional
+        :return: None
+        :rtype: :class:`NoneType`
+        """
+        if len(video_ids) != len(anns):
+            raise RuntimeError(
+                'Can not match "video_ids" and "anns" lists, len(video_ids) != len(anns)'
+            )
+        if len(video_ids) == 0:
+            return
+
+        try:
+            video_infos = self._api.video.get_info_by_id_batch(video_ids)
+        except RuntimeError as e:
+            raise RuntimeError("All videos must belong to the same project and dataset.") from e
+
+        project_id = video_infos[0].project_id
+        dataset_id = video_infos[0].dataset_id
+
+        tag_api = self._api.video.tag
+        object_api = self._api.video.object
+        figure_api = self._api.video.figure
+
+        key_id_map = KeyIdMap()
+        for video_id, ann in zip(video_ids, anns):
+            tag_api.append_to_entity(video_id, project_id, ann.tags, key_id_map=key_id_map)
+            new_objects = []
+            for obj in ann.objects:
+                if key_id_map.get_object_id(obj.key()) is None:
+                    new_objects.append(obj)
+            if len(new_objects) > 0:
+                object_api._append_bulk(
+                    tag_api=tag_api,
+                    entity_id=video_id,
+                    project_id=project_id,
+                    dataset_id=dataset_id,
+                    objects=new_objects,
+                    key_id_map=key_id_map,
+                    is_pointcloud=False,
+                    is_video_multi_view=True,
+                )
+            tags_to_obj = {}
+            for obj in ann.objects:
+                obj_id = key_id_map.get_object_id(obj.key())
+                tags_to_obj[obj_id] = obj.tags
+            if len(tags_to_obj) > 0:
+                tag_api.add_tags_collection_to_objects(project_id, tags_to_obj, is_video_multi_view=True, entity_id=video_id)
+
+            figure_api.append_bulk(video_id, ann.figures, key_id_map)
+            if progress_cb is not None and len(ann.figures) > 0:
+                if hasattr(progress_cb, "update") and callable(getattr(progress_cb, "update")):
+                    progress_cb.update(len(ann.figures))
+                else:
+                    progress_cb(len(ann.figures))
+
     def copy_batch(
         self,
         src_video_ids: List[int],
@@ -236,11 +350,13 @@ class VideoAnnotationAPI(EntityAnnotationAPI):
         dst_project_meta = ProjectMeta.from_json(
             self._api.project.get_meta(dst_dataset_info.project_id)
         )
-        for src_ids_batch, dst_ids_batch in batched(list(zip(src_video_ids, dst_video_ids))):
+        for src_ids_batch, dst_ids_batch in zip(batched(src_video_ids), batched(dst_video_ids)):
             ann_jsons = self.download_bulk(src_dataset_id, src_ids_batch)
             for dst_id, ann_json in zip(dst_ids_batch, ann_jsons):
                 try:
-                    ann = VideoAnnotation.from_json(ann_json, dst_project_meta)
+                    ann = VideoAnnotation.from_json(
+                        ann_json, dst_project_meta, key_id_map=KeyIdMap()
+                    )
                 except Exception as e:
                     raise RuntimeError("Failed to validate Annotation") from e
                 self.append(dst_id, ann)

supervisely/api/video/video_api.py

@@ -5,8 +5,10 @@ import asyncio
 import datetime
 import json
 import os
+import re
 import urllib.parse
 from functools import partial
+from itertools import zip_longest
 from typing import (
     AsyncGenerator,
     Callable,
@@ -23,7 +25,11 @@ from typing import (
 import aiofiles
 from numerize.numerize import numerize
 from requests import Response
-from requests_toolbelt import MultipartEncoder, MultipartEncoderMonitor
+from requests_toolbelt import (
+    MultipartDecoder,
+    MultipartEncoder,
+    MultipartEncoderMonitor,
+)
 from tqdm import tqdm
 
 import supervisely.io.fs as sly_fs
@@ -46,6 +52,7 @@ from supervisely.io.fs import (
     get_file_hash,
     get_file_hash_async,
     get_file_hash_chunked,
+    get_file_hash_chunked_async,
     get_file_name_with_ext,
     get_file_size,
     list_files,
@@ -700,7 +707,7 @@ class VideoApi(RemoveableBulkModuleApi):
         return project_id, dataset_id
 
     def upload_hash(
-        self, dataset_id: int, name: str, hash: str, stream_index: Optional[int] = None
+        self, dataset_id: int, name: str, hash: str, stream_index: Optional[int] = None, metadata: Optional[Dict] = None
     ) -> VideoInfo:
         """
         Upload Video from given hash to Dataset.
@@ -713,6 +720,8 @@ class VideoApi(RemoveableBulkModuleApi):
         :type hash: str
         :param stream_index: Index of video stream.
         :type stream_index: int, optional
+        :param metadata: Video metadata.
+        :type metadata: dict, optional
         :return: Information about Video. See :class:`info_sequence<info_sequence>`
         :rtype: :class:`VideoInfo`
         :Usage example:
@@ -781,6 +790,8 @@ class VideoApi(RemoveableBulkModuleApi):
         meta = {}
         if stream_index is not None and type(stream_index) is int:
             meta = {"videoStreamIndex": stream_index}
+        if metadata is not None:
+            meta.update(metadata)
         return self.upload_hashes(dataset_id, [name], [hash], [meta])[0]
 
     def upload_hashes(
@@ -1106,10 +1117,10 @@ class VideoApi(RemoveableBulkModuleApi):
             validate_ext(os.path.splitext(name)[1])
 
         for batch in batched(list(zip(names, items, metas))):
-            images = []
+            videos = []
             for name, item, meta in batch:
                 item_tuple = func_item_to_kv(item)
-                images.append(
+                videos.append(
                     {
                         "title": name,
                         item_tuple[0]: item_tuple[1],
@@ -1120,12 +1131,12 @@ class VideoApi(RemoveableBulkModuleApi):
                 "videos.bulk.add",
                 {
                     ApiField.DATASET_ID: dataset_id,
-                    ApiField.VIDEOS: images,
+                    ApiField.VIDEOS: videos,
                     ApiField.FORCE_METADATA_FOR_LINKS: force_metadata_for_links,
                 },
             )
             if progress_cb is not None:
-                progress_cb(len(images))
+                progress_cb(len(videos))
 
             results = [self._convert_json_info(item) for item in response.json()]
             name_to_res = {img_info.name: img_info for img_info in results}
@@ -1186,6 +1197,41 @@ class VideoApi(RemoveableBulkModuleApi):
                 if progress_cb is not None:
                     progress_cb(len(chunk))
 
+    def download_frames(
+        self, video_id: int, frames: List[int], paths: List[str], progress_cb=None
+    ) -> None:
+        endpoint = "videos.bulk.download-frame"
+        response: Response = self._api.get(
+            endpoint,
+            params={},
+            data={ApiField.VIDEO_ID: video_id, ApiField.FRAMES: frames},
+            stream=True,
+        )
+        response.raise_for_status()
+
+        files = {frame_n: None for frame_n in frames}
+        file_paths = {frame_n: path for frame_n, path in zip(frames, paths)}
+
+        try:
+            decoder = MultipartDecoder.from_response(response)
+            for part in decoder.parts:
+                content_utf8 = part.headers[b"Content-Disposition"].decode("utf-8")
+                # Find name="1245" preceded by a whitespace, semicolon or beginning of line.
+                # The regex has 2 capture group: one for the prefix and one for the actual name value.
+                frame_n = int(re.findall(r'(^|[\s;])name="(\d*)"', content_utf8)[0][1])
+                if files[frame_n] is None:
+                    file_path = file_paths[frame_n]
+                    files[frame_n] = open(file_path, "wb")
+                    if progress_cb is not None:
+                        progress_cb(1)
+                f = files[frame_n]
+                f.write(part.content)
+
+        finally:
+            for f in files.values():
+                if f is not None:
+                    f.close()
+
     def download_range_by_id(
         self,
         id: int,
@@ -1536,15 +1582,20 @@ class VideoApi(RemoveableBulkModuleApi):
         for hash_value, meta in zip(unique_hashes, unique_metas):
             hash_meta_dict[hash_value] = meta
 
-        metas = [hash_meta_dict[hash_value] for hash_value in hashes]
-
-        metas2 = [meta["meta"] for meta in metas]
-
+        video_metadatas = [hash_meta_dict[hash_value] for hash_value in hashes]
+        video_metadatas2 = [meta["meta"] for meta in video_metadatas]
         names = self.get_free_names(dataset_id, names)
 
-        for name, hash, meta in zip(names, hashes, metas2):
+        if metas is None:
+            metas = [None] * len(names)
+        if not isinstance(metas, list):
+            raise ValueError("metas must be a list")
+
+        for name, hash, video_metadata, metadata in zip_longest(
+            names, hashes, video_metadatas2, metas
+        ):
             try:
-                all_streams = meta["streams"]
+                all_streams = video_metadata["streams"]
                 video_streams = get_video_streams(all_streams)
                 for stream_info in video_streams:
                     stream_index = stream_info["index"]
@@ -1559,7 +1610,7 @@ class VideoApi(RemoveableBulkModuleApi):
                     # info = self._api.video.get_info_by_name(dataset_id, item_name)
                     # if info is not None:
                     #     item_name = gen_video_stream_name(name, stream_index)
-                    res = self.upload_hash(dataset_id, name, hash, stream_index)
+                    res = self.upload_hash(dataset_id, name, hash, stream_index, metadata)
                     video_info_results.append(res)
             except Exception as e:
                 from supervisely.io.exception_handlers import (
@@ -2531,7 +2582,7 @@ class VideoApi(RemoveableBulkModuleApi):
                         progress_cb(len(chunk))
             if check_hash:
                 if hash_to_check is not None:
-                    downloaded_file_hash = await get_file_hash_async(path)
+                    downloaded_file_hash = await get_file_hash_chunked_async(path)
                     if hash_to_check != downloaded_file_hash:
                         raise RuntimeError(
                             f"Downloaded hash of video with ID:{id} does not match the expected hash: {downloaded_file_hash} != {hash_to_check}"