Create get_clearml_task for Ignite.contrib.handlers.ClearMLLogger

ignite/contrib/handlers/clearml_logger.py

@@ -125,29 +125,16 @@ def __init__(self, **kwargs: Any):
         if self.bypass_mode():
             warnings.warn("ClearMLSaver: running in bypass mode")
 
-            class _Stub(object):
-                def __call__(self, *_: Any, **__: Any) -> "_Stub":
-                    return self
-
-                def __getattr__(self, attr: str) -> "_Stub":
-                    if attr in ("name", "id"):
-                        return ""  # type: ignore[return-value]
-                    return self
-
-                def __setattr__(self, attr: str, val: Any) -> None:
-                    pass
-
-            self._task = _Stub()
-        else:
-            # Try to retrieve current the ClearML Task before trying to create a new one
-            self._task = Task.current_task()
-            if self._task is None:
-                self._task = Task.init(
-                    project_name=kwargs.get("project_name"),
-                    task_name=kwargs.get("task_name"),
-                    task_type=kwargs.get("task_type", Task.TaskTypes.training),
-                    **experiment_kwargs,
-                )
+        # Try to retrieve current the ClearML Task before trying to create a new one
+        self._task = Task.current_task()
+
+        if self._task is None:
+            self._task = Task.init(
+                project_name=kwargs.get("project_name"),
+                task_name=kwargs.get("task_name"),
+                task_type=kwargs.get("task_type", Task.TaskTypes.training),
+                **experiment_kwargs,
+            )
 
         self.clearml_logger = self._task.get_logger()
 
@@ -156,13 +143,20 @@ def __setattr__(self, attr: str, val: Any) -> None:
     @classmethod
     def set_bypass_mode(cls, bypass: bool) -> None:
         """
-        Will bypass all outside communication, and will drop all logs.
+        Set ``clearml.Task`` to offline mode.
+        Will bypass all outside communication, and will save all data and logs to a local session folder.
         Should only be used in "standalone mode", when there is no access to the *clearml-server*.
 
         Args:
             bypass: If ``True``, all outside communication is skipped.
+                Data and logs will be stored in a local session folder.
+                For more information, please refer to `ClearML docs
+                <https://clear.ml/docs/latest/docs/clearml_sdk/task_sdk/#offline-mode>`_.
         """
+        from clearml import Task
+
         setattr(cls, "_bypass", bypass)
+        return Task.set_offline(offline_mode=bypass)
 
     @classmethod
     def bypass_mode(cls) -> bool:
@@ -172,12 +166,32 @@ def bypass_mode(cls) -> bool:
         Note:
             `GITHUB_ACTIONS` env will automatically set bypass_mode to ``True``
             unless overridden specifically with ``ClearMLLogger.set_bypass_mode(False)``.
+            For more information, please refer to `ClearML docs
+            <https://clear.ml/docs/latest/docs/clearml_sdk/task_sdk/#offline-mode>`_.
 
         Return:
-            If True, all outside communication is skipped.
+            If True, ``clearml.Task`` is on offline mode, and all outside communication is skipped.
         """
         return getattr(cls, "_bypass", bool(os.environ.get("CI")))
 
+    def __getattr__(self, attr: Any) -> Any:
+        """
+        Calls the corresponding method of ``clearml.Logger``.
+
+        Args:
+            attr: methods of the ``clearml.Logger`` class.
+        """
+        return getattr(self.clearml_logger, attr)
+
+    def get_task(self) -> Any:
+        """
+        Returns the task context that the logger is reporting.
+
+        Return:
+            Returns the current task, equivalent to ``clearml.Task.current_task()``.
+        """
+        return self._task
+
     def close(self) -> None:
         self.clearml_logger.flush()
 

tests/ignite/contrib/handlers/test_clearml_logger.py

@@ -718,7 +718,8 @@ def update_fn(engine, batch):
 
         def dummy_handler(engine, logger, event_name):
             global_step = engine.state.get_event_attrib_value(event_name)
-            logger.clearml_logger.report_scalar(title="", series="", value="test_value", iteration=global_step)
+            test_value = 0.3  # example
+            logger.clearml_logger.report_scalar(title="", series="", value=test_value, iteration=global_step)
 
         logger.attach(trainer, log_handler=dummy_handler, event_name=Events.EPOCH_COMPLETED)
 
@@ -745,13 +746,47 @@ def update_fn(engine, batch):
 
             def dummy_handler(engine, logger, event_name):
                 global_step = engine.state.get_event_attrib_value(event_name)
-                logger.clearml_logger.report_scalar(title="", series="", value="test_value", iteration=global_step)
+                test_value = 0.3  # example
+                logger.clearml_logger.report_scalar(title="", series="", value=test_value, iteration=global_step)
 
             clearml_logger.attach(trainer, log_handler=dummy_handler, event_name=Events.EPOCH_COMPLETED)
 
             trainer.run(data, max_epochs=n_epochs)
 
 
+def test_clearml_logger_getattr_method(dirname):
+
+    with pytest.warns(UserWarning, match="ClearMLSaver: running in bypass mode"):
+        ClearMLLogger.set_bypass_mode(True)
+
+        logger = ClearMLLogger(output_uri=dirname)
+
+        # Create a mock clearml.Logger() object
+        mock_logger = MagicMock()
+        logger.clearml_logger = mock_logger
+
+        # Test a method called by __getattr__ calls the corresponding method of the mock project.
+        logger.report_single_value("accuracy", 0.72)
+        mock_logger.report_single_value.assert_called_once_with("accuracy", 0.72)
+
+        # Test a method called by __getattr__ calls the corresponding classmethod of the mock project's class.
+        logger.current_logger()
+        mock_logger.current_logger.assert_called_once()
+
+        logger.close()
+
+
+def test_clearml_logger_get_task_bypass(dirname):
+
+    with pytest.warns(UserWarning, match="ClearMLSaver: running in bypass mode"):
+        ClearMLLogger.set_bypass_mode(True)
+
+        with ClearMLLogger(output_uri=dirname) as clearml_logger:
+            task = clearml_logger.get_task()
+            assert isinstance(task, clearml.Task)
+            assert task == clearml.Task.current_task()
+
+
 def test_clearml_disk_saver_integration():
     model = torch.nn.Module()
     to_save_serializable = {"model": model}