supervisely 6.73.410__py3-none-any.whl → 6.73.470__py3-none-any.whl

supervisely/api/app_api.py

@@ -140,7 +140,7 @@ def check_workflow_compatibility(api, min_instance_version: str) -> bool:
             "instance_version", api.instance_version
         )
 
-        if instance_version == "unknown":
+        if instance_version is None or instance_version == "unknown":
             # to check again on the next call
             del _workflow_compatibility_version_cache["instance_version"]
             logger.info(
@@ -1394,9 +1394,75 @@ class AppApi(TaskApi):
         """get_url"""
         return f"/apps/sessions/{task_id}"
 
-    def download_git_file(self, app_id, version, file_path, save_path):
-        """download_git_file"""
-        raise NotImplementedError()
+    def download_git_file(
+        self,
+        module_id,
+        save_path,
+        app_id=None,
+        version=None,
+        file_path=None,
+        file_key=None,
+        log_progress=True,
+        ext_logger=None,
+    ):
+        """
+        Download a file from app repository. File should be added in the app config under `files` key.
+
+        :param module_id: ID of the module
+        :type module_id: int
+        :param save_path: Path to save the file
+        :type save_path: str
+        :param app_id: ID of the app
+        :type app_id: int
+        :param version: Version of the app
+        :type version: str
+        :param file_path: Path to the file in the app github repository
+        :type file_path: str
+        :param file_key: Key of the file in the app github repository
+        :type file_key: str
+        :param log_progress: If True, will log the progress of the download
+        :type log_progress: bool
+        :param ext_logger: Logger to use for logging
+        :type ext_logger: Logger
+        :return: None
+        :rtype: None
+        """
+        if file_path is None and file_key is None:
+            raise ValueError("Either file_path or file_key must be provided")
+        payload = {
+            ApiField.MODULE_ID: module_id,
+        }
+        if version is not None:
+            payload[ApiField.VERSION] = version
+        if app_id is not None:
+            payload[ApiField.APP_ID] = app_id
+        if file_path is not None:
+            payload[ApiField.FILE_PATH] = file_path
+        if file_key is not None:
+            payload[ApiField.FILE_KEY] = file_key
+
+        response = self._api.post("ecosystem.file.download", payload, stream=True)
+        progress = None
+        if log_progress:
+            if ext_logger is None:
+                ext_logger = logger
+
+            length = None
+            # Content-Length
+            if "Content-Length" in response.headers:
+                length = int(response.headers["Content-Length"])
+            progress = Progress("Downloading: ", length, ext_logger=ext_logger, is_size=True)
+
+        mb1 = 1024 * 1024
+        ensure_base_path(save_path)
+        with open(save_path, "wb") as fd:
+            log_size = 0
+            for chunk in response.iter_content(chunk_size=mb1):
+                fd.write(chunk)
+                log_size += len(chunk)
+                if log_progress and log_size > mb1 and progress is not None:
+                    progress.iters_done_report(log_size)
+                    log_size = 0
 
     def download_git_archive(
         self,
@@ -1418,6 +1484,7 @@ class AppApi(TaskApi):
             payload[ApiField.APP_ID] = app_id
 
         response = self._api.post("ecosystem.file.download", payload, stream=True)
+        progress = None
         if log_progress:
             if ext_logger is None:
                 ext_logger = logger
@@ -1435,7 +1502,7 @@ class AppApi(TaskApi):
             for chunk in response.iter_content(chunk_size=mb1):
                 fd.write(chunk)
                 log_size += len(chunk)
-                if log_progress and log_size > mb1:
+                if log_progress and log_size > mb1 and progress is not None:
                     progress.iters_done_report(log_size)
                     log_size = 0
 

supervisely/api/dataset_api.py

@@ -185,6 +185,7 @@ class DatasetApi(UpdateableModule, RemoveableModuleApi):
         filters: Optional[List[Dict[str, str]]] = None,
         recursive: Optional[bool] = False,
         parent_id: Optional[int] = None,
+        include_custom_data: Optional[bool] = False,
     ) -> List[DatasetInfo]:
         """
         Returns list of dataset in the given project, or list of nested datasets
@@ -200,6 +201,9 @@ class DatasetApi(UpdateableModule, RemoveableModuleApi):
         :type recursive: bool, optional
         :param parent_id: Parent Dataset ID. If set to None, the search will be performed at the top level of the Project,
             otherwise the search will be performed in the specified Dataset.
+        :type parent_id: Union[int, None], optional
+        :param include_custom_data: If True, the response will include the `custom_data` field for each Dataset.
+        :type include_custom_data: bool, optional
         :return: List of all Datasets with information for the given Project. See :class:`info_sequence<info_sequence>`
         :rtype: :class:`List[DatasetInfo]`
         :Usage example:
@@ -246,14 +250,16 @@ class DatasetApi(UpdateableModule, RemoveableModuleApi):
             filters.append({"field": ApiField.PARENT_ID, "operator": "=", "value": parent_id})
             recursive = True
 
-        return self.get_list_all_pages(
-            "datasets.list",
-            {
-                ApiField.PROJECT_ID: project_id,
-                ApiField.FILTER: filters,
-                ApiField.RECURSIVE: recursive,
-            },
-        )
+        method = "datasets.list"
+        data = {
+            ApiField.PROJECT_ID: project_id,
+            ApiField.FILTER: filters,
+            ApiField.RECURSIVE: recursive,
+        }
+        if include_custom_data:
+            data[ApiField.EXTRA_FIELDS] = [ApiField.CUSTOM_DATA]
+
+        return self.get_list_all_pages(method, data)
 
     def get_info_by_id(self, id: int, raise_error: Optional[bool] = False) -> DatasetInfo:
         """
@@ -304,6 +310,7 @@ class DatasetApi(UpdateableModule, RemoveableModuleApi):
         description: Optional[str] = "",
         change_name_if_conflict: Optional[bool] = False,
         parent_id: Optional[int] = None,
+        custom_data: Optional[Dict[Any, Any]] = None,
     ) -> DatasetInfo:
         """
         Create Dataset with given name in the given Project.
@@ -318,6 +325,9 @@ class DatasetApi(UpdateableModule, RemoveableModuleApi):
         :type change_name_if_conflict: bool, optional
         :param parent_id: Parent Dataset ID. If set to None, then the Dataset will be created at
             the top level of the Project, otherwise the Dataset will be created in a specified Dataset.
+        :type parent_id: Union[int, None]
+        :param custom_data: Custom data to store in the Dataset.
+        :type custom_data: Dict[Any, Any], optional
         :return: Information about Dataset. See :class:`info_sequence<info_sequence>`
         :rtype: :class:`DatasetInfo`
         :Usage example:
@@ -345,15 +355,16 @@ class DatasetApi(UpdateableModule, RemoveableModuleApi):
             change_name_if_conflict=change_name_if_conflict,
             parent_id=parent_id,
         )
-        response = self._api.post(
-            "datasets.add",
-            {
-                ApiField.PROJECT_ID: project_id,
-                ApiField.NAME: effective_name,
-                ApiField.DESCRIPTION: description,
-                ApiField.PARENT_ID: parent_id,
-            },
-        )
+        method = "datasets.add"
+        payload = {
+            ApiField.PROJECT_ID: project_id,
+            ApiField.NAME: effective_name,
+            ApiField.DESCRIPTION: description,
+            ApiField.PARENT_ID: parent_id,
+        }
+        if custom_data is not None:
+            payload[ApiField.CUSTOM_DATA] = custom_data
+        response = self._api.post(method, payload)
         return self._convert_json_info(response.json())
 
     def get_or_create(
@@ -564,6 +575,7 @@ class DatasetApi(UpdateableModule, RemoveableModuleApi):
                 new_dataset_name,
                 dataset.description,
                 change_name_if_conflict=change_name_if_conflict,
+                custom_data=dataset.custom_data,
             )
             items_api.copy_batch(
                 new_dataset.id, src_item_ids, change_name_if_conflict, with_annotations
@@ -797,6 +809,7 @@ class DatasetApi(UpdateableModule, RemoveableModuleApi):
         sort_order: Optional[str] = None,
         per_page: Optional[int] = None,
         page: Union[int, Literal["all"]] = "all",
+        include_custom_data: Optional[bool] = False,
     ) -> dict:
         """
         List all available datasets from all available teams for the user that match the specified filtering criteria.
@@ -807,22 +820,20 @@ class DatasetApi(UpdateableModule, RemoveableModuleApi):
                         - 'operator': Takes values '=', 'eq', '!=', 'not', 'in', '!in', '>', 'gt', '>=', 'gte', '<', 'lt', '<=', 'lte'
                         - 'value': Takes on values according to the meaning of 'field' or null
         :type filters: List[Dict[str, str]], optional
-
         :param sort: Specifies by which parameter to sort the project list.
                         Takes values 'id', 'name', 'size', 'createdAt', 'updatedAt'
         :type sort: str, optional
-
         :param sort_order: Determines which value to list from.
         :type sort_order: str, optional
-
         :param per_page: Number of first items found to be returned.
                         'None' will return the first page with a default size of 20000 datasets.
         :type per_page: int, optional
-
         :param page: Page number, used to retrieve the following items if the number of them found is more than per_page.
                      The default value is 'all', which retrieves all available datasets.
                      'None' will return the first page with datasets, the amount of which is set in param 'per_page'.
         :type page: Union[int, Literal["all"]], optional
+        :param include_custom_data: If True, the response will include the `custom_data` field for each Dataset.
+        :type include_custom_data: bool, optional
 
         :return: Search response information and 'DatasetInfo' of all datasets that are searched by a given criterion.
         :rtype: dict
@@ -899,6 +910,8 @@ class DatasetApi(UpdateableModule, RemoveableModuleApi):
             request_body[ApiField.PER_PAGE] = per_page
         if page is not None and page != "all":
             request_body[ApiField.PAGE] = page
+        if include_custom_data:
+            request_body[ApiField.EXTRA_FIELDS] = [ApiField.CUSTOM_DATA]
 
         first_response = self._api.post(method, request_body).json()
 
@@ -1008,13 +1021,66 @@ class DatasetApi(UpdateableModule, RemoveableModuleApi):
 
         return dataset_tree
 
-    def tree(self, project_id: int) -> Generator[Tuple[List[str], DatasetInfo], None, None]:
+    def _yield_tree(
+        self, tree: Dict[DatasetInfo, Dict], path: List[str]
+    ) -> Generator[Tuple[List[str], DatasetInfo], None, None]:
+        """
+        Helper method for recursive tree traversal.
+        Yields tuples of (path, dataset) for all datasets in the tree. For each node (dataset) at the current level,
+        yields its (path, dataset) before recursively traversing and yielding from its children.
+        
+        :param tree: Tree structure to yield from.
+        :type tree: Dict[DatasetInfo, Dict]
+        :param path: Current path (used for recursion).
+        :type path: List[str]
+        :return: Generator of tuples of (path, dataset).
+        :rtype: Generator[Tuple[List[str], DatasetInfo], None, None]
+        """
+        for dataset, children in tree.items():
+            yield path, dataset
+            new_path = path + [dataset.name]
+            if children:
+                yield from self._yield_tree(children, new_path)
+
+    def _find_dataset_in_tree(
+        self, tree: Dict[DatasetInfo, Dict], target_id: int, path: List[str] = None
+    ) -> Tuple[Optional[DatasetInfo], Optional[Dict], List[str]]:
+        """Find a specific dataset in the tree and return its subtree and path.
+        
+        :param tree: Tree structure to search in.
+        :type tree: Dict[DatasetInfo, Dict]
+        :param target_id: ID of the dataset to find.
+        :type target_id: int
+        :param path: Current path (used for recursion).
+        :type path: List[str], optional
+        :return: Tuple of (found_dataset, its_subtree, path_to_dataset).
+        :rtype: Tuple[Optional[DatasetInfo], Optional[Dict], List[str]]
+        """
+        if path is None:
+            path = []
+            
+        for dataset, children in tree.items():
+            if dataset.id == target_id:
+                return dataset, children, path
+            # Search in children
+            if children:
+                found_dataset, found_children, found_path = self._find_dataset_in_tree(
+                    children, target_id, path + [dataset.name]
+                )
+                if found_dataset is not None:
+                    return found_dataset, found_children, found_path
+        return None, None, []
+
+    def tree(self, project_id: int, dataset_id: Optional[int] = None) -> Generator[Tuple[List[str], DatasetInfo], None, None]:
         """Yields tuples of (path, dataset) for all datasets in the project.
         Path of the dataset is a list of parents, e.g. ["ds1", "ds2", "ds3"].
         For root datasets, the path is an empty list.
 
         :param project_id: Project ID in which the Dataset is located.
         :type project_id: int
+        :param dataset_id: Optional Dataset ID to start the tree from. If provided, only yields
+            the subtree starting from this dataset (including the dataset itself and all its children).
+        :type dataset_id: Optional[int]
         :return: Generator of tuples of (path, dataset).
         :rtype: Generator[Tuple[List[str], DatasetInfo], None, None]
         :Usage example:
@@ -1027,11 +1093,17 @@ class DatasetApi(UpdateableModule, RemoveableModuleApi):
 
             project_id = 123
 
+            # Get all datasets in the project
             for parents, dataset in api.dataset.tree(project_id):
                 parents: List[str]
                 dataset: sly.DatasetInfo
                 print(parents, dataset.name)
 
+            # Get only a specific branch starting from dataset_id = 456
+            for parents, dataset in api.dataset.tree(project_id, dataset_id=456):
+                parents: List[str]
+                dataset: sly.DatasetInfo
+                print(parents, dataset.name)
 
             # Output:
             # [] ds1
@@ -1039,17 +1111,20 @@ class DatasetApi(UpdateableModule, RemoveableModuleApi):
             # ["ds1", "ds2"] ds3
         """
 
-        def yield_tree(
-            tree: Dict[DatasetInfo, Dict], path: List[str]
-        ) -> Generator[Tuple[List[str], DatasetInfo], None, None]:
-            """Yields tuples of (path, dataset) for all datasets in the tree."""
-            for dataset, children in tree.items():
-                yield path, dataset
-                new_path = path + [dataset.name]
-                if children:
-                    yield from yield_tree(children, new_path)
-
-        yield from yield_tree(self.get_tree(project_id), [])
+        full_tree = self.get_tree(project_id)
+        
+        if dataset_id is None:
+            # Return the full tree
+            yield from self._yield_tree(full_tree, [])
+        else:
+            # Find the specific dataset and return only its subtree
+            target_dataset, subtree, dataset_path = self._find_dataset_in_tree(full_tree, dataset_id)
+            if target_dataset is not None:
+                # Yield the target dataset first, then its children
+                yield dataset_path, target_dataset
+                if subtree:
+                    new_path = dataset_path + [target_dataset.name]
+                    yield from self._yield_tree(subtree, new_path)
 
     def get_nested(self, project_id: int, dataset_id: int) -> List[DatasetInfo]:
         """Returns a list of all nested datasets in the specified dataset.

supervisely/api/entity_annotation/figure_api.py

@@ -24,6 +24,7 @@ from requests_toolbelt import MultipartDecoder, MultipartEncoder
 from tqdm import tqdm
 
 from supervisely._utils import batched, logger, run_coroutine
+from supervisely.annotation.label import LabelingStatus
 from supervisely.api.module_api import ApiField, ModuleApi, RemoveableBulkModuleApi
 from supervisely.geometry.rectangle import Rectangle
 from supervisely.video_annotation.key_id_map import KeyIdMap
@@ -221,6 +222,8 @@ class FigureApi(RemoveableBulkModuleApi):
             "meta",
             "area",
             "priority",
+            "nnCreated",
+            "nnUpdated",
         ]
         return self._get_info_by_id(id, "figures.info", {ApiField.FIELDS: fields})
 
@@ -233,6 +236,7 @@ class FigureApi(RemoveableBulkModuleApi):
         geometry_type: str,
         track_id: Optional[int] = None,
         custom_data: Optional[dict] = None,
+        status: Optional[LabelingStatus] = None,
     ) -> int:
         """"""
         input_figure = {
@@ -242,6 +246,13 @@ class FigureApi(RemoveableBulkModuleApi):
             ApiField.GEOMETRY: geometry_json,
         }
 
+        if status is None:
+            status = LabelingStatus.MANUAL
+
+        nn_created, nn_updated = LabelingStatus.to_flags(status)
+        input_figure[ApiField.NN_CREATED] = nn_created
+        input_figure[ApiField.NN_UPDATED] = nn_updated
+
         if track_id is not None:
             input_figure[ApiField.TRACK_ID] = track_id
 
@@ -376,6 +387,8 @@ class FigureApi(RemoveableBulkModuleApi):
             ApiField.AREA,
             ApiField.PRIORITY,
             ApiField.CUSTOM_DATA,
+            ApiField.NN_CREATED,
+            ApiField.NN_UPDATED,
         ]
         figures_infos = self.get_list_all_pages(
             "figures.list",
@@ -496,6 +509,8 @@ class FigureApi(RemoveableBulkModuleApi):
             ApiField.AREA,
             ApiField.PRIORITY,
             ApiField.CUSTOM_DATA,
+            ApiField.NN_CREATED,
+            ApiField.NN_UPDATED,
         ]
         if skip_geometry is True:
             fields = [x for x in fields if x != ApiField.GEOMETRY]
@@ -580,10 +595,13 @@ class FigureApi(RemoveableBulkModuleApi):
         """
         geometries = {}
         for idx, part in self._download_geometries_generator(ids):
-            if progress_cb is not None:
-                progress_cb(len(part.content))
-            geometry_json = json.loads(part.content)
-            geometries[idx] = geometry_json
+            try:
+                if progress_cb is not None:
+                    progress_cb(len(part.content))
+                geometry_json = json.loads(part.content)
+                geometries[idx] = geometry_json
+            except Exception as e:
+                raise RuntimeError(f"Failed to decode geometry for figure ID {idx}") from e
 
         if len(geometries) != len(ids):
             raise RuntimeError("Not all geometries were downloaded")
@@ -800,6 +818,7 @@ class FigureApi(RemoveableBulkModuleApi):
         skip_geometry: bool = False,
         semaphore: Optional[asyncio.Semaphore] = None,
         log_progress: bool = True,
+        batch_size: int = 300,
     ) -> Dict[int, List[FigureInfo]]:
         """
         Asynchronously download figures for the given dataset ID. Can be filtered by image IDs.
@@ -815,6 +834,10 @@ class FigureApi(RemoveableBulkModuleApi):
         :type semaphore: Optional[asyncio.Semaphore], optional
         :param log_progress: If True, log the progress of the download.
         :type log_progress: bool, optional
+        :param batch_size: Size of the batch for downloading figures per 1 request. Default is 300.
+                        Used for batching image_ids when filtering by specific images.
+                        Adjust this value for optimal performance, value cannot exceed 500.
+        :type batch_size: int, optional
         :return: A dictionary where keys are image IDs and values are lists of figures.
         :rtype: Dict[int, List[FigureInfo]]
 
@@ -849,75 +872,110 @@ class FigureApi(RemoveableBulkModuleApi):
             ApiField.AREA,
             ApiField.PRIORITY,
             ApiField.CUSTOM_DATA,
+            ApiField.NN_CREATED,
+            ApiField.NN_UPDATED,
         ]
         if skip_geometry is True:
             fields = [x for x in fields if x != ApiField.GEOMETRY]
 
-        if image_ids is None:
-            filters = []
-        else:
-            filters = [
-                {
-                    ApiField.FIELD: ApiField.ENTITY_ID,
-                    ApiField.OPERATOR: "in",
-                    ApiField.VALUE: image_ids,
-                }
-            ]
-
-        data = {
+        # Base data setup
+        base_data = {
             ApiField.DATASET_ID: dataset_id,
             ApiField.FIELDS: fields,
-            ApiField.FILTER: filters,
         }
 
-        # Get first page to determine total pages
         if semaphore is None:
             semaphore = self._api.get_default_semaphore()
-        images_figures = defaultdict(list)
-        pages_count = None
-        total = 0
-        tasks = []
 
-        async def _get_page(page_data, page_num):
+        async def _get_page_figures(page_data, semaphore, progress_cb: tqdm = None):
+            """Helper function to get figures from a single page"""
             async with semaphore:
                 response = await self._api.post_async("figures.list", page_data)
                 response_json = response.json()
-                nonlocal pages_count, total
-                pages_count = response_json["pagesCount"]
-                if page_num == 1:
-                    total = response_json["total"]
 
                 page_figures = []
                 for info in response_json["entities"]:
                     figure_info = self._convert_json_info(info, True)
                     page_figures.append(figure_info)
+                if progress_cb is not None:
+                    progress_cb.update(len(response_json["entities"]))
                 return page_figures
 
-        # Get first page
-        data[ApiField.PAGE] = 1
-        first_page_figures = await _get_page(data, 1)
+        async def _get_all_pages(ids_filter, progress_cb: tqdm = None):
+            """Internal function to process all pages for given filter"""
+            data = base_data.copy()
+            data[ApiField.FILTER] = ids_filter
+
+            # Get first page to determine pagination
+            data[ApiField.PAGE] = 1
+            async with semaphore:
+                response = await self._api.post_async("figures.list", data)
+                response_json = response.json()
+
+            pages_count = response_json["pagesCount"]
+            all_figures = []
+
+            # Process first page
+            for info in response_json["entities"]:
+                figure_info = self._convert_json_info(info, True)
+                all_figures.append(figure_info)
+            if progress_cb is not None:
+                progress_cb.update(len(response_json["entities"]))
+
+            # Process remaining pages in parallel if needed
+            if pages_count > 1:
+                tasks = []
+                for page in range(2, pages_count + 1):
+                    page_data = data.copy()
+                    page_data[ApiField.PAGE] = page
+                    tasks.append(
+                        asyncio.create_task(
+                            _get_page_figures(page_data, semaphore, progress_cb=progress_cb)
+                        )
+                    )
+
+                if tasks:
+                    page_results = await asyncio.gather(*tasks)
+                    for page_figures in page_results:
+                        all_figures.extend(page_figures)
+
+            return all_figures
 
         if log_progress:
-            progress_cb = tqdm(total=total, desc="Downloading figures")
+            progress_cb = tqdm(desc="Downloading figures", unit="figure", total=0)
+        else:
+            progress_cb = None
 
-        for figure in first_page_figures:
-            images_figures[figure.entity_id].append(figure)
-            if log_progress:
-                progress_cb.update(1)
-
-        # Get rest of the pages in parallel
-        if pages_count > 1:
-            for page in range(2, pages_count + 1):
-                page_data = data.copy()
-                page_data[ApiField.PAGE] = page
-                tasks.append(asyncio.create_task(_get_page(page_data, page)))
-
-            for task in asyncio.as_completed(tasks):
-                page_figures = await task
-                for figure in page_figures:
-                    images_figures[figure.entity_id].append(figure)
-                    if log_progress:
-                        progress_cb.update(1)
+        # Strategy: batch processing based on image_ids
+        tasks = []
+
+        if image_ids is None:
+            # Single task for all figures in dataset
+            filters = []
+            tasks.append(_get_all_pages(filters, progress_cb=progress_cb))
+        else:
+            # Batch image_ids and create tasks for each batch
+            for batch_ids in batched(image_ids, batch_size):
+                filters = [
+                    {
+                        ApiField.FIELD: ApiField.ENTITY_ID,
+                        ApiField.OPERATOR: "in",
+                        ApiField.VALUE: list(batch_ids),
+                    }
+                ]
+                tasks.append(_get_all_pages(filters, progress_cb=progress_cb))
+                # Small delay between batches to reduce server load
+                await asyncio.sleep(0.02)
+
+        # Execute all tasks in parallel and collect results
+        all_results = await asyncio.gather(*tasks)
+
+        # Combine results from all batches
+        images_figures = defaultdict(list)
+
+        for batch_figures in all_results:
+            for figure in batch_figures:
+                images_figures[figure.entity_id].append(figure)
 
         return dict(images_figures)
 
@@ -928,6 +986,7 @@ class FigureApi(RemoveableBulkModuleApi):
         skip_geometry: bool = False,
         semaphore: Optional[asyncio.Semaphore] = None,
         log_progress: bool = True,
+        batch_size: int = 300,
     ) -> Dict[int, List[FigureInfo]]:
         """
         Download figures for the given dataset ID. Can be filtered by image IDs.
@@ -945,6 +1004,10 @@ class FigureApi(RemoveableBulkModuleApi):
         :type semaphore: Optional[asyncio.Semaphore], optional
         :param log_progress: If True, log the progress of the download.
         :type log_progress: bool, optional
+        :param batch_size: Size of the batch for downloading figures per 1 request. Default is 300.
+                        Used for batching image_ids when filtering by specific images.
+                        Adjust this value for optimal performance, value cannot exceed 500.
+        :type batch_size: int, optional
 
         :return: A dictionary where keys are image IDs and values are lists of figures.
         :rtype: Dict[int, List[FigureInfo]]
@@ -970,6 +1033,7 @@ class FigureApi(RemoveableBulkModuleApi):
                     skip_geometry=skip_geometry,
                     semaphore=semaphore,
                     log_progress=log_progress,
+                    batch_size=batch_size,
                 )
             )
         except Exception: