dgenerate-ultralytics-headless 8.3.137__py3-none-any.whl → 8.3.139__py3-none-any.whl

ultralytics/utils/checks.py

@@ -73,7 +73,7 @@ def parse_requirements(file_path=ROOT.parent / "requirements.txt", package=""):
     for line in requires:
         line = line.strip()
         if line and not line.startswith("#"):
-            line = line.split("#")[0].strip()  # ignore inline comments
+            line = line.partition("#")[0].strip()  # ignore inline comments
             if match := re.match(r"([a-zA-Z0-9-_]+)\s*([<>!=~]+.*)?", line):
                 requirements.append(SimpleNamespace(name=match[1], specifier=match[2].strip() if match[2] else ""))
 
@@ -379,7 +379,7 @@ def check_requirements(requirements=ROOT.parent / "requirements.txt", exclude=()
 
     pkgs = []
     for r in requirements:
-        r_stripped = r.split("/")[-1].replace(".git", "")  # replace git+https://org/repo.git -> 'repo'
+        r_stripped = r.rpartition("/")[-1].replace(".git", "")  # replace git+https://org/repo.git -> 'repo'
         match = re.match(r"([a-zA-Z0-9-_]+)([<>!=~]+.*)?", r_stripped)
         name, required = match[1], match[2].strip() if match[2] else ""
         try:
@@ -388,21 +388,28 @@ def check_requirements(requirements=ROOT.parent / "requirements.txt", exclude=()
             pkgs.append(r)
 
     @Retry(times=2, delay=1)
-    def attempt_install(packages, commands):
-        """Attempt pip install command with retries on failure."""
-        return subprocess.check_output(f"pip install --no-cache-dir {packages} {commands}", shell=True).decode()
+    def attempt_install(packages, commands, use_uv):
+        """Attempt package installation with uv if available, falling back to pip."""
+        if use_uv:
+            # Note requires --break-system-packages on ARM64 dockerfile
+            cmd = f"uv pip install --system --no-cache-dir {packages} {commands} --index-strategy=unsafe-best-match --break-system-packages --prerelease=allow"
+        else:
+            cmd = f"pip install --no-cache-dir {packages} {commands}"
+        return subprocess.check_output(cmd, shell=True).decode()
 
     s = " ".join(f'"{x}"' for x in pkgs)  # console string
     if s:
         if install and AUTOINSTALL:  # check environment variable
+            # Note uv fails on arm64 macOS and Raspberry Pi runners
+            uv = not ARM64 and subprocess.run(["command", "-v", "uv"], capture_output=True, shell=True).returncode == 0
             n = len(pkgs)  # number of packages updates
             LOGGER.info(f"{prefix} Ultralytics requirement{'s' * (n > 1)} {pkgs} not found, attempting AutoUpdate...")
             try:
                 t = time.time()
                 assert ONLINE, "AutoUpdate skipped (offline)"
-                LOGGER.info(attempt_install(s, cmds))
+                LOGGER.info(attempt_install(s, cmds, use_uv=uv))
                 dt = time.time() - t
-                LOGGER.info(f"{prefix} AutoUpdate success ✅ {dt:.1f}s, installed {n} package{'s' * (n > 1)}: {pkgs}")
+                LOGGER.info(f"{prefix} AutoUpdate success ✅ {dt:.1f}s")
                 LOGGER.warning(
                     f"{prefix} {colorstr('bold', 'Restart runtime or rerun command for updates to take effect')}\n"
                 )
@@ -423,6 +430,7 @@ def check_torchvision():
     to the compatibility table based on: https://github.com/pytorch/vision#installation.
     """
     compatibility_table = {
+        "2.7": ["0.22"],
         "2.6": ["0.21"],
         "2.5": ["0.20"],
         "2.4": ["0.19"],
@@ -435,10 +443,10 @@ def check_torchvision():
     }
 
     # Check major and minor versions
-    v_torch = ".".join(torch.__version__.split("+")[0].split(".")[:2])
+    v_torch = ".".join(torch.__version__.split("+", 1)[0].split(".")[:2])
     if v_torch in compatibility_table:
         compatible_versions = compatibility_table[v_torch]
-        v_torchvision = ".".join(TORCHVISION_VERSION.split("+")[0].split(".")[:2])
+        v_torchvision = ".".join(TORCHVISION_VERSION.split("+", 1)[0].split(".")[:2])
         if all(v_torchvision != v for v in compatible_versions):
             LOGGER.warning(
                 f"torchvision=={v_torchvision} is incompatible with torch=={v_torch}.\n"
@@ -461,9 +469,8 @@ def check_suffix(file="yolo11n.pt", suffix=".pt", msg=""):
         if isinstance(suffix, str):
             suffix = {suffix}
         for f in file if isinstance(file, (list, tuple)) else [file]:
-            s = Path(f).suffix.lower().strip()  # file suffix
-            if len(s):
-                assert s in suffix, f"{msg}{f} acceptable suffix is {suffix}, not {s}"
+            if s := str(f).rpartition(".")[-1].lower().strip():  # file suffix
+                assert f".{s}" in suffix, f"{msg}{f} acceptable suffix is {suffix}, not .{s}"
 
 
 def check_yolov5u_filename(file: str, verbose: bool = True):
@@ -504,10 +511,10 @@ def check_model_file_from_stem(model="yolo11n"):
     Returns:
         (str | Path): Model filename with appropriate suffix.
     """
-    if model and not Path(model).suffix and Path(model).stem in downloads.GITHUB_ASSETS_STEMS:
-        return Path(model).with_suffix(".pt")  # add suffix, i.e. yolo11n -> yolo11n.pt
-    else:
-        return model
+    path = Path(model)
+    if not path.suffix and path.stem in downloads.GITHUB_ASSETS_STEMS:
+        return path.with_suffix(".pt")  # add suffix, i.e. yolo11n -> yolo11n.pt
+    return model
 
 
 def check_file(file, suffix="", download=True, download_dir=".", hard=True):
@@ -655,7 +662,7 @@ def collect_system_info():
     from ultralytics.utils.torch_utils import get_cpu_info, get_gpu_info
 
     gib = 1 << 30  # bytes per GiB
-    cuda = torch and torch.cuda.is_available()
+    cuda = torch.cuda.is_available()
     check_yolo()
     total, used, free = shutil.disk_usage("/")
 
@@ -837,7 +844,7 @@ def cuda_device_count() -> int:
             )
 
             # Take the first line and strip any leading/trailing white space
-            first_line = output.strip().split("\n")[0]
+            first_line = output.strip().split("\n", 1)[0]
 
             return int(first_line)
         except (subprocess.CalledProcessError, FileNotFoundError, ValueError):

ultralytics/utils/downloads.py

@@ -32,11 +32,13 @@ GITHUB_ASSETS_NAMES = frozenset(
     + [f"sam2.1_{k}.pt" for k in "blst"]
     + [f"FastSAM-{k}.pt" for k in "sx"]
     + [f"rtdetr-{k}.pt" for k in "lx"]
-    + ["mobile_sam.pt"]
-    + ["mobileclip_blt.ts"]
-    + ["calibration_image_sample_data_20x128x128x3_float32.npy.zip"]
+    + [
+        "mobile_sam.pt",
+        "mobileclip_blt.ts",
+        "calibration_image_sample_data_20x128x128x3_float32.npy.zip",
+    ]
 )
-GITHUB_ASSETS_STEMS = frozenset(k.rsplit(".", 1)[0] for k in GITHUB_ASSETS_NAMES)
+GITHUB_ASSETS_STEMS = frozenset(k.rpartition(".")[0] for k in GITHUB_ASSETS_NAMES)
 
 
 def is_url(url, check=False):
@@ -247,7 +249,7 @@ def get_google_drive_file_info(link):
     """
     import requests  # slow import
 
-    file_id = link.split("/d/")[1].split("/view")[0]
+    file_id = link.split("/d/")[1].split("/view", 1)[0]
     drive_url = f"https://drive.google.com/uc?export=download&id={file_id}"
     filename = None
 

ultralytics/utils/export.py

@@ -97,7 +97,7 @@ def export_engine(
     builder = trt.Builder(logger)
     config = builder.create_builder_config()
     workspace = int((workspace or 0) * (1 << 30))
-    is_trt10 = int(trt.__version__.split(".")[0]) >= 10  # is TensorRT >= 10
+    is_trt10 = int(trt.__version__.split(".", 1)[0]) >= 10  # is TensorRT >= 10
     if is_trt10 and workspace > 0:
         config.set_memory_pool_limit(trt.MemoryPoolType.WORKSPACE, workspace)
     elif workspace > 0:  # TensorRT versions 7, 8

ultralytics/utils/metrics.py

@@ -8,7 +8,7 @@ from pathlib import Path
 import numpy as np
 import torch
 
-from ultralytics.utils import LOGGER, SimpleClass, TryExcept, checks, plt_settings
+from ultralytics.utils import LOGGER, DataExportMixin, SimpleClass, TryExcept, checks, plt_settings
 
 OKS_SIGMA = (
     np.array([0.26, 0.25, 0.25, 0.35, 0.35, 0.79, 0.79, 0.72, 0.72, 0.62, 0.62, 1.07, 1.07, 0.87, 0.87, 0.89, 0.89])
@@ -865,7 +865,7 @@ class Metric(SimpleClass):
         ]
 
 
-class DetMetrics(SimpleClass):
+class DetMetrics(SimpleClass, DataExportMixin):
     """
     Utility class for computing detection metrics such as precision, recall, and mean average precision (mAP).
 
@@ -961,8 +961,29 @@ class DetMetrics(SimpleClass):
         """Return dictionary of computed performance metrics and statistics."""
         return self.box.curves_results
 
+    def summary(self, **kwargs):
+        """Returns per-class detection metrics with shared scalar values included."""
+        scalars = {
+            "box-map": self.box.map,
+            "box-map50": self.box.map50,
+            "box-map75": self.box.map75,
+        }
+        per_class = {
+            "box-p": self.box.p,
+            "box-r": self.box.r,
+            "box-f1": self.box.f1,
+        }
+        return [
+            {
+                "class_name": self.names[i] if hasattr(self, "names") and i in self.names else str(i),
+                **{k: v[i] for k, v in per_class.items()},
+                **scalars,
+            }
+            for i in range(len(next(iter(per_class.values()), [])))
+        ]
 
-class SegmentMetrics(SimpleClass):
+
+class SegmentMetrics(SimpleClass, DataExportMixin):
     """
     Calculates and aggregates detection and segmentation metrics over a given set of classes.
 
@@ -1097,6 +1118,29 @@ class SegmentMetrics(SimpleClass):
         """Return dictionary of computed performance metrics and statistics."""
         return self.box.curves_results + self.seg.curves_results
 
+    def summary(self, **kwargs):
+        """Returns per-class segmentation metrics with shared scalar values included (box + mask)."""
+        scalars = {
+            "box-map": self.box.map,
+            "box-map50": self.box.map50,
+            "box-map75": self.box.map75,
+            "mask-map": self.seg.map,
+            "mask-map50": self.seg.map50,
+            "mask-map75": self.seg.map75,
+        }
+        per_class = {
+            "box-p": self.box.p,
+            "box-r": self.box.r,
+            "box-f1": self.box.f1,
+            "mask-p": self.seg.p,
+            "mask-r": self.seg.r,
+            "mask-f1": self.seg.f1,
+        }
+        return [
+            {"class_name": self.names[i], **{k: v[i] for k, v in per_class.items()}, **scalars}
+            for i in range(len(next(iter(per_class.values()), [])))
+        ]
+
 
 class PoseMetrics(SegmentMetrics):
     """
@@ -1229,8 +1273,31 @@ class PoseMetrics(SegmentMetrics):
         """Return dictionary of computed performance metrics and statistics."""
         return self.box.curves_results + self.pose.curves_results
 
+    def summary(self, **kwargs):
+        """Returns per-class pose metrics with shared scalar values included (box + pose)."""
+        scalars = {
+            "box-map": self.box.map,
+            "box-map50": self.box.map50,
+            "box-map75": self.box.map75,
+            "pose-map": self.pose.map,
+            "pose-map50": self.pose.map50,
+            "pose-map75": self.pose.map75,
+        }
+        per_class = {
+            "box-p": self.box.p,
+            "box-r": self.box.r,
+            "box-f1": self.box.f1,
+            "pose-p": self.pose.p,
+            "pose-r": self.pose.r,
+            "pose-f1": self.pose.f1,
+        }
+        return [
+            {"class_name": self.names[i], **{k: v[i] for k, v in per_class.items()}, **scalars}
+            for i in range(len(next(iter(per_class.values()), [])))
+        ]
+
 
-class ClassifyMetrics(SimpleClass):
+class ClassifyMetrics(SimpleClass, DataExportMixin):
     """
     Class for computing classification metrics including top-1 and top-5 accuracy.
 
@@ -1286,8 +1353,12 @@ class ClassifyMetrics(SimpleClass):
         """Return a list of curves for accessing specific metrics curves."""
         return []
 
+    def summary(self, **kwargs):
+        """Returns a single-row summary for classification metrics (top1/top5)."""
+        return [{"classify-top1": self.top1, "classify-top5": self.top5}]
+
 
-class OBBMetrics(SimpleClass):
+class OBBMetrics(SimpleClass, DataExportMixin):
     """
     Metrics for evaluating oriented bounding box (OBB) detection.
 
@@ -1316,6 +1387,7 @@ class OBBMetrics(SimpleClass):
         self.names = names
         self.box = Metric()
         self.speed = {"preprocess": 0.0, "inference": 0.0, "loss": 0.0, "postprocess": 0.0}
+        self.task = "obb"
 
     def process(self, tp, conf, pred_cls, target_cls, on_plot=None):
         """
@@ -1383,3 +1455,16 @@ class OBBMetrics(SimpleClass):
     def curves_results(self):
         """Return a list of curves for accessing specific metrics curves."""
         return []
+
+    def summary(self, **kwargs):
+        """Returns per-class detection metrics with shared scalar values included."""
+        scalars = {
+            "box-map": self.box.map,
+            "box-map50": self.box.map50,
+            "box-map75": self.box.map75,
+        }
+        per_class = {"box-p": self.box.p, "box-r": self.box.r, "box-f1": self.box.f1}
+        return [
+            {"class_name": self.names[i], **{k: v[i] for k, v in per_class.items()}, **scalars}
+            for i in range(len(next(iter(per_class.values()), [])))
+        ]

ultralytics/utils/plotting.py

@@ -1000,7 +1000,7 @@ def feature_visualization(x, module_type, stage, n=32, save_dir=Path("runs/detec
     if isinstance(x, torch.Tensor):
         _, channels, height, width = x.shape  # batch, channels, height, width
         if height > 1 and width > 1:
-            f = save_dir / f"stage{stage}_{module_type.split('.')[-1]}_features.png"  # filename
+            f = save_dir / f"stage{stage}_{module_type.rsplit('.', 1)[-1]}_features.png"  # filename
 
             blocks = torch.chunk(x[0].cpu(), channels, dim=0)  # select batch index 0, block by channels
             n = min(n, channels)  # number of plots

ultralytics/utils/torch_utils.py

@@ -1,5 +1,6 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
+import functools
 import gc
 import math
 import os
@@ -101,6 +102,7 @@ def autocast(enabled: bool, device: str = "cuda"):
         return torch.cuda.amp.autocast(enabled)
 
 
+@functools.lru_cache
 def get_cpu_info():
     """Return a string with system CPU information, i.e. 'Apple M2'."""
     from ultralytics.utils import PERSISTENT_CACHE  # avoid circular import error
@@ -118,6 +120,7 @@ def get_cpu_info():
     return PERSISTENT_CACHE.get("cpu_info", "unknown")
 
 
+@functools.lru_cache
 def get_gpu_info(index):
     """Return a string with system GPU information, i.e. 'Tesla T4, 15102MiB'."""
     properties = torch.cuda.get_device_properties(index)

ultralytics/utils/triton.py

@@ -53,7 +53,7 @@ class TritonRemoteModel:
         """
         if not endpoint and not scheme:  # Parse all args from URL string
             splits = urlsplit(url)
-            endpoint = splits.path.strip("/").split("/")[0]
+            endpoint = splits.path.strip("/").split("/", 1)[0]
             scheme = splits.scheme
             url = splits.netloc