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

ultralytics/utils/tqdm.py

@@ -139,10 +139,10 @@ class TQDM:
         self.initial = initial
 
         # Set bar format based on whether we have a total
-        if self.total is not None:
-            self.bar_format = bar_format or "{desc}: {percentage:3.0f}% {bar} {n_fmt}/{total_fmt} {rate_fmt} {elapsed}"
+        if self.total:
+            self.bar_format = bar_format or "{desc}: {percent:.0f}% {bar} {n}/{total} {rate} {elapsed}<{remaining}"
         else:
-            self.bar_format = bar_format or "{desc}: {bar} {n_fmt} {rate_fmt} {elapsed}"
+            self.bar_format = bar_format or "{desc}: {bar} {n} {rate} {elapsed}"
 
         self.file = file or sys.stdout
 
@@ -155,7 +155,7 @@ class TQDM:
         self.closed = False
 
         # Display initial bar if we have total and not disabled
-        if not self.disable and self.total is not None and not self.noninteractive:
+        if not self.disable and self.total and not self.noninteractive:
             self._display()
 
     def _format_rate(self, rate: float) -> str:
@@ -165,11 +165,18 @@ class TQDM:
 
         # For bytes with scaling, use binary units
         if self.unit in ("B", "bytes") and self.unit_scale:
-            for threshold, unit in [(1024**3, "GB/s"), (1024**2, "MB/s"), (1024, "KB/s")]:
-                if rate >= threshold:
-                    return f"{rate / threshold:.1f}{unit}"
-            return f"{rate:.1f}B/s"
-
+            return next(
+                (
+                    f"{rate / threshold:.1f}{unit}"
+                    for threshold, unit in [
+                        (1073741824, "GB/s"),
+                        (1048576, "MB/s"),
+                        (1024, "KB/s"),
+                    ]
+                    if rate >= threshold
+                ),
+                f"{rate:.1f}B/s",
+            )
         # For other scalable units, use decimal units
         if self.unit_scale and self.unit in ("it", "items", ""):
             for threshold, prefix in [(1000000, "M"), (1000, "K")]:
@@ -210,7 +217,7 @@ class TQDM:
         filled = int(frac * width)
         bar = "━" * filled + "─" * (width - filled)
         if filled < width and frac * width - filled > 0.5:
-            bar = bar[:filled] + "╸" + bar[filled + 1 :]
+            bar = f"{bar[:filled]}╸{bar[filled + 1 :]}"
         return bar
 
     def _should_update(self, dt: float, dn: int) -> bool:
@@ -218,10 +225,7 @@ class TQDM:
         if self.noninteractive:
             return False
 
-        if self.total is not None and self.n >= self.total:
-            return True
-
-        return dt >= self.mininterval
+        return True if self.total and self.n >= self.total else dt >= self.mininterval
 
     def _display(self, final: bool = False) -> None:
         """Display progress bar."""
@@ -256,30 +260,41 @@ class TQDM:
         self.last_print_t = current_time
         elapsed = current_time - self.start_t
 
+        # Calculate remaining time
+        remaining_str = ""
+        if self.total and 0 < self.n < self.total and rate > 0:
+            remaining_str = self._format_time((self.total - self.n) / rate)
+
         # Build progress components
-        if self.total is not None:
-            percentage = (self.n / self.total) * 100
+        if self.total:
+            percent = (self.n / self.total) * 100
             # For bytes with unit scaling, avoid repeating units: show "5.4/5.4MB" not "5.4MB/5.4MB"
-            n_fmt = self._format_num(self.n)
-            total_fmt = self._format_num(self.total)
+            n = self._format_num(self.n)
+            total = self._format_num(self.total)
             if self.unit_scale and self.unit in ("B", "bytes"):
-                n_fmt = n_fmt.rstrip("KMGTPB")  # Remove unit suffix from current
+                n = n.rstrip("KMGTPB")  # Remove unit suffix from current
         else:
-            percentage = 0
-            n_fmt = self._format_num(self.n)
-            total_fmt = "?"
+            percent = 0
+            n = self._format_num(self.n)
+            total = "?"
 
         elapsed_str = self._format_time(elapsed)
-        rate_fmt = self._format_rate(rate) or (self._format_rate(self.n / elapsed) if elapsed > 0 else "")
+
+        # Use different format for completion
+        if self.total and self.n >= self.total:
+            format_str = self.bar_format.replace("<{remaining}", "")
+        else:
+            format_str = self.bar_format
 
         # Format progress string
-        progress_str = self.bar_format.format(
+        progress_str = format_str.format(
             desc=self.desc,
-            percentage=percentage,
+            percent=percent,
             bar=self._generate_bar(),
-            n_fmt=n_fmt,
-            total_fmt=total_fmt,
-            rate_fmt=rate_fmt,
+            n=n,
+            total=total,
+            rate=self._format_rate(rate) or (self._format_rate(self.n / elapsed) if elapsed > 0 else ""),
+            remaining=remaining_str,
             elapsed=elapsed_str,
             unit=self.unit,
         )
@@ -395,12 +410,12 @@ if __name__ == "__main__":
     import time
 
     print("1. Basic progress bar with known total:")
-    for i in TQDM(range(0), desc="Known total"):
+    for i in TQDM(range(3), desc="Known total"):
         time.sleep(0.05)
 
     print("\n2. Manual updates with known total:")
-    pbar = TQDM(total=30, desc="Manual updates", unit="files")
-    for i in range(30):
+    pbar = TQDM(total=300, desc="Manual updates", unit="files")
+    for i in range(300):
         time.sleep(0.03)
         pbar.update(1)
         if i % 10 == 9:
@@ -438,8 +453,7 @@ if __name__ == "__main__":
 
     def process_files():
         """Simulate processing files of unknown count."""
-        files = [f"file_{i}.txt" for i in range(18)]
-        return files
+        return [f"file_{i}.txt" for i in range(18)]
 
     pbar = TQDM(desc="Scanning files", unit="files")
     files = process_files()

ultralytics/utils/triton.py

@@ -1,6 +1,7 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
-from typing import List
+from __future__ import annotations
+
 from urllib.parse import urlsplit
 
 import numpy as np
@@ -86,7 +87,7 @@ class TritonRemoteModel:
         self.output_names = [x["name"] for x in config["output"]]
         self.metadata = eval(config.get("parameters", {}).get("metadata", {}).get("string_value", "None"))
 
-    def __call__(self, *inputs: np.ndarray) -> List[np.ndarray]:
+    def __call__(self, *inputs: np.ndarray) -> list[np.ndarray]:
         """
         Call the model with the given inputs and return inference results.