litlogger 0.0.15__py3-none-any.whl

litlogger/__init__.py

@@ -0,0 +1,5 @@
+from litlogger.logger import LightningLogger
+
+__all__ = ["LightningLogger"]
+
+__version__ = "0.0.15"

litlogger/artifacts.py

@@ -0,0 +1,9 @@
+# Copyright The Lightning AI team.
+# Licensed under the Apache License, Version 2.0 (the "License");
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+from lightning_utilities import module_available
+
+if module_available("litmodels"):
+    # for compatibility with past versions but could be dropped in the future
+    from litmodels import download_model, upload_model  # noqa: F401

litlogger/client.py

@@ -0,0 +1,87 @@
+# Copyright The Lightning AI team.
+# Licensed under the Apache License, Version 2.0 (the "License");
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+import time
+from functools import wraps
+from logging import Logger
+from typing import Any, Callable
+
+import urllib3
+from lightning_sdk.lightning_cloud.openapi.rest import ApiException
+from lightning_sdk.lightning_cloud.rest_client import GridRestClient, _get_next_backoff_time, create_swagger_client
+
+logger = Logger(__name__)
+
+
+def _should_retry(ex: BaseException) -> bool:
+    if isinstance(ex, urllib3.exceptions.HTTPError):
+        return True
+
+    if "not found" in str(ex):
+        return False
+
+    if str(ex.status).startswith("4") and ex.status not in (400, 401, 404):
+        return True
+
+    return str(ex.status).startswith("5")
+
+
+def _retry_wrapper(self: Any, func: Callable, max_retries: int = -1) -> Callable:
+    """Returns the function decorated by a wrapper that retries the call several times if a connection error occurs.
+
+    The retries follow an exponential backoff.
+
+    """
+
+    @wraps(func)
+    def wrapped(*args: Any, **kwargs: Any) -> Any:
+        consecutive_errors = 0
+
+        while True:
+            try:
+                return func(self, *args, **kwargs)
+            except (ApiException, urllib3.exceptions.HTTPError) as ex:
+                if not _should_retry(ex):
+                    raise ex
+
+                msg = f"error: {ex!s}" if isinstance(ex, urllib3.exceptions.HTTPError) else f"response: {ex.status}"
+
+                if consecutive_errors == max_retries:
+                    raise RuntimeError(f"The {func.__name__} request failed to reach the server, {msg}.") from ex
+
+                consecutive_errors += 1
+                backoff_time = _get_next_backoff_time(consecutive_errors)
+                logger.warning(
+                    f"The {func.__name__} request failed to reach the server, {msg}."
+                    f" Retrying after {backoff_time} seconds."
+                )
+
+                time.sleep(backoff_time)
+
+    return wrapped
+
+
+class LitRestClient(GridRestClient):
+    """The LitRestClient is a wrapper around the GridRestClient.
+
+    It wraps all methods to monitor connection exceptions and employs a retry strategy.
+
+    Args:
+        max_retries: Maximum number of attempts where each delay between retries is exponential.
+            If set to -1, it will retry forever, in contrast if set 0, it runs it only once.
+
+    """
+
+    def __init__(self, max_retries: int = -1) -> None:
+        super().__init__(api_client=create_swagger_client())
+        if max_retries == 0:
+            return
+        for base_class in GridRestClient.__mro__:
+            for name, attribute in base_class.__dict__.items():
+                if callable(attribute) and attribute.__name__ != "__init__":
+                    setattr(
+                        self,
+                        name,
+                        _retry_wrapper(self, attribute, max_retries=max_retries),
+                    )

litlogger/colors.py

@@ -0,0 +1,217 @@
+# Copyright The Lightning AI team.
+# Licensed under the Apache License, Version 2.0 (the "License");
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+import random
+from typing import Tuple
+
+_LIGHT_THEME_COLORS = [
+    "#792EE5",
+    "#3FC55F",
+    "#E02C2D",
+    "#1877F2",
+    "#F1AA03",
+    "#D22CE0",
+    "#FF6666",
+    "#5CDB95",
+    "#FFA500",
+    "#00CED1",
+    "#FFD700",
+    "#BA55D3",
+    "#1E90FF",
+    "#FF1493",
+    "#228B22",
+    "#800000",
+    "#FF00FF",
+    "#00FA9A",
+    "#8B008B",
+    "#808080",
+    "#7029e0",
+    "#e52534",
+    "#1172e8",
+    "#cf33dc",
+    "#188a23",
+    "#7d0007",
+    "#8d0894",
+    "#7732dc",
+    "#e43029",
+    "#1d6eea",
+    "#23911d",
+    "#870009",
+    "#8b0383",
+    "#7427e3",
+    "#e92633",
+    "#1d6ef7",
+    "#d02edc",
+    "#188421",
+    "#860100",
+    "#8a0086",
+    "#792fe7",
+    "#e22830",
+    "#1075f1",
+    "#d02cdc",
+    "#2c861b",
+    "#780505",
+    "#930283",
+    "#7536e3",
+    "#d6252a",
+    "#cb24e3",
+    "#1e9126",
+    "#760000",
+    "#8d0893",
+    "#7124dc",
+    "#df292f",
+    "#1c74f2",
+    "#ce24da",
+    "#b05aca",
+    "#1f9123",
+    "#780009",
+    "#8b0790",
+    "#7c7b7e",
+    "#7d30e0",
+    "#da2e2b",
+    "#258122",
+    "#8b0a87",
+    "#7529e1",
+    "#dd2532",
+    "#1276f4",
+    "#d822da",
+    "#188321",
+    "#770a03",
+    "#920091",
+    "#7d26e6",
+    "#e92d2d",
+    "#1979ec",
+    "#d526d7",
+    "#23901b",
+    "#790700",
+    "#8e0185",
+    "#798082",
+    "#7134e0",
+    "#da2824",
+    "#1b77ef",
+    "#20851a",
+    "#7b0700",
+    "#870185",
+    "#797c85",
+    "#732aee",
+    "#e22a26",
+    "#146efb",
+    "#b551cc",
+    "#258c19",
+    "#870001",
+    "#900081",
+    "#768184",
+    "#8335ed",
+    "#e82634",
+    "#1c78eb",
+    "#1a8d24",
+]
+
+_DARK_THEME_COLORS = [
+    "#FA00F0",
+    "#00FA9A",
+    "#FA0000",
+    "#0091FA",
+    "#FFD700",
+    "#FF6666",
+    "#D22CE0",
+    "#5CDB95",
+    "#FFA500",
+    "#00CED1",
+    "#F1AA03",
+    "#BA55D3",
+    "#1E90FF",
+    "#FF1493",
+    "#228B22",
+    "#800000",
+    "#FF00FF",
+    "#3FC55F",
+    "#8B008B",
+    "#808080",
+    "#fe00ed",
+    "#06eea7",
+    "#0085f9",
+    "#f5cf00",
+    "#ff6b6c",
+    "#d224ee",
+    "#5fdfa1",
+    "#ffa700",
+    "#00cdd6",
+    "#ffa110",
+    "#b751d5",
+    "#128ef4",
+    "#ff1688",
+    "#ff08f6",
+    "#43c961",
+    "#7a8784",
+    "#ff00ef",
+    "#0bfaad",
+    "#0086f3",
+    "#ffd700",
+    "#ff646b",
+    "#5ce394",
+    "#ffab00",
+    "#00d0cf",
+    "#fbaa03",
+    "#219aff",
+    "#ff137b",
+    "#ff0cf1",
+    "#39d56b",
+    "#6f9176",
+    "#fb00ea",
+    "#00fbb8",
+    "#0a91fb",
+    "#f8d902",
+    "#fb7073",
+    "#54dca1",
+    "#fb9d02",
+    "#00c2db",
+    "#ffb30f",
+    "#268cf0",
+    "#f11170",
+    "#f211f2",
+    "#47ce7a",
+    "#719b73",
+    "#f305e3",
+    "#03ffbd",
+    "#048df6",
+    "#ffe200",
+    "#f56973",
+    "#4cdeaf",
+    "#ff9a0f",
+    "#00c3ce",
+    "#ffb417",
+    "#2898f6",
+    "#f10468",
+    "#ff03e5",
+    "#54d584",
+    "#6a9179",
+    "#fe0be3",
+    "#00fec0",
+    "#0097fb",
+    "#feef01",
+    "#f2756e",
+    "#4ee0a4",
+    "#f29902",
+    "#00cfce",
+    "#ffa91e",
+    "#2292f9",
+    "#fb0361",
+    "#f306e6",
+    "#4ed78e",
+    "#70897c",
+    "#fe05e8",
+    "#00f6bd",
+    "#00a6ff",
+    "#ffe900",
+    "#f67b78",
+    "#40d3a0",
+    "#e98e10",
+    "#00d0db",
+]
+
+
+def _create_colors() -> Tuple[str, str]:
+    idx = random.randint(0, len(_DARK_THEME_COLORS) - 1)
+    return _LIGHT_THEME_COLORS[idx], _DARK_THEME_COLORS[idx]

litlogger/diagnostics.py

@@ -0,0 +1,193 @@
+# Copyright The Lightning AI team.
+# Licensed under the Apache License, Version 2.0 (the "License");
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+import os
+import platform
+import re
+import subprocess
+import sys
+
+import pkg_resources
+import psutil
+
+import litlogger
+
+
+def get_os_info() -> str:
+    """Return a pretty name of operating system and its version: 'Ubuntu 20.04.6 LTS' or 'MacOS 15.0.1'.
+
+    If it's not possible, then the more verbose name is returned:
+    'Linux-5.15.0-1070-aws-x86_64-with-glibc2.31' or 'macOS-15.0.1-arm64-arm-64bit'.
+    """
+    os_name = platform.system()
+    default_os_name = platform.platform()
+
+    if os_name == "Linux":
+        try:
+            with open("/etc/os-release", encoding="utf-8") as f:
+                for line in f:
+                    if line.startswith("PRETTY_NAME"):
+                        return line.strip().split("=")[1].strip('"')
+            return default_os_name
+        except FileNotFoundError:
+            return default_os_name
+
+    if os_name == "Darwin":
+        try:
+            version = platform.mac_ver()[0]
+            return f"MacOS {version}"
+        except Exception:
+            return default_os_name
+
+    return default_os_name
+
+
+def get_cpu_name() -> str:
+    """Return the name of the CPU (e.g. Apple M3 Pro, Intel(R) Xeon(R) Platinum 8488C)."""
+    system = platform.system()
+    try:
+        if system == "Linux":
+            cpu_info = subprocess.check_output("grep 'model name' /proc/cpuinfo | head -n 1", shell=True, text=True)
+            return cpu_info.split(":")[1].strip()
+
+        if system == "Darwin":
+            cpu_info = subprocess.check_output(["sysctl", "-n", "machdep.cpu.brand_string"], text=True)
+            return cpu_info.strip()
+
+        return ""
+    except Exception:
+        return ""
+
+
+def get_gpu_info() -> dict:
+    """Return Nvidia GPU info: name, count and memory size in GB.
+
+    Example output: {"name": "Nvidia T4, "count": 4, "memory_gb": 16}
+    """
+    default_output = {
+        "name": "",
+        "count": 0,
+        "memory_gb": 0,
+    }
+
+    try:
+        output = subprocess.check_output(
+            ["nvidia-smi", "--query-gpu=name,memory.total", "--format=csv,noheader,nounits"], text=True
+        ).strip()
+
+        if not output:
+            return default_output
+
+        gpu_list = output.split("\n")
+        gpu_name, gpu_memory_mib = re.split(r",\s+", gpu_list[0])
+        gpu_memory_gb = round((int(gpu_memory_mib) / 1e6) * 1024)
+
+        return {"name": gpu_name, "count": len(gpu_list), "memory_gb": gpu_memory_gb}
+
+    except Exception:
+        return default_output
+
+
+def get_cuda_version() -> str:
+    """Return the CUDA version installed on the system."""
+    try:
+        output = subprocess.check_output(["nvcc", "--version"], text=True)
+        match = re.search(r"release (\d+\.\d+)", output)
+        return match.group(1) if match else ""
+    except Exception:
+        return ""
+
+
+def get_cudnn_version() -> str:
+    """Return the cuDNN version installed on the system."""
+    cudnn_path = "/usr/include/cudnn_version.h"
+    if os.path.isfile(cudnn_path):
+        # Read the file content and find cuDNN version
+        with open(cudnn_path, encoding="utf-8") as fin:
+            content = fin.read()
+            # Find the major, minor, and patch versions of cuDNN
+            major = re.search(r"#define CUDNN_MAJOR (\d+)", content)
+            minor = re.search(r"#define CUDNN_MINOR (\d+)", content)
+            patch = re.search(r"#define CUDNN_PATCHLEVEL (\d+)", content)
+            if major and minor and patch:
+                return f"{major.group(1)}.{minor.group(1)}.{patch.group(1)}"
+    return ""
+
+
+def _parse_cmd_arguments(cmd_args: str) -> list[str]:
+    """Parse command-line arguments into a list of strings.
+
+    >>> _parse_cmd_arguments("--option1 value1 --flag2 --option3 value3 --option4=value4")
+    ['--option1 value1', '--flag2', '--option3 value3', '--option4 value4']
+    """
+    return ["--" + arg.replace("=", " ").strip() for arg in cmd_args.strip().split("--") if arg]
+
+
+def get_cli_args() -> str:
+    r"""Parse and format command-line arguments into a human-readable string.
+
+    Pairs flags with their values (e.g., `--option value`) and leaves standalone
+    flags (e.g., `--flag`). Returns one argument or pair per line.
+
+    Example:
+        For the input
+        `["--option1", "value1", "--flag2", "--option3", "value3", "--option4=value4", "--option5 value5 value6"]`,
+        the output would be:
+        `"--option1 value1\n--flag2\n--option3 value3\n--option4 value4\n--option5 value5 value6"`.
+    """
+    args_str = " ".join(sys.argv[1:])
+    return "\n".join(_parse_cmd_arguments(args_str))
+
+
+def collect_system_info() -> dict:
+    """Collects git, system, hardware and CLI args information."""
+
+    # git
+    def get_git_info(command: list[str], default_message: str) -> str:
+        try:
+            return subprocess.check_output(
+                command,
+                text=True,
+                stderr=subprocess.DEVNULL,
+            ).strip()
+        except subprocess.CalledProcessError:
+            return default_message
+
+    git_repo_name = get_git_info(["git", "rev-parse", "--show-toplevel"], "Not a git repository").split("/")[-1]
+    git_branch = get_git_info(["git", "rev-parse", "--abbrev-ref", "HEAD"], "No branch found")
+    git_commit_hash = get_git_info(["git", "rev-parse", "HEAD"], "No commit hash found")
+
+    # software
+    litlogger_version = litlogger.__version__
+    installed_packages = "\n".join(sorted([f"{pkg.project_name}=={pkg.version}" for pkg in pkg_resources.working_set]))
+
+    # hardware
+    system_memory_gb = psutil.virtual_memory().total // 1024**3
+    gpu_info = get_gpu_info()
+
+    # args
+    execution_command = os.path.abspath(sys.argv[0])
+    cli_args = get_cli_args()
+
+    return {
+        "git_repo_name": git_repo_name,
+        "git_branch": git_branch,
+        "git_commit_hash": git_commit_hash,
+        "os_name": get_os_info(),
+        "python_version": platform.python_version(),
+        "litlogger_version": litlogger_version,
+        "installed_packages": installed_packages,
+        "cpu_name": get_cpu_name(),
+        "cpu_count_logical": psutil.cpu_count(logical=True),
+        "cpu_count_physical": psutil.cpu_count(logical=False),
+        "system_memory_gb": system_memory_gb,
+        "gpu_name": gpu_info["name"],
+        "gpu_count": gpu_info["count"],
+        "gpu_memory_gb": gpu_info["memory_gb"],
+        "cuda_version": get_cuda_version(),
+        "cudnn_version": get_cudnn_version(),
+        "execution_command": execution_command,
+        "cli_args": cli_args,
+        "hostname": platform.node(),
+    }