{"repo": "aliqasim222/yolov8-ghost", "files": {"Ultralytics/utils/__init__.py": {"5d187e0a90b9261c0597a053f602dd387d4395a9": {"t": 1785595831.8621316, "n": 59046, "h": "08f2c8823eb61cc6", "c": "# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license\n\nimport contextlib\nimport importlib.metadata\nimport inspect\nimport json\nimport logging\nimport os\nimport platform\nimport re\nimport subprocess\nimport sys\nimport threading\nimport time\nimport warnings\nfrom pathlib import Path\nfrom threading import Lock\nfrom types import SimpleNamespace\nfrom typing import Union\nfrom urllib.parse import unquote\n\nimport cv2\nimport numpy as np\nimport torch\nimport tqdm\n\nfrom ultralytics import __version__\nfrom ultralytics.utils.patches import imread, imshow, imwrite, torch_load, torch_save  # for patches\n\n# PyTorch Multi-GPU DDP Constants\nRANK = int(os.getenv(\"RANK\", -1))\nLOCAL_RANK = int(os.getenv(\"LOCAL_RANK\", -1))  # https://pytorch.org/docs/stable/elastic/run.html\n\n# Other Constants\nARGV = sys.argv or [\"\", \"\"]  # sometimes sys.argv = []\nFILE = Path(__file__).resolve()\nROOT = FILE.parents[1]  # YOLO\nASSETS = ROOT / \"assets\"  # default images\nASSETS_URL = \"https://github.com/ultralytics/assets/releases/download/v0.0.0\"  # assets GitHub URL\nDEFAULT_CFG_PATH = ROOT / \"cfg/default.yaml\"\nNUM_THREADS = min(8, max(1, os.cpu_count() - 1))  # number of YOLO multiprocessing threads\nAUTOINSTALL = str(os.getenv(\"YOLO_AUTOINSTALL\", True)).lower() == \"true\"  # global auto-install mode\nVERBOSE = str(os.getenv(\"YOLO_VERBOSE\", True)).lower() == \"true\"  # global verbose mode\nTQDM_BAR_FORMAT = \"{l_bar}{bar:10}{r_bar}\" if VERBOSE else None  # tqdm bar format\nLOGGING_NAME = \"ultralytics\"\nMACOS, LINUX, WINDOWS = (platform.system() == x for x in [\"Darwin\", \"Linux\", \"Windows\"])  # environment booleans\nMACOS_VERSION = platform.mac_ver()[0] if MACOS else None\nARM64 = platform.machine() in {\"arm64\", \"aarch64\"}  # ARM64 booleans\nPYTHON_VERSION = platform.python_version()\nTORCH_VERSION = torch.__version__\nTORCHVISION_VERSION = importlib.metadata.version(\"torchvision\")  # faster than importing torchvision\nIS_VSCODE = os.environ.get(\"TERM_PROGRAM\", False) == \"vscode\"\nRKNN_CHIPS = frozenset(\n    {\n        \"rk3588\",\n        \"rk3576\",\n        \"rk3566\",\n        \"rk3568\",\n        \"rk3562\",\n        \"rv1103\",\n        \"rv1106\",\n        \"rv1103b\",\n        \"rv1106b\",\n        \"rk2118\",\n    }\n)  # Rockchip processors available for export\nHELP_MSG = \"\"\"\n    Examples for running Ultralytics:\n\n    1. Install the ultralytics package:\n\n        pip install ultralytics\n\n    2. Use the Python SDK:\n\n        from ultralytics import YOLO\n\n        # Load a model\n        model = YOLO(\"yolo11n.yaml\")  # build a new model from scratch\n        model = YOLO(\"yolo11n.pt\")  # load a pretrained model (recommended for training)\n\n        # Use the model\n        results = model.train(data=\"coco8.yaml\", epochs=3)  # train the model\n        results = model.val()  # evaluate model performance on the validation set\n        results = model(\"https://ultralytics.com/images/bus.jpg\")  # predict on an image\n        success = model.export(format=\"onnx\")  # export the model to ONNX format\n\n    3. Use the command line interface (CLI):\n\n        Ultralytics 'yolo' CLI commands use the following syntax:\n\n            yolo TASK MODE ARGS\n\n            Where   TASK (optional) is one of [detect, segment, classify, pose, obb]\n                    MODE (required) is one of [train, val, predict, export, track, benchmark]\n                    ARGS (optional) are any number of custom \"arg=value\" pairs like \"imgsz=320\" that override defaults.\n                        See all ARGS at https://docs.ultralytics.com/usage/cfg or with \"yolo cfg\"\n\n        - Train a detection model for 10 epochs with an initial learning_rate of 0.01\n            yolo detect train data=coco8.yaml model=yolo11n.pt epochs=10 lr0=0.01\n\n        - Predict a YouTube video using a pretrained segmentation model at image size 320:\n            yolo segment predict model=yolo11n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320\n\n        - Val a pretrained detection model at batch-size 1 and image size 640:\n            yolo detect val model=yolo11n.pt data=coco8.yaml batch=1 imgsz=640\n\n        - Export a YOLO11n classification model to ONNX format at image size 224 by 128 (no TASK required)\n            yolo export model=yolo11n-cls.pt format=onnx imgsz=224,128\n\n        - Run special commands:\n            yolo help\n            yolo checks\n            yolo version\n            yolo settings\n            yolo copy-cfg\n            yolo cfg\n\n    Docs: https://docs.ultralytics.com\n    Community: https://community.ultralytics.com\n    GitHub: https://github.com/ultralytics/ultralytics\n    \"\"\"\n\n# Settings and Environment Variables\ntorch.set_printoptions(linewidth=320, precision=4, profile=\"default\")\nnp.set_printoptions(linewidth=320, formatter=dict(float_kind=\"{:11.5g}\".format))  # format short g, %precision=5\ncv2.setNumThreads(0)  # prevent OpenCV from multithreading (incompatible with PyTorch DataLoader)\nos.environ[\"NUMEXPR_MAX_THREADS\"] = str(NUM_THREADS)  # NumExpr max threads\nos.environ[\"TF_CPP_MIN_LOG_LEVEL\"] = \"3\"  # suppress verbose TF compiler warnings in Colab\nos.environ[\"TORCH_CPP_LOG_LEVEL\"] = \"ERROR\"  # suppress \"NNPACK.cpp could not initialize NNPACK\" warnings\nos.environ[\"KINETO_LOG_LEVEL\"] = \"5\"  # suppress verbose PyTorch profiler output when computing FLOPs\n\nif TQDM_RICH := str(os.getenv(\"YOLO_TQDM_RICH\", False)).lower() == \"true\":\n    from tqdm import rich\n\n\nclass TQDM(rich.tqdm if TQDM_RICH else tqdm.tqdm):\n    \"\"\"\n    A custom TQDM progress bar class that extends the original tqdm functionality.\n\n    This class modifies the behavior of the original tqdm progress bar based on global settings and provides\n    additional customization options.\n\n    Attributes:\n        disable (bool): Whether to disable the progress bar. Determined by the global VERBOSE setting and\n            any passed 'disable' argument.\n        bar_format (str): The format string for the progress bar. Uses the global TQDM_BAR_FORMAT if not\n            explicitly set.\n\n    Methods:\n        __init__: Initializes the TQDM object with custom settings.\n\n    Examples:\n        >>> from ultralytics.utils import TQDM\n        >>> for i in TQDM(range(100)):\n        ...     # Your processing code here\n        ...     pass\n    \"\"\"\n\n    def __init__(self, *args, **kwargs):\n        \"\"\"\n        Initializes a custom TQDM progress bar.\n\n        This class extends the original tqdm class to provide customized behavior for Ultralytics projects.\n\n        Args:\n            *args (Any): Variable length argument list to be passed to the original tqdm constructor.\n            **kwargs (Any): Arbitrary keyword arguments to be passed to the original tqdm constructor.\n\n        Notes:\n            - The progress bar is disabled if VERBOSE is False or if 'disable' is explicitly set to True in kwargs.\n            - The default bar format is set to TQDM_BAR_FORMAT unless overridden in kwargs.\n\n        Examples:\n            >>> from ultralytics.utils import TQDM\n            >>> for i in TQDM(range(100)):\n            ...     # Your code here\n            ...     pass\n        \"\"\"\n        warnings.filterwarnings(\"ignore\", category=tqdm.TqdmExperimentalWarning)  # suppress tqdm.rich warning\n        kwargs[\"disable\"] = not VERBOSE or kwargs.get(\"disable\", False)\n        kwargs.setdefault(\"bar_format\", TQDM_BAR_FORMAT)  # override default value if passed\n        super().__init__(*args, **kwargs)\n\n    def __iter__(self):\n        \"\"\"Return self as iterator to satisfy Iterable interface.\"\"\"\n        return super().__iter__()\n\n\nclass DataExportMixin:\n    \"\"\"\n    Mixin class for exporting validation metrics or prediction results in various formats.\n\n    This class provides utilities to export performance metrics (e.g., mAP, precision, recall) or prediction results\n    from classification, object detection, segmentation, or pose estimation tasks into various formats, Pandas DataFrame\n    CSV, XML, HTML, JSON and SQLite (SQL)\n\n    Methods:\n        to_df(): Convert summary to a Pandas DataFrame.\n        to_csv(): Export results as a CSV string.\n        to_xml(): Export results as an XML string (requires `lxml`).\n        to_html(): Export results as an HTML table.\n        to_json(): Export results as a JSON string.\n        tojson(): Deprecated alias for `to_json()`.\n        to_sql(): Export results to an SQLite database.\n\n    Examples:\n        >>> model = YOLO(\"yolov8n.pt\")\n        >>> results = model(\"image.jpg\")\n        >>> df = results.to_df()\n        >>> print(df)\n        >>> csv_data = results.to_csv()\n        >>> results.to_sql(table_name=\"yolo_results\")\n    \"\"\"\n\n    def to_df(self, normalize=False, decimals=5):\n        \"\"\"\n        Create a pandas DataFrame from the prediction results summary or validation metrics.\n\n        Args:\n            normalize (bool, optional): Normalize numerical values for easier comparison. Defaults to False.\n            decimals (int, optional): Decimal places to round floats. Defaults to 5.\n\n        Returns:\n            (DataFrame): DataFrame containing the summary data.\n        \"\"\"\n        import pandas as pd  # scope for faster 'import ultralytics'\n\n        return pd.DataFrame(self.summary(normalize=normalize, decimals=decimals))\n\n    def to_csv(self, normalize=False, decimals=5):\n        \"\"\"\n        Export results to CSV string format.\n\n        Args:\n           normalize (bool, optional): Normalize numeric values. Defaults to False.\n           decimals (int, optional): Decimal precision. Defaults to 5.\n\n        Returns:\n           (str): CSV content as string.\n        \"\"\"\n        return self.to_df(normalize=normalize, decimals=decimals).to_csv()\n\n    def to_xml(self, normalize=False, decimals=5):\n        \"\"\"\n        Export results to XML format.\n\n        Args:\n            normalize (bool, optional): Normalize numeric values. Defaults to False.\n            decimals (int, optional): Decimal precision. Defaults to 5.\n\n        Returns:\n            (str): XML string.\n\n        Note:\n            Requires `lxml` package to be installed.\n        \"\"\"\n        from ultralytics.utils.checks import check_requirements\n\n        check_requirements(\"lxml\")\n        df = self.to_df(normalize=normalize, decimals=decimals)\n        return '<?xml version=\"1.0\" encoding=\"utf-8\"?>\\n<root></root>' if df.empty else df.to_xml()\n\n    def to_html(self, normalize=False, decimals=5, index=False):\n        \"\"\"\n        Export results to HTML table format.\n\n        Args:\n            normalize (bool, optional): Normalize numeric values. Defaults to False.\n            decimals (int, optional): Decimal precision. Defaults to 5.\n            index (bool, optional): Whether to include index column in the HTML table. Defaults to False.\n\n        Returns:\n            (str): HTML representation of the results.\n        \"\"\"\n        df = self.to_df(normalize=normalize, decimals=decimals)\n        return \"<table></table>\" if df.empty else df.to_html(index=index)\n\n    def tojson(self, normalize=False, decimals=5):\n        \"\"\"Deprecated version of to_json().\"\"\"\n        LOGGER.warning(\"'result.tojson()' is deprecated, replace with 'result.to_json()'.\")\n        return self.to_json(normalize, decimals)\n\n    def to_json(self, normalize=False, decimals=5):\n        \"\"\"\n        Export results to JSON format.\n\n        Args:\n            normalize (bool, optional): Normalize numeric values. Defaults to False.\n            decimals (int, optional): Decimal precision. Defaults to 5.\n\n        Returns:\n            (str): JSON-formatted string of the results.\n        \"\"\"\n        return self.to_df(normalize=normalize, decimals=decimals).to_json(orient=\"records\", indent=2)\n\n    def to_sql(self, normalize=False, decimals=5, table_name=\"results\", db_path=\"results.db\"):\n        \"\"\"\n        Save results to an SQLite database.\n\n        Args:\n            normalize (bool, optional): Normalize numeric values. Defaults to False.\n            decimals (int, optional): Decimal precision. Defaults to 5.\n            table_name (str, optional): Name of the SQL table. Defaults to \"results\".\n            db_path (str, optional): SQLite database file path. Defaults to \"results.db\".\n        \"\"\"\n        df = self.to_df(normalize, decimals)\n        if df.empty or df.columns.empty:  # Exit if df is None or has no columns (i.e., no schema)\n            return\n\n        import sqlite3\n\n        conn = sqlite3.connect(db_path)\n        cursor = conn.cursor()\n\n        # Dynamically create table schema based on summary to support prediction and validation results export\n        columns = []\n        for col in df.columns:\n            sample_val = df[col].dropna().iloc[0] if not df[col].dropna().empty else \"\"\n            if isinstance(sample_val, dict):\n                col_type = \"TEXT\"\n            elif isinstance(sample_val, (float, int)):\n                col_type = \"REAL\"\n            else:\n                col_type = \"TEXT\"\n            columns.append(f'\"{col}\" {col_type}')  # Quote column names to handle special characters like hyphens\n\n        # Create table (Drop table from db if it's already exist)\n        cursor.execute(f'DROP TABLE IF EXISTS \"{table_name}\"')\n        cursor.execute(f'CREATE TABLE \"{table_name}\" (id INTEGER PRIMARY KEY AUTOINCREMENT, {\", \".join(columns)})')\n\n        for _, row in df.iterrows():\n            values = [json.dumps(v) if isinstance(v, dict) else v for v in row]\n            column_names = \", \".join(f'\"{col}\"' for col in df.columns)\n            placeholders = \", \".join(\"?\" for _ in df.columns)\n            cursor.execute(f'INSERT INTO \"{table_name}\" ({column_names}) VALUES ({placeholders})', values)\n\n        conn.commit()\n        conn.close()\n        LOGGER.info(f\"Results saved to SQL table '{table_name}' in '{db_path}'.\")\n\n\nclass SimpleClass:\n    \"\"\"\n    A simple base class for creating objects with string representations of their attributes.\n\n    This class provides a foundation for creating objects that can be easily printed or represented as strings,\n    showing all their non-callable attributes. It's useful for debugging and introspection of object states.\n\n    Methods:\n        __str__: Returns a human-readable string representation of the object.\n        __repr__: Returns a machine-readable string representation of the object.\n        __getattr__: Provides a custom attribute access error message with helpful information.\n\n    Examples:\n        >>> class MyClass(SimpleClass):\n        ...     def __init__(self):\n        ...         self.x = 10\n        ...         self.y = \"hello\"\n        >>> obj = MyClass()\n        >>> print(obj)\n        __main__.MyClass object with attributes:\n\n        x: 10\n        y: 'hello'\n\n    Notes:\n        - This class is designed to be subclassed. It provides a convenient way to inspect object attributes.\n        - The string representation includes the module and class name of the object.\n        - Callable attributes and attributes starting with an underscore are excluded from the string representation.\n    \"\"\"\n\n    def __str__(self):\n        \"\"\"Return a human-readable string representation of the object.\"\"\"\n        attr = []\n        for a in dir(self):\n            v = getattr(self, a)\n            if not callable(v) and not a.startswith(\"_\"):\n                if isinstance(v, SimpleClass):\n                    # Display only the module and class name for subclasses\n                    s = f\"{a}: {v.__module__}.{v.__class__.__name__} object\"\n                else:\n                    s = f\"{a}: {repr(v)}\"\n                attr.append(s)\n        return f\"{self.__module__}.{self.__class__.__name__} object with attributes:\\n\\n\" + \"\\n\".join(attr)\n\n    def __repr__(self):\n        \"\"\"Return a machine-readable string representation of the object.\"\"\"\n        return self.__str__()\n\n    def __getattr__(self, attr):\n        \"\"\"Custom attribute access error message with helpful information.\"\"\"\n        name = self.__class__.__name__\n        raise AttributeError(f\"'{name}' object has no attribute '{attr}'. See valid attributes below.\\n{self.__doc__}\")\n\n\nclass IterableSimpleNamespace(SimpleNamespace):\n    \"\"\"\n    An iterable SimpleNamespace class that provides enhanced functionality for attribute access and iteration.\n\n    This class extends the SimpleNamespace class with additional methods for iteration, string representation,\n    and attribute access. It is designed to be used as a convenient container for storing and accessing\n    configuration parameters.\n\n    Methods:\n        __iter__: Returns an iterator of key-value pairs from the namespace's attributes.\n        __str__: Returns a human-readable string representation of the object.\n        __getattr__: Provides a custom attribute access error message with helpful information.\n        get: Retrieves the value of a specified key, or a default value if the key doesn't exist.\n\n    Examples:\n        >>> cfg = IterableSimpleNamespace(a=1, b=2, c=3)\n        >>> for k, v in cfg:\n        ...     print(f\"{k}: {v}\")\n        a: 1\n        b: 2\n        c: 3\n        >>> print(cfg)\n        a=1\n        b=2\n        c=3\n        >>> cfg.get(\"b\")\n        2\n        >>> cfg.get(\"d\", \"default\")\n        'default'\n\n    Notes:\n        This class is particularly useful for storing configuration parameters in a more accessible\n        and iterable format compared to a standard dictionary.\n    \"\"\"\n\n    def __iter__(self):\n        \"\"\"Return an iterator of key-value pairs from the namespace's attributes.\"\"\"\n        return iter(vars(self).items())\n\n    def __str__(self):\n        \"\"\"Return a human-readable string representation of the object.\"\"\"\n        return \"\\n\".join(f\"{k}={v}\" for k, v in vars(self).items())\n\n    def __getattr__(self, attr):\n        \"\"\"Custom attribute access error message with helpful information.\"\"\"\n        name = self.__class__.__name__\n        raise AttributeError(\n            f\"\"\"\n            '{name}' object has no attribute '{attr}'. This may be caused by a modified or out of date ultralytics\n            'default.yaml' file.\\nPlease update your code with 'pip install -U ultralytics' and if necessary replace\n            {DEFAULT_CFG_PATH} with the latest version from\n            https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/default.yaml\n            \"\"\"\n        )\n\n    def get(self, key, default=None):\n        \"\"\"Return the value of the specified key if it exists; otherwise, return the default value.\"\"\"\n        return getattr(self, key, default)\n\n\ndef plt_settings(rcparams=None, backend=\"Agg\"):\n    \"\"\"\n    Decorator to temporarily set rc parameters and the backend for a plotting function.\n\n    Args:\n        rcparams (dict, optional): Dictionary of rc parameters to set.\n        backend (str, optional): Name of the backend to use. Defaults to 'Agg'.\n\n    Returns:\n        (Callable): Decorated function with temporarily set rc parameters and backend.\n\n    Examples:\n        >>> @plt_settings({\"font.size\": 12})\n        >>> def plot_function():\n        ...     plt.figure()\n        ...     plt.plot([1, 2, 3])\n        ...     plt.show()\n\n        >>> with plt_settings({\"font.size\": 12}):\n        ...     plt.figure()\n        ...     plt.plot([1, 2, 3])\n        ...     plt.show()\n    \"\"\"\n    if rcparams is None:\n        rcparams = {\"font.size\": 11}\n\n    def decorator(func):\n        \"\"\"Decorator to apply temporary rc parameters and backend to a function.\"\"\"\n\n        def wrapper(*args, **kwargs):\n            \"\"\"Sets rc parameters and backend, calls the original function, and restores the settings.\"\"\"\n            import matplotlib.pyplot as plt  # scope for faster 'import ultralytics'\n\n            original_backend = plt.get_backend()\n            switch = backend.lower() != original_backend.lower()\n            if switch:\n                plt.close(\"all\")  # auto-close()ing of figures upon backend switching is deprecated since 3.8\n                plt.switch_backend(backend)\n\n            # Plot with backend and always revert to original backend\n            try:\n                with plt.rc_context(rcparams):\n                    result = func(*args, **kwargs)\n            finally:\n                if switch:\n                    plt.close(\"all\")\n                    plt.switch_backend(original_backend)\n            return result\n\n        return wrapper\n\n    return decorator\n\n\ndef set_logging(name=\"LOGGING_NAME\", verbose=True):\n    \"\"\"\n    Sets up logging with UTF-8 encoding and configurable verbosity.\n\n    This function configures logging for the Ultralytics library, setting the appropriate logging level and\n    formatter based on the verbosity flag and the current process rank. It handles special cases for Windows\n    environments where UTF-8 encoding might not be the default.\n\n    Args:\n        name (str): Name of the logger. Defaults to \"LOGGING_NAME\".\n        verbose (bool): Flag to set logging level to INFO if True, ERROR otherwise. Defaults to True.\n\n    Returns:\n        (logging.Logger): Configured logger object.\n\n    Examples:\n        >>> set_logging(name=\"ultralytics\", verbose=True)\n        >>> logger = logging.getLogger(\"ultralytics\")\n        >>> logger.info(\"This is an info message\")\n\n    Notes:\n        - On Windows, this function attempts to reconfigure stdout to use UTF-8 encoding if possible.\n        - If reconfiguration is not possible, it falls back to a custom formatter that handles non-UTF-8 environments.\n        - The function sets up a StreamHandler with the appropriate formatter and level.\n        - The logger's propagate flag is set to False to prevent duplicate logging in parent loggers.\n    \"\"\"\n    level = logging.INFO if verbose and RANK in {-1, 0} else logging.ERROR  # rank in world for Multi-GPU trainings\n\n    class PrefixFormatter(logging.Formatter):\n        def format(self, record):\n            \"\"\"Format log records with prefixes based on level.\"\"\"\n            # Apply prefixes based on log level\n            if record.levelno == logging.WARNING:\n                prefix = \"WARNING ⚠️\" if not WINDOWS else \"WARNING\"\n                record.msg = f\"{prefix} {record.msg}\"\n            elif record.levelno == logging.ERROR:\n                prefix = \"ERROR ❌\" if not WINDOWS else \"ERROR\"\n                record.msg = f\"{prefix} {record.msg}\"\n\n            # Handle emojis in message based on platform\n            formatted_message = super().format(record)\n            return emojis(formatted_message)\n\n    formatter = PrefixFormatter(\"%(message)s\")\n\n    # Handle Windows UTF-8 encoding issues\n    if WINDOWS and hasattr(sys.stdout, \"encoding\") and sys.stdout.encoding != \"utf-8\":\n        try:\n            # Attempt to reconfigure stdout to use UTF-8 encoding if possible\n            if hasattr(sys.stdout, \"reconfigure\"):\n                sys.stdout.reconfigure(encoding=\"utf-8\")\n            # For environments where reconfigure is not available, wrap stdout in a TextIOWrapper\n            elif hasattr(sys.stdout, \"buffer\"):\n                import io\n\n                sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding=\"utf-8\")\n        except Exception:\n            pass\n\n    # Create and configure the StreamHandler with the appropriate formatter and level\n    stream_handler = logging.StreamHandler(sys.stdout)\n    stream_handler.setFormatter(formatter)\n    stream_handler.setLevel(level)\n\n    # Set up the logger\n    logger = logging.getLogger(name)\n    logger.setLevel(level)\n    logger.addHandler(stream_handler)\n    logger.propagate = False\n    return logger\n\n\n# Set logger\nLOGGER = set_logging(LOGGING_NAME, verbose=VERBOSE)  # define globally (used in train.py, val.py, predict.py, etc.)\nfor logger in \"sentry_sdk\", \"urllib3.connectionpool\":\n    logging.getLogger(logger).setLevel(logging.CRITICAL + 1)\n\n\ndef emojis(string=\"\"):\n    \"\"\"Return platform-dependent emoji-safe version of string.\"\"\"\n    return string.encode().decode(\"ascii\", \"ignore\") if WINDOWS else string\n\n\nclass ThreadingLocked:\n    \"\"\"\n    A decorator class for ensuring thread-safe execution of a function or method.\n\n    This class can be used as a decorator to make sure that if the decorated function is called from multiple threads,\n    only one thread at a time will be able to execute the function.\n\n    Attributes:\n        lock (threading.Lock): A lock object used to manage access to the decorated function.\n\n    Examples:\n        >>> from ultralytics.utils import ThreadingLocked\n        >>> @ThreadingLocked()\n        >>> def my_function():\n        ...    # Your code here\n    \"\"\"\n\n    def __init__(self):\n        \"\"\"Initialize the decorator class with a threading lock.\"\"\"\n        self.lock = threading.Lock()\n\n    def __call__(self, f):\n        \"\"\"Run thread-safe execution of function or method.\"\"\"\n        from functools import wraps\n\n        @wraps(f)\n        def decorated(*args, **kwargs):\n            \"\"\"Applies thread-safety to the decorated function or method.\"\"\"\n            with self.lock:\n                return f(*args, **kwargs)\n\n        return decorated\n\n\nclass YAML:\n    \"\"\"\n    YAML utility class for efficient file operations with automatic C-implementation detection.\n\n    This class provides optimized YAML loading and saving operations using PyYAML's fastest available implementation\n    (C-based when possible). It implements a singleton pattern with lazy initialization, allowing direct class method\n    usage without explicit instantiation. The class handles file path creation, validation, and character encoding\n    issues automatically.\n\n    The implementation prioritizes performance through:\n        - Automatic C-based loader/dumper selection when available\n        - Singleton pattern to reuse the same instance\n        - Lazy initialization to defer import costs until needed\n        - Fallback mechanisms for handling problematic YAML content\n\n    Attributes:\n        _instance: Internal singleton instance storage.\n        yaml: Reference to the PyYAML module.\n        SafeLoader: Best available YAML loader (CSafeLoader if available).\n        SafeDumper: Best available YAML dumper (CSafeDumper if available).\n\n    Examples:\n        >>> data = YAML.load(\"config.yaml\")\n        >>> data[\"new_value\"] = 123\n        >>> YAML.save(\"updated_config.yaml\", data)\n        >>> YAML.print(data)\n    \"\"\"\n\n    _instance = None\n\n    @classmethod\n    def _get_instance(cls):\n        \"\"\"Initialize singleton instance on first use.\"\"\"\n        if cls._instance is None:\n            cls._instance = cls()\n        return cls._instance\n\n    def __init__(self):\n        \"\"\"Initialize with optimal YAML implementation (C-based when available).\"\"\"\n        import yaml\n\n        self.yaml = yaml\n        # Use C-based implementation if available for better performance\n        try:\n            self.SafeLoader = yaml.CSafeLoader\n            self.SafeDumper = yaml.CSafeDumper\n        except (AttributeError, ImportError):\n            self.SafeLoader = yaml.SafeLoader\n            self.SafeDumper = yaml.SafeDumper\n\n    @classmethod\n    def save(cls, file=\"data.yaml\", data=None, header=\"\"):\n        \"\"\"\n        Save Python object as YAML file.\n\n        Args:\n            file (str | Path): Path to save YAML file.\n            data (dict | None): Dict or compatible object to save.\n            header (str): Optional string to add at file beginning.\n        \"\"\"\n        instance = cls._get_instance()\n        if data is None:\n            data = {}\n\n        # Create parent directories if needed\n        file = Path(file)\n        file.parent.mkdir(parents=True, exist_ok=True)\n\n        # Convert non-serializable objects to strings\n        valid_types = int, float, str, bool, list, tuple, dict, type(None)\n        for k, v in data.items():\n            if not isinstance(v, valid_types):\n                data[k] = str(v)\n\n        # Write YAML file\n        with open(file, \"w\", errors=\"ignore\", encoding=\"utf-8\") as f:\n            if header:\n                f.write(header)\n            instance.yaml.dump(data, f, sort_keys=False, allow_unicode=True, Dumper=instance.SafeDumper)\n\n    @classmethod\n    def load(cls, file=\"data.yaml\", append_filename=False):\n        \"\"\"\n        Load YAML file to Python object with robust error handling.\n\n        Args:\n            file (str | Path): Path to YAML file.\n            append_filename (bool): Whether to add filename to returned dict.\n\n        Returns:\n            (dict): Loaded YAML content.\n        \"\"\"\n        instance = cls._get_instance()\n        assert str(file).endswith((\".yaml\", \".yml\")), f\"Not a YAML file: {file}\"\n\n        # Read file content\n        with open(file, errors=\"ignore\", encoding=\"utf-8\") as f:\n            s = f.read()\n\n        # Try loading YAML with fallback for problematic characters\n        try:\n            data = instance.yaml.load(s, Loader=instance.SafeLoader) or {}\n        except Exception:\n            # Remove problematic characters and retry\n            s = re.sub(r\"[^\\x09\\x0A\\x0D\\x20-\\x7E\\x85\\xA0-\\uD7FF\\uE000-\\uFFFD\\U00010000-\\U0010ffff]+\", \"\", s)\n            data = instance.yaml.load(s, Loader=instance.SafeLoader) or {}\n\n        # Check for accidental user-error None strings (should be 'null' in YAML)\n        if \"None\" in data.values():\n            data = {k: None if v == \"None\" else v for k, v in data.items()}\n\n        if append_filename:\n            data[\"yaml_file\"] = str(file)\n        return data\n\n    @classmethod\n    def print(cls, yaml_file):\n        \"\"\"\n        Pretty print YAML file or object to console.\n\n        Args:\n            yaml_file (str | Path | dict): Path to YAML file or dict to print.\n        \"\"\"\n        instance = cls._get_instance()\n\n        # Load file if path provided\n        yaml_dict = cls.load(yaml_file) if isinstance(yaml_file, (str, Path)) else yaml_file\n\n        # Use -1 for unlimited width in C implementation\n        dump = instance.yaml.dump(yaml_dict, sort_keys=False, allow_unicode=True, width=-1, Dumper=instance.SafeDumper)\n\n        LOGGER.info(f\"Printing '{colorstr('bold', 'black', yaml_file)}'\\n\\n{dump}\")\n\n\n# Default configuration\nDEFAULT_CFG_DICT = YAML.load(DEFAULT_CFG_PATH)\nDEFAULT_CFG_KEYS = DEFAULT_CFG_DICT.keys()\nDEFAULT_CFG = IterableSimpleNamespace(**DEFAULT_CFG_DICT)\n\n\ndef read_device_model() -> str:\n    \"\"\"\n    Reads the device model information from the system and caches it for quick access.\n\n    Returns:\n        (str): Kernel release information.\n    \"\"\"\n    return platform.release().lower()\n\n\ndef is_ubuntu() -> bool:\n    \"\"\"\n    Check if the OS is Ubuntu.\n\n    Returns:\n        (bool): True if OS is Ubuntu, False otherwise.\n    \"\"\"\n    try:\n        with open(\"/etc/os-release\") as f:\n            return \"ID=ubuntu\" in f.read()\n    except FileNotFoundError:\n        return False\n\n\ndef is_colab():\n    \"\"\"\n    Check if the current script is running inside a Google Colab notebook.\n\n    Returns:\n        (bool): True if running inside a Colab notebook, False otherwise.\n    \"\"\"\n    return \"COLAB_RELEASE_TAG\" in os.environ or \"COLAB_BACKEND_VERSION\" in os.environ\n\n\ndef is_kaggle():\n    \"\"\"\n    Check if the current script is running inside a Kaggle kernel.\n\n    Returns:\n        (bool): True if running inside a Kaggle kernel, False otherwise.\n    \"\"\"\n    return os.environ.get(\"PWD\") == \"/kaggle/working\" and os.environ.get(\"KAGGLE_URL_BASE\") == \"https://www.kaggle.com\"\n\n\ndef is_jupyter():\n    \"\"\"\n    Check if the current script is running inside a Jupyter Notebook.\n\n    Returns:\n        (bool): True if running inside a Jupyter Notebook, False otherwise.\n\n    Note:\n        - Only works on Colab and Kaggle, other environments like Jupyterlab and Paperspace are not reliably detectable.\n        - \"get_ipython\" in globals() method suffers false positives when IPython package installed manually.\n    \"\"\"\n    return IS_COLAB or IS_KAGGLE\n\n\ndef is_runpod():\n    \"\"\"\n    Check if the current script is running inside a RunPod container.\n\n    Returns:\n        (bool): True if running in RunPod, False otherwise.\n    \"\"\"\n    return \"RUNPOD_POD_ID\" in os.environ\n\n\ndef is_docker() -> bool:\n    \"\"\"\n    Determine if the script is running inside a Docker container.\n\n    Returns:\n        (bool): True if the script is running inside a Docker container, False otherwise.\n    \"\"\"\n    try:\n        with open(\"/proc/self/cgroup\") as f:\n            return \"docker\" in f.read()\n    except Exception:\n        return False\n\n\ndef is_raspberrypi() -> bool:\n    \"\"\"\n    Determines if the Python environment is running on a Raspberry Pi.\n\n    Returns:\n        (bool): True if running on a Raspberry Pi, False otherwise.\n    \"\"\"\n    return \"rpi\" in DEVICE_MODEL\n\n\ndef is_jetson() -> bool:\n    \"\"\"\n    Determines if the Python environment is running on an NVIDIA Jetson device.\n\n    Returns:\n        (bool): True if running on an NVIDIA Jetson device, False otherwise.\n    \"\"\"\n    return \"tegra\" in DEVICE_MODEL\n\n\ndef is_online() -> bool:\n    \"\"\"\n    Check internet connectivity by attempting to connect to a known online host.\n\n    Returns:\n        (bool): True if connection is successful, False otherwise.\n    \"\"\"\n    try:\n        assert str(os.getenv(\"YOLO_OFFLINE\", \"\")).lower() != \"true\"  # check if ENV var YOLO_OFFLINE=\"True\"\n        import socket\n\n        for dns in (\"1.1.1.1\", \"8.8.8.8\"):  # check Cloudflare and Google DNS\n            socket.create_connection(address=(dns, 80), timeout=2.0).close()\n            return True\n    except Exception:\n        return False\n\n\ndef is_pip_package(filepath: str = __name__) -> bool:\n    \"\"\"\n    Determines if the file at the given filepath is part of a pip package.\n\n    Args:\n        filepath (str): The filepath to check.\n\n    Returns:\n        (bool): True if the file is part of a pip package, False otherwise.\n    \"\"\"\n    import importlib.util\n\n    # Get the spec for the module\n    spec = importlib.util.find_spec(filepath)\n\n    # Return whether the spec is not None and the origin is not None (indicating it is a package)\n    return spec is not None and spec.origin is not None\n\n\ndef is_dir_writeable(dir_path: Union[str, Path]) -> bool:\n    \"\"\"\n    Check if a directory is writeable.\n\n    Args:\n        dir_path (str | Path): The path to the directory.\n\n    Returns:\n        (bool): True if the directory is writeable, False otherwise.\n    \"\"\"\n    return os.access(str(dir_path), os.W_OK)\n\n\ndef is_pytest_running():\n    \"\"\"\n    Determines whether pytest is currently running or not.\n\n    Returns:\n        (bool): True if pytest is running, False otherwise.\n    \"\"\"\n    return (\"PYTEST_CURRENT_TEST\" in os.environ) or (\"pytest\" in sys.modules) or (\"pytest\" in Path(ARGV[0]).stem)\n\n\ndef is_github_action_running() -> bool:\n    \"\"\"\n    Determine if the current environment is a GitHub Actions runner.\n\n    Returns:\n        (bool): True if the current environment is a GitHub Actions runner, False otherwise.\n    \"\"\"\n    return \"GITHUB_ACTIONS\" in os.environ and \"GITHUB_WORKFLOW\" in os.environ and \"RUNNER_OS\" in os.environ\n\n\ndef get_git_dir():\n    \"\"\"\n    Determines whether the current file is part of a git repository and if so, returns the repository root directory.\n\n    Returns:\n        (Path | None): Git root directory if found or None if not found.\n    \"\"\"\n    for d in Path(__file__).parents:\n        if (d / \".git\").is_dir():\n            return d\n\n\ndef is_git_dir():\n    \"\"\"\n    Determines whether the current file is part of a git repository.\n\n    Returns:\n        (bool): True if current file is part of a git repository.\n    \"\"\"\n    return GIT_DIR is not None\n\n\ndef get_git_origin_url():\n    \"\"\"\n    Retrieves the origin URL of a git repository.\n\n    Returns:\n        (str | None): The origin URL of the git repository or None if not git directory.\n    \"\"\"\n    if IS_GIT_DIR:\n        try:\n            origin = subprocess.check_output([\"git\", \"config\", \"--get\", \"remote.origin.url\"])\n            return origin.decode().strip()\n        except subprocess.CalledProcessError:\n            return None\n\n\ndef get_git_branch():\n    \"\"\"\n    Returns the current git branch name. If not in a git repository, returns None.\n\n    Returns:\n        (str | None): The current git branch name or None if not a git directory.\n    \"\"\"\n    if IS_GIT_DIR:\n        try:\n            origin = subprocess.check_output([\"git\", \"rev-parse\", \"--abbrev-ref\", \"HEAD\"])\n            return origin.decode().strip()\n        except subprocess.CalledProcessError:\n            return None\n\n\ndef get_default_args(func):\n    \"\"\"\n    Returns a dictionary of default arguments for a function.\n\n    Args:\n        func (callable): The function to inspect.\n\n    Returns:\n        (dict): A dictionary where each key is a parameter name, and each value is the default value of that parameter.\n    \"\"\"\n    signature = inspect.signature(func)\n    return {k: v.default for k, v in signature.parameters.items() if v.default is not inspect.Parameter.empty}\n\n\ndef get_ubuntu_version():\n    \"\"\"\n    Retrieve the Ubuntu version if the OS is Ubuntu.\n\n    Returns:\n        (str): Ubuntu version or None if not an Ubuntu OS.\n    \"\"\"\n    if is_ubuntu():\n        try:\n            with open(\"/etc/os-release\") as f:\n                return re.search(r'VERSION_ID=\"(\\d+\\.\\d+)\"', f.read())[1]\n        except (FileNotFoundError, AttributeError):\n            return None\n\n\ndef get_user_config_dir(sub_dir=\"Ultralytics\"):\n    \"\"\"\n    Return the appropriate config directory based on the environment operating system.\n\n    Args:\n        sub_dir (str): The name of the subdirectory to create.\n\n    Returns:\n        (Path): The path to the user config directory.\n    \"\"\"\n    if WINDOWS:\n        path = Path.home() / \"AppData\" / \"Roaming\" / sub_dir\n    elif MACOS:  # macOS\n        path = Path.home() / \"Library\" / \"Application Support\" / sub_dir\n    elif LINUX:\n        path = Path.home() / \".config\" / sub_dir\n    else:\n        raise ValueError(f\"Unsupported operating system: {platform.system()}\")\n\n    # GCP and AWS lambda fix, only /tmp is writeable\n    if not is_dir_writeable(path.parent):\n        LOGGER.warning(\n            f\"user config directory '{path}' is not writeable, defaulting to '/tmp' or CWD.\"\n            \"Alternatively you can define a YOLO_CONFIG_DIR environment variable for this path.\"\n        )\n        path = Path(\"/tmp\") / sub_dir if is_dir_writeable(\"/tmp\") else Path().cwd() / sub_dir\n\n    # Create the subdirectory if it does not exist\n    path.mkdir(parents=True, exist_ok=True)\n\n    return path\n\n\n# Define constants (required below)\nDEVICE_MODEL = read_device_model()  # is_jetson() and is_raspberrypi() depend on this constant\nONLINE = is_online()\nIS_COLAB = is_colab()\nIS_KAGGLE = is_kaggle()\nIS_DOCKER = is_docker()\nIS_JETSON = is_jetson()\nIS_JUPYTER = is_jupyter()\nIS_PIP_PACKAGE = is_pip_package()\nIS_RASPBERRYPI = is_raspberrypi()\nGIT_DIR = get_git_dir()\nIS_GIT_DIR = is_git_dir()\nUSER_CONFIG_DIR = Path(os.getenv(\"YOLO_CONFIG_DIR\") or get_user_config_dir())  # Ultralytics settings dir\nSETTINGS_FILE = USER_CONFIG_DIR / \"settings.json\"\n\n\ndef colorstr(*input):\n    r\"\"\"\n    Colors a string based on the provided color and style arguments. Utilizes ANSI escape codes.\n    See https://en.wikipedia.org/wiki/ANSI_escape_code for more details.\n\n    This function can be called in two ways:\n        - colorstr('color', 'style', 'your string')\n        - colorstr('your string')\n\n    In the second form, 'blue' and 'bold' will be applied by default.\n\n    Args:\n        *input (str | Path): A sequence of strings where the first n-1 strings are color and style arguments,\n                      and the last string is the one to be colored.\n\n    Supported Colors and Styles:\n        Basic Colors: 'black', 'red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'white'\n        Bright Colors: 'bright_black', 'bright_red', 'bright_green', 'bright_yellow',\n                       'bright_blue', 'bright_magenta', 'bright_cyan', 'bright_white'\n        Misc: 'end', 'bold', 'underline'\n\n    Returns:\n        (str): The input string wrapped with ANSI escape codes for the specified color and style.\n\n    Examples:\n        >>> colorstr(\"blue\", \"bold\", \"hello world\")\n        >>> \"\\033[34m\\033[1mhello world\\033[0m\"\n    \"\"\"\n    *args, string = input if len(input) > 1 else (\"blue\", \"bold\", input[0])  # color arguments, string\n    colors = {\n        \"black\": \"\\033[30m\",  # basic colors\n        \"red\": \"\\033[31m\",\n        \"green\": \"\\033[32m\",\n        \"yellow\": \"\\033[33m\",\n        \"blue\": \"\\033[34m\",\n        \"magenta\": \"\\033[35m\",\n        \"cyan\": \"\\033[36m\",\n        \"white\": \"\\033[37m\",\n        \"bright_black\": \"\\033[90m\",  # bright colors\n        \"bright_red\": \"\\033[91m\",\n        \"bright_green\": \"\\033[92m\",\n        \"bright_yellow\": \"\\033[93m\",\n        \"bright_blue\": \"\\033[94m\",\n        \"bright_magenta\": \"\\033[95m\",\n        \"bright_cyan\": \"\\033[96m\",\n        \"bright_white\": \"\\033[97m\",\n        \"end\": \"\\033[0m\",  # misc\n        \"bold\": \"\\033[1m\",\n        \"underline\": \"\\033[4m\",\n    }\n    return \"\".join(colors[x] for x in args) + f\"{string}\" + colors[\"end\"]\n\n\ndef remove_colorstr(input_string):\n    \"\"\"\n    Removes ANSI escape codes from a string, effectively un-coloring it.\n\n    Args:\n        input_string (str): The string to remove color and style from.\n\n    Returns:\n        (str): A new string with all ANSI escape codes removed.\n\n    Examples:\n        >>> remove_colorstr(colorstr(\"blue\", \"bold\", \"hello world\"))\n        >>> \"hello world\"\n    \"\"\"\n    ansi_escape = re.compile(r\"\\x1B\\[[0-9;]*[A-Za-z]\")\n    return ansi_escape.sub(\"\", input_string)\n\n\nclass TryExcept(contextlib.ContextDecorator):\n    \"\"\"\n    Ultralytics TryExcept class. Use as @TryExcept() decorator or 'with TryExcept():' context manager.\n\n    Examples:\n        As a decorator:\n        >>> @TryExcept(msg=\"Error occurred in func\", verbose=True)\n        >>> def func():\n        >>> # Function logic here\n        >>>     pass\n\n        As a context manager:\n        >>> with TryExcept(msg=\"Error occurred in block\", verbose=True):\n        >>> # Code block here\n        >>>     pass\n    \"\"\"\n\n    def __init__(self, msg=\"\", verbose=True):\n        \"\"\"Initialize TryExcept class with optional message and verbosity settings.\"\"\"\n        self.msg = msg\n        self.verbose = verbose\n\n    def __enter__(self):\n        \"\"\"Executes when entering TryExcept context, initializes instance.\"\"\"\n        pass\n\n    def __exit__(self, exc_type, value, traceback):\n        \"\"\"Defines behavior when exiting a 'with' block, prints error message if necessary.\"\"\"\n        if self.verbose and value:\n            LOGGER.warning(f\"{self.msg}{': ' if self.msg else ''}{value}\")\n        return True\n\n\nclass Retry(contextlib.ContextDecorator):\n    \"\"\"\n    Retry class for function execution with exponential backoff.\n\n    Can be used as a decorator to retry a function on exceptions, up to a specified number of times with an\n    exponentially increasing delay between retries.\n\n    Examples:\n        Example usage as a decorator:\n        >>> @Retry(times=3, delay=2)\n        >>> def test_func():\n        >>> # Replace with function logic that may raise exceptions\n        >>>     return True\n    \"\"\"\n\n    def __init__(self, times=3, delay=2):\n        \"\"\"Initialize Retry class with specified number of retries and delay.\"\"\"\n        self.times = times\n        self.delay = delay\n        self._attempts = 0\n\n    def __call__(self, func):\n        \"\"\"Decorator implementation for Retry with exponential backoff.\"\"\"\n\n        def wrapped_func(*args, **kwargs):\n            \"\"\"Applies retries to the decorated function or method.\"\"\"\n            self._attempts = 0\n            while self._attempts < self.times:\n                try:\n                    return func(*args, **kwargs)\n                except Exception as e:\n                    self._attempts += 1\n                    LOGGER.warning(f\"Retry {self._attempts}/{self.times} failed: {e}\")\n                    if self._attempts >= self.times:\n                        raise e\n                    time.sleep(self.delay * (2**self._attempts))  # exponential backoff delay\n\n        return wrapped_func\n\n\ndef threaded(func):\n    \"\"\"\n    Multi-threads a target function by default and returns the thread or function result.\n\n    This decorator provides flexible execution of the target function, either in a separate thread or synchronously.\n    By default, the function runs in a thread, but this can be controlled via the 'threaded=False' keyword argument\n    which is removed from kwargs before calling the function.\n\n    Args:\n        func (callable): The function to be potentially executed in a separate thread.\n\n    Returns:\n        (callable): A wrapper function that either returns a daemon thread or the direct function result.\n\n    Examples:\n        >>> @threaded\n        ... def process_data(data):\n        ...     return data\n        >>>\n        >>> thread = process_data(my_data)  # Runs in background thread\n        >>> result = process_data(my_data, threaded=False)  # Runs synchronously, returns function result\n    \"\"\"\n\n    def wrapper(*args, **kwargs):\n        \"\"\"Multi-threads a given function based on 'threaded' kwarg and returns the thread or function result.\"\"\"\n        if kwargs.pop(\"threaded\", True):  # run in thread\n            thread = threading.Thread(target=func, args=args, kwargs=kwargs, daemon=True)\n            thread.start()\n            return thread\n        else:\n            return func(*args, **kwargs)\n\n    return wrapper\n\n\ndef set_sentry():\n    \"\"\"\n    Initialize the Sentry SDK for error tracking and reporting.\n\n    Only used if sentry_sdk package is installed and sync=True in settings. Run 'yolo settings' to see and update\n    settings.\n\n    Conditions required to send errors (ALL conditions must be met or no errors will be reported):\n        - sentry_sdk package is installed\n        - sync=True in YOLO settings\n        - pytest is not running\n        - running in a pip package installation\n        - running in a non-git directory\n        - running with rank -1 or 0\n        - online environment\n        - CLI used to run package (checked with 'yolo' as the name of the main CLI command)\n    \"\"\"\n    if (\n        not SETTINGS[\"sync\"]\n        or RANK not in {-1, 0}\n        or Path(ARGV[0]).name != \"yolo\"\n        or TESTS_RUNNING\n        or not ONLINE\n        or not IS_PIP_PACKAGE\n        or IS_GIT_DIR\n    ):\n        return\n    # If sentry_sdk package is not installed then return and do not use Sentry\n    try:\n        import sentry_sdk  # noqa\n    except ImportError:\n        return\n\n    def before_send(event, hint):\n        \"\"\"\n        Modify the event before sending it to Sentry based on specific exception types and messages.\n\n        Args:\n            event (dict): The event dictionary containing information about the error.\n            hint (dict): A dictionary containing additional information about the error.\n\n        Returns:\n            dict: The modified event or None if the event should not be sent to Sentry.\n        \"\"\"\n        if \"exc_info\" in hint:\n            exc_type, exc_value, _ = hint[\"exc_info\"]\n            if exc_type in {KeyboardInterrupt, FileNotFoundError} or \"out of memory\" in str(exc_value):\n                return None  # do not send event\n\n        event[\"tags\"] = {\n            \"sys_argv\": ARGV[0],\n            \"sys_argv_name\": Path(ARGV[0]).name,\n            \"install\": \"git\" if IS_GIT_DIR else \"pip\" if IS_PIP_PACKAGE else \"other\",\n            \"os\": ENVIRONMENT,\n        }\n        return event\n\n    sentry_sdk.init(\n        dsn=\"https://888e5a0778212e1d0314c37d4b9aae5d@o4504521589325824.ingest.us.sentry.io/4504521592406016\",\n        debug=False,\n        auto_enabling_integrations=False,\n        traces_sample_rate=1.0,\n        release=__version__,\n        environment=\"runpod\" if is_runpod() else \"production\",\n        before_send=before_send,\n        ignore_errors=[KeyboardInterrupt, FileNotFoundError],\n    )\n    sentry_sdk.set_user({\"id\": SETTINGS[\"uuid\"]})  # SHA-256 anonymized UUID hash\n\n\nclass JSONDict(dict):\n    \"\"\"\n    A dictionary-like class that provides JSON persistence for its contents.\n\n    This class extends the built-in dictionary to automatically save its contents to a JSON file whenever they are\n    modified. It ensures thread-safe operations using a lock.\n\n    Attributes:\n        file_path (Path): The path to the JSON file used for persistence.\n        lock (threading.Lock): A lock object to ensure thread-safe operations.\n\n    Methods:\n        _load: Loads the data from the JSON file into the dictionary.\n        _save: Saves the current state of the dictionary to the JSON file.\n        __setitem__: Stores a key-value pair and persists it to disk.\n        __delitem__: Removes an item and updates the persistent storage.\n        update: Updates the dictionary and persists changes.\n        clear: Clears all entries and updates the persistent storage.\n\n    Examples:\n        >>> json_dict = JSONDict(\"data.json\")\n        >>> json_dict[\"key\"] = \"value\"\n        >>> print(json_dict[\"key\"])\n        value\n        >>> del json_dict[\"key\"]\n        >>> json_dict.update({\"new_key\": \"new_value\"})\n        >>> json_dict.clear()\n    \"\"\"\n\n    def __init__(self, file_path: Union[str, Path] = \"data.json\"):\n        \"\"\"Initialize a JSONDict object with a specified file path for JSON persistence.\"\"\"\n        super().__init__()\n        self.file_path = Path(file_path)\n        self.lock = Lock()\n        self._load()\n\n    def _load(self):\n        \"\"\"Load the data from the JSON file into the dictionary.\"\"\"\n        try:\n            if self.file_path.exists():\n                with open(self.file_path) as f:\n                    self.update(json.load(f))\n        except json.JSONDecodeError:\n            LOGGER.warning(f\"Error decoding JSON from {self.file_path}. Starting with an empty dictionary.\")\n        except Exception as e:\n            LOGGER.error(f\"Error reading from {self.file_path}: {e}\")\n\n    def _save(self):\n        \"\"\"Save the current state of the dictionary to the JSON file.\"\"\"\n        try:\n            self.file_path.parent.mkdir(parents=True, exist_ok=True)\n            with open(self.file_path, \"w\", encoding=\"utf-8\") as f:\n                json.dump(dict(self), f, indent=2, default=self._json_default)\n        except Exception as e:\n            LOGGER.error(f\"Error writing to {self.file_path}: {e}\")\n\n    @staticmethod\n    def _json_default(obj):\n        \"\"\"Handle JSON serialization of Path objects.\"\"\"\n        if isinstance(obj, Path):\n            return str(obj)\n        raise TypeError(f\"Object of type {type(obj).__name__} is not JSON serializable\")\n\n    def __setitem__(self, key, value):\n        \"\"\"Store a key-value pair and persist to disk.\"\"\"\n        with self.lock:\n            super().__setitem__(key, value)\n            self._save()\n\n    def __delitem__(self, key):\n        \"\"\"Remove an item and update the persistent storage.\"\"\"\n        with self.lock:\n            super().__delitem__(key)\n            self._save()\n\n    def __str__(self):\n        \"\"\"Return a pretty-printed JSON string representation of the dictionary.\"\"\"\n        contents = json.dumps(dict(self), indent=2, ensure_ascii=False, default=self._json_default)\n        return f'JSONDict(\"{self.file_path}\"):\\n{contents}'\n\n    def update(self, *args, **kwargs):\n        \"\"\"Update the dictionary and persist changes.\"\"\"\n        with self.lock:\n            super().update(*args, **kwargs)\n            self._save()\n\n    def clear(self):\n        \"\"\"Clear all entries and update the persistent storage.\"\"\"\n        with self.lock:\n            super().clear()\n            self._save()\n\n\nclass SettingsManager(JSONDict):\n    \"\"\"\n    SettingsManager class for managing and persisting Ultralytics settings.\n\n    This class extends JSONDict to provide JSON persistence for settings, ensuring thread-safe operations and default\n    values. It validates settings on initialization and provides methods to update or reset settings.\n\n    Attributes:\n        file (Path): The path to the JSON file used for persistence.\n        version (str): The version of the settings schema.\n        defaults (dict): A dictionary containing default settings.\n        help_msg (str): A help message for users on how to view and update settings.\n\n    Methods:\n        _validate_settings: Validates the current settings and resets if necessary.\n        update: Updates settings, validating keys and types.\n        reset: Resets the settings to default and saves them.\n\n    Examples:\n        Initialize and update settings:\n        >>> settings = SettingsManager()\n        >>> settings.update(runs_dir=\"/new/runs/dir\")\n        >>> print(settings[\"runs_dir\"])\n        /new/runs/dir\n    \"\"\"\n\n    def __init__(self, file=SETTINGS_FILE, version=\"0.0.6\"):\n        \"\"\"Initializes the SettingsManager with default settings and loads user settings.\"\"\"\n        import hashlib\n        import uuid\n\n        from ultralytics.utils.torch_utils import torch_distributed_zero_first\n\n        root = GIT_DIR or Path()\n        datasets_root = (root.parent if GIT_DIR and is_dir_writeable(root.parent) else root).resolve()\n\n        self.file = Path(file)\n        self.version = version\n        self.defaults = {\n            \"settings_version\": version,  # Settings schema version\n            \"datasets_dir\": str(datasets_root / \"datasets\"),  # Datasets directory\n            \"weights_dir\": str(root / \"weights\"),  # Model weights directory\n            \"runs_dir\": str(root / \"runs\"),  # Experiment runs directory\n            \"uuid\": hashlib.sha256(str(uuid.getnode()).encode()).hexdigest(),  # SHA-256 anonymized UUID hash\n            \"sync\": True,  # Enable synchronization\n            \"api_key\": \"\",  # Ultralytics API Key\n            \"openai_api_key\": \"\",  # OpenAI API Key\n            \"clearml\": True,  # ClearML integration\n            \"comet\": True,  # Comet integration\n            \"dvc\": True,  # DVC integration\n            \"hub\": True,  # Ultralytics HUB integration\n            \"mlflow\": True,  # MLflow integration\n            \"neptune\": True,  # Neptune integration\n            \"raytune\": True,  # Ray Tune integration\n            \"tensorboard\": False,  # TensorBoard logging\n            \"wandb\": False,  # Weights & Biases logging\n            \"vscode_msg\": True,  # VSCode message\n            \"openvino_msg\": True,  # OpenVINO export on Intel CPU message\n        }\n\n        self.help_msg = (\n            f\"\\nView Ultralytics Settings with 'yolo settings' or at '{self.file}'\"\n            \"\\nUpdate Settings with 'yolo settings key=value', i.e. 'yolo settings runs_dir=path/to/dir'. \"\n            \"For help see https://docs.ultralytics.com/quickstart/#ultralytics-settings.\"\n        )\n\n        with torch_distributed_zero_first(LOCAL_RANK):\n            super().__init__(self.file)\n\n            if not self.file.exists() or not self:  # Check if file doesn't exist or is empty\n                LOGGER.info(f\"Creating new Ultralytics Settings v{version} file ✅ {self.help_msg}\")\n                self.reset()\n\n            self._validate_settings()\n\n    def _validate_settings(self):\n        \"\"\"Validate the current settings and reset if necessary.\"\"\"\n        correct_keys = frozenset(self.keys()) == frozenset(self.defaults.keys())\n        correct_types = all(isinstance(self.get(k), type(v)) for k, v in self.defaults.items())\n        correct_version = self.get(\"settings_version\", \"\") == self.version\n\n        if not (correct_keys and correct_types and correct_version):\n            LOGGER.warning(\n                \"Ultralytics settings reset to default values. This may be due to a possible problem \"\n                f\"with your settings or a recent ultralytics package update. {self.help_msg}\"\n            )\n            self.reset()\n\n        if self.get(\"datasets_dir\") == self.get(\"runs_dir\"):\n            LOGGER.warning(\n                f\"Ultralytics setting 'datasets_dir: {self.get('datasets_dir')}' \"\n                f\"must be different than 'runs_dir: {self.get('runs_dir')}'. \"\n                f\"Please change one to avoid possible issues during training. {self.help_msg}\"\n            )\n\n    def __setitem__(self, key, value):\n        \"\"\"Updates one key: value pair.\"\"\"\n        self.update({key: value})\n\n    def update(self, *args, **kwargs):\n        \"\"\"Updates settings, validating keys and types.\"\"\"\n        for arg in args:\n            if isinstance(arg, dict):\n                kwargs.update(arg)\n        for k, v in kwargs.items():\n            if k not in self.defaults:\n                raise KeyError(f\"No Ultralytics setting '{k}'. {self.help_msg}\")\n            t = type(self.defaults[k])\n            if not isinstance(v, t):\n                raise TypeError(\n                    f\"Ultralytics setting '{k}' must be '{t.__name__}' type, not '{type(v).__name__}'. {self.help_msg}\"\n                )\n        super().update(*args, **kwargs)\n\n    def reset(self):\n        \"\"\"Resets the settings to default and saves them.\"\"\"\n        self.clear()\n        self.update(self.defaults)\n\n\ndef deprecation_warn(arg, new_arg=None):\n    \"\"\"Issue a deprecation warning when a deprecated argument is used, suggesting an updated argument.\"\"\"\n    msg = f\"'{arg}' is deprecated and will be removed in in the future.\"\n    if new_arg is not None:\n        msg += f\" Use '{new_arg}' instead.\"\n    LOGGER.warning(msg)\n\n\ndef clean_url(url):\n    \"\"\"Strip auth from URL, i.e. https://url.com/file.txt?auth -> https://url.com/file.txt.\"\"\"\n    url = Path(url).as_posix().replace(\":/\", \"://\")  # Pathlib turns :// -> :/, as_posix() for Windows\n    return unquote(url).split(\"?\", 1)[0]  # '%2F' to '/', split https://url.com/file.txt?auth\n\n\ndef url2file(url):\n    \"\"\"Convert URL to filename, i.e. https://url.com/file.txt?auth -> file.txt.\"\"\"\n    return Path(clean_url(url)).name\n\n\ndef vscode_msg(ext=\"ultralytics.ultralytics-snippets\") -> str:\n    \"\"\"Display a message to install Ultralytics-Snippets for VS Code if not already installed.\"\"\"\n    path = (USER_CONFIG_DIR.parents[2] if WINDOWS else USER_CONFIG_DIR.parents[1]) / \".vscode/extensions\"\n    obs_file = path / \".obsolete\"  # file tracks uninstalled extensions, while source directory remains\n    installed = any(path.glob(f\"{ext}*\")) and ext not in (obs_file.read_text(\"utf-8\") if obs_file.exists() else \"\")\n    url = \"https://docs.ultralytics.com/integrations/vscode\"\n    return \"\" if installed else f\"{colorstr('VS Code:')} view Ultralytics VS Code Extension ⚡ at {url}\"\n\n\n# Run below code on utils init ------------------------------------------------------------------------------------\n\n# Check first-install steps\nPREFIX = colorstr(\"Ultralytics: \")\nSETTINGS = SettingsManager()  # initialize settings\nPERSISTENT_CACHE = JSONDict(USER_CONFIG_DIR / \"persistent_cache.json\")  # initialize persistent cache\nDATASETS_DIR = Path(SETTINGS[\"datasets_dir\"])  # global datasets directory\nWEIGHTS_DIR = Path(SETTINGS[\"weights_dir\"])  # global weights directory\nRUNS_DIR = Path(SETTINGS[\"runs_dir\"])  # global runs directory\nENVIRONMENT = (\n    \"Colab\"\n    if IS_COLAB\n    else \"Kaggle\"\n    if IS_KAGGLE\n    else \"Jupyter\"\n    if IS_JUPYTER\n    else \"Docker\"\n    if IS_DOCKER\n    else platform.system()\n)\nTESTS_RUNNING = is_pytest_running() or is_github_action_running()\nset_sentry()\n\n# Apply monkey patches\ntorch.load = torch_load\ntorch.save = torch_save\nif WINDOWS:\n    # Apply cv2 patches for non-ASCII and non-UTF characters in image paths\n    cv2.imread, cv2.imwrite, cv2.imshow = imread, imwrite, imshow\n"}}}}