supervisely 6.73.213__py3-none-any.whl → 6.73.215__py3-none-any.whl

supervisely/app/widgets/report_thumbnail/report_thumbnail.py

@@ -1,32 +1,44 @@
-import os
+from typing import Optional
 
 from supervisely._utils import abs_url, is_debug_with_sly_net, is_development
 from supervisely.api.file_api import FileInfo
 from supervisely.app import DataJson
 from supervisely.app.widgets import Widget
+from supervisely.imaging.color import _validate_hex_color
 
 
 class ReportThumbnail(Widget):
-    def __init__(self, info: FileInfo = None, widget_id: str = None):
+
+    def __init__(
+        self,
+        info: Optional[FileInfo] = None,
+        widget_id: Optional[str] = None,
+        title: Optional[str] = None,
+        color: Optional[str] = "#dcb0ff",
+        bg_color: Optional[str] = "#faebff",
+    ):
         self._id: int = None
         self._info: FileInfo = None
         self._description: str = None
         self._url: str = None
         self._set_info(info)
+        self._title = title
+        self._color = color if _validate_hex_color(color) else "#dcb0ff"
+        self._bg_color = bg_color if _validate_hex_color(bg_color) else "#faebff"
 
         super().__init__(widget_id=widget_id, file_path=__file__)
 
     def get_json_data(self):
         return {
             "id": self._id,
-            "name": "Evaluation Report",
+            "name": self._title or "Evaluation Report",
             "description": self._description,
             "url": self._url,
             "description": self._description,
             "icon": {
                 "className": "zmdi zmdi-assignment",
-                "color": "#dcb0ff",
-                "bgColor": "#faebff",
+                "color": self._color,
+                "bgColor": self._bg_color,
             },
         }
 

supervisely/app/widgets/team_files_selector/team_files_selector.py

@@ -23,6 +23,7 @@ class TeamFilesSelector(Widget):
             Literal["id", "createdAt", "updatedAt", "type", "size", "mimeType"]
         ] = [],
         widget_id: str = None,
+        initial_folder: str = None,
     ):
         self._api = Api()
         self._team_id = team_id
@@ -42,6 +43,7 @@ class TeamFilesSelector(Widget):
 
         self._additional_fields = additional_fields
         self._selected = []
+        self._initial_folder = initial_folder or "/"
 
         super().__init__(widget_id=widget_id, file_path=__file__)
 
@@ -55,6 +57,7 @@ class TeamFilesSelector(Widget):
                 "hideHeader": self._hide_header,
                 "hideEmptyTable": self._hide_empty_table,
                 "additionalFields": self._additional_fields,
+                "initialFolder": {"path": self._initial_folder},
             },
         }
 

supervisely/io/network_exceptions.py

@@ -1,14 +1,17 @@
 # coding: utf-8
 
+import time
 import traceback
+
 import requests
-import time
 
-CONNECTION_ERROR = 'Temporary connection error, please wait ...'
-AGENT_CONNECTION_ERROR = 'Temporary connection error (agent ping), please wait ...'
+CONNECTION_ERROR = "Temporary connection error, please wait ..."
+AGENT_CONNECTION_ERROR = "Temporary connection error (agent ping), please wait ..."
 
-REQUEST_FAILED = 'Request has failed. This may be due to connection problems or invalid requests. '
-SPECIAL_RECONNECT_ERROR = "Agent should call AgentConnected or AgentPing before attempting any other request"
+REQUEST_FAILED = "Request has failed. This may be due to connection problems or invalid requests. "
+SPECIAL_RECONNECT_ERROR = (
+    "Agent should call AgentConnected or AgentPing before attempting any other request"
+)
 RETRY_STATUS_CODES = {
     408,  # Request Timeout
     429,  # Too Many Requests
@@ -19,51 +22,100 @@ RETRY_STATUS_CODES = {
     504,  # Gateway Timeout
     509,  # Bandwidth Limit Exceeded (Apache)
     598,  # Network read timeout error
-    599   # Network connect timeout error
+    599,  # Network connect timeout error
 }
 
 
-def process_requests_exception(external_logger, exc, api_method_name, url,
-                               verbose=True, swallow_exc=False, sleep_sec=None, response=None, retry_info=None):
-    is_connection_error = isinstance(exc, (requests.exceptions.ConnectionError,
-                                           requests.exceptions.Timeout,
-                                           requests.exceptions.TooManyRedirects,
-                                           requests.exceptions.ChunkedEncodingError))
-
-    is_server_retryable_error = isinstance(exc, requests.exceptions.HTTPError) and \
-                                hasattr(exc, 'response') and \
-                                (exc.response.status_code in RETRY_STATUS_CODES)
+def process_requests_exception(
+    external_logger,
+    exc,
+    api_method_name,
+    url,
+    verbose=True,
+    swallow_exc=False,
+    sleep_sec=None,
+    response=None,
+    retry_info=None,
+):
+    is_connection_error = isinstance(
+        exc,
+        (
+            requests.exceptions.ConnectionError,
+            requests.exceptions.Timeout,
+            requests.exceptions.TooManyRedirects,
+            requests.exceptions.ChunkedEncodingError,
+        ),
+    )
+
+    is_server_retryable_error = (
+        isinstance(exc, requests.exceptions.HTTPError)
+        and hasattr(exc, "response")
+        and (exc.response.status_code in RETRY_STATUS_CODES)
+    )
 
     is_need_ping_error = False
-    if isinstance(exc, requests.exceptions.HTTPError) and hasattr(exc, 'response') and (exc.response.status_code == 400):
+    if (
+        isinstance(exc, requests.exceptions.HTTPError)
+        and hasattr(exc, "response")
+        and (exc.response.status_code == 400)
+    ):
         try:
             server_explanation = exc.response.json()
-            is_need_ping_error = (server_explanation.get('error', None) == SPECIAL_RECONNECT_ERROR)
+            is_need_ping_error = server_explanation.get("error", None) == SPECIAL_RECONNECT_ERROR
         except (AttributeError, ValueError):
             pass
 
     if is_connection_error or is_server_retryable_error:
-        process_retryable_request(external_logger, exc, api_method_name, url,
-                                  CONNECTION_ERROR,
-                                  verbose=verbose, swallow_exc=swallow_exc, sleep_sec=sleep_sec, retry_info=retry_info)
+        process_retryable_request(
+            external_logger,
+            exc,
+            api_method_name,
+            url,
+            CONNECTION_ERROR,
+            verbose=verbose,
+            swallow_exc=swallow_exc,
+            sleep_sec=sleep_sec,
+            retry_info=retry_info,
+        )
     elif is_need_ping_error:
-        process_retryable_request(external_logger, exc, api_method_name, url,
-                                  AGENT_CONNECTION_ERROR,
-                                  verbose=verbose, swallow_exc=swallow_exc, sleep_sec=sleep_sec, retry_info=retry_info)
+        process_retryable_request(
+            external_logger,
+            exc,
+            api_method_name,
+            url,
+            AGENT_CONNECTION_ERROR,
+            verbose=verbose,
+            swallow_exc=swallow_exc,
+            sleep_sec=sleep_sec,
+            retry_info=retry_info,
+        )
+    elif response is None:
+        process_unhandled_request(external_logger, exc)
     elif isinstance(exc, requests.exceptions.HTTPError):
         process_invalid_request(external_logger, exc, response, verbose)
     else:
         process_unhandled_request(external_logger, exc)
 
 
-def process_retryable_request(external_logger, exc, api_method_name, url, user_message,
-                              verbose=True, swallow_exc=False, sleep_sec=None, retry_info=None):
+def process_retryable_request(
+    external_logger,
+    exc,
+    api_method_name,
+    url,
+    user_message,
+    verbose=True,
+    swallow_exc=False,
+    sleep_sec=None,
+    retry_info=None,
+):
     if retry_info is not None:
         retry_idx = retry_info["retry_idx"]
         retry_limit = retry_info["retry_limit"]
         user_message = "{}:  Retrying ({}/{}).".format(user_message, retry_idx, retry_limit)
     if verbose:
-        external_logger.warn(user_message, extra={'method': api_method_name, 'url': url, 'details': str(exc)})
+        external_logger.warn(
+            user_message, extra={"method": api_method_name, "url": url, "details": str(exc)}
+        )
 
     if sleep_sec is not None:
         time.sleep(sleep_sec)
@@ -74,13 +126,18 @@ def process_retryable_request(external_logger, exc, api_method_name, url, user_m
 
 def process_invalid_request(external_logger, exc, response, verbose=True):
     if verbose:
-        external_logger.warn(REQUEST_FAILED, extra={'reason': response.content.decode('utf-8'),
-                                                    'status_code': response.status_code,
-                                                    'url': response.url})
+        external_logger.warn(
+            REQUEST_FAILED,
+            extra={
+                "reason": response.content.decode("utf-8"),
+                "status_code": response.status_code,
+                "url": response.url,
+            },
+        )
     raise exc
 
 
 def process_unhandled_request(external_logger, exc):
     exc_str = str(exc)
-    external_logger.error(traceback.format_exc(), exc_info=True, extra={'exc_str': exc_str})
-    raise RuntimeError(REQUEST_FAILED + 'Last failure: {!r}'.format(exc_str))
+    external_logger.error(traceback.format_exc(), exc_info=True, extra={"exc_str": exc_str})
+    raise RuntimeError(REQUEST_FAILED + "Last failure: {!r}".format(exc_str))