supervisely 6.73.243__py3-none-any.whl → 6.73.245__py3-none-any.whl

supervisely/nn/training/gui/utils.py

@@ -0,0 +1,128 @@
+from typing import Any, Callable, Dict, List, Optional, Tuple
+
+from supervisely.app import DataJson
+from supervisely.app.widgets import Button, Card, Stepper, Text, Widget
+
+button_clicked = {}
+
+
+def update_custom_params(
+    button: Button,
+    params_dct: Dict[str, Any],
+) -> None:
+    button_state = button.get_json_data()
+    for key in params_dct.keys():
+        if key not in button_state:
+            raise AttributeError(f"Parameter {key} doesn't exists.")
+        else:
+            DataJson()[button.widget_id][key] = params_dct[key]
+    DataJson().send_changes()
+
+
+def update_custom_button_params(
+    button: Button,
+    params_dct: Dict[str, Any],
+) -> None:
+    params = params_dct.copy()
+    if "icon" in params and params["icon"] is not None:
+        new_icon = f'<i class="{params["icon"]}" style="margin-right: {button._icon_gap}px"></i>'
+        params["icon"] = new_icon
+    update_custom_params(button, params)
+
+
+def disable_enable(widgets: List[Widget], disable: bool = True):
+    for w in widgets:
+        if disable:
+            w.disable()
+        else:
+            w.enable()
+
+
+def unlock_lock(cards: List[Card], unlock: bool = True, message: str = None):
+    for w in cards:
+        if unlock:
+            w.unlock()
+            # w.uncollapse()
+        else:
+            w.lock(message)
+            # w.collapse()
+
+
+def collapse_uncollapse(cards: List[Card], collapse: bool = True):
+    for w in cards:
+        if collapse:
+            w.collapse()
+        else:
+            w.uncollapse()
+
+
+def wrap_button_click(
+    button: Button,
+    cards_to_unlock: List[Card],
+    widgets_to_disable: List[Widget],
+    callback: Optional[Callable] = None,
+    lock_msg: str = None,
+    upd_params: bool = True,
+    validation_text: Text = None,
+    validation_func: Optional[Callable] = None,
+    on_select_click: Optional[Callable] = None,
+    on_reselect_click: Optional[Callable] = None,
+    collapse_card: Tuple[Card, bool] = None,
+) -> Callable[[Optional[bool]], None]:
+    global button_clicked
+
+    select_params = {"icon": None, "plain": False, "text": "Select"}
+    reselect_params = {"icon": "zmdi zmdi-refresh", "plain": True, "text": "Reselect"}
+    bid = button.widget_id
+    button_clicked[bid] = False
+
+    def button_click(button_clicked_value: Optional[bool] = None):
+        if button_clicked_value is None or button_clicked_value is False:
+            if validation_func is not None:
+                success = validation_func()
+                if not success:
+                    return
+
+        if button_clicked_value is not None:
+            button_clicked[bid] = button_clicked_value
+        else:
+            button_clicked[bid] = not button_clicked[bid]
+
+        if button_clicked[bid] and upd_params:
+            update_custom_button_params(button, reselect_params)
+            if on_select_click is not None:
+                for func in on_select_click:
+                    func()
+        else:
+            update_custom_button_params(button, select_params)
+            if on_reselect_click is not None:
+                for func in on_reselect_click:
+                    func()
+            validation_text.hide()
+
+        unlock_lock(
+            cards_to_unlock,
+            unlock=button_clicked[bid],
+            message=lock_msg,
+        )
+        disable_enable(
+            widgets_to_disable,
+            disable=button_clicked[bid],
+        )
+        if callback is not None and not button_clicked[bid]:
+            callback(False)
+
+        if collapse_card is not None:
+            card, collapse = collapse_card
+            if collapse:
+                collapse_uncollapse([card], collapse)
+
+    return button_click
+
+
+def set_stepper_step(stepper: Stepper, button: Button, next_pos: int):
+    bid = button.widget_id
+    if button_clicked[bid] is True:
+        stepper.set_active_step(next_pos)
+    else:
+        stepper.set_active_step(next_pos - 1)

supervisely/nn/training/loggers/base_train_logger.py

@@ -0,0 +1,58 @@
+from typing import Callable
+
+
+class BaseTrainLogger:
+    def __init__(self):
+        self._on_train_started_callbacks = []
+        self._on_train_finished_callbacks = []
+        self._on_epoch_started_callbacks = []
+        self._on_epoch_finished_callbacks = []
+        self._on_step_callbacks = []
+        self.epoch_idx = 0
+        self.step_idx = 0
+
+    def train_started(self, total_epochs: int):
+        for callback in self._on_train_started_callbacks:
+            callback(total_epochs)
+
+    def train_finished(self):
+        for callback in self._on_train_finished_callbacks:
+            callback()
+
+    def epoch_started(self, total_steps: int):
+        for callback in self._on_epoch_started_callbacks:
+            callback(total_steps)
+
+    def epoch_finished(self):
+        self.epoch_idx += 1
+        for callback in self._on_epoch_finished_callbacks:
+            callback()
+
+    def on_step_end(self):
+        self.step_idx += 1
+        for callback in self._on_step_callbacks:
+            callback()
+
+    def add_on_train_started_callback(self, callback: Callable):
+        self._on_train_started_callbacks.append(callback)
+
+    def add_on_train_finish_callback(self, callback: Callable):
+        self._on_train_finished_callbacks.append(callback)
+
+    def add_on_epoch_started_callback(self, callback: Callable):
+        self._on_epoch_started_callbacks.append(callback)
+
+    def add_on_epoch_finish_callback(self, callback: Callable):
+        self._on_epoch_finished_callbacks.append(callback)
+
+    def add_on_step_callback(self, callback: Callable):
+        self._on_step_callbacks.append(callback)
+
+    def log(self, logs: dict, idx: int):
+        raise NotImplementedError
+
+    def log_step(self, logs: dict):
+        raise NotImplementedError
+
+    def log_epoch(self, logs: dict):
+        raise NotImplementedError

supervisely/nn/training/loggers/tensorboard_logger.py

@@ -0,0 +1,46 @@
+from supervisely import logger
+
+try:
+    from tensorboardX import SummaryWriter
+    _tensorboard_supported = True
+except ImportError:
+    logger.warning("TensorboardX is not installed. TensorboardLogger will not work.")
+    _tensorboard_supported = False
+
+from supervisely.nn.training.loggers.base_train_logger import BaseTrainLogger
+
+
+class TensorboardLogger(BaseTrainLogger):
+    def __init__(self, log_dir=None):
+        if log_dir is None:
+            self.log_dir = None
+            self.writer = None
+        else:
+            self.log_dir = log_dir
+            self.writer = SummaryWriter(log_dir)
+        super().__init__()
+
+    def set_log_dir(self, log_dir):
+        self.log_dir = log_dir
+        self.writer = SummaryWriter(log_dir)
+    
+    def close(self):
+        if self.writer is not None:
+            self.writer.close()
+        self.writer = None
+
+    def log(self, logs: dict, idx: int):
+        for key, value in logs.items():
+            if isinstance(value, (int, float)):
+                self.writer.add_scalar(key, value, idx)
+        self.writer.flush()
+
+    def log_step(self, logs: dict):
+        self.log(logs, self.step_idx)
+
+    def log_epoch(self, logs: dict):
+        self.log(logs, self.epoch_idx)
+
+
+if _tensorboard_supported:
+    tb_logger = TensorboardLogger()