dgenerate-ultralytics-headless 8.3.189__py3-none-any.whl → 8.3.191__py3-none-any.whl

ultralytics/utils/files.py

@@ -1,5 +1,7 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
+from __future__ import annotations
+
 import contextlib
 import glob
 import os
@@ -8,7 +10,6 @@ import tempfile
 from contextlib import contextmanager
 from datetime import datetime
 from pathlib import Path
-from typing import Union
 
 
 class WorkingDirectory(contextlib.ContextDecorator):
@@ -39,7 +40,7 @@ class WorkingDirectory(contextlib.ContextDecorator):
         >>>     pass
     """
 
-    def __init__(self, new_dir: Union[str, Path]):
+    def __init__(self, new_dir: str | Path):
         """Initialize the WorkingDirectory context manager with the target directory."""
         self.dir = new_dir  # new dir
         self.cwd = Path.cwd().resolve()  # current dir
@@ -54,7 +55,7 @@ class WorkingDirectory(contextlib.ContextDecorator):
 
 
 @contextmanager
-def spaces_in_path(path: Union[str, Path]):
+def spaces_in_path(path: str | Path):
     """
     Context manager to handle paths with spaces in their names.
 
@@ -105,7 +106,7 @@ def spaces_in_path(path: Union[str, Path]):
         yield path
 
 
-def increment_path(path: Union[str, Path], exist_ok: bool = False, sep: str = "", mkdir: bool = False) -> Path:
+def increment_path(path: str | Path, exist_ok: bool = False, sep: str = "", mkdir: bool = False) -> Path:
     """
     Increment a file or directory path, i.e., runs/exp --> runs/exp{sep}2, runs/exp{sep}3, ... etc.
 
@@ -153,19 +154,19 @@ def increment_path(path: Union[str, Path], exist_ok: bool = False, sep: str = ""
     return path
 
 
-def file_age(path: Union[str, Path] = __file__) -> int:
+def file_age(path: str | Path = __file__) -> int:
     """Return days since the last modification of the specified file."""
     dt = datetime.now() - datetime.fromtimestamp(Path(path).stat().st_mtime)  # delta
     return dt.days  # + dt.seconds / 86400  # fractional days
 
 
-def file_date(path: Union[str, Path] = __file__) -> str:
+def file_date(path: str | Path = __file__) -> str:
     """Return the file modification date in 'YYYY-M-D' format."""
     t = datetime.fromtimestamp(Path(path).stat().st_mtime)
     return f"{t.year}-{t.month}-{t.day}"
 
 
-def file_size(path: Union[str, Path]) -> float:
+def file_size(path: str | Path) -> float:
     """Return the size of a file or directory in megabytes (MB)."""
     if isinstance(path, (str, Path)):
         mb = 1 << 20  # bytes to MiB (1024 ** 2)

ultralytics/utils/git.py

@@ -0,0 +1,139 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+from __future__ import annotations
+
+from functools import cached_property
+from pathlib import Path
+
+
+class GitRepo:
+    """
+    Represent a local Git repository and expose branch, commit, and remote metadata.
+
+    This class discovers the repository root by searching for a .git entry from the given path upward, resolves the
+    actual .git directory (including worktrees), and reads Git metadata directly from on-disk files. It does not
+    invoke the git binary and therefore works in restricted environments. All metadata properties are resolved
+    lazily and cached; construct a new instance to refresh state.
+
+    Attributes:
+        root (Path | None): Repository root directory containing the .git entry; None if not in a repository.
+        gitdir (Path | None): Resolved .git directory path; handles worktrees; None if unresolved.
+        head (str | None): Raw contents of HEAD; a SHA for detached HEAD or "ref: <refname>" for branch heads.
+        is_repo (bool): Whether the provided path resides inside a Git repository.
+        branch (str | None): Current branch name when HEAD points to a branch; None for detached HEAD or non-repo.
+        commit (str | None): Current commit SHA for HEAD; None if not determinable.
+        origin (str | None): URL of the "origin" remote as read from gitdir/config; None if unset or unavailable.
+
+    Examples:
+        Initialize from the current working directory and read metadata
+        >>> from pathlib import Path
+        >>> repo = GitRepo(Path.cwd())
+        >>> repo.is_repo
+        True
+        >>> repo.branch, repo.commit[:7], repo.origin
+        ('main', '1a2b3c4', 'https://example.com/owner/repo.git')
+
+    Notes:
+        - Resolves metadata by reading files: HEAD, packed-refs, and config; no subprocess calls are used.
+        - Caches properties on first access using cached_property; recreate the object to reflect repository changes.
+    """
+
+    def __init__(self, path: Path = Path(__file__).resolve()):
+        """
+        Initialize a Git repository context by discovering the repository root from a starting path.
+
+        Args:
+            path (Path, optional): File or directory path used as the starting point to locate the repository root.
+        """
+        self.root = self._find_root(path)
+        self.gitdir = self._gitdir(self.root) if self.root else None
+
+    @staticmethod
+    def _find_root(p: Path) -> Path | None:
+        """Return repo root or None."""
+        return next((d for d in [p] + list(p.parents) if (d / ".git").exists()), None)
+
+    @staticmethod
+    def _gitdir(root: Path) -> Path | None:
+        """Resolve actual .git directory (handles worktrees)."""
+        g = root / ".git"
+        if g.is_dir():
+            return g
+        if g.is_file():
+            t = g.read_text(errors="ignore").strip()
+            if t.startswith("gitdir:"):
+                return (root / t.split(":", 1)[1].strip()).resolve()
+        return None
+
+    def _read(self, p: Path | None) -> str | None:
+        """Read and strip file if exists."""
+        return p.read_text(errors="ignore").strip() if p and p.exists() else None
+
+    @cached_property
+    def head(self) -> str | None:
+        """HEAD file contents."""
+        return self._read(self.gitdir / "HEAD" if self.gitdir else None)
+
+    def _ref_commit(self, ref: str) -> str | None:
+        """Commit for ref (handles packed-refs)."""
+        rf = self.gitdir / ref
+        s = self._read(rf)
+        if s:
+            return s
+        pf = self.gitdir / "packed-refs"
+        b = pf.read_bytes().splitlines() if pf.exists() else []
+        tgt = ref.encode()
+        for line in b:
+            if line[:1] in (b"#", b"^") or b" " not in line:
+                continue
+            sha, name = line.split(b" ", 1)
+            if name.strip() == tgt:
+                return sha.decode()
+        return None
+
+    @property
+    def is_repo(self) -> bool:
+        """True if inside a git repo."""
+        return self.gitdir is not None
+
+    @cached_property
+    def branch(self) -> str | None:
+        """Current branch or None."""
+        if not self.is_repo or not self.head or not self.head.startswith("ref: "):
+            return None
+        ref = self.head[5:].strip()
+        return ref[len("refs/heads/") :] if ref.startswith("refs/heads/") else ref
+
+    @cached_property
+    def commit(self) -> str | None:
+        """Current commit SHA or None."""
+        if not self.is_repo or not self.head:
+            return None
+        return self._ref_commit(self.head[5:].strip()) if self.head.startswith("ref: ") else self.head
+
+    @cached_property
+    def origin(self) -> str | None:
+        """Origin URL or None."""
+        if not self.is_repo:
+            return None
+        cfg = self.gitdir / "config"
+        remote, url = None, None
+        for s in (self._read(cfg) or "").splitlines():
+            t = s.strip()
+            if t.startswith("[") and t.endswith("]"):
+                remote = t.lower()
+            elif t.lower().startswith("url =") and remote == '[remote "origin"]':
+                url = t.split("=", 1)[1].strip()
+                break
+        return url
+
+
+if __name__ == "__main__":
+    import time
+
+    g = GitRepo()
+    if g.is_repo:
+        t0 = time.perf_counter()
+        print(f"repo={g.root}\nbranch={g.branch}\ncommit={g.commit}\norigin={g.origin}")
+        dt = (time.perf_counter() - t0) * 1000
+        print(f"\n⏱️ Profiling: total {dt:.3f} ms")

ultralytics/utils/instance.py

@@ -1,9 +1,10 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
+from __future__ import annotations
+
 from collections import abc
 from itertools import repeat
 from numbers import Number
-from typing import List, Union
 
 import numpy as np
 
@@ -101,7 +102,7 @@ class Bboxes:
             else self.bboxes[:, 3] * self.bboxes[:, 2]  # format xywh or ltwh
         )
 
-    def mul(self, scale: Union[int, tuple, list]) -> None:
+    def mul(self, scale: int | tuple | list) -> None:
         """
         Multiply bounding box coordinates by scale factor(s).
 
@@ -118,7 +119,7 @@ class Bboxes:
         self.bboxes[:, 2] *= scale[2]
         self.bboxes[:, 3] *= scale[3]
 
-    def add(self, offset: Union[int, tuple, list]) -> None:
+    def add(self, offset: int | tuple | list) -> None:
         """
         Add offset to bounding box coordinates.
 
@@ -140,7 +141,7 @@ class Bboxes:
         return len(self.bboxes)
 
     @classmethod
-    def concatenate(cls, boxes_list: List["Bboxes"], axis: int = 0) -> "Bboxes":
+    def concatenate(cls, boxes_list: list[Bboxes], axis: int = 0) -> Bboxes:
         """
         Concatenate a list of Bboxes objects into a single Bboxes object.
 
@@ -163,7 +164,7 @@ class Bboxes:
             return boxes_list[0]
         return cls(np.concatenate([b.bboxes for b in boxes_list], axis=axis))
 
-    def __getitem__(self, index: Union[int, np.ndarray, slice]) -> "Bboxes":
+    def __getitem__(self, index: int | np.ndarray | slice) -> Bboxes:
         """
         Retrieve a specific bounding box or a set of bounding boxes using indexing.
 
@@ -327,7 +328,7 @@ class Instances:
             self.keypoints[..., 0] += padw
             self.keypoints[..., 1] += padh
 
-    def __getitem__(self, index: Union[int, np.ndarray, slice]) -> "Instances":
+    def __getitem__(self, index: int | np.ndarray | slice) -> Instances:
         """
         Retrieve a specific instance or a set of instances using indexing.
 
@@ -452,7 +453,7 @@ class Instances:
         return len(self.bboxes)
 
     @classmethod
-    def concatenate(cls, instances_list: List["Instances"], axis=0) -> "Instances":
+    def concatenate(cls, instances_list: list[Instances], axis=0) -> Instances:
         """
         Concatenate a list of Instances objects into a single Instances object.
 

ultralytics/utils/logger.py

@@ -9,9 +9,6 @@ import time
 from datetime import datetime
 from pathlib import Path
 
-import psutil
-import requests
-
 from ultralytics.utils import MACOS, RANK
 from ultralytics.utils.checks import check_requirements
 
@@ -189,8 +186,10 @@ class ConsoleLogger:
         """Write log to API endpoint or local file destination."""
         try:
             if self.is_api:
+                import requests  # scoped as slow import
+
                 payload = {"timestamp": datetime.now().isoformat(), "message": text.strip()}
-                requests.post(self.destination, json=payload, timeout=5)
+                requests.post(str(self.destination), json=payload, timeout=5)
             else:
                 self.destination.parent.mkdir(parents=True, exist_ok=True)
                 with self.destination.open("a", encoding="utf-8") as f:
@@ -237,7 +236,6 @@ class SystemLogger:
     Attributes:
         pynvml: NVIDIA pynvml module instance if successfully imported, None otherwise.
         nvidia_initialized (bool): Whether NVIDIA GPU monitoring is available and initialized.
-        process (psutil.Process): Current psutil.Process instance for process-specific metrics.
         net_start: Initial network I/O counters for calculating cumulative usage.
         disk_start: Initial disk I/O counters for calculating cumulative usage.
 
@@ -260,9 +258,10 @@ class SystemLogger:
 
     def __init__(self):
         """Initialize the system logger."""
+        import psutil  # scoped as slow import
+
         self.pynvml = None
         self.nvidia_initialized = self._init_nvidia()
-        self.process = psutil.Process()
         self.net_start = psutil.net_io_counters()
         self.disk_start = psutil.disk_io_counters()
 
@@ -315,6 +314,8 @@ class SystemLogger:
         Returns:
             metrics (dict): System metrics containing 'cpu', 'ram', 'disk', 'network', 'gpus' with respective usage data.
         """
+        import psutil  # scoped as slow import
+
         net = psutil.net_io_counters()
         disk = psutil.disk_io_counters()
         memory = psutil.virtual_memory()

ultralytics/utils/loss.py

@@ -1,6 +1,8 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
-from typing import Any, Dict, List, Tuple
+from __future__ import annotations
+
+from typing import Any
 
 import torch
 import torch.nn as nn
@@ -122,7 +124,7 @@ class BboxLoss(nn.Module):
         target_scores: torch.Tensor,
         target_scores_sum: torch.Tensor,
         fg_mask: torch.Tensor,
-    ) -> Tuple[torch.Tensor, torch.Tensor]:
+    ) -> tuple[torch.Tensor, torch.Tensor]:
         """Compute IoU and DFL losses for bounding boxes."""
         weight = target_scores.sum(-1)[fg_mask].unsqueeze(-1)
         iou = bbox_iou(pred_bboxes[fg_mask], target_bboxes[fg_mask], xywh=False, CIoU=True)
@@ -155,7 +157,7 @@ class RotatedBboxLoss(BboxLoss):
         target_scores: torch.Tensor,
         target_scores_sum: torch.Tensor,
         fg_mask: torch.Tensor,
-    ) -> Tuple[torch.Tensor, torch.Tensor]:
+    ) -> tuple[torch.Tensor, torch.Tensor]:
         """Compute IoU and DFL losses for rotated bounding boxes."""
         weight = target_scores.sum(-1)[fg_mask].unsqueeze(-1)
         iou = probiou(pred_bboxes[fg_mask], target_bboxes[fg_mask])
@@ -240,7 +242,7 @@ class v8DetectionLoss:
             # pred_dist = (pred_dist.view(b, a, c // 4, 4).softmax(2) * self.proj.type(pred_dist.dtype).view(1, 1, -1, 1)).sum(2)
         return dist2bbox(pred_dist, anchor_points, xywh=False)
 
-    def __call__(self, preds: Any, batch: Dict[str, torch.Tensor]) -> Tuple[torch.Tensor, torch.Tensor]:
+    def __call__(self, preds: Any, batch: dict[str, torch.Tensor]) -> tuple[torch.Tensor, torch.Tensor]:
         """Calculate the sum of the loss for box, cls and dfl multiplied by batch size."""
         loss = torch.zeros(3, device=self.device)  # box, cls, dfl
         feats = preds[1] if isinstance(preds, tuple) else preds
@@ -305,7 +307,7 @@ class v8SegmentationLoss(v8DetectionLoss):
         super().__init__(model)
         self.overlap = model.args.overlap_mask
 
-    def __call__(self, preds: Any, batch: Dict[str, torch.Tensor]) -> Tuple[torch.Tensor, torch.Tensor]:
+    def __call__(self, preds: Any, batch: dict[str, torch.Tensor]) -> tuple[torch.Tensor, torch.Tensor]:
         """Calculate and return the combined loss for detection and segmentation."""
         loss = torch.zeros(4, device=self.device)  # box, seg, cls, dfl
         feats, pred_masks, proto = preds if len(preds) == 3 else preds[1]
@@ -493,7 +495,7 @@ class v8PoseLoss(v8DetectionLoss):
         sigmas = torch.from_numpy(OKS_SIGMA).to(self.device) if is_pose else torch.ones(nkpt, device=self.device) / nkpt
         self.keypoint_loss = KeypointLoss(sigmas=sigmas)
 
-    def __call__(self, preds: Any, batch: Dict[str, torch.Tensor]) -> Tuple[torch.Tensor, torch.Tensor]:
+    def __call__(self, preds: Any, batch: dict[str, torch.Tensor]) -> tuple[torch.Tensor, torch.Tensor]:
         """Calculate the total loss and detach it for pose estimation."""
         loss = torch.zeros(5, device=self.device)  # box, cls, dfl, kpt_location, kpt_visibility
         feats, pred_kpts = preds if isinstance(preds[0], list) else preds[1]
@@ -577,7 +579,7 @@ class v8PoseLoss(v8DetectionLoss):
         stride_tensor: torch.Tensor,
         target_bboxes: torch.Tensor,
         pred_kpts: torch.Tensor,
-    ) -> Tuple[torch.Tensor, torch.Tensor]:
+    ) -> tuple[torch.Tensor, torch.Tensor]:
         """
         Calculate the keypoints loss for the model.
 
@@ -645,7 +647,7 @@ class v8PoseLoss(v8DetectionLoss):
 class v8ClassificationLoss:
     """Criterion class for computing training losses for classification."""
 
-    def __call__(self, preds: Any, batch: Dict[str, torch.Tensor]) -> Tuple[torch.Tensor, torch.Tensor]:
+    def __call__(self, preds: Any, batch: dict[str, torch.Tensor]) -> tuple[torch.Tensor, torch.Tensor]:
         """Compute the classification loss between predictions and true labels."""
         preds = preds[1] if isinstance(preds, (list, tuple)) else preds
         loss = F.cross_entropy(preds, batch["cls"], reduction="mean")
@@ -678,7 +680,7 @@ class v8OBBLoss(v8DetectionLoss):
                     out[j, :n] = torch.cat([targets[matches, 1:2], bboxes], dim=-1)
         return out
 
-    def __call__(self, preds: Any, batch: Dict[str, torch.Tensor]) -> Tuple[torch.Tensor, torch.Tensor]:
+    def __call__(self, preds: Any, batch: dict[str, torch.Tensor]) -> tuple[torch.Tensor, torch.Tensor]:
         """Calculate and return the loss for oriented bounding box detection."""
         loss = torch.zeros(3, device=self.device)  # box, cls, dfl
         feats, pred_angle = preds if isinstance(preds[0], list) else preds[1]
@@ -778,7 +780,7 @@ class E2EDetectLoss:
         self.one2many = v8DetectionLoss(model, tal_topk=10)
         self.one2one = v8DetectionLoss(model, tal_topk=1)
 
-    def __call__(self, preds: Any, batch: Dict[str, torch.Tensor]) -> Tuple[torch.Tensor, torch.Tensor]:
+    def __call__(self, preds: Any, batch: dict[str, torch.Tensor]) -> tuple[torch.Tensor, torch.Tensor]:
         """Calculate the sum of the loss for box, cls and dfl multiplied by batch size."""
         preds = preds[1] if isinstance(preds, tuple) else preds
         one2many = preds["one2many"]
@@ -799,7 +801,7 @@ class TVPDetectLoss:
         self.ori_no = self.vp_criterion.no
         self.ori_reg_max = self.vp_criterion.reg_max
 
-    def __call__(self, preds: Any, batch: Dict[str, torch.Tensor]) -> Tuple[torch.Tensor, torch.Tensor]:
+    def __call__(self, preds: Any, batch: dict[str, torch.Tensor]) -> tuple[torch.Tensor, torch.Tensor]:
         """Calculate the loss for text-visual prompt detection."""
         feats = preds[1] if isinstance(preds, tuple) else preds
         assert self.ori_reg_max == self.vp_criterion.reg_max  # TODO: remove it
@@ -813,7 +815,7 @@ class TVPDetectLoss:
         box_loss = vp_loss[0][1]
         return box_loss, vp_loss[1]
 
-    def _get_vp_features(self, feats: List[torch.Tensor]) -> List[torch.Tensor]:
+    def _get_vp_features(self, feats: list[torch.Tensor]) -> list[torch.Tensor]:
         """Extract visual-prompt features from the model output."""
         vnc = feats[0].shape[1] - self.ori_reg_max * 4 - self.ori_nc
 
@@ -835,7 +837,7 @@ class TVPSegmentLoss(TVPDetectLoss):
         super().__init__(model)
         self.vp_criterion = v8SegmentationLoss(model)
 
-    def __call__(self, preds: Any, batch: Dict[str, torch.Tensor]) -> Tuple[torch.Tensor, torch.Tensor]:
+    def __call__(self, preds: Any, batch: dict[str, torch.Tensor]) -> tuple[torch.Tensor, torch.Tensor]:
         """Calculate the loss for text-visual prompt segmentation."""
         feats, pred_masks, proto = preds if len(preds) == 3 else preds[1]
         assert self.ori_reg_max == self.vp_criterion.reg_max  # TODO: remove it