ultralytics 8.3.87__py3-none-any.whl → 8.3.88__py3-none-any.whl

ultralytics/solutions/object_cropper.py

@@ -0,0 +1,84 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+import os
+from pathlib import Path
+
+from ultralytics.solutions.solutions import BaseSolution, SolutionResults
+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.
+
+    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.
+
+    Attributes:
+        crop_dir (str): Directory where cropped object images are stored.
+        crop_idx (int): Counter for the total number of cropped objects.
+        iou (float): IoU (Intersection over Union) threshold for non-maximum suppression.
+        conf (float): Confidence threshold for filtering detections.
+
+    Methods:
+        process: Crops detected objects from the input image and saves them to the output directory.
+
+    Examples:
+        >>> cropper = ObjectCropper()
+        >>> frame = cv2.imread("frame.jpg")
+        >>> processed_results = cropper.process(frame)
+        >>> print(f"Total cropped objects: {cropper.crop_idx}")
+    """
+
+    def __init__(self, **kwargs):
+        """
+        Initializes 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.
+        """
+        super().__init__(**kwargs)
+
+        self.crop_dir = kwargs.get("crop_dir", "cropped-detections")  # Directory for storing cropped detections
+        if not os.path.exists(self.crop_dir):
+            os.mkdir(self.crop_dir)  # Create directory if it does not exist
+        if self.CFG["show"]:
+            self.LOGGER.info(
+                f"⚠️ show=True disabled for crop solution, results will be saved in the directory named: {self.crop_dir}"
+            )
+        self.crop_idx = 0  # Initialize counter for total cropped objects
+        self.iou = self.CFG["iou"]
+        self.conf = self.CFG["conf"] if self.CFG["conf"] is not None else 0.25
+
+    def process(self, im0):
+        """
+        Crops detected objects from the input image and saves them as separate images.
+
+        Args:
+            im0 (numpy.ndarray): The input image containing detected objects.
+
+        Returns:
+            (SolutionResults): A SolutionResults object containing the total number of cropped objects and processed image.
+
+        Examples:
+            >>> cropper = ObjectCropper()
+            >>> frame = cv2.imread("image.jpg")
+            >>> results = cropper.process(frame)
+            >>> print(f"Total cropped objects: {results.total_crop_objects}")
+        """
+        results = self.model.predict(
+            im0, classes=self.classes, conf=self.conf, iou=self.iou, device=self.CFG["device"]
+        )[0]
+
+        for box in results.boxes:
+            self.crop_idx += 1
+            save_one_box(
+                box.xyxy,
+                im0,
+                file=Path(self.crop_dir) / f"crop_{self.crop_idx}.jpg",
+                BGR=True,
+            )
+
+        # Return SolutionResults
+        return SolutionResults(plot_im=im0, total_crop_objects=self.crop_idx)

ultralytics/solutions/parking_management.py

@@ -5,10 +5,9 @@ import json
 import cv2
 import numpy as np
 
-from ultralytics.solutions.solutions import BaseSolution
+from ultralytics.solutions.solutions import BaseSolution, SolutionAnnotator, SolutionResults
 from ultralytics.utils import LOGGER
 from ultralytics.utils.checks import check_imshow
-from ultralytics.utils.plotting import Annotator
 
 
 class ParkingPtsSelection:
@@ -189,7 +188,7 @@ class ParkingManagement(BaseSolution):
         dc (Tuple[int, int, int]): RGB color tuple for centroid visualization of detected objects.
 
     Methods:
-        process_data: Processes model data for parking lot management and visualization.
+        process: Processes the input image for parking lot management and visualization.
 
     Examples:
         >>> from ultralytics.solutions import ParkingManagement
@@ -216,9 +215,9 @@ class ParkingManagement(BaseSolution):
         self.occ = (0, 255, 0)  # occupied region color
         self.dc = (255, 0, 189)  # centroid color for each box
 
-    def process_data(self, im0):
+    def process(self, im0):
         """
-        Processes the model data for parking lot management.
+        Processes 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,
@@ -227,14 +226,18 @@ class ParkingManagement(BaseSolution):
         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).
+
         Examples:
             >>> parking_manager = ParkingManagement(json_file="parking_regions.json")
             >>> image = cv2.imread("parking_lot.jpg")
-            >>> parking_manager.process_data(image)
+            >>> results = parking_manager.process(image)
         """
         self.extract_tracks(im0)  # extract tracks from im0
         es, fs = len(self.json), 0  # empty slots, filled slots
-        annotator = Annotator(im0, self.line_width)  # init annotator
+        annotator = SolutionAnnotator(im0, self.line_width)  # init annotator
 
         for region in self.json:
             # Convert points to a NumPy array with the correct dtype and reshape properly
@@ -257,5 +260,14 @@ class ParkingManagement(BaseSolution):
         self.pr_info["Occupancy"], self.pr_info["Available"] = fs, es
 
         annotator.display_analytics(im0, self.pr_info, (104, 31, 17), (255, 255, 255), 10)
-        self.display_output(im0)  # display output with base class function
-        return im0  # return output image for more usage
+
+        plot_im = annotator.result()
+        self.display_output(plot_im)  # display output with base class function
+
+        # Return SolutionResults
+        return SolutionResults(
+            plot_im=plot_im,
+            filled_slots=self.pr_info["Occupancy"],
+            available_slots=self.pr_info["Available"],
+            total_tracks=len(self.track_ids),
+        )

ultralytics/solutions/queue_management.py

@@ -1,7 +1,7 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
-from ultralytics.solutions.solutions import BaseSolution
-from ultralytics.utils.plotting import Annotator, colors
+from ultralytics.solutions.solutions import BaseSolution, SolutionAnnotator, SolutionResults
+from ultralytics.utils.plotting import colors
 
 
 class QueueManager(BaseSolution):
@@ -15,13 +15,12 @@ class QueueManager(BaseSolution):
         counts (int): The current count of objects in the queue.
         rect_color (Tuple[int, int, int]): RGB color tuple for drawing the queue region rectangle.
         region_length (int): The number of points defining the queue region.
-        annotator (Annotator): An instance of the Annotator class for drawing on frames.
         track_line (List[Tuple[int, int]]): List of track line coordinates.
         track_history (Dict[int, List[Tuple[int, int]]]): Dictionary storing tracking history for each object.
 
     Methods:
         initialize_region: Initializes the queue region.
-        process_queue: Processes a single frame for queue management.
+        process: Processes a single frame for queue management.
         extract_tracks: Extracts object tracks from the current frame.
         store_tracking_history: Stores the tracking history for an object.
         display_output: Displays the processed output.
@@ -33,18 +32,18 @@ class QueueManager(BaseSolution):
         >>>     success, im0 = cap.read()
         >>>     if not success:
         >>>         break
-        >>>     out = queue.process_queue(im0)
+        >>>     results = queue_manager.process(im0)
     """
 
     def __init__(self, **kwargs):
         """Initializes the QueueManager with parameters for tracking and counting objects in a video stream."""
         super().__init__(**kwargs)
         self.initialize_region()
-        self.counts = 0  # Queue counts Information
-        self.rect_color = (255, 255, 255)  # Rectangle color
+        self.counts = 0  # Queue counts information
+        self.rect_color = (255, 255, 255)  # Rectangle color for visualization
         self.region_length = len(self.region)  # Store region length for further usage
 
-    def process_queue(self, im0):
+    def process(self, im0):
         """
         Processes the queue management for a single frame of video.
 
@@ -52,48 +51,28 @@ class QueueManager(BaseSolution):
             im0 (numpy.ndarray): Input image for processing, typically a frame from a video stream.
 
         Returns:
-            (numpy.ndarray): Processed image with annotations, bounding boxes, and queue counts.
-
-        This method performs the following steps:
-        1. Resets the queue count for the current frame.
-        2. Initializes an Annotator object for drawing on the image.
-        3. Extracts tracks from the image.
-        4. Draws the counting region on the image.
-        5. For each detected object:
-           - Draws bounding boxes and labels.
-           - Stores tracking history.
-           - Draws centroids and tracks.
-           - Checks if the object is inside the counting region and updates the count.
-        6. Displays the queue count on the image.
-        7. Displays the processed output.
+            (SolutionResults): Contains processed image `im0`, 'queue_count' (int, number of objects in the queue) and
+                'total_tracks' (int, total number of tracked objects).
 
         Examples:
             >>> queue_manager = QueueManager()
             >>> frame = cv2.imread("frame.jpg")
-            >>> processed_frame = queue_manager.process_queue(frame)
+            >>> results = queue_manager.process(frame)
         """
         self.counts = 0  # Reset counts every frame
-        self.annotator = Annotator(im0, line_width=self.line_width)  # Initialize annotator
-        self.extract_tracks(im0)  # Extract tracks
-
-        self.annotator.draw_region(
-            reg_pts=self.region, color=self.rect_color, thickness=self.line_width * 2
-        )  # Draw region
+        self.extract_tracks(im0)  # Extract tracks from the current frame
+        annotator = SolutionAnnotator(im0, line_width=self.line_width)  # Initialize annotator
+        annotator.draw_region(reg_pts=self.region, color=self.rect_color, thickness=self.line_width * 2)  # Draw region
 
         for box, track_id, cls in zip(self.boxes, self.track_ids, self.clss):
             # Draw bounding box and counting region
-            self.annotator.box_label(box, label=self.names[cls], color=colors(track_id, True))
+            annotator.box_label(box, label=self.names[cls], color=colors(track_id, True))
             self.store_tracking_history(track_id, box)  # Store track history
 
-            # Draw tracks of objects
-            self.annotator.draw_centroid_and_tracks(
-                self.track_line, color=colors(int(track_id), True), track_thickness=self.line_width
-            )
-
             # Cache frequently accessed attributes
             track_history = self.track_history.get(track_id, [])
 
-            # store previous position of track and check if the object is inside the counting region
+            # Store previous position of track and check if the object is inside the counting region
             prev_position = None
             if len(track_history) > 1:
                 prev_position = track_history[-2]
@@ -101,12 +80,14 @@ class QueueManager(BaseSolution):
                 self.counts += 1
 
         # Display queue counts
-        self.annotator.queue_counts_display(
+        annotator.queue_counts_display(
             f"Queue Counts : {str(self.counts)}",
             points=self.region,
             region_color=self.rect_color,
             txt_color=(104, 31, 17),
         )
-        self.display_output(im0)  # display output with base class function
+        plot_im = annotator.result()
+        self.display_output(plot_im)  # Display output with base class function
 
-        return im0  # return output image for more usage
+        # Return a SolutionResults object with processed data
+        return SolutionResults(plot_im=plot_im, queue_count=self.counts, total_tracks=len(self.track_ids))

ultralytics/solutions/region_counter.py

@@ -1,33 +1,33 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
-from ultralytics.solutions.solutions import BaseSolution
-from ultralytics.utils import LOGGER
-from ultralytics.utils.plotting import Annotator, colors
+import numpy as np
+
+from ultralytics.solutions.solutions import BaseSolution, SolutionAnnotator, SolutionResults
+from ultralytics.utils.plotting import colors
 
 
 class RegionCounter(BaseSolution):
     """
-    A class designed for real-time counting of objects within user-defined regions in a video stream.
+    A class for real-time counting of objects within user-defined regions in a video stream.
 
-    This class inherits from `BaseSolution` and offers functionalities to define polygonal regions in a video
-    frame, track objects, and count those objects that pass through each defined region. This makes it useful
-    for applications that require counting in specified areas, such as monitoring zones or segmented sections.
+    This class inherits from `BaseSolution` and provides functionality to define polygonal regions in a video frame,
+    track objects, and count those objects that pass through each defined region. Useful for applications requiring
+    counting in specified areas, such as monitoring zones or segmented sections.
 
     Attributes:
-        region_template (dict): A template for creating new counting regions with default attributes including
-                                the name, polygon coordinates, and display colors.
-        counting_regions (list): A list storing all defined regions, where each entry is based on `region_template`
-                                 and includes specific region settings like name, coordinates, and color.
+        region_template (Dict): Template for creating new counting regions with default attributes including name,
+            polygon coordinates, and display colors.
+        counting_regions (List): List storing all defined regions, where each entry is based on `region_template`
+            and includes specific region settings like name, coordinates, and color.
+        region_counts (Dict): Dictionary storing the count of objects for each named region.
 
     Methods:
-        add_region: Adds a new counting region with specified attributes, such as the region's name, polygon points,
-                    region color, and text color.
-        count: Processes video frames to count objects in each region, drawing regions and displaying counts
-               on the frame. Handles object detection, region definition, and containment checks.
+        add_region: Adds a new counting region with specified attributes.
+        process: Processes video frames to count objects in each region.
     """
 
     def __init__(self, **kwargs):
-        """Initializes the RegionCounter class for real-time counting in different regions of the video streams."""
+        """Initializes the RegionCounter class for real-time counting in different regions of video streams."""
         super().__init__(**kwargs)
         self.region_template = {
             "name": "Default Region",
@@ -37,6 +37,7 @@ class RegionCounter(BaseSolution):
             "region_color": (255, 255, 255),
             "text_color": (0, 0, 0),
         }
+        self.region_counts = {}
         self.counting_regions = []
 
     def add_region(self, name, polygon_points, region_color, text_color):
@@ -45,9 +46,9 @@ class RegionCounter(BaseSolution):
 
         Args:
             name (str): Name assigned to the new region.
-            polygon_points (list[tuple]): List of (x, y) coordinates defining the region's polygon.
-            region_color (tuple): BGR color for region visualization.
-            text_color (tuple): BGR color for the text within the region.
+            polygon_points (List[Tuple]): List of (x, y) coordinates defining the region's polygon.
+            region_color (Tuple): BGR color for region visualization.
+            text_color (Tuple): BGR color for the text within the region.
         """
         region = self.region_template.copy()
         region.update(
@@ -60,57 +61,59 @@ class RegionCounter(BaseSolution):
         )
         self.counting_regions.append(region)
 
-    def count(self, im0):
+    def process(self, im0):
         """
         Processes the input frame to detect and count objects within each defined region.
 
         Args:
-            im0 (numpy.ndarray): Input image frame where objects and regions are annotated.
+            im0 (np.ndarray): Input image frame where objects and regions are annotated.
 
         Returns:
-           im0 (numpy.ndarray): Processed image frame with annotated counting information.
+            (SolutionResults): Contains processed image `plot_im`, 'total_tracks' (int, total number of tracked objects),
+                and 'region_counts' (Dict, counts of objects per region).
         """
-        self.annotator = Annotator(im0, line_width=self.line_width)
         self.extract_tracks(im0)
+        annotator = SolutionAnnotator(im0, line_width=self.line_width)
+
+        # Ensure self.region is initialized and structured as a dictionary
+        if not isinstance(self.region, dict):
+            self.region = {"Region#01": self.region or self.initialize_region()}
 
-        # Region initialization and conversion
-        if self.region is None:
-            self.initialize_region()
-            regions = {"Region#01": self.region}
-        else:
-            regions = self.region if isinstance(self.region, dict) else {"Region#01": self.region}
-
-        # Draw regions and process counts for each defined area
-        for idx, (region_name, reg_pts) in enumerate(regions.items(), start=1):
-            if not isinstance(reg_pts, list) or not all(isinstance(pt, tuple) for pt in reg_pts):
-                LOGGER.warning(f"Invalid region points for {region_name}: {reg_pts}")
-                continue  # Skip invalid entries
+        # Draw only valid regions
+        for idx, (region_name, reg_pts) in enumerate(self.region.items(), start=1):
             color = colors(idx, True)
-            self.annotator.draw_region(reg_pts=reg_pts, color=color, thickness=self.line_width * 2)
-            self.add_region(region_name, reg_pts, color, self.annotator.get_txt_color())
+            annotator.draw_region(reg_pts, color, self.line_width * 2)
+            self.add_region(region_name, reg_pts, color, annotator.get_txt_color())
 
-        # Prepare regions for containment check
+        # Prepare regions for containment check (only process valid ones)
         for region in self.counting_regions:
-            region["prepared_polygon"] = self.prep(region["polygon"])
+            if "prepared_polygon" not in region:
+                region["prepared_polygon"] = self.prep(region["polygon"])
+
+        # Convert bounding boxes to NumPy array for center points
+        boxes_np = np.array([((box[0] + box[2]) / 2, (box[1] + box[3]) / 2) for box in self.boxes], dtype=np.float32)
+        points = [self.Point(pt) for pt in boxes_np]  # Convert centers to Point objects
 
-        # Process bounding boxes and count objects within each region
-        for box, cls in zip(self.boxes, self.clss):
-            self.annotator.box_label(box, label=self.names[cls], color=colors(cls, True))
-            bbox_center = ((box[0] + box[2]) / 2, (box[1] + box[3]) / 2)
+        # Process bounding boxes & check containment
+        if points:
+            for (point, cls), box in zip(zip(points, self.clss), self.boxes):
+                annotator.box_label(box, label=self.names[cls], color=colors(cls))
 
-            for region in self.counting_regions:
-                if region["prepared_polygon"].contains(self.Point(bbox_center)):
-                    region["counts"] += 1
+                for region in self.counting_regions:
+                    if region["prepared_polygon"].contains(point):
+                        region["counts"] += 1
+                        self.region_counts[region["name"]] = region["counts"]
 
-        # Display counts in each region
+        # Display region counts
         for region in self.counting_regions:
-            self.annotator.text_label(
+            annotator.text_label(
                 region["polygon"].bounds,
                 label=str(region["counts"]),
                 color=region["region_color"],
                 txt_color=region["text_color"],
             )
-            region["counts"] = 0  # Reset count for next frame
+            region["counts"] = 0  # Reset for next frame
+        plot_im = annotator.result()
+        self.display_output(plot_im)
 
-        self.display_output(im0)
-        return im0
+        return SolutionResults(plot_im=plot_im, total_tracks=len(self.track_ids), region_counts=self.region_counts)

ultralytics/solutions/security_alarm.py

@@ -1,36 +1,44 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
-from ultralytics.solutions.solutions import BaseSolution
+from ultralytics.solutions.solutions import BaseSolution, SolutionAnnotator, SolutionResults
 from ultralytics.utils import LOGGER
-from ultralytics.utils.plotting import Annotator, colors
+from ultralytics.utils.plotting import colors
 
 
 class SecurityAlarm(BaseSolution):
     """
     A class to manage security alarm functionalities for real-time monitoring.
 
-    This class extends the BaseSolution class and provides features to monitor
-    objects in a frame, send email notifications when specific thresholds are
-    exceeded for total detections, and annotate the output frame for visualization.
+    This class extends the BaseSolution class and provides features to monitor objects in a frame, send email
+    notifications when specific thresholds are exceeded for total detections, and annotate the output frame for
+    visualization.
 
     Attributes:
-       email_sent (bool): Flag to track if an email has already been sent for the current event.
-       records (int): Threshold for the number of detected objects to trigger an alert.
+        email_sent (bool): Flag to track if an email has already been sent for the current event.
+        records (int): Threshold for the number of detected objects to trigger an alert.
+        server (smtplib.SMTP): SMTP server connection for sending email alerts.
+        to_email (str): Recipient's email address for alerts.
+        from_email (str): Sender's email address for alerts.
 
     Methods:
-       authenticate: Sets up email server authentication for sending alerts.
-       send_email: Sends an email notification with details and an image attachment.
-       monitor: Monitors the frame, processes detections, and triggers alerts if thresholds are crossed.
+        authenticate: Sets up email server authentication for sending alerts.
+        send_email: Sends an email notification with details and an image attachment.
+        process: Monitors the frame, processes detections, and triggers alerts if thresholds are crossed.
 
     Examples:
         >>> security = SecurityAlarm()
         >>> security.authenticate("abc@gmail.com", "1111222233334444", "xyz@gmail.com")
         >>> frame = cv2.imread("frame.jpg")
-        >>> processed_frame = security.monitor(frame)
+        >>> results = security.process(frame)
     """
 
     def __init__(self, **kwargs):
-        """Initializes the SecurityAlarm class with parameters for real-time object monitoring."""
+        """
+        Initializes the SecurityAlarm class with parameters for real-time object monitoring.
+
+        Args:
+            **kwargs (Any): Additional keyword arguments passed to the parent class.
+        """
         super().__init__(**kwargs)
         self.email_sent = False
         self.records = self.CFG["records"]
@@ -47,8 +55,7 @@ class SecurityAlarm(BaseSolution):
             password (str): Password for the sender's email account.
             to_email (str): Recipient's email address.
 
-        This method initializes a secure connection with the SMTP server
-        and logs in using the provided credentials.
+        This method initializes a secure connection with the SMTP server and logs in using the provided credentials.
 
         Examples:
             >>> alarm = SecurityAlarm()
@@ -70,8 +77,8 @@ class SecurityAlarm(BaseSolution):
             im0 (numpy.ndarray): The input image or frame to be attached to the email.
             records (int): The number of detected objects to be included in the email message.
 
-        This method encodes the input image, composes the email message with
-        details about the detection, and sends it to the specified recipient.
+        This method encodes the input image, composes the email message with details about the detection, and sends it
+        to the specified recipient.
 
         Examples:
             >>> alarm = SecurityAlarm()
@@ -105,40 +112,43 @@ class SecurityAlarm(BaseSolution):
             self.server.send_message(message)
             LOGGER.info("✅ Email sent successfully!")
         except Exception as e:
-            print(f"❌ Failed to send email: {e}")
+            LOGGER.error(f"❌ Failed to send email: {e}")
 
-    def monitor(self, im0):
+    def process(self, im0):
         """
         Monitors the frame, processes object detections, and triggers alerts if thresholds are exceeded.
 
         Args:
             im0 (numpy.ndarray): The input image or frame to be processed and annotated.
 
-        This method processes the input frame, extracts detections, annotates the frame
-        with bounding boxes, and sends an email notification if the number of detected objects
-        surpasses the specified threshold and an alert has not already been sent.
-
         Returns:
-            (numpy.ndarray): The processed frame with annotations.
+            (SolutionResults): Contains processed image `plot_im`, 'total_tracks' (total number of tracked objects) and
+                'email_sent' (whether an email alert was triggered).
+
+        This method processes the input frame, extracts detections, annotates the frame with bounding boxes, and sends
+        an email notification if the number of detected objects surpasses the specified threshold and an alert has not
+        already been sent.
 
         Examples:
             >>> alarm = SecurityAlarm()
             >>> frame = cv2.imread("path/to/image.jpg")
-            >>> processed_frame = alarm.monitor(frame)
+            >>> results = alarm.process(frame)
         """
-        self.annotator = Annotator(im0, line_width=self.line_width)  # Initialize annotator
         self.extract_tracks(im0)  # Extract tracks
+        annotator = SolutionAnnotator(im0, line_width=self.line_width)  # Initialize annotator
 
-        # Iterate over bounding boxes, track ids and classes index
+        # Iterate over bounding boxes and classes index
         for box, cls in zip(self.boxes, self.clss):
             # Draw bounding box
-            self.annotator.box_label(box, label=self.names[cls], color=colors(cls, True))
+            annotator.box_label(box, label=self.names[cls], color=colors(cls, True))
 
         total_det = len(self.clss)
-        if total_det > self.records and not self.email_sent:  # Only send email If not sent before
+        if total_det > self.records and not self.email_sent:  # Only send email if not sent before
             self.send_email(im0, total_det)
             self.email_sent = True
 
-        self.display_output(im0)  # display output with base class function
+        plot_im = annotator.result()
+        self.display_output(plot_im)  # Display output with base class function
 
-        return im0  # return output image for more usage
+        # Return a SolutionResults
+        return SolutionResults(plot_im=plot_im, total_tracks=len(self.track_ids), email_sent=self.email_sent)