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

ultralytics/data/augment.py

@@ -1,9 +1,11 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
+from __future__ import annotations
+
 import math
 import random
 from copy import deepcopy
-from typing import Any, Dict, List, Tuple, Union
+from typing import Any
 
 import cv2
 import numpy as np
@@ -231,7 +233,7 @@ class Compose:
         """
         self.transforms.insert(index, transform)
 
-    def __getitem__(self, index: Union[list, int]) -> "Compose":
+    def __getitem__(self, index: list | int) -> Compose:
         """
         Retrieve a specific transform or a set of transforms using indexing.
 
@@ -253,7 +255,7 @@ class Compose:
         assert isinstance(index, (int, list)), f"The indices should be either list or int type but got {type(index)}"
         return Compose([self.transforms[i] for i in index]) if isinstance(index, list) else self.transforms[index]
 
-    def __setitem__(self, index: Union[list, int], value: Union[list, int]) -> None:
+    def __setitem__(self, index: list | int, value: list | int) -> None:
         """
         Set one or more transforms in the composition using indexing.
 
@@ -366,7 +368,7 @@ class BaseMixTransform:
         self.pre_transform = pre_transform
         self.p = p
 
-    def __call__(self, labels: Dict[str, Any]) -> Dict[str, Any]:
+    def __call__(self, labels: dict[str, Any]) -> dict[str, Any]:
         """
         Apply pre-processing transforms and cutmix/mixup/mosaic transforms to labels data.
 
@@ -406,7 +408,7 @@ class BaseMixTransform:
         labels.pop("mix_labels", None)
         return labels
 
-    def _mix_transform(self, labels: Dict[str, Any]):
+    def _mix_transform(self, labels: dict[str, Any]):
         """
         Apply CutMix, MixUp or Mosaic augmentation to the label dictionary.
 
@@ -442,7 +444,7 @@ class BaseMixTransform:
         return random.randint(0, len(self.dataset) - 1)
 
     @staticmethod
-    def _update_label_text(labels: Dict[str, Any]) -> Dict[str, Any]:
+    def _update_label_text(labels: dict[str, Any]) -> dict[str, Any]:
         """
         Update label text and class IDs for mixed labels in image augmentation.
 
@@ -564,7 +566,7 @@ class Mosaic(BaseMixTransform):
         else:  # select any images
             return [random.randint(0, len(self.dataset) - 1) for _ in range(self.n - 1)]
 
-    def _mix_transform(self, labels: Dict[str, Any]) -> Dict[str, Any]:
+    def _mix_transform(self, labels: dict[str, Any]) -> dict[str, Any]:
         """
         Apply mosaic augmentation to the input image and labels.
 
@@ -587,13 +589,13 @@ class Mosaic(BaseMixTransform):
             >>> mosaic = Mosaic(dataset, imgsz=640, p=1.0, n=4)
             >>> augmented_data = mosaic._mix_transform(labels)
         """
-        assert labels.get("rect_shape", None) is None, "rect and mosaic are mutually exclusive."
+        assert labels.get("rect_shape") is None, "rect and mosaic are mutually exclusive."
         assert len(labels.get("mix_labels", [])), "There are no other images for mosaic augment."
         return (
             self._mosaic3(labels) if self.n == 3 else self._mosaic4(labels) if self.n == 4 else self._mosaic9(labels)
         )  # This code is modified for mosaic3 method.
 
-    def _mosaic3(self, labels: Dict[str, Any]) -> Dict[str, Any]:
+    def _mosaic3(self, labels: dict[str, Any]) -> dict[str, Any]:
         """
         Create a 1x3 image mosaic by combining three images.
 
@@ -652,7 +654,7 @@ class Mosaic(BaseMixTransform):
         final_labels["img"] = img3[-self.border[0] : self.border[0], -self.border[1] : self.border[1]]
         return final_labels
 
-    def _mosaic4(self, labels: Dict[str, Any]) -> Dict[str, Any]:
+    def _mosaic4(self, labels: dict[str, Any]) -> dict[str, Any]:
         """
         Create a 2x2 image mosaic from four input images.
 
@@ -710,7 +712,7 @@ class Mosaic(BaseMixTransform):
         final_labels["img"] = img4
         return final_labels
 
-    def _mosaic9(self, labels: Dict[str, Any]) -> Dict[str, Any]:
+    def _mosaic9(self, labels: dict[str, Any]) -> dict[str, Any]:
         """
         Create a 3x3 image mosaic from the input image and eight additional images.
 
@@ -783,7 +785,7 @@ class Mosaic(BaseMixTransform):
         return final_labels
 
     @staticmethod
-    def _update_labels(labels, padw: int, padh: int) -> Dict[str, Any]:
+    def _update_labels(labels, padw: int, padh: int) -> dict[str, Any]:
         """
         Update label coordinates with padding values.
 
@@ -809,7 +811,7 @@ class Mosaic(BaseMixTransform):
         labels["instances"].add_padding(padw, padh)
         return labels
 
-    def _cat_labels(self, mosaic_labels: List[Dict[str, Any]]) -> Dict[str, Any]:
+    def _cat_labels(self, mosaic_labels: list[dict[str, Any]]) -> dict[str, Any]:
         """
         Concatenate and process labels for mosaic augmentation.
 
@@ -836,7 +838,7 @@ class Mosaic(BaseMixTransform):
             >>> print(result.keys())
             dict_keys(['im_file', 'ori_shape', 'resized_shape', 'cls', 'instances', 'mosaic_border'])
         """
-        if len(mosaic_labels) == 0:
+        if not mosaic_labels:
             return {}
         cls = []
         instances = []
@@ -902,7 +904,7 @@ class MixUp(BaseMixTransform):
         """
         super().__init__(dataset=dataset, pre_transform=pre_transform, p=p)
 
-    def _mix_transform(self, labels: Dict[str, Any]) -> Dict[str, Any]:
+    def _mix_transform(self, labels: dict[str, Any]) -> dict[str, Any]:
         """
         Apply MixUp augmentation to the input labels.
 
@@ -967,7 +969,7 @@ class CutMix(BaseMixTransform):
         self.beta = beta
         self.num_areas = num_areas
 
-    def _rand_bbox(self, width: int, height: int) -> Tuple[int, int, int, int]:
+    def _rand_bbox(self, width: int, height: int) -> tuple[int, int, int, int]:
         """
         Generate random bounding box coordinates for the cut region.
 
@@ -997,7 +999,7 @@ class CutMix(BaseMixTransform):
 
         return x1, y1, x2, y2
 
-    def _mix_transform(self, labels: Dict[str, Any]) -> Dict[str, Any]:
+    def _mix_transform(self, labels: dict[str, Any]) -> dict[str, Any]:
         """
         Apply CutMix augmentation to the input labels.
 
@@ -1086,7 +1088,7 @@ class RandomPerspective:
         scale: float = 0.5,
         shear: float = 0.0,
         perspective: float = 0.0,
-        border: Tuple[int, int] = (0, 0),
+        border: tuple[int, int] = (0, 0),
         pre_transform=None,
     ):
         """
@@ -1117,7 +1119,7 @@ class RandomPerspective:
         self.border = border  # mosaic border
         self.pre_transform = pre_transform
 
-    def affine_transform(self, img: np.ndarray, border: Tuple[int, int]) -> Tuple[np.ndarray, np.ndarray, float]:
+    def affine_transform(self, img: np.ndarray, border: tuple[int, int]) -> tuple[np.ndarray, np.ndarray, float]:
         """
         Apply a sequence of affine transformations centered around the image center.
 
@@ -1215,7 +1217,7 @@ class RandomPerspective:
         y = xy[:, [1, 3, 5, 7]]
         return np.concatenate((x.min(1), y.min(1), x.max(1), y.max(1)), dtype=bboxes.dtype).reshape(4, n).T
 
-    def apply_segments(self, segments: np.ndarray, M: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
+    def apply_segments(self, segments: np.ndarray, M: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
         """
         Apply affine transformations to segments and generate new bounding boxes.
 
@@ -1285,7 +1287,7 @@ class RandomPerspective:
         visible[out_mask] = 0
         return np.concatenate([xy, visible], axis=-1).reshape(n, nkpt, 3)
 
-    def __call__(self, labels: Dict[str, Any]) -> Dict[str, Any]:
+    def __call__(self, labels: dict[str, Any]) -> dict[str, Any]:
         """
         Apply random perspective and affine transformations to an image and its associated labels.
 
@@ -1453,7 +1455,7 @@ class RandomHSV:
         self.sgain = sgain
         self.vgain = vgain
 
-    def __call__(self, labels: Dict[str, Any]) -> Dict[str, Any]:
+    def __call__(self, labels: dict[str, Any]) -> dict[str, Any]:
         """
         Apply random HSV augmentation to an image within predefined limits.
 
@@ -1515,7 +1517,7 @@ class RandomFlip:
         >>> flipped_instances = result["instances"]
     """
 
-    def __init__(self, p: float = 0.5, direction: str = "horizontal", flip_idx: List[int] = None) -> None:
+    def __init__(self, p: float = 0.5, direction: str = "horizontal", flip_idx: list[int] = None) -> None:
         """
         Initialize the RandomFlip class with probability and direction.
 
@@ -1541,7 +1543,7 @@ class RandomFlip:
         self.direction = direction
         self.flip_idx = flip_idx
 
-    def __call__(self, labels: Dict[str, Any]) -> Dict[str, Any]:
+    def __call__(self, labels: dict[str, Any]) -> dict[str, Any]:
         """
         Apply random flip to an image and update any instances like bounding boxes or keypoints accordingly.
 
@@ -1615,7 +1617,7 @@ class LetterBox:
 
     def __init__(
         self,
-        new_shape: Tuple[int, int] = (640, 640),
+        new_shape: tuple[int, int] = (640, 640),
         auto: bool = False,
         scale_fill: bool = False,
         scaleup: bool = True,
@@ -1662,7 +1664,7 @@ class LetterBox:
         self.padding_value = padding_value
         self.interpolation = interpolation
 
-    def __call__(self, labels: Dict[str, Any] = None, image: np.ndarray = None) -> Union[Dict[str, Any], np.ndarray]:
+    def __call__(self, labels: dict[str, Any] = None, image: np.ndarray = None) -> dict[str, Any] | np.ndarray:
         """
         Resize and pad an image for object detection, instance segmentation, or pose estimation tasks.
 
@@ -1741,7 +1743,7 @@ class LetterBox:
             return img
 
     @staticmethod
-    def _update_labels(labels: Dict[str, Any], ratio: Tuple[float, float], padw: float, padh: float) -> Dict[str, Any]:
+    def _update_labels(labels: dict[str, Any], ratio: tuple[float, float], padw: float, padh: float) -> dict[str, Any]:
         """
         Update labels after applying letterboxing to an image.
 
@@ -1801,12 +1803,12 @@ class CopyPaste(BaseMixTransform):
         assert mode in {"flip", "mixup"}, f"Expected `mode` to be `flip` or `mixup`, but got {mode}."
         self.mode = mode
 
-    def _mix_transform(self, labels: Dict[str, Any]) -> Dict[str, Any]:
+    def _mix_transform(self, labels: dict[str, Any]) -> dict[str, Any]:
         """Apply Copy-Paste augmentation to combine objects from another image into the current image."""
         labels2 = labels["mix_labels"][0]
         return self._transform(labels, labels2)
 
-    def __call__(self, labels: Dict[str, Any]) -> Dict[str, Any]:
+    def __call__(self, labels: dict[str, Any]) -> dict[str, Any]:
         """Apply Copy-Paste augmentation to an image and its labels."""
         if len(labels["instances"].segments) == 0 or self.p == 0:
             return labels
@@ -1833,7 +1835,7 @@ class CopyPaste(BaseMixTransform):
         labels.pop("mix_labels", None)
         return labels
 
-    def _transform(self, labels1: Dict[str, Any], labels2: Dict[str, Any] = {}) -> Dict[str, Any]:
+    def _transform(self, labels1: dict[str, Any], labels2: dict[str, Any] = {}) -> dict[str, Any]:
         """Apply Copy-Paste augmentation to combine objects from another image into the current image."""
         im = labels1["img"]
         if "mosaic_border" not in labels1:
@@ -2011,7 +2013,7 @@ class Albumentations:
         except Exception as e:
             LOGGER.info(f"{prefix}{e}")
 
-    def __call__(self, labels: Dict[str, Any]) -> Dict[str, Any]:
+    def __call__(self, labels: dict[str, Any]) -> dict[str, Any]:
         """
         Apply Albumentations transformations to input labels.
 
@@ -2153,7 +2155,7 @@ class Format:
         self.batch_idx = batch_idx  # keep the batch indexes
         self.bgr = bgr
 
-    def __call__(self, labels: Dict[str, Any]) -> Dict[str, Any]:
+    def __call__(self, labels: dict[str, Any]) -> dict[str, Any]:
         """
         Format image annotations for object detection, instance segmentation, and pose estimation tasks.
 
@@ -2255,7 +2257,7 @@ class Format:
 
     def _format_segments(
         self, instances: Instances, cls: np.ndarray, w: int, h: int
-    ) -> Tuple[np.ndarray, Instances, np.ndarray]:
+    ) -> tuple[np.ndarray, Instances, np.ndarray]:
         """
         Convert polygon segments to bitmap masks.
 
@@ -2317,7 +2319,7 @@ class LoadVisualPrompt:
 
         return (r >= x1) * (r < x2) * (c >= y1) * (c < y2)
 
-    def __call__(self, labels: Dict[str, Any]) -> Dict[str, Any]:
+    def __call__(self, labels: dict[str, Any]) -> dict[str, Any]:
         """
         Process labels to create visual prompts.
 
@@ -2340,10 +2342,10 @@ class LoadVisualPrompt:
 
     def get_visuals(
         self,
-        category: Union[int, np.ndarray, torch.Tensor],
-        shape: Tuple[int, int],
-        bboxes: Union[np.ndarray, torch.Tensor] = None,
-        masks: Union[np.ndarray, torch.Tensor] = None,
+        category: int | np.ndarray | torch.Tensor,
+        shape: tuple[int, int],
+        bboxes: np.ndarray | torch.Tensor = None,
+        masks: np.ndarray | torch.Tensor = None,
     ) -> torch.Tensor:
         """
         Generate visual masks based on bounding boxes or masks.
@@ -2415,10 +2417,10 @@ class RandomLoadText:
     def __init__(
         self,
         prompt_format: str = "{}",
-        neg_samples: Tuple[int, int] = (80, 80),
+        neg_samples: tuple[int, int] = (80, 80),
         max_samples: int = 80,
         padding: bool = False,
-        padding_value: List[str] = [""],
+        padding_value: list[str] = [""],
     ) -> None:
         """
         Initialize the RandomLoadText class for randomly sampling positive and negative texts.
@@ -2459,7 +2461,7 @@ class RandomLoadText:
         self.padding = padding
         self.padding_value = padding_value
 
-    def __call__(self, labels: Dict[str, Any]) -> Dict[str, Any]:
+    def __call__(self, labels: dict[str, Any]) -> dict[str, Any]:
         """
         Randomly sample positive and negative texts and update class indices accordingly.
 
@@ -2595,9 +2597,9 @@ def v8_transforms(dataset, imgsz: int, hyp: IterableSimpleNamespace, stretch: bo
 
 # Classification augmentations -----------------------------------------------------------------------------------------
 def classify_transforms(
-    size: Union[Tuple[int, int], int] = 224,
-    mean: Tuple[float, float, float] = DEFAULT_MEAN,
-    std: Tuple[float, float, float] = DEFAULT_STD,
+    size: tuple[int, int] | int = 224,
+    mean: tuple[float, float, float] = DEFAULT_MEAN,
+    std: tuple[float, float, float] = DEFAULT_STD,
     interpolation: str = "BILINEAR",
     crop_fraction: float = None,
 ):
@@ -2647,10 +2649,10 @@ def classify_transforms(
 # Classification training augmentations --------------------------------------------------------------------------------
 def classify_augmentations(
     size: int = 224,
-    mean: Tuple[float, float, float] = DEFAULT_MEAN,
-    std: Tuple[float, float, float] = DEFAULT_STD,
-    scale: Tuple[float, float] = None,
-    ratio: Tuple[float, float] = None,
+    mean: tuple[float, float, float] = DEFAULT_MEAN,
+    std: tuple[float, float, float] = DEFAULT_STD,
+    scale: tuple[float, float] = None,
+    ratio: tuple[float, float] = None,
     hflip: float = 0.5,
     vflip: float = 0.0,
     auto_augment: str = None,
@@ -2773,7 +2775,7 @@ class ClassifyLetterBox:
         (640, 640, 3)
     """
 
-    def __init__(self, size: Union[int, Tuple[int, int]] = (640, 640), auto: bool = False, stride: int = 32):
+    def __init__(self, size: int | tuple[int, int] = (640, 640), auto: bool = False, stride: int = 32):
         """
         Initialize the ClassifyLetterBox object for image preprocessing.
 
@@ -2862,7 +2864,7 @@ class CenterCrop:
         (640, 640, 3)
     """
 
-    def __init__(self, size: Union[int, Tuple[int, int]] = (640, 640)):
+    def __init__(self, size: int | tuple[int, int] = (640, 640)):
         """
         Initialize the CenterCrop object for image preprocessing.
 
@@ -2886,7 +2888,7 @@ class CenterCrop:
         super().__init__()
         self.h, self.w = (size, size) if isinstance(size, int) else size
 
-    def __call__(self, im: Union[Image.Image, np.ndarray]) -> np.ndarray:
+    def __call__(self, im: Image.Image | np.ndarray) -> np.ndarray:
         """
         Apply center cropping to an input image.
 

ultralytics/data/base.py

@@ -1,5 +1,7 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
+from __future__ import annotations
+
 import glob
 import math
 import os
@@ -7,7 +9,7 @@ import random
 from copy import deepcopy
 from multiprocessing.pool import ThreadPool
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any
 
 import cv2
 import numpy as np
@@ -69,18 +71,18 @@ class BaseDataset(Dataset):
 
     def __init__(
         self,
-        img_path: Union[str, List[str]],
+        img_path: str | list[str],
         imgsz: int = 640,
-        cache: Union[bool, str] = False,
+        cache: bool | str = False,
         augment: bool = True,
-        hyp: Dict[str, Any] = DEFAULT_CFG,
+        hyp: dict[str, Any] = DEFAULT_CFG,
         prefix: str = "",
         rect: bool = False,
         batch_size: int = 16,
         stride: int = 32,
         pad: float = 0.5,
         single_cls: bool = False,
-        classes: Optional[List[int]] = None,
+        classes: list[int] | None = None,
         fraction: float = 1.0,
         channels: int = 3,
     ):
@@ -145,7 +147,7 @@ class BaseDataset(Dataset):
         # Transforms
         self.transforms = self.build_transforms(hyp=hyp)
 
-    def get_img_files(self, img_path: Union[str, List[str]]) -> List[str]:
+    def get_img_files(self, img_path: str | list[str]) -> list[str]:
         """
         Read image files from the specified path.
 
@@ -183,7 +185,7 @@ class BaseDataset(Dataset):
         check_file_speeds(im_files, prefix=self.prefix)  # check image read speeds
         return im_files
 
-    def update_labels(self, include_class: Optional[List[int]]) -> None:
+    def update_labels(self, include_class: list[int] | None) -> None:
         """
         Update labels to include only specified classes.
 
@@ -207,7 +209,7 @@ class BaseDataset(Dataset):
             if self.single_cls:
                 self.labels[i]["cls"][:, 0] = 0
 
-    def load_image(self, i: int, rect_mode: bool = True) -> Tuple[np.ndarray, Tuple[int, int], Tuple[int, int]]:
+    def load_image(self, i: int, rect_mode: bool = True) -> tuple[np.ndarray, tuple[int, int], tuple[int, int]]:
         """
         Load an image from dataset index 'i'.
 
@@ -374,11 +376,11 @@ class BaseDataset(Dataset):
         self.batch_shapes = np.ceil(np.array(shapes) * self.imgsz / self.stride + self.pad).astype(int) * self.stride
         self.batch = bi  # batch index of image
 
-    def __getitem__(self, index: int) -> Dict[str, Any]:
+    def __getitem__(self, index: int) -> dict[str, Any]:
         """Return transformed label information for given index."""
         return self.transforms(self.get_image_and_label(index))
 
-    def get_image_and_label(self, index: int) -> Dict[str, Any]:
+    def get_image_and_label(self, index: int) -> dict[str, Any]:
         """
         Get and return label information from the dataset.
 
@@ -403,11 +405,11 @@ class BaseDataset(Dataset):
         """Return the length of the labels list for the dataset."""
         return len(self.labels)
 
-    def update_labels_info(self, label: Dict[str, Any]) -> Dict[str, Any]:
+    def update_labels_info(self, label: dict[str, Any]) -> dict[str, Any]:
         """Custom your label format here."""
         return label
 
-    def build_transforms(self, hyp: Optional[Dict[str, Any]] = None):
+    def build_transforms(self, hyp: dict[str, Any] | None = None):
         """
         Users can customize augmentations here.
 
@@ -421,7 +423,7 @@ class BaseDataset(Dataset):
         """
         raise NotImplementedError
 
-    def get_labels(self) -> List[Dict[str, Any]]:
+    def get_labels(self) -> list[dict[str, Any]]:
         """
         Users can customize their own format here.
 

ultralytics/data/build.py

@@ -1,9 +1,12 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
+from __future__ import annotations
+
 import os
 import random
+from collections.abc import Iterator
 from pathlib import Path
-from typing import Any, Dict, Iterator
+from typing import Any
 
 import numpy as np
 import torch
@@ -116,7 +119,7 @@ def build_yolo_dataset(
     cfg: IterableSimpleNamespace,
     img_path: str,
     batch: int,
-    data: Dict[str, Any],
+    data: dict[str, Any],
     mode: str = "train",
     rect: bool = False,
     stride: int = 32,
@@ -133,7 +136,7 @@ def build_yolo_dataset(
         rect=cfg.rect or rect,  # rectangular batches
         cache=cfg.cache or None,
         single_cls=cfg.single_cls or False,
-        stride=int(stride),
+        stride=stride,
         pad=0.0 if mode == "train" else 0.5,
         prefix=colorstr(f"{mode}: "),
         task=cfg.task,
@@ -165,7 +168,7 @@ def build_grounding(
         rect=cfg.rect or rect,  # rectangular batches
         cache=cfg.cache or None,
         single_cls=cfg.single_cls or False,
-        stride=int(stride),
+        stride=stride,
         pad=0.0 if mode == "train" else 0.5,
         prefix=colorstr(f"{mode}: "),
         task=cfg.task,

ultralytics/data/converter.py

@@ -1,5 +1,7 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
+from __future__ import annotations
+
 import asyncio
 import json
 import random
@@ -7,7 +9,6 @@ import shutil
 from collections import defaultdict
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from pathlib import Path
-from typing import List, Optional, Union
 
 import cv2
 import numpy as np
@@ -19,7 +20,7 @@ from ultralytics.utils.downloads import download, zip_directory
 from ultralytics.utils.files import increment_path
 
 
-def coco91_to_coco80_class() -> List[int]:
+def coco91_to_coco80_class() -> list[int]:
     """
     Convert 91-index COCO class IDs to 80-index COCO class IDs.
 
@@ -122,7 +123,7 @@ def coco91_to_coco80_class() -> List[int]:
     ]
 
 
-def coco80_to_coco91_class() -> List[int]:
+def coco80_to_coco91_class() -> list[int]:
     r"""
     Convert 80-index (val2014) to 91-index (paper).
 
@@ -531,7 +532,7 @@ def min_index(arr1: np.ndarray, arr2: np.ndarray):
     return np.unravel_index(np.argmin(dis, axis=None), dis.shape)
 
 
-def merge_multi_segment(segments: List[List]):
+def merge_multi_segment(segments: list[list]):
     """
     Merge multiple segments into one list by connecting the coordinates with the minimum distance between each segment.
 
@@ -582,9 +583,7 @@ def merge_multi_segment(segments: List[List]):
     return s
 
 
-def yolo_bbox2segment(
-    im_dir: Union[str, Path], save_dir: Optional[Union[str, Path]] = None, sam_model: str = "sam_b.pt", device=None
-):
+def yolo_bbox2segment(im_dir: str | Path, save_dir: str | Path | None = None, sam_model: str = "sam_b.pt", device=None):
     """
     Convert existing object detection dataset (bounding boxes) to segmentation dataset or oriented bounding box (OBB) in
     YOLO format. Generate segmentation data using SAM auto-annotator as needed.
@@ -706,7 +705,7 @@ def create_synthetic_coco_dataset():
     LOGGER.info("Synthetic COCO dataset created successfully.")
 
 
-def convert_to_multispectral(path: Union[str, Path], n_channels: int = 10, replace: bool = False, zip: bool = False):
+def convert_to_multispectral(path: str | Path, n_channels: int = 10, replace: bool = False, zip: bool = False):
     """
     Convert RGB images to multispectral images by interpolating across wavelength bands.
 
@@ -733,7 +732,7 @@ def convert_to_multispectral(path: Union[str, Path], n_channels: int = 10, repla
     path = Path(path)
     if path.is_dir():
         # Process directory
-        im_files = sum([list(path.rglob(f"*.{ext}")) for ext in (IMG_FORMATS - {"tif", "tiff"})], [])
+        im_files = sum((list(path.rglob(f"*.{ext}")) for ext in (IMG_FORMATS - {"tif", "tiff"})), [])
         for im_path in im_files:
             try:
                 convert_to_multispectral(im_path, n_channels)
@@ -758,7 +757,7 @@ def convert_to_multispectral(path: Union[str, Path], n_channels: int = 10, repla
         LOGGER.info(f"Converted {output_path}")
 
 
-async def convert_ndjson_to_yolo(ndjson_path: Union[str, Path], output_path: Optional[Union[str, Path]] = None) -> Path:
+async def convert_ndjson_to_yolo(ndjson_path: str | Path, output_path: str | Path | None = None) -> Path:
     """
     Convert NDJSON dataset format to Ultralytics YOLO11 dataset structure.