supervisely 6.73.227__py3-none-any.whl → 6.73.229__py3-none-any.whl

supervisely/__init__.py

@@ -309,4 +309,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.11.16"
+os.environ["MINIMUM_INSTANCE_VERSION_FOR_SDK"] = "6.12.5"

supervisely/_utils.py

@@ -14,7 +14,7 @@ import urllib
 from datetime import datetime
 from functools import wraps
 from tempfile import gettempdir
-from typing import List, Literal, Optional
+from typing import Any, Dict, List, Literal, Optional, Tuple
 
 import numpy as np
 from requests.utils import DEFAULT_CA_BUNDLE_PATH
@@ -316,6 +316,15 @@ def get_readable_datetime(value: str) -> str:
     return dt.strftime("%Y-%m-%d %H:%M:%S")
 
 
+def get_unix_timestamp() -> int:
+    """Return the current Unix timestamp.
+
+    :return: Current Unix timestamp.
+    :rtype: int
+    """
+    return int(time.time())
+
+
 def get_certificates_list(path: str = DEFAULT_CA_BUNDLE_PATH) -> List[str]:
     with open(path, "r", encoding="ascii") as f:
         content = f.read().strip()
@@ -385,6 +394,51 @@ def add_callback(func, callback):
     return wrapper
 
 
+def compare_dicts(
+    template: Dict[Any, Any], data: Dict[Any, Any], strict: bool = True
+) -> Tuple[List[str], List[str]]:
+    """Compare two dictionaries recursively (by keys only) and return lists of missing and extra fields.
+    If strict is True, the keys of the template and data dictionaries must match exactly.
+    Otherwise, the data dictionary may contain additional keys that are not in the template dictionary.
+
+    :param template: The template dictionary.
+    :type template: Dict[Any, Any]
+    :param data: The data dictionary.
+    :type data: Dict[Any, Any]
+    :param strict: If True, the keys of the template and data dictionaries must match exactly.
+    :type strict: bool, optional
+    :return: A tuple containing a list of missing fields and a list of extra fields.
+    :rtype: Tuple[List[str], List[str]]
+    """
+    missing_fields = []
+    extra_fields = []
+
+    if not isinstance(template, dict) or not isinstance(data, dict):
+        return missing_fields, extra_fields
+
+    if strict:
+        template_keys = set(template.keys())
+        data_keys = set(data.keys())
+
+        missing_fields = list(template_keys - data_keys)
+        extra_fields = list(data_keys - template_keys)
+
+        for key in template_keys & data_keys:
+            sub_missing, sub_extra = compare_dicts(template[key], data[key], strict)
+            missing_fields.extend([f"{key}.{m}" for m in sub_missing])
+            extra_fields.extend([f"{key}.{e}" for e in sub_extra])
+    else:
+        for key in template:
+            if key not in data:
+                missing_fields.append(key)
+            else:
+                sub_missing, sub_extra = compare_dicts(template[key], data[key], strict)
+                missing_fields.extend([f"{key}.{m}" for m in sub_missing])
+                extra_fields.extend([f"{key}.{e}" for e in sub_extra])
+
+    return missing_fields, extra_fields
+
+
 def get_or_create_event_loop() -> asyncio.AbstractEventLoop:
     """
     Get the current event loop or create a new one if it doesn't exist.

supervisely/api/annotation_api.py

@@ -1388,7 +1388,7 @@ class AnnotationApi(ModuleApi):
             ann_info = loop.run_until_complete(api.annotation.download_async(image_id))
         """
         if semaphore is None:
-            semaphore = self._api._get_default_semaphore()
+            semaphore = self._api.get_default_semaphore()
         async with semaphore:
             response = await self._api.post_async(
                 "annotations.info",
@@ -1501,7 +1501,7 @@ class AnnotationApi(ModuleApi):
             context["project_meta"] = project_meta
 
         if semaphore is None:
-            semaphore = self._api._get_default_semaphore()
+            semaphore = self._api.get_default_semaphore()
         tasks = []
         for image in image_ids:
             task = self.download_async(

supervisely/api/api.py

@@ -377,6 +377,7 @@ class Api:
 
         self.async_httpx_client: httpx.AsyncClient = None
         self.httpx_client: httpx.Client = None
+        self._semaphore = None
 
     @classmethod
     def normalize_server_address(cls, server_address: str) -> str:
@@ -999,7 +1000,10 @@ class Api:
     def post_httpx(
         self,
         method: str,
-        data: Union[bytes, Dict],
+        json: Dict = None,
+        content: Union[str, bytes, Iterable[bytes], AsyncIterable[bytes]] = None,
+        files: Union[Mapping] = None,
+        params: Union[str, bytes] = None,
         headers: Optional[Dict[str, str]] = None,
         retries: Optional[int] = None,
         raise_error: Optional[bool] = False,
@@ -1009,8 +1013,14 @@ class Api:
 
         :param method: Method name.
         :type method: str
-        :param data: Bytes with data content or dictionary with params.
-        :type data: bytes or dict
+        :param json: Dictionary to send in the body of request.
+        :type json: dict, optional
+        :param content: Bytes with data content or dictionary with params.
+        :type content: bytes or dict, optional
+        :param files: Files to send in the body of request.
+        :type files: dict, optional
+        :param params: URL query parameters.
+        :type params: str, bytes, optional
         :param headers: Custom headers to include in the request.
         :type headers: dict, optional
         :param retries: The number of attempts to connect to the server.
@@ -1021,6 +1031,7 @@ class Api:
         :rtype: :class:`httpx.Response`
         """
         self._set_client()
+
         if retries is None:
             retries = self.retry_count
 
@@ -1032,18 +1043,17 @@ class Api:
         else:
             headers = {**self.headers, **headers}
 
-        if isinstance(data, bytes):
-            request_params = {"content": data}
-        elif isinstance(data, Dict):
-            json_body = {**data, **self.additional_fields}
-            request_params = {"json": json_body}
-        else:
-            request_params = {"params": data}
-
         for retry_idx in range(retries):
             response = None
             try:
-                response = self.httpx_client.post(url, headers=headers, **request_params)
+                response = self.httpx_client.post(
+                    url,
+                    content=content,
+                    files=files,
+                    json=json,
+                    params=params,
+                    headers=headers,
+                )
                 if response.status_code != httpx.codes.OK:
                     self._check_version()
                     Api._raise_for_status_httpx(response)
@@ -1065,9 +1075,8 @@ class Api:
                     )
             except Exception as exc:
                 process_unhandled_request(self.logger, exc)
-        raise httpx.HTTPStatusError(
-            "Retry limit exceeded ({!r})".format(url),
-            response=response,
+        raise httpx.RequestError(
+            f"Retry limit exceeded ({url})",
             request=getattr(response, "request", None),
         )
 
@@ -1093,6 +1102,7 @@ class Api:
         :rtype: :class:`Response<Response>`
         """
         self._set_client()
+
         if retries is None:
             retries = self.retry_count
 
@@ -1171,8 +1181,8 @@ class Api:
         :return: Generator object.
         :rtype: :class:`Generator`
         """
-
         self._set_client()
+
         if retries is None:
             retries = self.retry_count
 
@@ -1408,14 +1418,13 @@ class Api:
         url = self.api_server_address + "/v3/" + method
         if not use_public_api:
             url = os.path.join(self.server_address, method)
+        logger.trace(f"{method_type} {url}")
 
         if headers is None:
             headers = self.headers.copy()
         else:
             headers = {**self.headers, **headers}
 
-        logger.trace(f"{method_type} {url}")
-
         if isinstance(data, (bytes, Generator)):
             content = data
             json_body = None
@@ -1506,42 +1515,80 @@ class Api:
 
     def _set_async_client(self):
         """
-        Set async httpx client if it is not set yet.
-        Switch on HTTP/2 if the server address uses HTTPS.
+        Set async httpx client with HTTP/2 if it is not set yet.
         """
         if self.async_httpx_client is None:
-            self._check_https_redirect()
-            if self.server_address.startswith("https://"):
-                self.async_httpx_client = httpx.AsyncClient(http2=True)
-            else:
-                self.async_httpx_client = httpx.AsyncClient()
+            self.async_httpx_client = httpx.AsyncClient(http2=True)
 
     def _set_client(self):
         """
-        Set httpx client if it is not set yet.
-        Switch on HTTP/2 if the server address uses HTTPS.
+        Set sync httpx client with HTTP/2 if it is not set yet.
         """
         if self.httpx_client is None:
-            self._check_https_redirect()
-            if self.server_address.startswith("https://"):
-                self.httpx_client = httpx.Client(http2=True)
-            else:
-                self.httpx_client = httpx.Client()
+            self.httpx_client = httpx.Client(http2=True)
+
+    def get_default_semaphore(self) -> asyncio.Semaphore:
+        """
+        Get default global API semaphore for async requests.
+        If the semaphore is not set, it will be initialized.
+
+        During initialization, the semaphore size will be set from the environment variable SUPERVISELY_ASYNC_SEMAPHORE.
+        If the environment variable is not set, the default value will be set based on the server address.
+        Depending on the server address, the semaphore size will be set to 10 for HTTPS and 5 for HTTP.
+
+        :return: Semaphore object.
+        :rtype: :class:`asyncio.Semaphore`
+        """
+        if self._semaphore is None:
+            self._initialize_semaphore()
+        return self._semaphore
 
-    def _get_default_semaphore(self):
+    def _initialize_semaphore(self):
         """
-        Get default semaphore for async requests.
-        Check if the environment variable SUPERVISELY_ASYNC_SEMAPHORE is set.
-        If it is set, create a semaphore with the given value.
-        Otherwise, create a semaphore with a default value.
-        If server supports HTTPS, create a semaphore with a higher value.
+        Initialize the semaphore for async requests.
+
+        If the environment variable SUPERVISELY_ASYNC_SEMAPHORE is set, create a semaphore with the given value.
+
+        Otherwise, create a semaphore with a default value:
+
+            - If server supports HTTPS, create a semaphore with value 10.
+            - If server supports HTTP, create a semaphore with value 5.
         """
-        env_semaphore = os.getenv("SUPERVISELY_ASYNC_SEMAPHORE")
-        if env_semaphore is not None:
-            return asyncio.Semaphore(int(env_semaphore))
+        semaphore_size = sly_env.semaphore_size()
+        if semaphore_size is not None:
+            self._semaphore = asyncio.Semaphore(semaphore_size)
+            logger.debug(
+                f"Setting global API semaphore size to {semaphore_size} from environment variable"
+            )
         else:
             self._check_https_redirect()
             if self.server_address.startswith("https://"):
-                return asyncio.Semaphore(25)
+                self._semaphore = asyncio.Semaphore(10)
+                logger.debug("Setting global API semaphore size to 10 for HTTPS")
             else:
-                return asyncio.Semaphore(5)
+                self._semaphore = asyncio.Semaphore(5)
+                logger.debug("Setting global API semaphore size to 5 for HTTP")
+
+    def set_semaphore_size(self, size: int = None):
+        """
+        Set the global API semaphore with the given size. Will replace the existing semaphore.
+        If the size is not set, will set from the environment variable SUPERVISELY_ASYNC_SEMAPHORE.
+        If the environment variable is not set, will set the default value.
+
+        :param size: Size of the semaphore.
+        :type size: int, optional
+        """
+        if size is not None:
+            self._semaphore = asyncio.Semaphore(size)
+        else:
+            self._initialize_semaphore()
+
+    @property
+    def semaphore(self) -> asyncio.Semaphore:
+        """
+        Get the global API semaphore for async requests.
+
+        :return: Semaphore object.
+        :rtype: :class:`asyncio.Semaphore`
+        """
+        return self._semaphore

supervisely/api/app_api.py

@@ -551,7 +551,7 @@ class AppApi(TaskApi):
 
         def is_enabled(self) -> bool:
             """Check if the workflow functionality is enabled."""
-            logger.info(f"Workflow check: is {'enabled' if self._enabled else 'disabled'}.")
+            logger.debug(f"Workflow check: is {'enabled' if self._enabled else 'disabled'}.")
             return self._enabled
 
         # pylint: disable=no-self-argument
@@ -579,8 +579,8 @@ class AppApi(TaskApi):
                         ):
                             self.__last_warning_time = time.monotonic()
                             logger.warning(
-                                "Workflow is disabled in development mode. "
-                                "To enable it, use `api.app.workflow.enable()` right after Api initialization."
+                                "Workflow is disabled. "
+                                "To enable it, use `api.app.workflow.enable()`."
                             )
                         return
                     if not check_workflow_compatibility(self._api, version_to_check):

supervisely/api/dataset_api.py

@@ -4,7 +4,17 @@
 # docs
 from __future__ import annotations
 
-from typing import Dict, Generator, List, Literal, NamedTuple, Optional, Tuple, Union
+from typing import (
+    Any,
+    Dict,
+    Generator,
+    List,
+    Literal,
+    NamedTuple,
+    Optional,
+    Tuple,
+    Union,
+)
 
 from supervisely._utils import abs_url, compress_image_url, is_development
 from supervisely.api.module_api import (
@@ -61,6 +71,7 @@ class DatasetInfo(NamedTuple):
     team_id: int
     workspace_id: int
     parent_id: Union[int, None]
+    custom_data: dict
 
     @property
     def image_preview_url(self):
@@ -135,6 +146,7 @@ class DatasetApi(UpdateableModule, RemoveableModuleApi):
             ApiField.TEAM_ID,
             ApiField.WORKSPACE_ID,
             ApiField.PARENT_ID,
+            ApiField.CUSTOM_DATA,
         ]
 
     @staticmethod
@@ -362,6 +374,83 @@ class DatasetApi(UpdateableModule, RemoveableModuleApi):
             )
         return dataset_info
 
+    def update(
+        self,
+        id: int,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        custom_data: Optional[Dict[Any, Any]] = None,
+    ) -> DatasetInfo:
+        """Update Dataset information by given ID.
+
+        :param id: Dataset ID in Supervisely.
+        :type id: int
+        :param name: New Dataset name.
+        :type name: str, optional
+        :param description: New Dataset description.
+        :type description: str, optional
+        :param custom_data: New custom data.
+        :type custom_data: Dict[Any, Any], optional
+        :return: Information about Dataset. See :class:`info_sequence<info_sequence>`
+        :rtype: :class:`DatasetInfo`
+
+        :Usage example:
+
+             .. code-block:: python
+
+                import supervisely as sly
+
+                dataset_id = 384126
+
+                os.environ['SERVER_ADDRESS'] = 'https://app.supervisely.com'
+                os.environ['API_TOKEN'] = 'Your Supervisely API Token'
+                api = sly.Api.from_env()
+
+                new_ds = api.dataset.update(dataset_id, name='new_ds', description='new description')
+        """
+        fields = [name, description, custom_data]  # Extend later if needed.
+        if all(f is None for f in fields):
+            raise ValueError(f"At least one of the fields must be specified: {fields}")
+
+        payload = {
+            ApiField.ID: id,
+            ApiField.NAME: name,
+            ApiField.DESCRIPTION: description,
+            ApiField.CUSTOM_DATA: custom_data,
+        }
+
+        payload = {k: v for k, v in payload.items() if v is not None}
+
+        response = self._api.post(self._get_update_method(), payload)
+        return self._convert_json_info(response.json())
+
+    def update_custom_data(self, id: int, custom_data: Dict[Any, Any]) -> DatasetInfo:
+        """Update custom data for Dataset by given ID.
+        Custom data is a dictionary that can store any additional information about the Dataset.
+
+        :param id: Dataset ID in Supervisely.
+        :type id: int
+        :param custom_data: New custom data.
+        :type custom_data: Dict[Any, Any]
+        :return: Information about Dataset. See :class:`info_sequence<info_sequence>`
+        :rtype: :class:`DatasetInfo`
+
+        :Usage example:
+
+         .. code-block:: python
+
+            import supervisely as sly
+
+            dataset_id = 384126
+
+            os.environ['SERVER_ADDRESS'] = 'https://app.supervisely.com'
+            os.environ['API_TOKEN'] = 'Your Supervisely API Token'
+            api = sly.Api.from_env()
+
+            new_ds = api.dataset.update_custom_data(dataset_id, custom_data={'key': 'value'})
+        """
+        return self.update(id, custom_data=custom_data)
+
     def _get_update_method(self):
         """ """
         return "datasets.editInfo"

supervisely/api/file_api.py

@@ -1646,7 +1646,7 @@ class FileApi(ModuleApiBase):
             loop.run_until_complete(api.file.download_async(8, path_to_file, local_save_path))
         """
         if semaphore is None:
-            semaphore = self._api._get_default_semaphore()
+            semaphore = self._api.get_default_semaphore()
         async with semaphore:
             if self.is_on_agent(remote_path):
                 # for optimized download from agent
@@ -1774,7 +1774,7 @@ class FileApi(ModuleApiBase):
             )
 
         if semaphore is None:
-            semaphore = self._api._get_default_semaphore()
+            semaphore = self._api.get_default_semaphore()
 
         tasks = []
         for remote_path, local_path, cache in zip(
@@ -1836,7 +1836,7 @@ class FileApi(ModuleApiBase):
         """
 
         if semaphore is None:
-            semaphore = self._api._get_default_semaphore()
+            semaphore = self._api.get_default_semaphore()
 
         if not remote_path.endswith("/"):
             remote_path += "/"
@@ -1925,7 +1925,7 @@ class FileApi(ModuleApiBase):
         """
 
         if semaphore is None:
-            semaphore = self._api._get_default_semaphore()
+            semaphore = self._api.get_default_semaphore()
 
         remote_file_path = env.file(raise_not_found=False)
         remote_folder_path = env.folder(raise_not_found=False)
@@ -2061,7 +2061,7 @@ class FileApi(ModuleApiBase):
             # "sha256": sha256, #TODO add with resumaple api
         }
         if semaphore is None:
-            semaphore = self._api._get_default_semaphore()
+            semaphore = self._api.get_default_semaphore()
         async with semaphore:
             async with aiofiles.open(src, "rb") as fd:
                 item = await fd.read()
@@ -2129,7 +2129,7 @@ class FileApi(ModuleApiBase):
                 )
         """
         if semaphore is None:
-            semaphore = self._api._get_default_semaphore()
+            semaphore = self._api.get_default_semaphore()
         tasks = []
         for s, d in zip(src_paths, dst_paths):
             task = self.upload_async(