dgenerate-ultralytics-headless 8.3.222__py3-none-any.whl → 8.3.225__py3-none-any.whl

ultralytics/nn/text_model.py

@@ -20,8 +20,7 @@ except ImportError:
 
 
 class TextModel(nn.Module):
-    """
-    Abstract base class for text encoding models.
+    """Abstract base class for text encoding models.
 
     This class defines the interface for text encoding models used in vision-language tasks. Subclasses must implement
     the tokenize and encode_text methods to provide text tokenization and encoding functionality.
@@ -47,11 +46,10 @@ class TextModel(nn.Module):
 
 
 class CLIP(TextModel):
-    """
-    Implements OpenAI's CLIP (Contrastive Language-Image Pre-training) text encoder.
+    """Implements OpenAI's CLIP (Contrastive Language-Image Pre-training) text encoder.
 
-    This class provides a text encoder based on OpenAI's CLIP model, which can convert text into feature vectors
-    that are aligned with corresponding image features in a shared embedding space.
+    This class provides a text encoder based on OpenAI's CLIP model, which can convert text into feature vectors that
+    are aligned with corresponding image features in a shared embedding space.
 
     Attributes:
         model (clip.model.CLIP): The loaded CLIP model.
@@ -71,11 +69,10 @@ class CLIP(TextModel):
     """
 
     def __init__(self, size: str, device: torch.device) -> None:
-        """
-        Initialize the CLIP text encoder.
+        """Initialize the CLIP text encoder.
 
-        This class implements the TextModel interface using OpenAI's CLIP model for text encoding. It loads
-        a pre-trained CLIP model of the specified size and prepares it for text encoding tasks.
+        This class implements the TextModel interface using OpenAI's CLIP model for text encoding. It loads a
+        pre-trained CLIP model of the specified size and prepares it for text encoding tasks.
 
         Args:
             size (str): Model size identifier (e.g., 'ViT-B/32').
@@ -93,8 +90,7 @@ class CLIP(TextModel):
         self.eval()
 
     def tokenize(self, texts: str | list[str]) -> torch.Tensor:
-        """
-        Convert input texts to CLIP tokens.
+        """Convert input texts to CLIP tokens.
 
         Args:
             texts (str | list[str]): Input text or list of texts to tokenize.
@@ -111,8 +107,7 @@ class CLIP(TextModel):
 
     @smart_inference_mode()
     def encode_text(self, texts: torch.Tensor, dtype: torch.dtype = torch.float32) -> torch.Tensor:
-        """
-        Encode tokenized texts into normalized feature vectors.
+        """Encode tokenized texts into normalized feature vectors.
 
         This method processes tokenized text inputs through the CLIP model to generate feature vectors, which are then
         normalized to unit length. These normalized vectors can be used for text-image similarity comparisons.
@@ -137,15 +132,14 @@ class CLIP(TextModel):
 
     @smart_inference_mode()
     def encode_image(self, image: Image.Image | torch.Tensor, dtype: torch.dtype = torch.float32) -> torch.Tensor:
-        """
-        Encode preprocessed images into normalized feature vectors.
+        """Encode preprocessed images into normalized feature vectors.
 
-        This method processes preprocessed image inputs through the CLIP model to generate feature vectors, which are then
-        normalized to unit length. These normalized vectors can be used for text-image similarity comparisons.
+        This method processes preprocessed image inputs through the CLIP model to generate feature vectors, which are
+        then normalized to unit length. These normalized vectors can be used for text-image similarity comparisons.
 
         Args:
-            image (PIL.Image | torch.Tensor): Preprocessed image input. If a PIL Image is provided, it will be
-                converted to a tensor using the model's image preprocessing function.
+            image (PIL.Image | torch.Tensor): Preprocessed image input. If a PIL Image is provided, it will be converted
+                to a tensor using the model's image preprocessing function.
             dtype (torch.dtype, optional): Data type for output features.
 
         Returns:
@@ -169,8 +163,7 @@ class CLIP(TextModel):
 
 
 class MobileCLIP(TextModel):
-    """
-    Implement Apple's MobileCLIP text encoder for efficient text encoding.
+    """Implement Apple's MobileCLIP text encoder for efficient text encoding.
 
     This class implements the TextModel interface using Apple's MobileCLIP model, providing efficient text encoding
     capabilities for vision-language tasks with reduced computational requirements compared to standard CLIP models.
@@ -195,8 +188,7 @@ class MobileCLIP(TextModel):
     config_size_map = {"s0": "s0", "s1": "s1", "s2": "s2", "b": "b", "blt": "b"}
 
     def __init__(self, size: str, device: torch.device) -> None:
-        """
-        Initialize the MobileCLIP text encoder.
+        """Initialize the MobileCLIP text encoder.
 
         This class implements the TextModel interface using Apple's MobileCLIP model for efficient text encoding.
 
@@ -236,8 +228,7 @@ class MobileCLIP(TextModel):
         self.eval()
 
     def tokenize(self, texts: list[str]) -> torch.Tensor:
-        """
-        Convert input texts to MobileCLIP tokens.
+        """Convert input texts to MobileCLIP tokens.
 
         Args:
             texts (list[str]): List of text strings to tokenize.
@@ -253,8 +244,7 @@ class MobileCLIP(TextModel):
 
     @smart_inference_mode()
     def encode_text(self, texts: torch.Tensor, dtype: torch.dtype = torch.float32) -> torch.Tensor:
-        """
-        Encode tokenized texts into normalized feature vectors.
+        """Encode tokenized texts into normalized feature vectors.
 
         Args:
             texts (torch.Tensor): Tokenized text inputs.
@@ -276,8 +266,7 @@ class MobileCLIP(TextModel):
 
 
 class MobileCLIPTS(TextModel):
-    """
-    Load a TorchScript traced version of MobileCLIP.
+    """Load a TorchScript traced version of MobileCLIP.
 
     This class implements the TextModel interface using Apple's MobileCLIP model in TorchScript format, providing
     efficient text encoding capabilities for vision-language tasks with optimized inference performance.
@@ -299,11 +288,10 @@ class MobileCLIPTS(TextModel):
     """
 
     def __init__(self, device: torch.device):
-        """
-        Initialize the MobileCLIP TorchScript text encoder.
+        """Initialize the MobileCLIP TorchScript text encoder.
 
-        This class implements the TextModel interface using Apple's MobileCLIP model in TorchScript format for
-        efficient text encoding with optimized inference performance.
+        This class implements the TextModel interface using Apple's MobileCLIP model in TorchScript format for efficient
+        text encoding with optimized inference performance.
 
         Args:
             device (torch.device): Device to load the model on.
@@ -321,8 +309,7 @@ class MobileCLIPTS(TextModel):
         self.device = device
 
     def tokenize(self, texts: list[str]) -> torch.Tensor:
-        """
-        Convert input texts to MobileCLIP tokens.
+        """Convert input texts to MobileCLIP tokens.
 
         Args:
             texts (list[str]): List of text strings to tokenize.
@@ -338,8 +325,7 @@ class MobileCLIPTS(TextModel):
 
     @smart_inference_mode()
     def encode_text(self, texts: torch.Tensor, dtype: torch.dtype = torch.float32) -> torch.Tensor:
-        """
-        Encode tokenized texts into normalized feature vectors.
+        """Encode tokenized texts into normalized feature vectors.
 
         Args:
             texts (torch.Tensor): Tokenized text inputs.
@@ -360,8 +346,7 @@ class MobileCLIPTS(TextModel):
 
 
 def build_text_model(variant: str, device: torch.device = None) -> TextModel:
-    """
-    Build a text encoding model based on the specified variant.
+    """Build a text encoding model based on the specified variant.
 
     Args:
         variant (str): Model variant in format "base:size" (e.g., "clip:ViT-B/32" or "mobileclip:s0").

ultralytics/solutions/ai_gym.py

@@ -7,8 +7,7 @@ from ultralytics.solutions.solutions import BaseSolution, SolutionAnnotator, Sol
 
 
 class AIGym(BaseSolution):
-    """
-    A class to manage gym steps of people in a real-time video stream based on their poses.
+    """A class to manage gym steps of people in a real-time video stream based on their poses.
 
     This class extends BaseSolution to monitor workouts using YOLO pose estimation models. It tracks and counts
     repetitions of exercises based on predefined angle thresholds for up and down positions.
@@ -32,12 +31,11 @@ class AIGym(BaseSolution):
     """
 
     def __init__(self, **kwargs: Any) -> None:
-        """
-        Initialize AIGym for workout monitoring using pose estimation and predefined angles.
+        """Initialize AIGym for workout monitoring using pose estimation and predefined angles.
 
         Args:
-            **kwargs (Any): Keyword arguments passed to the parent class constructor.
-                model (str): Model name or path, defaults to "yolo11n-pose.pt".
+            **kwargs (Any): Keyword arguments passed to the parent class constructor including:
+                - model (str): Model name or path, defaults to "yolo11n-pose.pt".
         """
         kwargs["model"] = kwargs.get("model", "yolo11n-pose.pt")
         super().__init__(**kwargs)
@@ -49,22 +47,18 @@ class AIGym(BaseSolution):
         self.kpts = self.CFG["kpts"]  # User selected kpts of workouts storage for further usage
 
     def process(self, im0) -> SolutionResults:
-        """
-        Monitor workouts using Ultralytics YOLO Pose Model.
+        """Monitor workouts using Ultralytics YOLO Pose Model.
 
-        This function processes an input image to track and analyze human poses for workout monitoring. It uses
-        the YOLO Pose model to detect keypoints, estimate angles, and count repetitions based on predefined
-        angle thresholds.
+        This function processes an input image to track and analyze human poses for workout monitoring. It uses the YOLO
+        Pose model to detect keypoints, estimate angles, and count repetitions based on predefined angle thresholds.
 
         Args:
             im0 (np.ndarray): Input image for processing.
 
         Returns:
-            (SolutionResults): Contains processed image `plot_im`,
-                'workout_count' (list of completed reps),
-                'workout_stage' (list of current stages),
-                'workout_angle' (list of angles), and
-                'total_tracks' (total number of tracked individuals).
+            (SolutionResults): Contains processed image `plot_im`, 'workout_count' (list of completed reps),
+                'workout_stage' (list of current stages), 'workout_angle' (list of angles), and 'total_tracks' (total
+                number of tracked individuals).
 
         Examples:
             >>> gym = AIGym()

ultralytics/solutions/analytics.py

@@ -12,11 +12,10 @@ from ultralytics.solutions.solutions import BaseSolution, SolutionResults  # Imp
 
 
 class Analytics(BaseSolution):
-    """
-    A class for creating and updating various types of charts for visual analytics.
+    """A class for creating and updating various types of charts for visual analytics.
 
-    This class extends BaseSolution to provide functionality for generating line, bar, pie, and area charts
-    based on object detection and tracking data.
+    This class extends BaseSolution to provide functionality for generating line, bar, pie, and area charts based on
+    object detection and tracking data.
 
     Attributes:
         type (str): The type of analytics chart to generate ('line', 'bar', 'pie', or 'area').
@@ -92,8 +91,7 @@ class Analytics(BaseSolution):
                 self.ax.axis("equal")
 
     def process(self, im0: np.ndarray, frame_number: int) -> SolutionResults:
-        """
-        Process image data and run object tracking to update analytics charts.
+        """Process image data and run object tracking to update analytics charts.
 
         Args:
             im0 (np.ndarray): Input image for processing.
@@ -139,13 +137,12 @@ class Analytics(BaseSolution):
     def update_graph(
         self, frame_number: int, count_dict: dict[str, int] | None = None, plot: str = "line"
     ) -> np.ndarray:
-        """
-        Update the graph with new data for single or multiple classes.
+        """Update the graph with new data for single or multiple classes.
 
         Args:
             frame_number (int): The current frame number.
-            count_dict (dict[str, int], optional): Dictionary with class names as keys and counts as values for
-                multiple classes. If None, updates a single line graph.
+            count_dict (dict[str, int], optional): Dictionary with class names as keys and counts as values for multiple
+                classes. If None, updates a single line graph.
             plot (str): Type of the plot. Options are 'line', 'bar', 'pie', or 'area'.
 
         Returns:

ultralytics/solutions/config.py

@@ -10,12 +10,11 @@ import cv2
 
 @dataclass
 class SolutionConfig:
-    """
-    Manages configuration parameters for Ultralytics Vision AI solutions.
+    """Manages configuration parameters for Ultralytics Vision AI solutions.
 
-    The SolutionConfig class serves as a centralized configuration container for all the
-    Ultralytics solution modules: https://docs.ultralytics.com/solutions/#solutions.
-    It leverages Python `dataclass` for clear, type-safe, and maintainable parameter definitions.
+    The SolutionConfig class serves as a centralized configuration container for all the Ultralytics solution modules:
+    https://docs.ultralytics.com/solutions/#solutions. It leverages Python `dataclass` for clear, type-safe, and
+    maintainable parameter definitions.
 
     Attributes:
         source (str, optional): Path to the input source (video, RTSP, etc.). Only usable with Solutions CLI.

ultralytics/solutions/distance_calculation.py

@@ -10,11 +10,10 @@ from ultralytics.utils.plotting import colors
 
 
 class DistanceCalculation(BaseSolution):
-    """
-    A class to calculate distance between two objects in a real-time video stream based on their tracks.
+    """A class to calculate distance between two objects in a real-time video stream based on their tracks.
 
-    This class extends BaseSolution to provide functionality for selecting objects and calculating the distance
-    between them in a video stream using YOLO object detection and tracking.
+    This class extends BaseSolution to provide functionality for selecting objects and calculating the distance between
+    them in a video stream using YOLO object detection and tracking.
 
     Attributes:
         left_mouse_count (int): Counter for left mouse button clicks.
@@ -43,8 +42,7 @@ class DistanceCalculation(BaseSolution):
         self.centroids: list[list[int]] = []  # Store centroids of selected objects
 
     def mouse_event_for_distance(self, event: int, x: int, y: int, flags: int, param: Any) -> None:
-        """
-        Handle mouse events to select regions in a real-time video stream for distance calculation.
+        """Handle mouse events to select regions in a real-time video stream for distance calculation.
 
         Args:
             event (int): Type of mouse event (e.g., cv2.EVENT_MOUSEMOVE, cv2.EVENT_LBUTTONDOWN).
@@ -69,18 +67,17 @@ class DistanceCalculation(BaseSolution):
             self.left_mouse_count = 0
 
     def process(self, im0) -> SolutionResults:
-        """
-        Process a video frame and calculate the distance between two selected bounding boxes.
+        """Process a video frame and calculate the distance between two selected bounding boxes.
 
-        This method extracts tracks from the input frame, annotates bounding boxes, and calculates the distance
-        between two user-selected objects if they have been chosen.
+        This method extracts tracks from the input frame, annotates bounding boxes, and calculates the distance between
+        two user-selected objects if they have been chosen.
 
         Args:
             im0 (np.ndarray): The input image frame to process.
 
         Returns:
-            (SolutionResults): Contains processed image `plot_im`, `total_tracks` (int) representing the total number
-                of tracked objects, and `pixels_distance` (float) representing the distance between selected objects
+            (SolutionResults): Contains processed image `plot_im`, `total_tracks` (int) representing the total number of
+                tracked objects, and `pixels_distance` (float) representing the distance between selected objects
                 in pixels.
 
         Examples:

ultralytics/solutions/heatmap.py

@@ -12,8 +12,7 @@ from ultralytics.solutions.solutions import SolutionAnnotator, SolutionResults
 
 
 class Heatmap(ObjectCounter):
-    """
-    A class to draw heatmaps in real-time video streams based on object tracks.
+    """A class to draw heatmaps in real-time video streams based on object tracks.
 
     This class extends the ObjectCounter class to generate and visualize heatmaps of object movements in video
     streams. It uses tracked object positions to create a cumulative heatmap effect over time.
@@ -36,8 +35,7 @@ class Heatmap(ObjectCounter):
     """
 
     def __init__(self, **kwargs: Any) -> None:
-        """
-        Initialize the Heatmap class for real-time video stream heatmap generation based on object tracks.
+        """Initialize the Heatmap class for real-time video stream heatmap generation based on object tracks.
 
         Args:
             **kwargs (Any): Keyword arguments passed to the parent ObjectCounter class.
@@ -53,8 +51,7 @@ class Heatmap(ObjectCounter):
         self.heatmap = None
 
     def heatmap_effect(self, box: list[float]) -> None:
-        """
-        Efficiently calculate heatmap area and effect location for applying colormap.
+        """Efficiently calculate heatmap area and effect location for applying colormap.
 
         Args:
             box (list[float]): Bounding box coordinates [x0, y0, x1, y1].
@@ -75,18 +72,15 @@ class Heatmap(ObjectCounter):
         self.heatmap[y0:y1, x0:x1][within_radius] += 2
 
     def process(self, im0: np.ndarray) -> SolutionResults:
-        """
-        Generate heatmap for each frame using Ultralytics tracking.
+        """Generate heatmap for each frame using Ultralytics tracking.
 
         Args:
             im0 (np.ndarray): Input image array for processing.
 
         Returns:
-            (SolutionResults): Contains processed image `plot_im`,
-                'in_count' (int, count of objects entering the region),
-                'out_count' (int, count of objects exiting the region),
-                'classwise_count' (dict, per-class object count), and
-                'total_tracks' (int, total number of tracked objects).
+            (SolutionResults): Contains processed image `plot_im`, 'in_count' (int, count of objects entering the
+                region), 'out_count' (int, count of objects exiting the region), 'classwise_count' (dict, per-class
+                object count), and 'total_tracks' (int, total number of tracked objects).
         """
         if not self.initialized:
             self.heatmap = np.zeros_like(im0, dtype=np.float32) * 0.99

ultralytics/solutions/instance_segmentation.py

@@ -7,8 +7,7 @@ from ultralytics.solutions.solutions import BaseSolution, SolutionResults
 
 
 class InstanceSegmentation(BaseSolution):
-    """
-    A class to manage instance segmentation in images or video streams.
+    """A class to manage instance segmentation in images or video streams.
 
     This class extends the BaseSolution class and provides functionality for performing instance segmentation, including
     drawing segmented masks with bounding boxes and labels.
@@ -36,12 +35,11 @@ class InstanceSegmentation(BaseSolution):
     """
 
     def __init__(self, **kwargs: Any) -> None:
-        """
-        Initialize the InstanceSegmentation class for detecting and annotating segmented instances.
+        """Initialize the InstanceSegmentation class for detecting and annotating segmented instances.
 
         Args:
-            **kwargs (Any): Keyword arguments passed to the BaseSolution parent class.
-                model (str): Model name or path, defaults to "yolo11n-seg.pt".
+            **kwargs (Any): Keyword arguments passed to the BaseSolution parent class including:
+                - model (str): Model name or path, defaults to "yolo11n-seg.pt".
         """
         kwargs["model"] = kwargs.get("model", "yolo11n-seg.pt")
         super().__init__(**kwargs)
@@ -51,8 +49,7 @@ class InstanceSegmentation(BaseSolution):
         self.show_boxes = self.CFG.get("show_boxes", True)
 
     def process(self, im0) -> SolutionResults:
-        """
-        Perform instance segmentation on the input image and annotate the results.
+        """Perform instance segmentation on the input image and annotate the results.
 
         Args:
             im0 (np.ndarray): The input image for segmentation.

ultralytics/solutions/object_blurrer.py

@@ -10,8 +10,7 @@ from ultralytics.utils.plotting import colors
 
 
 class ObjectBlurrer(BaseSolution):
-    """
-    A class to manage the blurring of detected objects in a real-time video stream.
+    """A class to manage the blurring of detected objects in a real-time video stream.
 
     This class extends the BaseSolution class and provides functionality for blurring objects based on detected bounding
     boxes. The blurred areas are updated directly in the input image, allowing for privacy preservation or other effects.
@@ -34,12 +33,11 @@ class ObjectBlurrer(BaseSolution):
     """
 
     def __init__(self, **kwargs: Any) -> None:
-        """
-        Initialize the ObjectBlurrer class for applying a blur effect to objects detected in video streams or images.
+        """Initialize the ObjectBlurrer class for applying a blur effect to objects detected in video streams or images.
 
         Args:
-            **kwargs (Any): Keyword arguments passed to the parent class and for configuration.
-                blur_ratio (float): Intensity of the blur effect (0.1-1.0, default=0.5).
+            **kwargs (Any): Keyword arguments passed to the parent class and for configuration including:
+                - blur_ratio (float): Intensity of the blur effect (0.1-1.0, default=0.5).
         """
         super().__init__(**kwargs)
         blur_ratio = self.CFG["blur_ratio"]
@@ -49,11 +47,10 @@ class ObjectBlurrer(BaseSolution):
         self.blur_ratio = int(blur_ratio * 100)
 
     def process(self, im0) -> SolutionResults:
-        """
-        Apply a blurring effect to detected objects in the input image.
+        """Apply a blurring effect to detected objects in the input image.
 
-        This method extracts tracking information, applies blur to regions corresponding to detected objects,
-        and annotates the image with bounding boxes.
+        This method extracts tracking information, applies blur to regions corresponding to detected objects, and
+        annotates the image with bounding boxes.
 
         Args:
             im0 (np.ndarray): The input image containing detected objects.

ultralytics/solutions/object_counter.py

@@ -10,8 +10,7 @@ from ultralytics.utils.plotting import colors
 
 
 class ObjectCounter(BaseSolution):
-    """
-    A class to manage the counting of objects in a real-time video stream based on their tracks.
+    """A class to manage the counting of objects in a real-time video stream based on their tracks.
 
     This class extends the BaseSolution class and provides functionality for counting objects moving in and out of a
     specified region in a video stream. It supports both polygonal and linear regions for counting.
@@ -59,8 +58,7 @@ class ObjectCounter(BaseSolution):
         prev_position: tuple[float, float] | None,
         cls: int,
     ) -> None:
-        """
-        Count objects within a polygonal or linear region based on their tracks.
+        """Count objects within a polygonal or linear region based on their tracks.
 
         Args:
             current_centroid (tuple[float, float]): Current centroid coordinates (x, y) in the current frame.
@@ -117,8 +115,7 @@ class ObjectCounter(BaseSolution):
                 self.counted_ids.append(track_id)
 
     def display_counts(self, plot_im) -> None:
-        """
-        Display object counts on the input image or frame.
+        """Display object counts on the input image or frame.
 
         Args:
             plot_im (np.ndarray): The image or frame to display counts on.
@@ -138,19 +135,18 @@ class ObjectCounter(BaseSolution):
             self.annotator.display_analytics(plot_im, labels_dict, (104, 31, 17), (255, 255, 255), self.margin)
 
     def process(self, im0) -> SolutionResults:
-        """
-        Process input data (frames or object tracks) and update object counts.
+        """Process input data (frames or object tracks) and update object counts.
 
-        This method initializes the counting region, extracts tracks, draws bounding boxes and regions, updates
-        object counts, and displays the results on the input image.
+        This method initializes the counting region, extracts tracks, draws bounding boxes and regions, updates object
+        counts, and displays the results on the input image.
 
         Args:
             im0 (np.ndarray): The input image or frame to be processed.
 
         Returns:
             (SolutionResults): Contains processed image `im0`, 'in_count' (int, count of objects entering the region),
-                'out_count' (int, count of objects exiting the region), 'classwise_count' (dict, per-class object count),
-                and 'total_tracks' (int, total number of tracked objects).
+                'out_count' (int, count of objects exiting the region), 'classwise_count' (dict, per-class object
+                count), and 'total_tracks' (int, total number of tracked objects).
 
         Examples:
             >>> counter = ObjectCounter()

ultralytics/solutions/object_cropper.py

@@ -9,8 +9,7 @@ from ultralytics.utils.plotting import save_one_box
 
 
 class ObjectCropper(BaseSolution):
-    """
-    A class to manage the cropping of detected objects in a real-time video stream or images.
+    """A class to manage the cropping of detected objects in a real-time video stream or images.
 
     This class extends the BaseSolution class and provides functionality for cropping objects based on detected bounding
     boxes. The cropped images are saved to a specified directory for further analysis or usage.
@@ -32,12 +31,11 @@ class ObjectCropper(BaseSolution):
     """
 
     def __init__(self, **kwargs: Any) -> None:
-        """
-        Initialize the ObjectCropper class for cropping objects from detected bounding boxes.
+        """Initialize the ObjectCropper class for cropping objects from detected bounding boxes.
 
         Args:
-            **kwargs (Any): Keyword arguments passed to the parent class and used for configuration.
-                crop_dir (str): Path to the directory for saving cropped object images.
+            **kwargs (Any): Keyword arguments passed to the parent class and used for configuration including:
+                - crop_dir (str): Path to the directory for saving cropped object images.
         """
         super().__init__(**kwargs)
 
@@ -53,8 +51,7 @@ class ObjectCropper(BaseSolution):
         self.conf = self.CFG["conf"]
 
     def process(self, im0) -> SolutionResults:
-        """
-        Crop detected objects from the input image and save them as separate images.
+        """Crop detected objects from the input image and save them as separate images.
 
         Args:
             im0 (np.ndarray): The input image containing detected objects.

ultralytics/solutions/parking_management.py

@@ -14,11 +14,10 @@ from ultralytics.utils.checks import check_imshow
 
 
 class ParkingPtsSelection:
-    """
-    A class for selecting and managing parking zone points on images using a Tkinter-based UI.
+    """A class for selecting and managing parking zone points on images using a Tkinter-based UI.
 
-    This class provides functionality to upload an image, select points to define parking zones, and save the
-    selected points to a JSON file. It uses Tkinter for the graphical user interface.
+    This class provides functionality to upload an image, select points to define parking zones, and save the selected
+    points to a JSON file. It uses Tkinter for the graphical user interface.
 
     Attributes:
         tk (module): The Tkinter module for GUI operations.
@@ -178,11 +177,10 @@ class ParkingPtsSelection:
 
 
 class ParkingManagement(BaseSolution):
-    """
-    Manages parking occupancy and availability using YOLO model for real-time monitoring and visualization.
+    """Manages parking occupancy and availability using YOLO model for real-time monitoring and visualization.
 
-    This class extends BaseSolution to provide functionality for parking lot management, including detection of
-    occupied spaces, visualization of parking regions, and display of occupancy statistics.
+    This class extends BaseSolution to provide functionality for parking lot management, including detection of occupied
+    spaces, visualization of parking regions, and display of occupancy statistics.
 
     Attributes:
         json_file (str): Path to the JSON file containing parking region details.
@@ -221,19 +219,19 @@ class ParkingManagement(BaseSolution):
         self.dc = (255, 0, 189)  # Centroid color for each box
 
     def process(self, im0: np.ndarray) -> SolutionResults:
-        """
-        Process the input image for parking lot management and visualization.
+        """Process the input image for parking lot management and visualization.
 
-        This function analyzes the input image, extracts tracks, and determines the occupancy status of parking
-        regions defined in the JSON file. It annotates the image with occupied and available parking spots,
-        and updates the parking information.
+        This function analyzes the input image, extracts tracks, and determines the occupancy status of parking regions
+        defined in the JSON file. It annotates the image with occupied and available parking spots, and updates the
+        parking information.
 
         Args:
             im0 (np.ndarray): The input inference image.
 
         Returns:
             (SolutionResults): Contains processed image `plot_im`, 'filled_slots' (number of occupied parking slots),
-                'available_slots' (number of available parking slots), and 'total_tracks' (total number of tracked objects).
+                'available_slots' (number of available parking slots), and 'total_tracks' (total number of
+                tracked objects).
 
         Examples:
             >>> parking_manager = ParkingManagement(json_file="parking_regions.json")

ultralytics/solutions/queue_management.py

@@ -7,11 +7,10 @@ from ultralytics.utils.plotting import colors
 
 
 class QueueManager(BaseSolution):
-    """
-    Manages queue counting in real-time video streams based on object tracks.
+    """Manages queue counting in real-time video streams based on object tracks.
 
-    This class extends BaseSolution to provide functionality for tracking and counting objects within a specified
-    region in video frames.
+    This class extends BaseSolution to provide functionality for tracking and counting objects within a specified region
+    in video frames.
 
     Attributes:
         counts (int): The current count of objects in the queue.
@@ -46,8 +45,7 @@ class QueueManager(BaseSolution):
         self.region_length = len(self.region)  # Store region length for further usage
 
     def process(self, im0) -> SolutionResults:
-        """
-        Process queue management for a single frame of video.
+        """Process queue management for a single frame of video.
 
         Args:
             im0 (np.ndarray): Input image for processing, typically a frame from a video stream.