@@ -1,11 +1,13 @@
-import os
 import logging
 import logging.config
 from typing import Union
 
-from super_gradients.common.environment.env_variables import env_variables
+from super_gradients.common.abstractions.mute_processes import mute_subprocesses
 from super_gradients.common.auto_logging.auto_logger import AutoLoggerConfig
 
+# Mute on import to avoid the import prints/logs on sub processes
+mute_subprocesses()
+
 
 def get_logger(logger_name: str, log_level: Union[str, None] = None) -> logging.Logger:
     AutoLoggerConfig.get_instance()
@@ -13,8 +15,7 @@ def get_logger(logger_name: str, log_level: Union[str, None] = None) -> logging.
     if log_level is not None:
         logger.setLevel(log_level)
 
-    if int(env_variables.LOCAL_RANK) > 0:
-        mute_current_process()
+    mute_subprocesses()
     return logger
 
 
@@ -26,21 +27,3 @@ class ILogger:
     def __init__(self, logger_name: str = None):
         logger_name = logger_name if logger_name else str(self.__module__)
         self._logger: logging.Logger = get_logger(logger_name)
-
-
-def mute_current_process():
-    """Mute prints, warnings and all logs except ERRORS. This is meant when running multiple processes."""
-    # Ignore warnings
-    import warnings
-
-    warnings.filterwarnings("ignore")
-
-    # Ignore prints
-    import sys
-
-    sys.stdout = open(os.devnull, "w")
-
-    # Only show ERRORS
-    process_loggers = [logging.getLogger(name) for name in logging.root.manager.loggerDict]
-    for logger in process_loggers:
-        logger.setLevel(logging.ERROR)

import logging
import os
import platform

import psutil

from super_gradients.common.environment.env_variables import env_variables


def mute_subprocesses():
    """Mute (prints, warnings and all logs except ERRORS) of some subprocesses to avoid having duplicates in the logs."""

    # When running DDP, mute all nodes except for the master node
    if int(env_variables.LOCAL_RANK) > 0:
        mute_current_process()

    mute_non_linux_dataloader_worker_process()


def mute_current_process():
    """Mute prints, warnings and all logs except ERRORS. This is meant when running multiple processes."""
    # Ignore warnings
    import warnings

    warnings.filterwarnings("ignore")

    # Ignore prints
    import sys

    sys.stdout = open(os.devnull, "w")

    # Only show ERRORS
    process_loggers = [logging.getLogger(name) for name in logging.root.manager.loggerDict]
    for logger in process_loggers:
        logger.setLevel(logging.ERROR)


def mute_non_linux_dataloader_worker_process() -> None:
    """Mute any worker process when running on mac/windows.
    This is required because the dataloader workers are "spawned" on mac/windows and "forked" on linux.
    The consequence being that the on mac/windows every module will be imported on each worker process, leading to a huge number of prints/logs that are
    displayed on import.
    For more information: https://pytorch.org/docs/stable/data.html#platform-specific-behaviors

    To avoid this, we mute the dataloader workers when running on mac/windows.

    Note:
        We assume that the process tree looks like this:
            Without DDP:
                ... -> main_process -> worker_process
            With DDP:
                ... -> main_process -> node_process -> worker_process

        Knowing that depending on how the script is launched, main_process might be child of other non "python" processes such as:
                ssh(non-python) -> pycharm(non-python) -> main_process(python) -> ...
    """

    if is_non_linux_dataloader_worker_process():
        mute_current_process()


def is_non_linux_dataloader_worker_process() -> bool:
    """Check if current process is a dataloader worker process on a non linux device."""
    if any(os_name in platform.platform() for os_name in ["macOS", "Windows"]):

        # When using DDP with SG launcher, we expect the worker process to have 2 parents processes using python, and only 1 otherwise.
        # Note that this is a "root_process" is the root process only if current process is a worker process
        if int(env_variables.LOCAL_RANK) == -1:
            # NO DDP
            main_process = psutil.Process().parent()
        elif os.environ.get("TORCHELASTIC_RUN_ID") == "sg_initiated":
            # DDP launched using SG logic
            main_process = psutil.Process().parent().parent()
        else:
            # DDP launched using torch.distributed.launch or torchrun
            main_process = psutil.Process().parent()

        is_worker_process = main_process and "python" in main_process.name()

        if is_worker_process:
            return True
    return False

@@ -36,6 +36,7 @@ def is_main_process():
         - If DDP launched using SuperGradients: main process is the launching process (rank=-1)
         - If DDP launched with torch: main process is rank 0
     """
+
     if not is_distributed():  # If no DDP, or DDP launching process
         return True
     elif (

@@ -27,7 +27,7 @@ def check_os():
 
     if "linux" not in sys.platform.lower():
         error = "Deci officially supports only Linux kernels. Some features may not work as expected."
-        logger.error(msg=format_error_msg(test_name="operating system", error_msg=error))
+        logger.warning(msg=format_error_msg(test_name="operating system", error_msg=error))
 
 
 def get_requirements_path(requirements_file_name: str) -> Optional[Path]:
@@ -89,7 +89,7 @@ def check_packages():
 
         if package_name not in installed_packages.keys():
             error = f"{package_name} required but not found"
-            logger.error(msg=format_error_msg(test_name=test_name, error_msg=error))
+            logger.warning(msg=format_error_msg(test_name=test_name, error_msg=error))
             continue
 
         installed_version_str = installed_packages[package_name]
@@ -104,7 +104,7 @@ def check_packages():
 
                 requires_at_least = operator_str in ("==", "~=", ">=", ">")
                 if requires_at_least and installed_version < req_version:
-                    logger.error(msg=format_error_msg(test_name=test_name, error_msg=error))
+                    logger.warning(msg=format_error_msg(test_name=test_name, error_msg=error))
                 else:
                     logger.debug(msg=error)
 

@@ -18,7 +18,8 @@ from super_gradients.common.environment.argparse_utils import EXTRA_ARGS
 from super_gradients.common.environment.ddp_utils import find_free_port, is_distributed, is_launched_using_sg
 
 
-from super_gradients.common.abstractions.abstract_logger import get_logger, mute_current_process
+from super_gradients.common.abstractions.abstract_logger import get_logger
+from super_gradients.common.abstractions.mute_processes import mute_current_process
 from super_gradients.common.environment.device_utils import device_config
 
 from super_gradients.common.decorators.factory_decorator import resolve_param