ultralytics-opencv-headless 8.3.242__tar.gz → 8.3.243__tar.gz

{ultralytics_opencv_headless-8.3.242 → ultralytics_opencv_headless-8.3.243}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ultralytics-opencv-headless
-Version: 8.3.242
+Version: 8.3.243
 Summary: Ultralytics YOLO 🚀 for SOTA object detection, multi-object tracking, instance segmentation, pose estimation and image classification.
 Author-email: Glenn Jocher <glenn.jocher@ultralytics.com>, Jing Qiu <jing.qiu@ultralytics.com>
 Maintainer-email: Ultralytics <hello@ultralytics.com>
@@ -50,7 +50,7 @@ Requires-Dist: ipython; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: coverage[toml]; extra == "dev"
-Requires-Dist: zensical>=0.0.9; python_version >= "3.10" and extra == "dev"
+Requires-Dist: zensical>=0.0.15; python_version >= "3.10" and extra == "dev"
 Requires-Dist: mkdocs-ultralytics-plugin>=0.2.4; extra == "dev"
 Requires-Dist: minijinja>=2.0.0; extra == "dev"
 Provides-Extra: export

{ultralytics_opencv_headless-8.3.242 → ultralytics_opencv_headless-8.3.243}/pyproject.toml

@@ -83,7 +83,7 @@ dev = [
     "pytest",
     "pytest-cov",
     "coverage[toml]",
-    "zensical>=0.0.9; python_version >= '3.10'",
+    "zensical>=0.0.15; python_version >= '3.10'",
     "mkdocs-ultralytics-plugin>=0.2.4", # for meta descriptions and images, dates and authors
     "minijinja>=2.0.0", # render docs macros without mkdocs-macros-plugin
 ]

{ultralytics_opencv_headless-8.3.242 → ultralytics_opencv_headless-8.3.243}/ultralytics/__init__.py

@@ -1,6 +1,6 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
-__version__ = "8.3.242"
+__version__ = "8.3.243"
 
 import importlib
 import os

ultralytics_opencv_headless-8.3.243/ultralytics/utils/callbacks/platform.py

@@ -0,0 +1,290 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+import os
+import platform
+import socket
+import sys
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+from time import time
+
+from ultralytics.utils import ENVIRONMENT, GIT, LOGGER, PYTHON_VERSION, RANK, SETTINGS, TESTS_RUNNING
+
+_last_upload = 0  # Rate limit model uploads
+_console_logger = None  # Global console logger instance
+_system_logger = None  # Cached system logger instance
+
+try:
+    assert not TESTS_RUNNING  # do not log pytest
+    assert SETTINGS.get("platform", False) is True or os.getenv("ULTRALYTICS_API_KEY") or SETTINGS.get("api_key")
+    _api_key = os.getenv("ULTRALYTICS_API_KEY") or SETTINGS.get("api_key")
+    assert _api_key  # verify API key is present
+
+    import requests
+
+    from ultralytics.utils.logger import ConsoleLogger, SystemLogger
+    from ultralytics.utils.torch_utils import model_info_for_loggers
+
+    _executor = ThreadPoolExecutor(max_workers=10)  # Bounded thread pool for async operations
+
+except (AssertionError, ImportError):
+    _api_key = None
+
+
+def _send(event, data, project, name):
+    """Send event to Platform endpoint."""
+    try:
+        requests.post(
+            "https://alpha.ultralytics.com/api/webhooks/training/metrics",
+            json={"event": event, "project": project, "name": name, "data": data},
+            headers={"Authorization": f"Bearer {_api_key}"},
+            timeout=10,
+        ).raise_for_status()
+    except Exception as e:
+        LOGGER.debug(f"Platform: Failed to send {event}: {e}")
+
+
+def _send_async(event, data, project, name):
+    """Send event asynchronously using bounded thread pool."""
+    _executor.submit(_send, event, data, project, name)
+
+
+def _upload_model(model_path, project, name):
+    """Upload model checkpoint to Platform via signed URL."""
+    try:
+        model_path = Path(model_path)
+        if not model_path.exists():
+            return None
+
+        # Get signed upload URL
+        response = requests.post(
+            "https://alpha.ultralytics.com/api/webhooks/models/upload",
+            json={"project": project, "name": name, "filename": model_path.name},
+            headers={"Authorization": f"Bearer {_api_key}"},
+            timeout=10,
+        )
+        response.raise_for_status()
+        data = response.json()
+
+        # Upload to GCS
+        with open(model_path, "rb") as f:
+            requests.put(
+                data["uploadUrl"],
+                data=f,
+                headers={"Content-Type": "application/octet-stream"},
+                timeout=600,  # 10 min timeout for large models
+            ).raise_for_status()
+
+        LOGGER.info(f"Platform: Model uploaded to '{project}'")
+        return data.get("gcsPath")
+
+    except Exception as e:
+        LOGGER.debug(f"Platform: Failed to upload model: {e}")
+        return None
+
+
+def _upload_model_async(model_path, project, name):
+    """Upload model asynchronously using bounded thread pool."""
+    _executor.submit(_upload_model, model_path, project, name)
+
+
+def _get_environment_info():
+    """Collect comprehensive environment info using existing ultralytics utilities."""
+    import torch
+
+    from ultralytics import __version__
+    from ultralytics.utils.torch_utils import get_cpu_info, get_gpu_info
+
+    env = {
+        "ultralyticsVersion": __version__,
+        "hostname": socket.gethostname(),
+        "os": platform.platform(),
+        "environment": ENVIRONMENT,
+        "pythonVersion": PYTHON_VERSION,
+        "pythonExecutable": sys.executable,
+        "cpuCount": os.cpu_count() or 0,
+        "cpu": get_cpu_info(),
+        "command": " ".join(sys.argv),
+    }
+
+    # Git info using cached GIT singleton (no subprocess calls)
+    try:
+        if GIT.is_repo:
+            if GIT.origin:
+                env["gitRepository"] = GIT.origin
+            if GIT.branch:
+                env["gitBranch"] = GIT.branch
+            if GIT.commit:
+                env["gitCommit"] = GIT.commit[:12]  # Short hash
+    except Exception:
+        pass
+
+    # GPU info
+    try:
+        if torch.cuda.is_available():
+            env["gpuCount"] = torch.cuda.device_count()
+            env["gpuType"] = get_gpu_info(0) if torch.cuda.device_count() > 0 else None
+    except Exception:
+        pass
+
+    return env
+
+
+def on_pretrain_routine_start(trainer):
+    """Initialize Platform logging at training start."""
+    global _console_logger, _last_upload
+
+    if RANK not in {-1, 0} or not trainer.args.project:
+        return
+
+    # Initialize upload timer to now so first checkpoint waits 15 min from training start
+    _last_upload = time()
+
+    project, name = str(trainer.args.project), str(trainer.args.name or "train")
+    LOGGER.info(f"Platform: Streaming to project '{project}' as '{name}'")
+
+    # Create callback to send console output to Platform
+    def send_console_output(content, line_count, chunk_id):
+        """Send batched console output to Platform webhook."""
+        _send_async("console_output", {"chunkId": chunk_id, "content": content, "lineCount": line_count}, project, name)
+
+    # Start console capture with batching (5 lines or 5 seconds)
+    _console_logger = ConsoleLogger(batch_size=5, flush_interval=5.0, on_flush=send_console_output)
+    _console_logger.start_capture()
+
+    # Gather model info for richer metadata
+    model_info = {}
+    try:
+        info = model_info_for_loggers(trainer)
+        model_info = {
+            "parameters": info.get("model/parameters", 0),
+            "gflops": info.get("model/GFLOPs", 0),
+            "classes": getattr(trainer.model, "yaml", {}).get("nc", 0),  # number of classes
+        }
+    except Exception:
+        pass
+
+    # Collect environment info (W&B-style metadata)
+    environment = _get_environment_info()
+
+    _send_async(
+        "training_started",
+        {
+            "trainArgs": {k: str(v) for k, v in vars(trainer.args).items()},
+            "epochs": trainer.epochs,
+            "device": str(trainer.device),
+            "modelInfo": model_info,
+            "environment": environment,
+        },
+        project,
+        name,
+    )
+
+
+def on_fit_epoch_end(trainer):
+    """Log training and system metrics at epoch end."""
+    global _system_logger
+
+    if RANK not in {-1, 0} or not trainer.args.project:
+        return
+
+    project, name = str(trainer.args.project), str(trainer.args.name or "train")
+    metrics = {**trainer.label_loss_items(trainer.tloss, prefix="train"), **trainer.metrics}
+
+    if trainer.optimizer and trainer.optimizer.param_groups:
+        metrics["lr"] = trainer.optimizer.param_groups[0]["lr"]
+    if trainer.epoch == 0:
+        try:
+            metrics.update(model_info_for_loggers(trainer))
+        except Exception:
+            pass
+
+    # Get system metrics (cache SystemLogger for efficiency)
+    system = {}
+    try:
+        if _system_logger is None:
+            _system_logger = SystemLogger()
+        system = _system_logger.get_metrics(rates=True)
+    except Exception:
+        pass
+
+    _send_async(
+        "epoch_end",
+        {
+            "epoch": trainer.epoch,
+            "metrics": metrics,
+            "system": system,
+            "fitness": trainer.fitness,
+            "best_fitness": trainer.best_fitness,
+        },
+        project,
+        name,
+    )
+
+
+def on_model_save(trainer):
+    """Upload model checkpoint (rate limited to every 15 min)."""
+    global _last_upload
+
+    if RANK not in {-1, 0} or not trainer.args.project:
+        return
+
+    # Rate limit to every 15 minutes (900 seconds)
+    if time() - _last_upload < 900:
+        return
+
+    model_path = trainer.best if trainer.best and Path(trainer.best).exists() else trainer.last
+    if not model_path:
+        return
+
+    project, name = str(trainer.args.project), str(trainer.args.name or "train")
+    _upload_model_async(model_path, project, name)
+    _last_upload = time()
+
+
+def on_train_end(trainer):
+    """Log final results and upload best model."""
+    global _console_logger
+
+    if RANK not in {-1, 0} or not trainer.args.project:
+        return
+
+    project, name = str(trainer.args.project), str(trainer.args.name or "train")
+
+    # Stop console capture and flush remaining output
+    if _console_logger:
+        _console_logger.stop_capture()
+        _console_logger = None
+
+    # Upload best model (blocking to ensure it completes)
+    model_path = None
+    if trainer.best and Path(trainer.best).exists():
+        model_path = _upload_model(trainer.best, project, name)
+
+    # Send training complete
+    _send(
+        "training_complete",
+        {
+            "results": {
+                "metrics": {**trainer.metrics, "fitness": trainer.fitness},
+                "bestEpoch": getattr(trainer, "best_epoch", trainer.epoch),
+                "bestFitness": trainer.best_fitness,
+                "modelPath": model_path or str(trainer.best) if trainer.best else None,
+            }
+        },
+        project,
+        name,
+    )
+    LOGGER.info(f"Platform: Training complete, results uploaded to '{project}'")
+
+
+callbacks = (
+    {
+        "on_pretrain_routine_start": on_pretrain_routine_start,
+        "on_fit_epoch_end": on_fit_epoch_end,
+        "on_model_save": on_model_save,
+        "on_train_end": on_train_end,
+    }
+    if _api_key
+    else {}
+)

{ultralytics_opencv_headless-8.3.242 → ultralytics_opencv_headless-8.3.243}/ultralytics/utils/checks.py

@@ -418,6 +418,11 @@ def check_requirements(requirements=ROOT.parent / "requirements.txt", exclude=()
         >>> check_requirements([("onnxruntime", "onnxruntime-gpu"), "numpy"])
     """
     prefix = colorstr("red", "bold", "requirements:")
+
+    if os.environ.get("ULTRALYTICS_SKIP_REQUIREMENTS_CHECKS", "0") == "1":
+        LOGGER.info(f"{prefix} ULTRALYTICS_SKIP_REQUIREMENTS_CHECKS=1 detected, skipping requirements check.")
+        return True
+
     if isinstance(requirements, Path):  # requirements.txt file
         file = requirements.resolve()
         assert file.exists(), f"{prefix} {file} not found, check failed."

{ultralytics_opencv_headless-8.3.242 → ultralytics_opencv_headless-8.3.243}/ultralytics/utils/logger.py

@@ -1,7 +1,6 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
 import logging
-import queue
 import shutil
 import sys
 import threading
@@ -12,72 +11,81 @@ from pathlib import Path
 from ultralytics.utils import MACOS, RANK
 from ultralytics.utils.checks import check_requirements
 
-# Initialize default log file
-DEFAULT_LOG_PATH = Path("train.log")
-if RANK in {-1, 0} and DEFAULT_LOG_PATH.exists():
-    DEFAULT_LOG_PATH.unlink(missing_ok=True)
-
 
 class ConsoleLogger:
-    """Console output capture with API/file streaming and deduplication.
+    """Console output capture with batched streaming to file, API, or custom callback.
 
-    Captures stdout/stderr output and streams it to either an API endpoint or local file, with intelligent deduplication
-    to reduce noise from repetitive console output.
+    Captures stdout/stderr output and streams it with intelligent deduplication and configurable batching.
 
     Attributes:
-        destination (str | Path): Target destination for streaming (URL or Path object).
-        is_api (bool): Whether destination is an API endpoint (True) or local file (False).
-        original_stdout: Reference to original sys.stdout for restoration.
-        original_stderr: Reference to original sys.stderr for restoration.
-        log_queue (queue.Queue): Thread-safe queue for buffering log messages.
+        destination (str | Path | None): Target destination for streaming (URL, Path, or None for callback-only).
+        batch_size (int): Number of lines to batch before flushing (default: 1 for immediate).
+        flush_interval (float): Seconds between automatic flushes (default: 5.0).
+        on_flush (callable | None): Optional callback function called with batched content on flush.
         active (bool): Whether console capture is currently active.
-        worker_thread (threading.Thread): Background thread for processing log queue.
-        last_line (str): Last processed line for deduplication.
-        last_time (float): Timestamp of last processed line.
-        last_progress_line (str): Last progress bar line for progress deduplication.
-        last_was_progress (bool): Whether the last line was a progress bar.
 
     Examples:
-        Basic file logging:
+        File logging (immediate):
         >>> logger = ConsoleLogger("training.log")
         >>> logger.start_capture()
         >>> print("This will be logged")
         >>> logger.stop_capture()
 
-        API streaming:
-        >>> logger = ConsoleLogger("https://api.example.com/logs")
+        API streaming with batching:
+        >>> logger = ConsoleLogger("https://api.example.com/logs", batch_size=10)
+        >>> logger.start_capture()
+
+        Custom callback with batching:
+        >>> def my_handler(content, line_count, chunk_id):
+        ...     print(f"Received {line_count} lines")
+        >>> logger = ConsoleLogger(on_flush=my_handler, batch_size=5)
         >>> logger.start_capture()
-        >>> # All output streams to API
-        >>> logger.stop_capture()
     """
 
-    def __init__(self, destination):
-        """Initialize with API endpoint or local file path.
+    def __init__(self, destination=None, batch_size=1, flush_interval=5.0, on_flush=None):
+        """Initialize console logger with optional batching.
 
         Args:
-            destination (str | Path): API endpoint URL (http/https) or local file path for streaming output.
+            destination (str | Path | None): API endpoint URL (http/https), local file path, or None.
+            batch_size (int): Lines to accumulate before flush (1 = immediate, higher = batched).
+            flush_interval (float): Max seconds between flushes when batching.
+            on_flush (callable | None): Callback(content: str, line_count: int, chunk_id: int) for custom handling.
         """
         self.destination = destination
         self.is_api = isinstance(destination, str) and destination.startswith(("http://", "https://"))
-        if not self.is_api:
+        if destination is not None and not self.is_api:
             self.destination = Path(destination)
 
-        # Console capture
+        # Batching configuration
+        self.batch_size = max(1, batch_size)
+        self.flush_interval = flush_interval
+        self.on_flush = on_flush
+
+        # Console capture state
         self.original_stdout = sys.stdout
         self.original_stderr = sys.stderr
-        self.log_queue = queue.Queue(maxsize=1000)
         self.active = False
-        self.worker_thread = None
+        self._log_handler = None  # Track handler for cleanup
+
+        # Buffer for batching
+        self.buffer = []
+        self.buffer_lock = threading.Lock()
+        self.flush_thread = None
+        self.chunk_id = 0
 
-        # State tracking
+        # Deduplication state
         self.last_line = ""
         self.last_time = 0.0
-        self.last_progress_line = ""  # Track last progress line for deduplication
+        self.last_progress_line = ""  # Track progress sequence key for deduplication
         self.last_was_progress = False  # Track if last line was a progress bar
 
     def start_capture(self):
-        """Start capturing console output and redirect stdout/stderr to custom capture objects."""
-        if self.active:
+        """Start capturing console output and redirect stdout/stderr.
+
+        Notes:
+            In DDP training, only activates on rank 0/-1 to prevent duplicate logging.
+        """
+        if self.active or RANK not in {-1, 0}:
             return
 
         self.active = True
@@ -86,23 +94,35 @@ class ConsoleLogger:
 
         # Hook Ultralytics logger
         try:
-            handler = self._LogHandler(self._queue_log)
-            logging.getLogger("ultralytics").addHandler(handler)
+            self._log_handler = self._LogHandler(self._queue_log)
+            logging.getLogger("ultralytics").addHandler(self._log_handler)
         except Exception:
             pass
 
-        self.worker_thread = threading.Thread(target=self._stream_worker, daemon=True)
-        self.worker_thread.start()
+        # Start background flush thread for batched mode
+        if self.batch_size > 1:
+            self.flush_thread = threading.Thread(target=self._flush_worker, daemon=True)
+            self.flush_thread.start()
 
     def stop_capture(self):
-        """Stop capturing console output and restore original stdout/stderr."""
+        """Stop capturing console output and flush remaining buffer."""
         if not self.active:
             return
 
         self.active = False
         sys.stdout = self.original_stdout
         sys.stderr = self.original_stderr
-        self.log_queue.put(None)
+
+        # Remove logging handler to prevent memory leak
+        if self._log_handler:
+            try:
+                logging.getLogger("ultralytics").removeHandler(self._log_handler)
+            except Exception:
+                pass
+            self._log_handler = None
+
+        # Final flush
+        self._flush_buffer()
 
     def _queue_log(self, text):
         """Queue console text with deduplication and timestamp processing."""
@@ -126,12 +146,34 @@ class ConsoleLogger:
             if "─" in line:  # Has thin lines but no thick lines
                 continue
 
-            # Deduplicate completed progress bars only if they match the previous progress line
+            # Only show 100% completion lines for progress bars
             if " ━━" in line:
-                progress_core = line.split(" ━━")[0].strip()
-                if progress_core == self.last_progress_line and self.last_was_progress:
+                is_complete = "100%" in line
+
+                # Skip ALL non-complete progress lines
+                if not is_complete:
+                    continue
+
+                # Extract sequence key to deduplicate multiple 100% lines for same sequence
+                parts = line.split()
+                seq_key = ""
+                if parts:
+                    # Check for epoch pattern (X/Y at start)
+                    if "/" in parts[0] and parts[0].replace("/", "").isdigit():
+                        seq_key = parts[0]  # e.g., "1/3"
+                    elif parts[0] == "Class" and len(parts) > 1:
+                        seq_key = f"{parts[0]}_{parts[1]}"  # e.g., "Class_train:" or "Class_val:"
+                    elif parts[0] in ("train:", "val:"):
+                        seq_key = parts[0]  # Phase identifier
+
+                # Skip if we already showed 100% for this sequence
+                if seq_key and self.last_progress_line == f"{seq_key}:done":
                     continue
-                self.last_progress_line = progress_core
+
+                # Mark this sequence as done
+                if seq_key:
+                    self.last_progress_line = f"{seq_key}:done"
+
                 self.last_was_progress = True
             else:
                 # Skip empty line after progress bar
@@ -152,48 +194,62 @@ class ConsoleLogger:
                 timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
                 line = f"[{timestamp}] {line}"
 
-            # Queue with overflow protection
-            if not self._safe_put(f"{line}\n"):
-                continue  # Skip if queue handling fails
+            # Add to buffer and check if flush needed
+            should_flush = False
+            with self.buffer_lock:
+                self.buffer.append(line)
+                if len(self.buffer) >= self.batch_size:
+                    should_flush = True
 
-    def _safe_put(self, item):
-        """Safely put item in queue with overflow handling."""
-        try:
-            self.log_queue.put_nowait(item)
-            return True
-        except queue.Full:
-            try:
-                self.log_queue.get_nowait()  # Drop oldest
-                self.log_queue.put_nowait(item)
-                return True
-            except queue.Empty:
-                return False
-
-    def _stream_worker(self):
-        """Background worker for streaming logs to destination."""
+            # Flush outside lock to avoid deadlock
+            if should_flush:
+                self._flush_buffer()
+
+    def _flush_worker(self):
+        """Background worker that flushes buffer periodically."""
         while self.active:
+            time.sleep(self.flush_interval)
+            if self.active:
+                self._flush_buffer()
+
+    def _flush_buffer(self):
+        """Flush buffered lines to destination and/or callback."""
+        with self.buffer_lock:
+            if not self.buffer:
+                return
+            lines = self.buffer.copy()
+            self.buffer.clear()
+            self.chunk_id += 1
+            chunk_id = self.chunk_id  # Capture under lock to avoid race
+
+        content = "\n".join(lines)
+        line_count = len(lines)
+
+        # Call custom callback if provided
+        if self.on_flush:
             try:
-                log_text = self.log_queue.get(timeout=1)
-                if log_text is None:
-                    break
-                self._write_log(log_text)
-            except queue.Empty:
-                continue
+                self.on_flush(content, line_count, chunk_id)
+            except Exception:
+                pass  # Silently ignore callback errors to avoid flooding stderr
+
+        # Write to destination (file or API)
+        if self.destination is not None:
+            self._write_destination(content)
 
-    def _write_log(self, text):
-        """Write log to API endpoint or local file destination."""
+    def _write_destination(self, content):
+        """Write content to file or API destination."""
         try:
             if self.is_api:
-                import requests  # scoped as slow import
+                import requests
 
-                payload = {"timestamp": datetime.now().isoformat(), "message": text.strip()}
+                payload = {"timestamp": datetime.now().isoformat(), "message": content}
                 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:
-                    f.write(text)
+                    f.write(content + "\n")
         except Exception as e:
-            print(f"Platform logging error: {e}", file=self.original_stderr)
+            print(f"Console logger write error: {e}", file=self.original_stderr)
 
     class _ConsoleCapture:
         """Lightweight stdout/stderr capture."""

{ultralytics_opencv_headless-8.3.242 → ultralytics_opencv_headless-8.3.243}/ultralytics/utils/loss.py

@@ -498,7 +498,7 @@ class v8PoseLoss(v8DetectionLoss):
 
     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
+        loss = torch.zeros(5, device=self.device)  # box, pose, kobj, cls, dfl
         feats, pred_kpts = preds if isinstance(preds[0], list) else preds[1]
         pred_distri, pred_scores = torch.cat([xi.view(feats[0].shape[0], self.no, -1) for xi in feats], 2).split(
             (self.reg_max * 4, self.nc), 1
@@ -560,7 +560,7 @@ class v8PoseLoss(v8DetectionLoss):
         loss[3] *= self.hyp.cls  # cls gain
         loss[4] *= self.hyp.dfl  # dfl gain
 
-        return loss * batch_size, loss.detach()  # loss(box, cls, dfl)
+        return loss * batch_size, loss.detach()  # loss(box, pose, kobj, cls, dfl)
 
     @staticmethod
     def kpts_decode(anchor_points: torch.Tensor, pred_kpts: torch.Tensor) -> torch.Tensor:

{ultralytics_opencv_headless-8.3.242 → ultralytics_opencv_headless-8.3.243}/ultralytics_opencv_headless.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ultralytics-opencv-headless
-Version: 8.3.242
+Version: 8.3.243
 Summary: Ultralytics YOLO 🚀 for SOTA object detection, multi-object tracking, instance segmentation, pose estimation and image classification.
 Author-email: Glenn Jocher <glenn.jocher@ultralytics.com>, Jing Qiu <jing.qiu@ultralytics.com>
 Maintainer-email: Ultralytics <hello@ultralytics.com>
@@ -50,7 +50,7 @@ Requires-Dist: ipython; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: coverage[toml]; extra == "dev"
-Requires-Dist: zensical>=0.0.9; python_version >= "3.10" and extra == "dev"
+Requires-Dist: zensical>=0.0.15; python_version >= "3.10" and extra == "dev"
 Requires-Dist: mkdocs-ultralytics-plugin>=0.2.4; extra == "dev"
 Requires-Dist: minijinja>=2.0.0; extra == "dev"
 Provides-Extra: export