ultralytics 8.2.48__py3-none-any.whl → 8.2.50__py3-none-any.whl

tests/conftest.py

@@ -11,18 +11,24 @@ def pytest_addoption(parser):
     Add custom command-line options to pytest.
 
     Args:
-        parser (pytest.config.Parser): The pytest parser object.
+        parser (pytest.config.Parser): The pytest parser object for adding custom command-line options.
+
+    Returns:
+        (None)
     """
     parser.addoption("--slow", action="store_true", default=False, help="Run slow tests")
 
 
 def pytest_collection_modifyitems(config, items):
     """
-    Modify the list of test items to remove tests marked as slow if the --slow option is not provided.
+    Modify the list of test items to exclude tests marked as slow if the --slow option is not specified.
 
     Args:
-        config (pytest.config.Config): The pytest config object.
-        items (list): List of test items to be executed.
+        config (pytest.config.Config): The pytest configuration object that provides access to command-line options.
+        items (list): The list of collected pytest item objects to be modified based on the presence of --slow option.
+
+    Returns:
+        (None) The function modifies the 'items' list in place, and does not return a value.
     """
     if not config.getoption("--slow"):
         # Remove the item entirely from the list of test items if it's marked as 'slow'
@@ -38,6 +44,9 @@ def pytest_sessionstart(session):
 
     Args:
         session (pytest.Session): The pytest session object.
+
+    Returns:
+        (None)
     """
     from ultralytics.utils.torch_utils import init_seeds
 
@@ -54,9 +63,12 @@ def pytest_terminal_summary(terminalreporter, exitstatus, config):
     and directories used during testing.
 
     Args:
-        terminalreporter (pytest.terminal.TerminalReporter): The terminal reporter object.
+        terminalreporter (pytest.terminal.TerminalReporter): The terminal reporter object used for terminal output.
         exitstatus (int): The exit status of the test run.
         config (pytest.config.Config): The pytest config object.
+
+    Returns:
+        (None)
     """
     from ultralytics.utils import WEIGHTS_DIR
 

tests/test_cli.py

@@ -20,7 +20,7 @@ def run(cmd):
 
 
 def test_special_modes():
-    """Test various special command modes of YOLO."""
+    """Test various special command-line modes for YOLO functionality."""
     run("yolo help")
     run("yolo checks")
     run("yolo version")
@@ -30,30 +30,30 @@ def test_special_modes():
 
 @pytest.mark.parametrize("task,model,data", TASK_MODEL_DATA)
 def test_train(task, model, data):
-    """Test YOLO training for a given task, model, and data."""
+    """Test YOLO training for different tasks, models, and datasets."""
     run(f"yolo train {task} model={model} data={data} imgsz=32 epochs=1 cache=disk")
 
 
 @pytest.mark.parametrize("task,model,data", TASK_MODEL_DATA)
 def test_val(task, model, data):
-    """Test YOLO validation for a given task, model, and data."""
+    """Test YOLO validation process for specified task, model, and data using a shell command."""
     run(f"yolo val {task} model={model} data={data} imgsz=32 save_txt save_json")
 
 
 @pytest.mark.parametrize("task,model,data", TASK_MODEL_DATA)
 def test_predict(task, model, data):
-    """Test YOLO prediction on sample assets for a given task and model."""
+    """Test YOLO prediction on provided sample assets for specified task and model."""
     run(f"yolo predict model={model} source={ASSETS} imgsz=32 save save_crop save_txt")
 
 
 @pytest.mark.parametrize("model", MODELS)
 def test_export(model):
-    """Test exporting a YOLO model to different formats."""
+    """Test exporting a YOLO model to TorchScript format."""
     run(f"yolo export model={model} format=torchscript imgsz=32")
 
 
 def test_rtdetr(task="detect", model="yolov8n-rtdetr.yaml", data="coco8.yaml"):
-    """Test the RTDETR functionality with the Ultralytics framework."""
+    """Test the RTDETR functionality within Ultralytics for detection tasks using specified model and data."""
     # Warning: must use imgsz=640 (note also add coma, spaces, fraction=0.25 args to test single-image training)
     run(f"yolo train {task} model={model} data={data} --imgsz= 160 epochs =1, cache = disk fraction=0.25")
     run(f"yolo predict {task} model={model} source={ASSETS / 'bus.jpg'} imgsz=160 save save_crop save_txt")
@@ -61,7 +61,7 @@ def test_rtdetr(task="detect", model="yolov8n-rtdetr.yaml", data="coco8.yaml"):
 
 @pytest.mark.skipif(checks.IS_PYTHON_3_12, reason="MobileSAM with CLIP is not supported in Python 3.12")
 def test_fastsam(task="segment", model=WEIGHTS_DIR / "FastSAM-s.pt", data="coco8-seg.yaml"):
-    """Test FastSAM segmentation functionality within Ultralytics."""
+    """Test FastSAM model for segmenting objects in images using various prompts within Ultralytics."""
     source = ASSETS / "bus.jpg"
 
     run(f"yolo segment val {task} model={model} data={data} imgsz=32")
@@ -99,7 +99,7 @@ def test_fastsam(task="segment", model=WEIGHTS_DIR / "FastSAM-s.pt", data="coco8
 
 
 def test_mobilesam():
-    """Test MobileSAM segmentation functionality using Ultralytics."""
+    """Test MobileSAM segmentation with point prompts using Ultralytics."""
     from ultralytics import SAM
 
     # Load the model

tests/test_cuda.py

@@ -32,7 +32,7 @@ def test_checks():
     ],
 )
 def test_export_engine_matrix(task, dynamic, int8, half, batch):
-    """Test YOLO exports to TensorRT format."""
+    """Test YOLO model export to TensorRT format for various configurations and run inference."""
     file = YOLO(TASK2MODEL[task]).export(
         format="engine",
         imgsz=32,
@@ -51,7 +51,7 @@ def test_export_engine_matrix(task, dynamic, int8, half, batch):
 
 @pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason="CUDA is not available")
 def test_train():
-    """Test model training on a minimal dataset."""
+    """Test model training on a minimal dataset using available CUDA devices."""
     device = 0 if CUDA_DEVICE_COUNT == 1 else [0, 1]
     YOLO(MODEL).train(data="coco8.yaml", imgsz=64, epochs=1, device=device)  # requires imgsz>=64
 
@@ -59,7 +59,7 @@ def test_train():
 @pytest.mark.slow
 @pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason="CUDA is not available")
 def test_predict_multiple_devices():
-    """Validate model prediction on multiple devices."""
+    """Validate model prediction consistency across CPU and CUDA devices."""
     model = YOLO("yolov8n.pt")
     model = model.cpu()
     assert str(model.device) == "cpu"
@@ -84,7 +84,7 @@ def test_predict_multiple_devices():
 
 @pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason="CUDA is not available")
 def test_autobatch():
-    """Check batch size for YOLO model using autobatch."""
+    """Check optimal batch size for YOLO model training using autobatch utility."""
     from ultralytics.utils.autobatch import check_train_batch_size
 
     check_train_batch_size(YOLO(MODEL).model.cuda(), imgsz=128, amp=True)
@@ -103,7 +103,7 @@ def test_utils_benchmarks():
 
 @pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason="CUDA is not available")
 def test_predict_sam():
-    """Test SAM model prediction with various prompts."""
+    """Test SAM model predictions using different prompts, including bounding boxes and point annotations."""
     from ultralytics import SAM
     from ultralytics.models.sam import Predictor as SAMPredictor
 

tests/test_engine.py

@@ -12,12 +12,12 @@ from ultralytics.utils import ASSETS, DEFAULT_CFG, WEIGHTS_DIR
 
 
 def test_func(*args):  # noqa
-    """Test function callback."""
+    """Test function callback for evaluating YOLO model performance metrics."""
     print("callback test passed")
 
 
 def test_export():
-    """Test model exporting functionality."""
+    """Tests the model exporting function by adding a callback and asserting its execution."""
     exporter = Exporter()
     exporter.add_callback("on_export_start", test_func)
     assert test_func in exporter.callbacks["on_export_start"], "callback test failed"
@@ -26,7 +26,7 @@ def test_export():
 
 
 def test_detect():
-    """Test object detection functionality."""
+    """Test YOLO object detection training, validation, and prediction functionality."""
     overrides = {"data": "coco8.yaml", "model": "yolov8n.yaml", "imgsz": 32, "epochs": 1, "save": False}
     cfg = get_cfg(DEFAULT_CFG)
     cfg.data = "coco8.yaml"
@@ -65,7 +65,7 @@ def test_detect():
 
 
 def test_segment():
-    """Test image segmentation functionality."""
+    """Tests image segmentation training, validation, and prediction pipelines using YOLO models."""
     overrides = {"data": "coco8-seg.yaml", "model": "yolov8n-seg.yaml", "imgsz": 32, "epochs": 1, "save": False}
     cfg = get_cfg(DEFAULT_CFG)
     cfg.data = "coco8-seg.yaml"
@@ -104,7 +104,7 @@ def test_segment():
 
 
 def test_classify():
-    """Test image classification functionality."""
+    """Test image classification including training, validation, and prediction phases."""
     overrides = {"data": "imagenet10", "model": "yolov8n-cls.yaml", "imgsz": 32, "epochs": 1, "save": False}
     cfg = get_cfg(DEFAULT_CFG)
     cfg.data = "imagenet10"

tests/test_explorer.py

@@ -9,7 +9,7 @@ from ultralytics.utils import ASSETS
 
 @pytest.mark.slow
 def test_similarity():
-    """Test similarity calculations and SQL queries for correctness and response length."""
+    """Test the correctness and response length of similarity calculations and SQL queries in the Explorer."""
     exp = Explorer(data="coco8.yaml")
     exp.create_embeddings_table()
     similar = exp.get_similar(idx=1)
@@ -26,7 +26,7 @@ def test_similarity():
 
 @pytest.mark.slow
 def test_det():
-    """Test detection functionalities and ensure the embedding table has bounding boxes."""
+    """Test detection functionalities and verify embedding table includes bounding boxes."""
     exp = Explorer(data="coco8.yaml", model="yolov8n.pt")
     exp.create_embeddings_table(force=True)
     assert len(exp.table.head()["bboxes"]) > 0
@@ -39,7 +39,7 @@ def test_det():
 
 @pytest.mark.slow
 def test_seg():
-    """Test segmentation functionalities and verify the embedding table includes masks."""
+    """Test segmentation functionalities and ensure the embedding table includes segmentation masks."""
     exp = Explorer(data="coco8-seg.yaml", model="yolov8n-seg.pt")
     exp.create_embeddings_table(force=True)
     assert len(exp.table.head()["masks"]) > 0
@@ -51,7 +51,7 @@ def test_seg():
 
 @pytest.mark.slow
 def test_pose():
-    """Test pose estimation functionalities and check the embedding table for keypoints."""
+    """Test pose estimation functionality and verify the embedding table includes keypoints."""
     exp = Explorer(data="coco8-pose.yaml", model="yolov8n-pose.pt")
     exp.create_embeddings_table(force=True)
     assert len(exp.table.head()["keypoints"]) > 0

tests/test_exports.py

@@ -21,13 +21,13 @@ from ultralytics.utils.torch_utils import TORCH_1_9, TORCH_1_13
 
 
 def test_export_torchscript():
-    """Test YOLO exports to TorchScript format."""
+    """Test YOLO model exporting to TorchScript format for compatibility and correctness."""
     file = YOLO(MODEL).export(format="torchscript", optimize=False, imgsz=32)
     YOLO(file)(SOURCE, imgsz=32)  # exported model inference
 
 
 def test_export_onnx():
-    """Test YOLO exports to ONNX format."""
+    """Test YOLO model export to ONNX format with dynamic axes."""
     file = YOLO(MODEL).export(format="onnx", dynamic=True, imgsz=32)
     YOLO(file)(SOURCE, imgsz=32)  # exported model inference
 
@@ -35,7 +35,7 @@ def test_export_onnx():
 @pytest.mark.skipif(checks.IS_PYTHON_3_12, reason="OpenVINO not supported in Python 3.12")
 @pytest.mark.skipif(not TORCH_1_13, reason="OpenVINO requires torch>=1.13")
 def test_export_openvino():
-    """Test YOLO exports to OpenVINO format."""
+    """Test YOLO exports to OpenVINO format for model inference compatibility."""
     file = YOLO(MODEL).export(format="openvino", imgsz=32)
     YOLO(file)(SOURCE, imgsz=32)  # exported model inference
 
@@ -52,7 +52,7 @@ def test_export_openvino():
     ],
 )
 def test_export_openvino_matrix(task, dynamic, int8, half, batch):
-    """Test YOLO exports to OpenVINO format."""
+    """Test YOLO model exports to OpenVINO under various configuration matrix conditions."""
     file = YOLO(TASK2MODEL[task]).export(
         format="openvino",
         imgsz=32,
@@ -76,7 +76,7 @@ def test_export_openvino_matrix(task, dynamic, int8, half, batch):
     "task, dynamic, int8, half, batch, simplify", product(TASKS, [True, False], [False], [False], [1, 2], [True, False])
 )
 def test_export_onnx_matrix(task, dynamic, int8, half, batch, simplify):
-    """Test YOLO exports to ONNX format."""
+    """Test YOLO exports to ONNX format with various configurations and parameters."""
     file = YOLO(TASK2MODEL[task]).export(
         format="onnx",
         imgsz=32,
@@ -93,7 +93,7 @@ def test_export_onnx_matrix(task, dynamic, int8, half, batch, simplify):
 @pytest.mark.slow
 @pytest.mark.parametrize("task, dynamic, int8, half, batch", product(TASKS, [False], [False], [False], [1, 2]))
 def test_export_torchscript_matrix(task, dynamic, int8, half, batch):
-    """Test YOLO exports to TorchScript format."""
+    """Tests YOLO model exports to TorchScript format under varied configurations."""
     file = YOLO(TASK2MODEL[task]).export(
         format="torchscript",
         imgsz=32,
@@ -119,7 +119,7 @@ def test_export_torchscript_matrix(task, dynamic, int8, half, batch):
     ],
 )
 def test_export_coreml_matrix(task, dynamic, int8, half, batch):
-    """Test YOLO exports to CoreML format."""
+    """Test YOLO exports to CoreML format with various parameter configurations."""
     file = YOLO(TASK2MODEL[task]).export(
         format="coreml",
         imgsz=32,
@@ -144,7 +144,7 @@ def test_export_coreml_matrix(task, dynamic, int8, half, batch):
     ],
 )
 def test_export_tflite_matrix(task, dynamic, int8, half, batch):
-    """Test YOLO exports to TFLite format."""
+    """Test YOLO exports to TFLite format considering various export configurations."""
     file = YOLO(TASK2MODEL[task]).export(
         format="tflite",
         imgsz=32,
@@ -162,7 +162,7 @@ def test_export_tflite_matrix(task, dynamic, int8, half, batch):
 @pytest.mark.skipif(IS_RASPBERRYPI, reason="CoreML not supported on Raspberry Pi")
 @pytest.mark.skipif(checks.IS_PYTHON_3_12, reason="CoreML not supported in Python 3.12")
 def test_export_coreml():
-    """Test YOLO exports to CoreML format."""
+    """Test YOLO exports to CoreML format, optimized for macOS only."""
     if MACOS:
         file = YOLO(MODEL).export(format="coreml", imgsz=32)
         YOLO(file)(SOURCE, imgsz=32)  # model prediction only supported on macOS for nms=False models
@@ -173,11 +173,7 @@ def test_export_coreml():
 @pytest.mark.skipif(not checks.IS_PYTHON_MINIMUM_3_10, reason="TFLite export requires Python>=3.10")
 @pytest.mark.skipif(not LINUX, reason="Test disabled as TF suffers from install conflicts on Windows and macOS")
 def test_export_tflite():
-    """
-    Test YOLO exports to TFLite format.
-
-    Note TF suffers from install conflicts on Windows and macOS.
-    """
+    """Test YOLO exports to TFLite format under specific OS and Python version conditions."""
     model = YOLO(MODEL)
     file = model.export(format="tflite", imgsz=32)
     YOLO(file)(SOURCE, imgsz=32)
@@ -186,11 +182,7 @@ def test_export_tflite():
 @pytest.mark.skipif(True, reason="Test disabled")
 @pytest.mark.skipif(not LINUX, reason="TF suffers from install conflicts on Windows and macOS")
 def test_export_pb():
-    """
-    Test YOLO exports to *.pb format.
-
-    Note TF suffers from install conflicts on Windows and macOS.
-    """
+    """Test YOLO exports to TensorFlow's Protobuf (*.pb) format."""
     model = YOLO(MODEL)
     file = model.export(format="pb", imgsz=32)
     YOLO(file)(SOURCE, imgsz=32)
@@ -198,11 +190,7 @@ def test_export_pb():
 
 @pytest.mark.skipif(True, reason="Test disabled as Paddle protobuf and ONNX protobuf requirementsk conflict.")
 def test_export_paddle():
-    """
-    Test YOLO exports to Paddle format.
-
-    Note Paddle protobuf requirements conflicting with onnx protobuf requirements.
-    """
+    """Test YOLO exports to Paddle format, noting protobuf conflicts with ONNX."""
     YOLO(MODEL).export(format="paddle", imgsz=32)
 
 

tests/test_integrations.py

@@ -16,7 +16,7 @@ from ultralytics.utils.checks import check_requirements
 
 @pytest.mark.skipif(not check_requirements("ray", install=False), reason="ray[tune] not installed")
 def test_model_ray_tune():
-    """Tune YOLO model with Ray optimization library."""
+    """Tune YOLO model using Ray for hyperparameter optimization."""
     YOLO("yolov8n-cls.yaml").tune(
         use_ray=True, data="imagenet10", grace_period=1, iterations=1, imgsz=32, epochs=1, plots=False, device="cpu"
     )
@@ -24,7 +24,7 @@ def test_model_ray_tune():
 
 @pytest.mark.skipif(not check_requirements("mlflow", install=False), reason="mlflow not installed")
 def test_mlflow():
-    """Test training with MLflow tracking enabled."""
+    """Test training with MLflow tracking enabled (see https://mlflow.org/ for details)."""
     SETTINGS["mlflow"] = True
     YOLO("yolov8n-cls.yaml").train(data="imagenet10", imgsz=32, epochs=3, plots=False, device="cpu")
 
@@ -32,9 +32,9 @@ def test_mlflow():
 @pytest.mark.skipif(True, reason="Test failing in scheduled CI https://github.com/ultralytics/ultralytics/pull/8868")
 @pytest.mark.skipif(not check_requirements("mlflow", install=False), reason="mlflow not installed")
 def test_mlflow_keep_run_active():
+    """Ensure MLflow run status matches MLFLOW_KEEP_RUN_ACTIVE environment variable settings."""
     import mlflow
 
-    """Test training with MLflow tracking enabled."""
     SETTINGS["mlflow"] = True
     run_name = "Test Run"
     os.environ["MLFLOW_RUN"] = run_name
@@ -62,7 +62,11 @@ def test_mlflow_keep_run_active():
 
 @pytest.mark.skipif(not check_requirements("tritonclient", install=False), reason="tritonclient[all] not installed")
 def test_triton():
-    """Test NVIDIA Triton Server functionalities."""
+    """
+    Test NVIDIA Triton Server functionalities with YOLO model.
+
+    See https://catalog.ngc.nvidia.com/orgs/nvidia/containers/tritonserver.
+    """
     check_requirements("tritonclient[all]")
     from tritonclient.http import InferenceServerClient  # noqa
 
@@ -114,7 +118,7 @@ def test_triton():
 
 @pytest.mark.skipif(not check_requirements("pycocotools", install=False), reason="pycocotools not installed")
 def test_pycocotools():
-    """Validate model predictions using pycocotools."""
+    """Validate YOLO model predictions on COCO dataset using pycocotools."""
     from ultralytics.models.yolo.detect import DetectionValidator
     from ultralytics.models.yolo.pose import PoseValidator
     from ultralytics.models.yolo.segment import SegmentationValidator