dgenerate-ultralytics-headless 8.3.135__tar.gz → 8.3.138__tar.gz

{dgenerate_ultralytics_headless-8.3.135 → dgenerate_ultralytics_headless-8.3.138}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dgenerate-ultralytics-headless
-Version: 8.3.135
+Version: 8.3.138
 Summary: Automatically built Ultralytics package with python-opencv-headless dependency instead of python-opencv
 Author-email: Glenn Jocher <glenn.jocher@ultralytics.com>, Jing Qiu <jing.qiu@ultralytics.com>
 Maintainer-email: Ultralytics <hello@ultralytics.com>
@@ -46,7 +46,6 @@ Requires-Dist: tqdm>=4.64.0
 Requires-Dist: psutil
 Requires-Dist: py-cpuinfo
 Requires-Dist: pandas>=1.1.4
-Requires-Dist: seaborn>=0.11.0
 Requires-Dist: ultralytics-thop>=2.0.0
 Provides-Extra: dev
 Requires-Dist: ipython; extra == "dev"

{dgenerate_ultralytics_headless-8.3.135 → dgenerate_ultralytics_headless-8.3.138}/dgenerate_ultralytics_headless.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dgenerate-ultralytics-headless
-Version: 8.3.135
+Version: 8.3.138
 Summary: Automatically built Ultralytics package with python-opencv-headless dependency instead of python-opencv
 Author-email: Glenn Jocher <glenn.jocher@ultralytics.com>, Jing Qiu <jing.qiu@ultralytics.com>
 Maintainer-email: Ultralytics <hello@ultralytics.com>
@@ -46,7 +46,6 @@ Requires-Dist: tqdm>=4.64.0
 Requires-Dist: psutil
 Requires-Dist: py-cpuinfo
 Requires-Dist: pandas>=1.1.4
-Requires-Dist: seaborn>=0.11.0
 Requires-Dist: ultralytics-thop>=2.0.0
 Provides-Extra: dev
 Requires-Dist: ipython; extra == "dev"

{dgenerate_ultralytics_headless-8.3.135 → dgenerate_ultralytics_headless-8.3.138}/dgenerate_ultralytics_headless.egg-info/requires.txt

@@ -11,7 +11,6 @@ tqdm>=4.64.0
 psutil
 py-cpuinfo
 pandas>=1.1.4
-seaborn>=0.11.0
 ultralytics-thop>=2.0.0
 
 [:sys_platform == "win32"]

{dgenerate_ultralytics_headless-8.3.135 → dgenerate_ultralytics_headless-8.3.138}/pyproject.toml

@@ -75,7 +75,6 @@ dependencies = [
     "psutil", # system utilization
     "py-cpuinfo", # display CPU info
     "pandas>=1.1.4",
-    "seaborn>=0.11.0", # plotting
     "ultralytics-thop>=2.0.0", # FLOPs computation https://github.com/ultralytics/thop
 ]
 

{dgenerate_ultralytics_headless-8.3.135 → dgenerate_ultralytics_headless-8.3.138}/tests/test_cuda.py

@@ -41,7 +41,7 @@ def test_amp():
 
 
 @pytest.mark.slow
-# @pytest.mark.skipif(IS_JETSON, reason="Temporary disable ONNX for Jetson")
+@pytest.mark.skipif(IS_JETSON, reason="Temporary disable ONNX for Jetson")
 @pytest.mark.skipif(not DEVICES, reason="No CUDA devices available")
 @pytest.mark.parametrize(
     "task, dynamic, int8, half, batch, simplify, nms",
@@ -50,12 +50,7 @@ def test_amp():
         for task, dynamic, int8, half, batch, simplify, nms in product(
             TASKS, [True, False], [False], [False], [1, 2], [True, False], [True, False]
         )
-        if not (
-            (int8 and half)
-            or (task == "classify" and nms)
-            or (task == "obb" and nms and (not TORCH_1_13 or IS_JETSON))  # obb nms fails on NVIDIA Jetson
-            or (simplify and dynamic)  # onnxslim is slow when dynamic=True
-        )
+        if not ((int8 and half) or (task == "classify" and nms) or (task == "obb" and nms and not TORCH_1_13))
     ],
 )
 def test_export_onnx_matrix(task, dynamic, int8, half, batch, simplify, nms):

{dgenerate_ultralytics_headless-8.3.135 → dgenerate_ultralytics_headless-8.3.138}/tests/test_exports.py

@@ -83,12 +83,7 @@ def test_export_openvino_matrix(task, dynamic, int8, half, batch, nms):
         for task, dynamic, int8, half, batch, simplify, nms in product(
             TASKS, [True, False], [False], [False], [1, 2], [True, False], [True, False]
         )
-        if not (
-            (int8 and half)
-            or (task == "classify" and nms)
-            or (task == "obb" and nms and not TORCH_1_13)
-            or (simplify and dynamic)  # onnxslim is slow when dynamic=True
-        )
+        if not ((int8 and half) or (task == "classify" and nms) or (task == "obb" and nms and not TORCH_1_13))
     ],
 )
 def test_export_onnx_matrix(task, dynamic, int8, half, batch, simplify, nms):

dgenerate_ultralytics_headless-8.3.138/tests/test_solutions.py

@@ -0,0 +1,360 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# Tests Ultralytics Solutions: https://docs.ultralytics.com/solutions/,
+# including every solution excluding DistanceCalculation and Security Alarm System.
+
+import os
+from unittest.mock import patch
+
+import cv2
+import numpy as np
+import pytest
+
+from tests import MODEL, TMP
+from ultralytics import solutions
+from ultralytics.utils import ASSETS_URL, IS_RASPBERRYPI, LINUX, checks
+from ultralytics.utils.downloads import safe_download
+
+# Pre-defined arguments values
+SHOW = False
+DEMO_VIDEO = "solutions_ci_demo.mp4"  # for all the solutions, except workout, object cropping and parking management
+CROP_VIDEO = "decelera_landscape_min.mov"  # for object cropping solution
+POSE_VIDEO = "solution_ci_pose_demo.mp4"  # only for workouts monitoring solution
+PARKING_VIDEO = "solution_ci_parking_demo.mp4"  # only for parking management solution
+PARKING_AREAS_JSON = "solution_ci_parking_areas.json"  # only for parking management solution
+PARKING_MODEL = "solutions_ci_parking_model.pt"  # only for parking management solution
+VERTICAL_VIDEO = "solution_vertical_demo.mp4"  # only for vertical line counting
+REGION = [(10, 200), (540, 200), (540, 180), (10, 180)]  # for object counting, speed estimation and queue management
+HORIZONTAL_LINE = [(10, 200), (540, 200)]  # for object counting
+VERTICAL_LINE = [(320, 0), (320, 400)]  # for object counting
+
+# Test configs for each solution : (name, class, needs_frame_count, video, kwargs)
+SOLUTIONS = [
+    (
+        "ObjectCounter",
+        solutions.ObjectCounter,
+        False,
+        DEMO_VIDEO,
+        {"region": REGION, "model": MODEL, "show": SHOW},
+    ),
+    (
+        "ObjectCounter",
+        solutions.ObjectCounter,
+        False,
+        DEMO_VIDEO,
+        {"region": HORIZONTAL_LINE, "model": MODEL, "show": SHOW},
+    ),
+    (
+        "ObjectCounterVertical",
+        solutions.ObjectCounter,
+        False,
+        DEMO_VIDEO,
+        {"region": VERTICAL_LINE, "model": MODEL, "show": SHOW},
+    ),
+    (
+        "ObjectCounterwithOBB",
+        solutions.ObjectCounter,
+        False,
+        DEMO_VIDEO,
+        {"region": REGION, "model": "yolo11n-obb.pt", "show": SHOW},
+    ),
+    (
+        "Heatmap",
+        solutions.Heatmap,
+        False,
+        DEMO_VIDEO,
+        {"colormap": cv2.COLORMAP_PARULA, "model": MODEL, "show": SHOW, "region": None},
+    ),
+    (
+        "HeatmapWithRegion",
+        solutions.Heatmap,
+        False,
+        DEMO_VIDEO,
+        {"colormap": cv2.COLORMAP_PARULA, "region": REGION, "model": MODEL, "show": SHOW},
+    ),
+    (
+        "SpeedEstimator",
+        solutions.SpeedEstimator,
+        False,
+        DEMO_VIDEO,
+        {"region": REGION, "model": MODEL, "show": SHOW},
+    ),
+    (
+        "QueueManager",
+        solutions.QueueManager,
+        False,
+        DEMO_VIDEO,
+        {"region": REGION, "model": MODEL, "show": SHOW},
+    ),
+    (
+        "LineAnalytics",
+        solutions.Analytics,
+        True,
+        DEMO_VIDEO,
+        {"analytics_type": "line", "model": MODEL, "show": SHOW, "figsize": (6.4, 3.2)},
+    ),
+    (
+        "PieAnalytics",
+        solutions.Analytics,
+        True,
+        DEMO_VIDEO,
+        {"analytics_type": "pie", "model": MODEL, "show": SHOW, "figsize": (6.4, 3.2)},
+    ),
+    (
+        "BarAnalytics",
+        solutions.Analytics,
+        True,
+        DEMO_VIDEO,
+        {"analytics_type": "bar", "model": MODEL, "show": SHOW, "figsize": (6.4, 3.2)},
+    ),
+    (
+        "AreaAnalytics",
+        solutions.Analytics,
+        True,
+        DEMO_VIDEO,
+        {"analytics_type": "area", "model": MODEL, "show": SHOW, "figsize": (6.4, 3.2)},
+    ),
+    ("TrackZone", solutions.TrackZone, False, DEMO_VIDEO, {"region": REGION, "model": MODEL, "show": SHOW}),
+    (
+        "ObjectCropper",
+        solutions.ObjectCropper,
+        False,
+        CROP_VIDEO,
+        {"crop_dir": str(TMP / "cropped-detections"), "model": MODEL, "show": SHOW},
+    ),
+    (
+        "ObjectBlurrer",
+        solutions.ObjectBlurrer,
+        False,
+        DEMO_VIDEO,
+        {"blur_ratio": 0.02, "model": MODEL, "show": SHOW},
+    ),
+    (
+        "InstanceSegmentation",
+        solutions.InstanceSegmentation,
+        False,
+        DEMO_VIDEO,
+        {"model": "yolo11n-seg.pt", "show": SHOW},
+    ),
+    ("VisionEye", solutions.VisionEye, False, DEMO_VIDEO, {"model": MODEL, "show": SHOW}),
+    (
+        "RegionCounter",
+        solutions.RegionCounter,
+        False,
+        DEMO_VIDEO,
+        {"region": REGION, "model": MODEL, "show": SHOW},
+    ),
+    ("AIGym", solutions.AIGym, False, POSE_VIDEO, {"kpts": [6, 8, 10], "show": SHOW}),
+    (
+        "ParkingManager",
+        solutions.ParkingManagement,
+        False,
+        PARKING_VIDEO,
+        {"model": str(TMP / PARKING_MODEL), "show": SHOW, "json_file": str(TMP / PARKING_AREAS_JSON)},
+    ),
+    (
+        "StreamlitInference",
+        solutions.Inference,
+        False,
+        None,  # streamlit application don't require video file
+        {},  # streamlit application don't accept arguments
+    ),
+]
+
+
+def process_video(solution, video_path, needs_frame_count=False):
+    """Process video with solution, feeding frames and optional frame count."""
+    cap = cv2.VideoCapture(video_path)
+    assert cap.isOpened(), f"Error reading video file {video_path}"
+
+    frame_count = 0
+    while cap.isOpened():
+        success, im0 = cap.read()
+        if not success:
+            break
+        frame_count += 1
+        im_copy = im0.copy()
+        args = [im_copy, frame_count] if needs_frame_count else [im_copy]
+        _ = solution(*args)
+
+    cap.release()
+
+
+@pytest.mark.skipif(
+    (LINUX and checks.IS_PYTHON_3_11) or IS_RASPBERRYPI,
+    reason="Disabled for testing due to --slow test errors after YOLOE PR.",
+)
+@pytest.mark.parametrize("name, solution_class, needs_frame_count, video, kwargs", SOLUTIONS)
+def test_solution(name, solution_class, needs_frame_count, video, kwargs):
+    """Test individual Ultralytics solution."""
+    if video:
+        if name != "ObjectCounterVertical":
+            safe_download(url=f"{ASSETS_URL}/{video}", dir=TMP)
+        else:
+            safe_download(url=f"{ASSETS_URL}/{VERTICAL_VIDEO}", dir=TMP)
+    if name == "ParkingManager":
+        safe_download(url=f"{ASSETS_URL}/{PARKING_AREAS_JSON}", dir=TMP)
+        safe_download(url=f"{ASSETS_URL}/{PARKING_MODEL}", dir=TMP)
+    elif name == "StreamlitInference":
+        if checks.check_imshow():  # do not merge with elif above
+            solution_class(**kwargs).inference()  # requires interactive GUI environment
+        return
+
+    video = VERTICAL_VIDEO if name == "ObjectCounterVertical" else video
+    process_video(
+        solution=solution_class(**kwargs),
+        video_path=str(TMP / video),
+        needs_frame_count=needs_frame_count,
+    )
+
+
+@pytest.mark.slow
+@pytest.mark.skipif(checks.IS_PYTHON_3_8, reason="Disabled due to unsupported CLIP dependencies.")
+@pytest.mark.skipif(IS_RASPBERRYPI, reason="Disabled due to slow performance on Raspberry Pi.")
+def test_similarity_search():
+    """Test similarity search solution."""
+    searcher = solutions.VisualAISearch()
+    _ = searcher("a dog sitting on a bench")  # Returns the results in format "- img name | similarity score"
+
+
+def test_left_click_selection():
+    """Test distance calculation left click."""
+    dc = solutions.DistanceCalculation()
+    dc.boxes, dc.track_ids = [[10, 10, 50, 50]], [1]
+    dc.mouse_event_for_distance(cv2.EVENT_LBUTTONDOWN, 30, 30, None, None)
+    assert 1 in dc.selected_boxes
+
+
+def test_right_click_reset():
+    """Test distance calculation right click."""
+    dc = solutions.DistanceCalculation()
+    dc.selected_boxes, dc.left_mouse_count = {1: [10, 10, 50, 50]}, 1
+    dc.mouse_event_for_distance(cv2.EVENT_RBUTTONDOWN, 0, 0, None, None)
+    assert dc.selected_boxes == {}
+    assert dc.left_mouse_count == 0
+
+
+def test_parking_json_none():
+    """Test that ParkingManagement skips or errors cleanly when no JSON is provided."""
+    im0 = np.zeros((640, 480, 3), dtype=np.uint8)
+    try:
+        parkingmanager = solutions.ParkingManagement(json_path=None)
+        parkingmanager(im0)
+    except ValueError:
+        pytest.skip("Skipping test due to missing JSON.")
+
+
+def test_analytics_graph_not_supported():
+    """Test that unsupported analytics type raises ModuleNotFoundError."""
+    try:
+        analytics = solutions.Analytics(analytics_type="test")  # 'test' is unsupported
+        analytics.process(im0=None, frame_number=0)
+        assert False, "Expected ModuleNotFoundError for unsupported chart type"
+    except ModuleNotFoundError as e:
+        assert "test chart is not supported" in str(e)
+
+
+def test_area_chart_padding():
+    """Test area chart graph update with dynamic class padding logic."""
+    analytics = solutions.Analytics(analytics_type="area")
+    analytics.update_graph(frame_number=1, count_dict={"car": 2}, plot="area")
+    plot_im = analytics.update_graph(frame_number=2, count_dict={"car": 3, "person": 1}, plot="area")
+    assert plot_im is not None
+
+
+def test_config_update_method_with_invalid_argument():
+    """Test that update() raises ValueError for invalid config keys."""
+    obj = solutions.config.SolutionConfig()
+    try:
+        obj.update(invalid_key=123)
+        assert False, "Expected ValueError for invalid update argument"
+    except ValueError as e:
+        assert "❌ invalid_key is not a valid solution argument" in str(e)
+
+
+def test_plot_with_no_masks():
+    """Test that instance segmentation handles cases with no masks."""
+    im0 = np.zeros((640, 480, 3), dtype=np.uint8)
+    isegment = solutions.InstanceSegmentation(model="yolo11n-seg.pt")
+    results = isegment(im0)
+    assert results.plot_im is not None
+
+
+def test_streamlit_handle_video_upload_creates_file():
+    """Test Streamlit video upload logic saves file correctly."""
+    import io
+
+    fake_file = io.BytesIO(b"fake video content")
+    fake_file.read = fake_file.getvalue
+    if fake_file is not None:
+        g = io.BytesIO(fake_file.read())
+        with open("ultralytics.mp4", "wb") as out:
+            out.write(g.read())
+        output_path = "ultralytics.mp4"
+    else:
+        output_path = None
+    assert output_path == "ultralytics.mp4"
+    assert os.path.exists("ultralytics.mp4")
+    with open("ultralytics.mp4", "rb") as f:
+        assert f.read() == b"fake video content"
+    os.remove("ultralytics.mp4")
+
+
+def test_similarity_search_app_init():
+    """Test SearchApp initializes with required attributes."""
+    app = solutions.SearchApp(device="cpu")
+    assert hasattr(app, "searcher")
+    assert hasattr(app, "run")
+
+
+def test_similarity_search_complete(tmp_path):
+    """Test VisualAISearch end-to-end with sample image and query."""
+    from PIL import Image
+
+    image_dir = tmp_path / "images"
+    os.makedirs(image_dir, exist_ok=True)
+    for i in range(2):
+        img = Image.fromarray(np.uint8(np.random.rand(224, 224, 3) * 255))
+        img.save(image_dir / f"test_image_{i}.jpg")
+    searcher = solutions.VisualAISearch(data=str(image_dir))
+    results = searcher("a red and white object")
+    assert results
+
+
+def test_distance_calculation_process_method():
+    """Test DistanceCalculation.process() computes distance between selected boxes."""
+    from ultralytics.solutions.solutions import SolutionResults
+
+    dc = solutions.DistanceCalculation()
+    dc.boxes, dc.track_ids, dc.clss, dc.confs = (
+        [[100, 100, 200, 200], [300, 300, 400, 400]],
+        [1, 2],
+        [0, 0],
+        [0.9, 0.95],
+    )
+    dc.selected_boxes = {1: dc.boxes[0], 2: dc.boxes[1]}
+    frame = np.zeros((480, 640, 3), dtype=np.uint8)
+    with patch.object(dc, "extract_tracks"), patch.object(dc, "display_output"), patch("cv2.setMouseCallback"):
+        result = dc.process(frame)
+    assert isinstance(result, SolutionResults)
+    assert result.total_tracks == 2
+    assert result.pixels_distance > 0
+
+
+def test_object_crop_with_show_True():
+    """Test ObjectCropper init with show=True to cover display warning."""
+    solutions.ObjectCropper(show=True)
+
+
+def test_display_output_method():
+    """Test that display_output triggers imshow, waitKey, and destroyAllWindows when enabled."""
+    counter = solutions.ObjectCounter(show=True)
+    counter.env_check = True
+    frame = np.zeros((100, 100, 3), dtype=np.uint8)
+    with patch("cv2.imshow") as mock_imshow, patch("cv2.waitKey", return_value=ord("q")) as mock_wait, patch(
+        "cv2.destroyAllWindows"
+    ) as mock_destroy:
+        counter.display_output(frame)
+        mock_imshow.assert_called_once()
+        mock_wait.assert_called_once()
+        mock_destroy.assert_called_once()

{dgenerate_ultralytics_headless-8.3.135 → dgenerate_ultralytics_headless-8.3.138}/ultralytics/__init__.py

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

{dgenerate_ultralytics_headless-8.3.135 → dgenerate_ultralytics_headless-8.3.138}/ultralytics/cfg/__init__.py

@@ -7,8 +7,6 @@ from pathlib import Path
 from types import SimpleNamespace
 from typing import Any, Dict, List, Union
 
-import cv2
-
 from ultralytics import __version__
 from ultralytics.utils import (
     ASSETS,
@@ -313,7 +311,7 @@ def get_cfg(cfg: Union[str, Path, Dict, SimpleNamespace] = DEFAULT_CFG_DICT, ove
         if k in cfg and isinstance(cfg[k], (int, float)):
             cfg[k] = str(cfg[k])
     if cfg.get("name") == "model":  # assign model to 'name' arg
-        cfg["name"] = str(cfg.get("model", "")).split(".")[0]
+        cfg["name"] = str(cfg.get("model", "")).partition(".")[0]
         LOGGER.warning(f"'name=model' automatically updated to 'name={cfg['name']}'.")
 
     # Type and Value checks
@@ -707,6 +705,8 @@ def handle_yolo_solutions(args: List[str]) -> None:
             ]
         )
     else:
+        import cv2  # Only needed for cap and vw functionality
+
         from ultralytics import solutions
 
         solution = getattr(solutions, SOLUTION_MAP[solution_name])(is_cli=True, **overrides)  # class i.e ObjectCounter
@@ -919,7 +919,7 @@ def entrypoint(debug: str = "") -> None:
         if task not in TASKS:
             if task == "track":
                 LOGGER.warning(
-                    "invalid 'task=track', setting 'task=detect' and 'mode=track'. Valid tasks are {TASKS}.\n{CLI_HELP_MSG}."
+                    f"invalid 'task=track', setting 'task=detect' and 'mode=track'. Valid tasks are {TASKS}.\n{CLI_HELP_MSG}."
                 )
                 task, mode = "detect", "track"
             else:

{dgenerate_ultralytics_headless-8.3.135 → dgenerate_ultralytics_headless-8.3.138}/ultralytics/data/base.py

@@ -170,7 +170,7 @@ class BaseDataset(Dataset):
                         # F += [p.parent / x.lstrip(os.sep) for x in t]  # local to global path (pathlib)
                 else:
                     raise FileNotFoundError(f"{self.prefix}{p} does not exist")
-            im_files = sorted(x.replace("/", os.sep) for x in f if x.split(".")[-1].lower() in IMG_FORMATS)
+            im_files = sorted(x.replace("/", os.sep) for x in f if x.rpartition(".")[-1].lower() in IMG_FORMATS)
             # self.img_files = sorted([x for x in f if x.suffix[1:].lower() in IMG_FORMATS])  # pathlib
             assert im_files, f"{self.prefix}No images found in {img_path}. {FORMATS_HELP_MSG}"
         except Exception as e:

{dgenerate_ultralytics_headless-8.3.135 → dgenerate_ultralytics_headless-8.3.138}/ultralytics/data/build.py

@@ -200,10 +200,11 @@ def check_source(source):
     webcam, screenshot, from_img, in_memory, tensor = False, False, False, False, False
     if isinstance(source, (str, int, Path)):  # int for local usb camera
         source = str(source)
-        is_file = Path(source).suffix[1:] in (IMG_FORMATS | VID_FORMATS)
-        is_url = source.lower().startswith(("https://", "http://", "rtsp://", "rtmp://", "tcp://"))
+        source_lower = source.lower()
+        is_file = source_lower.rpartition(".")[-1] in (IMG_FORMATS | VID_FORMATS)
+        is_url = source_lower.startswith(("https://", "http://", "rtsp://", "rtmp://", "tcp://"))
         webcam = source.isnumeric() or source.endswith(".streams") or (is_url and not is_file)
-        screenshot = source.lower() == "screen"
+        screenshot = source_lower == "screen"
         if is_url and is_file:
             source = check_file(source)  # download
     elif isinstance(source, LOADERS):

{dgenerate_ultralytics_headless-8.3.135 → dgenerate_ultralytics_headless-8.3.138}/ultralytics/data/loaders.py

@@ -353,7 +353,7 @@ class LoadImagesAndVideos:
         # Define files as images or videos
         images, videos = [], []
         for f in files:
-            suffix = f.split(".")[-1].lower()  # Get file extension without the dot and lowercase
+            suffix = f.rpartition(".")[-1].lower()  # Get file extension without the dot and lowercase
             if suffix in IMG_FORMATS:
                 images.append(f)
             elif suffix in VID_FORMATS:
@@ -427,7 +427,7 @@ class LoadImagesAndVideos:
             else:
                 # Handle image files (including HEIC)
                 self.mode = "image"
-                if path.split(".")[-1].lower() == "heic":
+                if path.rpartition(".")[-1].lower() == "heic":
                     # Load HEIC image using Pillow with pillow-heif
                     check_requirements("pillow-heif")
 

{dgenerate_ultralytics_headless-8.3.135 → dgenerate_ultralytics_headless-8.3.138}/ultralytics/engine/exporter.py

@@ -244,7 +244,6 @@ class Exporter:
 
     def __call__(self, model=None) -> str:
         """Return list of exported files/dirs after running callbacks."""
-        self.run_callbacks("on_export_start")
         t = time.time()
         fmt = self.args.format.lower()  # to lowercase
         if fmt in {"tensorrt", "trt"}:  # 'engine' aliases
@@ -277,7 +276,7 @@ class Exporter:
             LOGGER.warning("TensorRT requires GPU export, automatically assigning device=0")
             self.args.device = "0"
         if fmt == "engine" and "dla" in str(self.args.device):  # convert int/list to str first
-            dla = self.args.device.split(":")[-1]
+            dla = self.args.device.rsplit(":", 1)[-1]
             self.args.device = "0"  # update device to "0"
             assert dla in {"0", "1"}, f"Expected self.args.device='dla:0' or 'dla:1, but got {self.args.device}."
         if imx and self.args.device is None and torch.cuda.is_available():
@@ -450,7 +449,7 @@ class Exporter:
             f"\n{colorstr('PyTorch:')} starting from '{file}' with input shape {tuple(im.shape)} BCHW and "
             f"output shape(s) {self.output_shape} ({file_size(file):.1f} MB)"
         )
-
+        self.run_callbacks("on_export_start")
         # Exports
         f = [""] * len(fmts)  # exported filenames
         if jit or ncnn:  # TorchScript
@@ -557,7 +556,7 @@ class Exporter:
         """YOLO ONNX export."""
         requirements = ["onnx>=1.12.0,<1.18.0"]
         if self.args.simplify:
-            requirements += ["onnxslim>=0.1.46", "onnxruntime" + ("-gpu" if torch.cuda.is_available() else "")]
+            requirements += ["onnxslim>=0.1.53", "onnxruntime" + ("-gpu" if torch.cuda.is_available() else "")]
         check_requirements(requirements)
         import onnx  # noqa
 
@@ -789,7 +788,7 @@ class Exporter:
         subprocess.run(cmd, check=True)
 
         # Remove debug files
-        pnnx_files = [x.split("=")[-1] for x in pnnx_args]
+        pnnx_files = [x.rsplit("=", 1)[-1] for x in pnnx_args]
         for f_debug in ("debug.bin", "debug.param", "debug2.bin", "debug2.param", *pnnx_files):
             Path(f_debug).unlink(missing_ok=True)
 
@@ -928,7 +927,7 @@ class Exporter:
                 "ai-edge-litert>=1.2.0",  # required by 'onnx2tf' package
                 "onnx>=1.12.0,<1.18.0",
                 "onnx2tf>=1.26.3",
-                "onnxslim>=0.1.46",
+                "onnxslim>=0.1.53",
                 "onnxruntime-gpu" if cuda else "onnxruntime",
                 "protobuf>=5",
             ),
@@ -1048,7 +1047,7 @@ class Exporter:
                 "sudo apt-get install edgetpu-compiler",
             ):
                 subprocess.run(c if is_sudo_available() else c.replace("sudo ", ""), shell=True, check=True)
-        ver = subprocess.run(cmd, shell=True, capture_output=True, check=True).stdout.decode().split()[-1]
+        ver = subprocess.run(cmd, shell=True, capture_output=True, check=True).stdout.decode().rsplit(maxsplit=1)[-1]
 
         LOGGER.info(f"\n{prefix} starting export with Edge TPU compiler {ver}...")
         f = str(tflite_model).replace(".tflite", "_edgetpu.tflite")  # Edge TPU model

{dgenerate_ultralytics_headless-8.3.135 → dgenerate_ultralytics_headless-8.3.138}/ultralytics/engine/model.py

@@ -288,7 +288,7 @@ class Model(torch.nn.Module):
             weights = checks.check_file(weights, download_dir=SETTINGS["weights_dir"])  # download and return local file
         weights = checks.check_model_file_from_stem(weights)  # add suffix, i.e. yolo11n -> yolo11n.pt
 
-        if Path(weights).suffix == ".pt":
+        if str(weights).rpartition(".")[-1] == "pt":
             self.model, self.ckpt = attempt_load_one_weight(weights)
             self.task = self.model.args["task"]
             self.overrides = self.model.args = self._reset_ckpt_args(self.model.args)
@@ -319,7 +319,7 @@ class Model(torch.nn.Module):
             >>> model = Model("yolo11n.onnx")
             >>> model._check_is_pytorch_model()  # Raises TypeError
         """
-        pt_str = isinstance(self.model, (str, Path)) and Path(self.model).suffix == ".pt"
+        pt_str = isinstance(self.model, (str, Path)) and str(self.model).rpartition(".")[-1] == "pt"
         pt_module = isinstance(self.model, torch.nn.Module)
         if not (pt_module or pt_str):
             raise TypeError(

{dgenerate_ultralytics_headless-8.3.135 → dgenerate_ultralytics_headless-8.3.138}/ultralytics/engine/predictor.py

@@ -43,7 +43,7 @@ import torch
 
 from ultralytics.cfg import get_cfg, get_save_dir
 from ultralytics.data import load_inference_source
-from ultralytics.data.augment import LetterBox, classify_transforms
+from ultralytics.data.augment import LetterBox
 from ultralytics.nn.autobackend import AutoBackend
 from ultralytics.utils import DEFAULT_CFG, LOGGER, MACOS, WINDOWS, callbacks, colorstr, ops
 from ultralytics.utils.checks import check_imgsz, check_imshow
@@ -247,15 +247,6 @@ class BasePredictor:
                 Source for inference.
         """
         self.imgsz = check_imgsz(self.args.imgsz, stride=self.model.stride, min_dim=2)  # check image size
-        self.transforms = (
-            getattr(
-                self.model.model,
-                "transforms",
-                classify_transforms(self.imgsz[0]),
-            )
-            if self.args.task == "classify"
-            else None
-        )
         self.dataset = load_inference_source(
             source=source,
             batch=self.args.batch,
@@ -395,6 +386,8 @@ class BasePredictor:
 
         self.device = self.model.device  # update device
         self.args.half = self.model.fp16  # update half
+        if hasattr(self.model, "imgsz"):
+            self.args.imgsz = self.model.imgsz  # reuse imgsz from export metadata
         self.model.eval()
 
     def write_results(self, i, p, im, s):

{dgenerate_ultralytics_headless-8.3.135 → dgenerate_ultralytics_headless-8.3.138}/ultralytics/engine/trainer.py

@@ -578,7 +578,7 @@ class BaseTrainer:
         try:
             if self.args.task == "classify":
                 data = check_cls_dataset(self.args.data)
-            elif self.args.data.split(".")[-1] in {"yaml", "yml"} or self.args.task in {
+            elif self.args.data.rsplit(".", 1)[-1] in {"yaml", "yml"} or self.args.task in {
                 "detect",
                 "segment",
                 "pose",