ultralytics 8.3.89__py3-none-any.whl → 8.3.91__py3-none-any.whl

ultralytics/engine/validator.py

@@ -41,43 +41,66 @@ from ultralytics.utils.torch_utils import de_parallel, select_device, smart_infe
 
 class BaseValidator:
     """
-    BaseValidator.
-
     A base class for creating validators.
 
+    This class provides the foundation for validation processes, including model evaluation, metric computation, and
+    result visualization.
+
     Attributes:
         args (SimpleNamespace): Configuration for the validator.
         dataloader (DataLoader): Dataloader to use for validation.
         pbar (tqdm): Progress bar to update during validation.
         model (nn.Module): Model to validate.
-        data (dict): Data dictionary.
+        data (Dict): Data dictionary containing dataset information.
         device (torch.device): Device to use for validation.
         batch_i (int): Current batch index.
         training (bool): Whether the model is in training mode.
-        names (dict): Class names.
-        seen: Records the number of images seen so far during validation.
-        stats: Placeholder for statistics during validation.
-        confusion_matrix: Placeholder for a confusion matrix.
-        nc: Number of classes.
-        iouv: (torch.Tensor): IoU thresholds from 0.50 to 0.95 in spaces of 0.05.
-        jdict (dict): Dictionary to store JSON validation results.
-        speed (dict): Dictionary with keys 'preprocess', 'inference', 'loss', 'postprocess' and their respective
-                      batch processing times in milliseconds.
+        names (Dict): Class names mapping.
+        seen (int): Number of images seen so far during validation.
+        stats (Dict): Statistics collected during validation.
+        confusion_matrix: Confusion matrix for classification evaluation.
+        nc (int): Number of classes.
+        iouv (torch.Tensor): IoU thresholds from 0.50 to 0.95 in spaces of 0.05.
+        jdict (List): List to store JSON validation results.
+        speed (Dict): Dictionary with keys 'preprocess', 'inference', 'loss', 'postprocess' and their respective
+            batch processing times in milliseconds.
         save_dir (Path): Directory to save results.
-        plots (dict): Dictionary to store plots for visualization.
-        callbacks (dict): Dictionary to store various callback functions.
+        plots (Dict): Dictionary to store plots for visualization.
+        callbacks (Dict): Dictionary to store various callback functions.
+
+    Methods:
+        __call__: Execute validation process, running inference on dataloader and computing performance metrics.
+        match_predictions: Match predictions to ground truth objects using IoU.
+        add_callback: Append the given callback to the specified event.
+        run_callbacks: Run all callbacks associated with a specified event.
+        get_dataloader: Get data loader from dataset path and batch size.
+        build_dataset: Build dataset from image path.
+        preprocess: Preprocess an input batch.
+        postprocess: Postprocess the predictions.
+        init_metrics: Initialize performance metrics for the YOLO model.
+        update_metrics: Update metrics based on predictions and batch.
+        finalize_metrics: Finalize and return all metrics.
+        get_stats: Return statistics about the model's performance.
+        check_stats: Check statistics.
+        print_results: Print the results of the model's predictions.
+        get_desc: Get description of the YOLO model.
+        on_plot: Register plots (e.g. to be consumed in callbacks).
+        plot_val_samples: Plot validation samples during training.
+        plot_predictions: Plot YOLO model predictions on batch images.
+        pred_to_json: Convert predictions to JSON format.
+        eval_json: Evaluate and return JSON format of prediction statistics.
     """
 
     def __init__(self, dataloader=None, save_dir=None, pbar=None, args=None, _callbacks=None):
         """
-        Initializes a BaseValidator instance.
+        Initialize a BaseValidator instance.
 
         Args:
-            dataloader (torch.utils.data.DataLoader): Dataloader to be used for validation.
+            dataloader (torch.utils.data.DataLoader, optional): Dataloader to be used for validation.
             save_dir (Path, optional): Directory to save results.
-            pbar (tqdm.tqdm): Progress bar for displaying progress.
-            args (SimpleNamespace): Configuration for the validator.
-            _callbacks (dict): Dictionary to store various callback functions.
+            pbar (tqdm.tqdm, optional): Progress bar for displaying progress.
+            args (SimpleNamespace, optional): Configuration for the validator.
+            _callbacks (Dict, optional): Dictionary to store various callback functions.
         """
         self.args = get_cfg(overrides=args)
         self.dataloader = dataloader
@@ -107,13 +130,22 @@ class BaseValidator:
 
     @smart_inference_mode()
     def __call__(self, trainer=None, model=None):
-        """Executes validation process, running inference on dataloader and computing performance metrics."""
+        """
+        Execute validation process, running inference on dataloader and computing performance metrics.
+
+        Args:
+            trainer (object, optional): Trainer object that contains the model to validate.
+            model (nn.Module, optional): Model to validate if not using a trainer.
+
+        Returns:
+            stats (dict): Dictionary containing validation statistics.
+        """
         self.training = trainer is not None
         augment = self.args.augment and (not self.training)
         if self.training:
             self.device = trainer.device
             self.data = trainer.data
-            # force FP16 val during training
+            # Force FP16 val during training
             self.args.half = self.device.type != "cpu" and trainer.amp
             model = trainer.ema.ema or trainer.model
             model = model.half() if self.args.half else model.float()
@@ -221,18 +253,20 @@ class BaseValidator:
                 LOGGER.info(f"Results saved to {colorstr('bold', self.save_dir)}")
             return stats
 
-    def match_predictions(self, pred_classes, true_classes, iou, use_scipy=False):
+    def match_predictions(
+        self, pred_classes: torch.Tensor, true_classes: torch.Tensor, iou: torch.Tensor, use_scipy: bool = False
+    ) -> torch.Tensor:
         """
-        Matches predictions to ground truth objects (pred_classes, true_classes) using IoU.
+        Match predictions to ground truth objects using IoU.
 
         Args:
-            pred_classes (torch.Tensor): Predicted class indices of shape(N,).
-            true_classes (torch.Tensor): Target class indices of shape(M,).
-            iou (torch.Tensor): An NxM tensor containing the pairwise IoU values for predictions and ground of truth
+            pred_classes (torch.Tensor): Predicted class indices of shape (N,).
+            true_classes (torch.Tensor): Target class indices of shape (M,).
+            iou (torch.Tensor): An NxM tensor containing the pairwise IoU values for predictions and ground truth.
             use_scipy (bool): Whether to use scipy for matching (more precise).
 
         Returns:
-            (torch.Tensor): Correct tensor of shape(N,10) for 10 IoU thresholds.
+            (torch.Tensor): Correct tensor of shape (N, 10) for 10 IoU thresholds.
         """
         # Dx10 matrix, where D - detections, 10 - IoU thresholds
         correct = np.zeros((pred_classes.shape[0], self.iouv.shape[0])).astype(bool)
@@ -264,11 +298,11 @@ class BaseValidator:
         return torch.tensor(correct, dtype=torch.bool, device=pred_classes.device)
 
     def add_callback(self, event: str, callback):
-        """Appends the given callback."""
+        """Append the given callback to the specified event."""
         self.callbacks[event].append(callback)
 
     def run_callbacks(self, event: str):
-        """Runs all callbacks associated with a specified event."""
+        """Run all callbacks associated with a specified event."""
         for callback in self.callbacks.get(event, []):
             callback(self)
 
@@ -277,15 +311,15 @@ class BaseValidator:
         raise NotImplementedError("get_dataloader function not implemented for this validator")
 
     def build_dataset(self, img_path):
-        """Build dataset."""
+        """Build dataset from image path."""
         raise NotImplementedError("build_dataset function not implemented in validator")
 
     def preprocess(self, batch):
-        """Preprocesses an input batch."""
+        """Preprocess an input batch."""
         return batch
 
     def postprocess(self, preds):
-        """Preprocesses the predictions."""
+        """Postprocess the predictions."""
         return preds
 
     def init_metrics(self, model):
@@ -293,23 +327,23 @@ class BaseValidator:
         pass
 
     def update_metrics(self, preds, batch):
-        """Updates metrics based on predictions and batch."""
+        """Update metrics based on predictions and batch."""
         pass
 
     def finalize_metrics(self, *args, **kwargs):
-        """Finalizes and returns all metrics."""
+        """Finalize and return all metrics."""
         pass
 
     def get_stats(self):
-        """Returns statistics about the model's performance."""
+        """Return statistics about the model's performance."""
         return {}
 
     def check_stats(self, stats):
-        """Checks statistics."""
+        """Check statistics."""
         pass
 
     def print_results(self):
-        """Prints the results of the model's predictions."""
+        """Print the results of the model's predictions."""
         pass
 
     def get_desc(self):
@@ -318,20 +352,20 @@ class BaseValidator:
 
     @property
     def metric_keys(self):
-        """Returns the metric keys used in YOLO training/validation."""
+        """Return the metric keys used in YOLO training/validation."""
         return []
 
     def on_plot(self, name, data=None):
-        """Registers plots (e.g. to be consumed in callbacks)."""
+        """Register plots (e.g. to be consumed in callbacks)."""
         self.plots[Path(name)] = {"data": data, "timestamp": time.time()}
 
     # TODO: may need to put these following functions into callback
     def plot_val_samples(self, batch, ni):
-        """Plots validation samples during training."""
+        """Plot validation samples during training."""
         pass
 
     def plot_predictions(self, batch, preds, ni):
-        """Plots YOLO model predictions on batch images."""
+        """Plot YOLO model predictions on batch images."""
         pass
 
     def pred_to_json(self, preds, batch):

ultralytics/hub/__init__.py

@@ -23,7 +23,7 @@ __all__ = (
 )
 
 
-def login(api_key: str = None, save=True) -> bool:
+def login(api_key: str = None, save: bool = True) -> bool:
     """
     Log in to the Ultralytics HUB API using the provided API key.
 
@@ -31,8 +31,8 @@ def login(api_key: str = None, save=True) -> bool:
     environment variable if successfully authenticated.
 
     Args:
-        api_key (str, optional): API key to use for authentication.
-            If not provided, it will be retrieved from SETTINGS or HUB_API_KEY environment variable.
+        api_key (str, optional): API key to use for authentication. If not provided, it will be retrieved from SETTINGS
+            or HUB_API_KEY environment variable.
         save (bool, optional): Whether to save the API key to SETTINGS if authentication is successful.
 
     Returns:
@@ -79,7 +79,7 @@ def logout():
     LOGGER.info(f"{PREFIX}logged out ✅. To log in again, use 'yolo login'.")
 
 
-def reset_model(model_id=""):
+def reset_model(model_id: str = ""):
     """Reset a trained model to an untrained state."""
     r = requests.post(f"{HUB_API_ROOT}/model-reset", json={"modelId": model_id}, headers={"x-api-key": Auth().api_key})
     if r.status_code == 200:
@@ -95,8 +95,8 @@ def export_fmts_hub():
     return list(export_formats()["Argument"][1:]) + ["ultralytics_tflite", "ultralytics_coreml"]
 
 
-def export_model(model_id="", format="torchscript"):
-    """Export a model to all formats."""
+def export_model(model_id: str = "", format: str = "torchscript"):
+    """Export a model to the specified format."""
     assert format in export_fmts_hub(), f"Unsupported export format '{format}', valid formats are {export_fmts_hub()}"
     r = requests.post(
         f"{HUB_API_ROOT}/v1/models/{model_id}/export", json={"format": format}, headers={"x-api-key": Auth().api_key}
@@ -105,7 +105,7 @@ def export_model(model_id="", format="torchscript"):
     LOGGER.info(f"{PREFIX}{format} export started ✅")
 
 
-def get_export(model_id="", format="torchscript"):
+def get_export(model_id: str = "", format: str = "torchscript"):
     """Get an exported model dictionary with download URL."""
     assert format in export_fmts_hub(), f"Unsupported export format '{format}', valid formats are {export_fmts_hub()}"
     r = requests.post(
@@ -119,17 +119,12 @@ def get_export(model_id="", format="torchscript"):
 
 def check_dataset(path: str, task: str) -> None:
     """
-    Function for error-checking HUB dataset Zip file before upload. It checks a dataset for errors before it is uploaded
-    to the HUB. Usage examples are given below.
+    Check HUB dataset Zip file for errors before upload.
 
     Args:
         path (str): Path to data.zip (with data.yaml inside data.zip).
         task (str): Dataset task. Options are 'detect', 'segment', 'pose', 'classify', 'obb'.
 
-    Note:
-        Download *.zip files from https://github.com/ultralytics/hub/tree/main/example_datasets
-        i.e. https://github.com/ultralytics/hub/raw/main/example_datasets/coco8.zip for coco8.zip.
-
     Examples:
         >>> from ultralytics.hub import check_dataset
         >>> check_dataset("path/to/coco8.zip", task="detect")  # detect dataset
@@ -137,6 +132,10 @@ def check_dataset(path: str, task: str) -> None:
         >>> check_dataset("path/to/coco8-pose.zip", task="pose")  # pose dataset
         >>> check_dataset("path/to/dota8.zip", task="obb")  # OBB dataset
         >>> check_dataset("path/to/imagenet10.zip", task="classify")  # classification dataset
+
+    Note:
+        Download *.zip files from https://github.com/ultralytics/hub/tree/main/example_datasets
+        i.e. https://github.com/ultralytics/hub/raw/main/example_datasets/coco8.zip for coco8.zip.
     """
     HUBDatasetStats(path=path, task=task).get_json()
     LOGGER.info(f"Checks completed correctly ✅. Upload this dataset to {HUB_WEB_ROOT}/datasets/.")

ultralytics/hub/auth.py

@@ -18,14 +18,14 @@ class Auth:
     3. Prompting the user to enter an API key.
 
     Attributes:
-        id_token (str or bool): Token used for identity verification, initialized as False.
-        api_key (str or bool): API key for authentication, initialized as False.
+        id_token (str | bool): Token used for identity verification, initialized as False.
+        api_key (str | bool): API key for authentication, initialized as False.
         model_key (bool): Placeholder for model key, initialized as False.
     """
 
     id_token = api_key = model_key = False
 
-    def __init__(self, api_key="", verbose=False):
+    def __init__(self, api_key: str = "", verbose: bool = False):
         """
         Initialize Auth class and authenticate user.
 
@@ -70,12 +70,8 @@ class Auth:
         elif verbose:
             LOGGER.info(f"{PREFIX}Get API key from {API_KEY_URL} and then run 'yolo login API_KEY'")
 
-    def request_api_key(self, max_attempts=3):
-        """
-        Prompt the user to input their API key.
-
-        Returns the model ID.
-        """
+    def request_api_key(self, max_attempts: int = 3) -> bool:
+        """Prompt the user to input their API key."""
         import getpass
 
         for attempts in range(max_attempts):
@@ -107,8 +103,9 @@ class Auth:
 
     def auth_with_cookies(self) -> bool:
         """
-        Attempt to fetch authentication via cookies and set id_token. User must be logged in to HUB and running in a
-        supported browser.
+        Attempt to fetch authentication via cookies and set id_token.
+
+        User must be logged in to HUB and running in a supported browser.
 
         Returns:
             (bool): True if authentication is successful, False otherwise.
@@ -131,7 +128,7 @@ class Auth:
         Get the authentication header for making API requests.
 
         Returns:
-            (dict): The authentication header if id_token or API key is set, None otherwise.
+            (dict | None): The authentication header if id_token or API key is set, None otherwise.
         """
         if self.id_token:
             return {"authorization": f"Bearer {self.id_token}"}

ultralytics/hub/session.py

@@ -20,13 +20,25 @@ class HUBTrainingSession:
     """
     HUB training session for Ultralytics HUB YOLO models. Handles model initialization, heartbeats, and checkpointing.
 
+    This class encapsulates the functionality for interacting with Ultralytics HUB during model training, including
+    model creation, metrics tracking, and checkpoint uploading.
+
     Attributes:
         model_id (str): Identifier for the YOLO model being trained.
         model_url (str): URL for the model in Ultralytics HUB.
-        rate_limits (dict): Rate limits for different API calls (in seconds).
-        timers (dict): Timers for rate limiting.
-        metrics_queue (dict): Queue for the model's metrics.
-        model (dict): Model data fetched from Ultralytics HUB.
+        rate_limits (Dict): Rate limits for different API calls (in seconds).
+        timers (Dict): Timers for rate limiting.
+        metrics_queue (Dict): Queue for the model's metrics.
+        metrics_upload_failed_queue (Dict): Queue for metrics that failed to upload.
+        model (Dict): Model data fetched from Ultralytics HUB.
+        model_file (str): Path to the model file.
+        train_args (Dict): Arguments for training the model.
+        client (HUBClient): Client for interacting with Ultralytics HUB.
+        filename (str): Filename of the model.
+
+    Examples:
+        >>> session = HUBTrainingSession("https://hub.ultralytics.com/models/example-model")
+        >>> session.upload_metrics()
     """
 
     def __init__(self, identifier):
@@ -78,7 +90,16 @@ class HUBTrainingSession:
 
     @classmethod
     def create_session(cls, identifier, args=None):
-        """Class method to create an authenticated HUBTrainingSession or return None."""
+        """
+        Create an authenticated HUBTrainingSession or return None.
+
+        Args:
+            identifier (str): Model identifier used to initialize the HUB training session.
+            args (Dict, optional): Arguments for creating a new model if identifier is not a HUB model URL.
+
+        Returns:
+            (HUBTrainingSession | None): An authenticated session or None if creation fails.
+        """
         try:
             session = cls(identifier)
             if args and not identifier.startswith(f"{HUB_WEB_ROOT}/models/"):  # not a HUB model URL
@@ -90,7 +111,15 @@ class HUBTrainingSession:
             return None
 
     def load_model(self, model_id):
-        """Loads an existing model from Ultralytics HUB using the provided model identifier."""
+        """
+        Load an existing model from Ultralytics HUB using the provided model identifier.
+
+        Args:
+            model_id (str): The identifier of the model to load.
+
+        Raises:
+            ValueError: If the specified HUB model does not exist.
+        """
         self.model = self.client.model(model_id)
         if not self.model.data:  # then model does not exist
             raise ValueError(emojis("❌ The specified HUB model does not exist"))  # TODO: improve error handling
@@ -108,7 +137,15 @@ class HUBTrainingSession:
         LOGGER.info(f"{PREFIX}View model at {self.model_url} 🚀")
 
     def create_model(self, model_args):
-        """Initializes a HUB training session with the specified model identifier."""
+        """
+        Initialize a HUB training session with the specified model arguments.
+
+        Args:
+            model_args (Dict): Arguments for creating the model, including batch size, epochs, image size, etc.
+
+        Returns:
+            (None): If the model could not be created.
+        """
         payload = {
             "config": {
                 "batchSize": model_args.get("batch", -1),
@@ -146,7 +183,7 @@ class HUBTrainingSession:
     @staticmethod
     def _parse_identifier(identifier):
         """
-        Parses the given identifier to determine the type of identifier and extract relevant components.
+        Parse the given identifier to determine the type and extract relevant components.
 
         The method supports different identifier formats:
             - A HUB model URL https://hub.ultralytics.com/models/MODEL
@@ -176,7 +213,7 @@ class HUBTrainingSession:
 
     def _set_train_args(self):
         """
-        Initializes training arguments and creates a model entry on the Ultralytics HUB.
+        Initialize training arguments and create a model entry on the Ultralytics HUB.
 
         This method sets up training arguments based on the model's state and updates them with any additional
         arguments provided. It handles different states of the model, such as whether it's resumable, pretrained,
@@ -218,10 +255,26 @@ class HUBTrainingSession:
         *args,
         **kwargs,
     ):
-        """Attempts to execute `request_func` with retries, timeout handling, optional threading, and progress."""
+        """
+        Attempt to execute `request_func` with retries, timeout handling, optional threading, and progress tracking.
+
+        Args:
+            request_func (callable): The function to execute.
+            retry (int): Number of retry attempts.
+            timeout (int): Maximum time to wait for the request to complete.
+            thread (bool): Whether to run the request in a separate thread.
+            verbose (bool): Whether to log detailed messages.
+            progress_total (int, optional): Total size for progress tracking.
+            stream_response (bool, optional): Whether to stream the response.
+            *args (Any): Additional positional arguments for request_func.
+            **kwargs (Any): Additional keyword arguments for request_func.
+
+        Returns:
+            (requests.Response | None): The response object if thread=False, otherwise None.
+        """
 
         def retry_request():
-            """Attempts to call `request_func` with retries, timeout, and optional threading."""
+            """Attempt to call `request_func` with retries, timeout, and optional threading."""
             t0 = time.time()  # Record the start time for the timeout
             response = None
             for i in range(retry + 1):
@@ -274,7 +327,15 @@ class HUBTrainingSession:
 
     @staticmethod
     def _should_retry(status_code):
-        """Determines if a request should be retried based on the HTTP status code."""
+        """
+        Determine if a request should be retried based on the HTTP status code.
+
+        Args:
+            status_code (int): The HTTP status code from the response.
+
+        Returns:
+            (bool): True if the request should be retried, False otherwise.
+        """
         retry_codes = {
             HTTPStatus.REQUEST_TIMEOUT,
             HTTPStatus.BAD_GATEWAY,
@@ -287,9 +348,9 @@ class HUBTrainingSession:
         Generate a retry message based on the response status code.
 
         Args:
-            response: The HTTP response object.
-            retry: The number of retry attempts allowed.
-            timeout: The maximum timeout duration.
+            response (requests.Response): The HTTP response object.
+            retry (int): The number of retry attempts allowed.
+            timeout (int): The maximum timeout duration.
 
         Returns:
             (str): The retry message.
@@ -367,9 +428,6 @@ class HUBTrainingSession:
         Args:
             content_length (int): The total size of the content to be downloaded in bytes.
             response (requests.Response): The response object from the file download request.
-
-        Returns:
-            None
         """
         with TQDM(total=content_length, unit="B", unit_scale=True, unit_divisor=1024) as pbar:
             for data in response.iter_content(chunk_size=1024):
@@ -382,9 +440,6 @@ class HUBTrainingSession:
 
         Args:
             response (requests.Response): The response object from the file download request.
-
-        Returns:
-            None
         """
         for _ in response.iter_content(chunk_size=1024):
             pass  # Do nothing with data chunks

ultralytics/hub/utils.py

@@ -43,7 +43,7 @@ def request_with_credentials(url: str) -> any:
         url (str): The URL to make the request to.
 
     Returns:
-        (any): The response data from the AJAX request.
+        (Any): The response data from the AJAX request.
 
     Raises:
         OSError: If the function is not run in a Google Colab environment.
@@ -83,14 +83,14 @@ def requests_with_progress(method, url, **kwargs):
     Args:
         method (str): The HTTP method to use (e.g. 'GET', 'POST').
         url (str): The URL to send the request to.
-        **kwargs (any): Additional keyword arguments to pass to the underlying `requests.request` function.
+        **kwargs (Any): Additional keyword arguments to pass to the underlying `requests.request` function.
 
     Returns:
         (requests.Response): The response object from the HTTP request.
 
-    Note:
+    Notes:
         - If 'progress' is set to True, the progress bar will display the download progress for responses with a known
-        content length.
+          content length.
         - If 'progress' is a number then progress bar will display assuming content length = progress.
     """
     progress = kwargs.pop("progress", False)
@@ -110,18 +110,18 @@ def requests_with_progress(method, url, **kwargs):
 
 def smart_request(method, url, retry=3, timeout=30, thread=True, code=-1, verbose=True, progress=False, **kwargs):
     """
-    Makes an HTTP request using the 'requests' library, with exponential backoff retries up to a specified timeout.
+    Make an HTTP request using the 'requests' library, with exponential backoff retries up to a specified timeout.
 
     Args:
         method (str): The HTTP method to use for the request. Choices are 'post' and 'get'.
         url (str): The URL to make the request to.
-        retry (int, optional): Number of retries to attempt before giving up. Default is 3.
-        timeout (int, optional): Timeout in seconds after which the function will give up retrying. Default is 30.
-        thread (bool, optional): Whether to execute the request in a separate daemon thread. Default is True.
-        code (int, optional): An identifier for the request, used for logging purposes. Default is -1.
-        verbose (bool, optional): A flag to determine whether to print out to console or not. Default is True.
-        progress (bool, optional): Whether to show a progress bar during the request. Default is False.
-        **kwargs (any): Keyword arguments to be passed to the requests function specified in method.
+        retry (int, optional): Number of retries to attempt before giving up.
+        timeout (int, optional): Timeout in seconds after which the function will give up retrying.
+        thread (bool, optional): Whether to execute the request in a separate daemon thread.
+        code (int, optional): An identifier for the request, used for logging purposes.
+        verbose (bool, optional): A flag to determine whether to print out to console or not.
+        progress (bool, optional): Whether to show a progress bar during the request.
+        **kwargs (Any): Keyword arguments to be passed to the requests function specified in method.
 
     Returns:
         (requests.Response): The HTTP response object. If the request is executed in a separate thread, returns None.
@@ -169,20 +169,22 @@ def smart_request(method, url, retry=3, timeout=30, thread=True, code=-1, verbos
 
 class Events:
     """
-    A class for collecting anonymous event analytics. Event analytics are enabled when sync=True in settings and
-    disabled when sync=False. Run 'yolo settings' to see and update settings.
+    A class for collecting anonymous event analytics.
+
+    Event analytics are enabled when sync=True in settings and disabled when sync=False. Run 'yolo settings' to see and
+    update settings.
 
     Attributes:
         url (str): The URL to send anonymous events.
         rate_limit (float): The rate limit in seconds for sending events.
-        metadata (dict): A dictionary containing metadata about the environment.
+        metadata (Dict): A dictionary containing metadata about the environment.
         enabled (bool): A flag to enable or disable Events based on certain conditions.
     """
 
     url = "https://www.google-analytics.com/mp/collect?measurement_id=G-X8NCJYTQXM&api_secret=QLQrATrNSwGRFRLE-cbHJw"
 
     def __init__(self):
-        """Initializes the Events object with default values for events, rate_limit, and metadata."""
+        """Initialize the Events object with default values for events, rate_limit, and metadata."""
         self.events = []  # events list
         self.rate_limit = 30.0  # rate limit (seconds)
         self.t = 0.0  # rate limit timer (seconds)
@@ -205,7 +207,7 @@ class Events:
 
     def __call__(self, cfg):
         """
-        Attempts to add a new event to the events list and send events if the rate limit is reached.
+        Attempt to add a new event to the events list and send events if the rate limit is reached.
 
         Args:
             cfg (IterableSimpleNamespace): The configuration object containing mode and task information.