ultralytics 8.3.7__py3-none-any.whl → 8.3.9__py3-none-any.whl

ultralytics/solutions/speed_estimation.py

@@ -1,116 +1,76 @@
 # Ultralytics YOLO 🚀, AGPL-3.0 license
 
-from collections import defaultdict
 from time import time
 
-import cv2
 import numpy as np
 
-from ultralytics.utils.checks import check_imshow
+from ultralytics.solutions.solutions import BaseSolution, LineString
 from ultralytics.utils.plotting import Annotator, colors
 
 
-class SpeedEstimator:
+class SpeedEstimator(BaseSolution):
     """A class to estimate the speed of objects in a real-time video stream based on their tracks."""
 
-    def __init__(self, names, reg_pts=None, view_img=False, line_thickness=2, spdl_dist_thresh=10):
-        """
-        Initializes the SpeedEstimator with the given parameters.
-
-        Args:
-            names (dict): Dictionary of class names.
-            reg_pts (list, optional): List of region points for speed estimation. Defaults to [(20, 400), (1260, 400)].
-            view_img (bool, optional): Whether to display the image with annotations. Defaults to False.
-            line_thickness (int, optional): Thickness of the lines for drawing boxes and tracks. Defaults to 2.
-            spdl_dist_thresh (int, optional): Distance threshold for speed calculation. Defaults to 10.
-        """
-        # Region information
-        self.reg_pts = reg_pts if reg_pts is not None else [(20, 400), (1260, 400)]
+    def __init__(self, **kwargs):
+        """Initializes the SpeedEstimator with the given parameters."""
+        super().__init__(**kwargs)
 
-        self.names = names  # Classes names
+        self.initialize_region()  # Initialize speed region
 
-        # Tracking information
-        self.trk_history = defaultdict(list)
-
-        self.view_img = view_img  # bool for displaying inference
-        self.tf = line_thickness  # line thickness for annotator
         self.spd = {}  # set for speed data
         self.trkd_ids = []  # list for already speed_estimated and tracked ID's
-        self.spdl = spdl_dist_thresh  # Speed line distance threshold
         self.trk_pt = {}  # set for tracks previous time
         self.trk_pp = {}  # set for tracks previous point
 
-        # Check if the environment supports imshow
-        self.env_check = check_imshow(warn=True)
-
-    def estimate_speed(self, im0, tracks):
+    def estimate_speed(self, im0):
         """
         Estimates the speed of objects based on tracking data.
 
         Args:
-            im0 (ndarray): Image.
-            tracks (list): List of tracks obtained from the object tracking process.
-
-        Returns:
-            (ndarray): The image with annotated boxes and tracks.
+            im0 (ndarray): The input image that will be used for processing
+        Returns
+            im0 (ndarray): The processed image for more usage
         """
-        if tracks[0].boxes.id is None:
-            return im0
+        self.annotator = Annotator(im0, line_width=self.line_width)  # Initialize annotator
+        self.extract_tracks(im0)  # Extract tracks
 
-        boxes = tracks[0].boxes.xyxy.cpu()
-        clss = tracks[0].boxes.cls.cpu().tolist()
-        t_ids = tracks[0].boxes.id.int().cpu().tolist()
-        annotator = Annotator(im0, line_width=self.tf)
-        annotator.draw_region(reg_pts=self.reg_pts, color=(255, 0, 255), thickness=self.tf * 2)
+        self.annotator.draw_region(
+            reg_pts=self.region, color=(104, 0, 123), thickness=self.line_width * 2
+        )  # Draw region
 
-        for box, t_id, cls in zip(boxes, t_ids, clss):
-            track = self.trk_history[t_id]
-            bbox_center = (float((box[0] + box[2]) / 2), float((box[1] + box[3]) / 2))
-            track.append(bbox_center)
+        for box, track_id, cls in zip(self.boxes, self.track_ids, self.clss):
+            self.store_tracking_history(track_id, box)  # Store track history
 
-            if len(track) > 30:
-                track.pop(0)
+            # Check if track_id is already in self.trk_pp or trk_pt initialize if not
+            if track_id not in self.trk_pt:
+                self.trk_pt[track_id] = 0
+            if track_id not in self.trk_pp:
+                self.trk_pp[track_id] = self.track_line[-1]
 
-            trk_pts = np.hstack(track).astype(np.int32).reshape((-1, 1, 2))
+            speed_label = f"{int(self.spd[track_id])} km/h" if track_id in self.spd else self.names[int(cls)]
+            self.annotator.box_label(box, label=speed_label, color=colors(track_id, True))  # Draw bounding box
 
-            if t_id not in self.trk_pt:
-                self.trk_pt[t_id] = 0
+            # Draw tracks of objects
+            self.annotator.draw_centroid_and_tracks(
+                self.track_line, color=colors(int(track_id), True), track_thickness=self.line_width
+            )
 
-            speed_label = f"{int(self.spd[t_id])} km/h" if t_id in self.spd else self.names[int(cls)]
-            bbox_color = colors(int(t_id), True)
-
-            annotator.box_label(box, speed_label, bbox_color)
-            cv2.polylines(im0, [trk_pts], isClosed=False, color=bbox_color, thickness=self.tf)
-            cv2.circle(im0, (int(track[-1][0]), int(track[-1][1])), self.tf * 2, bbox_color, -1)
-
-            # Calculation of object speed
-            if not self.reg_pts[0][0] < track[-1][0] < self.reg_pts[1][0]:
-                return
-            if self.reg_pts[1][1] - self.spdl < track[-1][1] < self.reg_pts[1][1] + self.spdl:
-                direction = "known"
-            elif self.reg_pts[0][1] - self.spdl < track[-1][1] < self.reg_pts[0][1] + self.spdl:
+            # Calculate object speed and direction based on region intersection
+            if LineString([self.trk_pp[track_id], self.track_line[-1]]).intersects(self.l_s):
                 direction = "known"
             else:
                 direction = "unknown"
 
-            if self.trk_pt.get(t_id) != 0 and direction != "unknown" and t_id not in self.trkd_ids:
-                self.trkd_ids.append(t_id)
-
-                time_difference = time() - self.trk_pt[t_id]
+            # Perform speed calculation and tracking updates if direction is valid
+            if direction == "known" and track_id not in self.trkd_ids:
+                self.trkd_ids.append(track_id)
+                time_difference = time() - self.trk_pt[track_id]
                 if time_difference > 0:
-                    self.spd[t_id] = np.abs(track[-1][1] - self.trk_pp[t_id][1]) / time_difference
-
-            self.trk_pt[t_id] = time()
-            self.trk_pp[t_id] = track[-1]
-
-        if self.view_img and self.env_check:
-            cv2.imshow("Ultralytics Speed Estimation", im0)
-            if cv2.waitKey(1) & 0xFF == ord("q"):
-                return
+                    self.spd[track_id] = np.abs(self.track_line[-1][1] - self.trk_pp[track_id][1]) / time_difference
 
-        return im0
+            self.trk_pt[track_id] = time()
+            self.trk_pp[track_id] = self.track_line[-1]
 
+        self.display_output(im0)  # display output with base class function
 
-if __name__ == "__main__":
-    names = {0: "person", 1: "car"}  # example class names
-    speed_estimator = SpeedEstimator(names)
+        return im0  # return output image for more usage

ultralytics/utils/__init__.py

@@ -523,10 +523,11 @@ def read_device_model() -> str:
     Returns:
         (str): Model file contents if read successfully or empty string otherwise.
     """
-    with contextlib.suppress(Exception):
+    try:
         with open("/proc/device-tree/model") as f:
             return f.read()
-    return ""
+    except:  # noqa E722
+        return ""
 
 
 def is_ubuntu() -> bool:
@@ -536,10 +537,11 @@ def is_ubuntu() -> bool:
     Returns:
         (bool): True if OS is Ubuntu, False otherwise.
     """
-    with contextlib.suppress(FileNotFoundError):
+    try:
         with open("/etc/os-release") as f:
             return "ID=ubuntu" in f.read()
-    return False
+    except FileNotFoundError:
+        return False
 
 
 def is_colab():
@@ -569,11 +571,7 @@ def is_jupyter():
     Returns:
         (bool): True if running inside a Jupyter Notebook, False otherwise.
     """
-    with contextlib.suppress(Exception):
-        from IPython import get_ipython
-
-        return get_ipython() is not None
-    return False
+    return "get_ipython" in locals()
 
 
 def is_docker() -> bool:
@@ -583,10 +581,11 @@ def is_docker() -> bool:
     Returns:
         (bool): True if the script is running inside a Docker container, False otherwise.
     """
-    with contextlib.suppress(Exception):
+    try:
         with open("/proc/self/cgroup") as f:
             return "docker" in f.read()
-    return False
+    except:  # noqa E722
+        return False
 
 
 def is_raspberrypi() -> bool:
@@ -617,14 +616,15 @@ def is_online() -> bool:
     Returns:
         (bool): True if connection is successful, False otherwise.
     """
-    with contextlib.suppress(Exception):
+    try:
         assert str(os.getenv("YOLO_OFFLINE", "")).lower() != "true"  # check if ENV var YOLO_OFFLINE="True"
         import socket
 
         for dns in ("1.1.1.1", "8.8.8.8"):  # check Cloudflare and Google DNS
             socket.create_connection(address=(dns, 80), timeout=2.0).close()
             return True
-    return False
+    except:  # noqa E722
+        return False
 
 
 def is_pip_package(filepath: str = __name__) -> bool:
@@ -711,9 +711,11 @@ def get_git_origin_url():
         (str | None): The origin URL of the git repository or None if not git directory.
     """
     if IS_GIT_DIR:
-        with contextlib.suppress(subprocess.CalledProcessError):
+        try:
             origin = subprocess.check_output(["git", "config", "--get", "remote.origin.url"])
             return origin.decode().strip()
+        except subprocess.CalledProcessError:
+            return None
 
 
 def get_git_branch():
@@ -724,9 +726,11 @@ def get_git_branch():
         (str | None): The current git branch name or None if not a git directory.
     """
     if IS_GIT_DIR:
-        with contextlib.suppress(subprocess.CalledProcessError):
+        try:
             origin = subprocess.check_output(["git", "rev-parse", "--abbrev-ref", "HEAD"])
             return origin.decode().strip()
+        except subprocess.CalledProcessError:
+            return None
 
 
 def get_default_args(func):
@@ -751,9 +755,11 @@ def get_ubuntu_version():
         (str): Ubuntu version or None if not an Ubuntu OS.
     """
     if is_ubuntu():
-        with contextlib.suppress(FileNotFoundError, AttributeError):
+        try:
             with open("/etc/os-release") as f:
                 return re.search(r'VERSION_ID="(\d+\.\d+)"', f.read())[1]
+        except (FileNotFoundError, AttributeError):
+            return None
 
 
 def get_user_config_dir(sub_dir="Ultralytics"):

ultralytics/utils/autobatch.py

@@ -1,6 +1,7 @@
 # Ultralytics YOLO 🚀, AGPL-3.0 license
 """Functions for estimating the best YOLO batch size to use a fraction of the available CUDA memory in PyTorch."""
 
+import os
 from copy import deepcopy
 
 import numpy as np
@@ -57,7 +58,7 @@ def autobatch(model, imgsz=640, fraction=0.60, batch_size=DEFAULT_CFG.batch):
 
     # Inspect CUDA memory
     gb = 1 << 30  # bytes to GiB (1024 ** 3)
-    d = str(device).upper()  # 'CUDA:0'
+    d = f"CUDA:{os.getenv('CUDA_VISIBLE_DEVICES', '0').strip()[0]}"  # 'CUDA:0'
     properties = torch.cuda.get_device_properties(device)  # device properties
     t = properties.total_memory / gb  # GiB total
     r = torch.cuda.memory_reserved(device) / gb  # GiB reserved
@@ -66,7 +67,7 @@ def autobatch(model, imgsz=640, fraction=0.60, batch_size=DEFAULT_CFG.batch):
     LOGGER.info(f"{prefix}{d} ({properties.name}) {t:.2f}G total, {r:.2f}G reserved, {a:.2f}G allocated, {f:.2f}G free")
 
     # Profile batch sizes
-    batch_sizes = [1, 2, 4, 8, 16]
+    batch_sizes = [1, 2, 4, 8, 16] if t < 16 else [1, 2, 4, 8, 16, 32, 64]
     try:
         img = [torch.empty(b, 3, imgsz, imgsz) for b in batch_sizes]
         results = profile(img, model, n=1, device=device)

ultralytics/utils/callbacks/clearml.py

@@ -68,9 +68,9 @@ def on_pretrain_routine_start(trainer):
             PatchedMatplotlib.update_current_task(None)
         else:
             task = Task.init(
-                project_name=trainer.args.project or "YOLOv8",
+                project_name=trainer.args.project or "Ultralytics",
                 task_name=trainer.args.name,
-                tags=["YOLOv8"],
+                tags=["Ultralytics"],
                 output_uri=True,
                 reuse_last_task_id=False,
                 auto_connect_frameworks={"pytorch": False, "matplotlib": False},

ultralytics/utils/callbacks/comet.py

@@ -15,7 +15,7 @@ try:
     # Ensures certain logging functions only run for supported tasks
     COMET_SUPPORTED_TASKS = ["detect"]
 
-    # Names of plots created by YOLOv8 that are logged to Comet
+    # Names of plots created by Ultralytics that are logged to Comet
     EVALUATION_PLOT_NAMES = "F1_curve", "P_curve", "R_curve", "PR_curve", "confusion_matrix"
     LABEL_PLOT_NAMES = "labels", "labels_correlogram"
 
@@ -31,8 +31,8 @@ def _get_comet_mode():
 
 
 def _get_comet_model_name():
-    """Returns the model name for Comet from the environment variable 'COMET_MODEL_NAME' or defaults to 'YOLOv8'."""
-    return os.getenv("COMET_MODEL_NAME", "YOLOv8")
+    """Returns the model name for Comet from the environment variable COMET_MODEL_NAME or defaults to 'Ultralytics'."""
+    return os.getenv("COMET_MODEL_NAME", "Ultralytics")
 
 
 def _get_eval_batch_logging_interval():
@@ -110,7 +110,7 @@ def _fetch_trainer_metadata(trainer):
 
 def _scale_bounding_box_to_original_image_shape(box, resized_image_shape, original_image_shape, ratio_pad):
     """
-    YOLOv8 resizes images during training and the label values are normalized based on this resized shape.
+    YOLO resizes images during training and the label values are normalized based on this resized shape.
 
     This function rescales the bounding box labels to the original image shape.
     """

ultralytics/utils/callbacks/mlflow.py

@@ -71,7 +71,7 @@ def on_pretrain_routine_end(trainer):
     mlflow.set_tracking_uri(uri)
 
     # Set experiment and run names
-    experiment_name = os.environ.get("MLFLOW_EXPERIMENT_NAME") or trainer.args.project or "/Shared/YOLOv8"
+    experiment_name = os.environ.get("MLFLOW_EXPERIMENT_NAME") or trainer.args.project or "/Shared/Ultralytics"
     run_name = os.environ.get("MLFLOW_RUN") or trainer.args.name
     mlflow.set_experiment(experiment_name)
 

ultralytics/utils/callbacks/neptune.py

@@ -52,7 +52,11 @@ def on_pretrain_routine_start(trainer):
     """Callback function called before the training routine starts."""
     try:
         global run
-        run = neptune.init_run(project=trainer.args.project or "YOLOv8", name=trainer.args.name, tags=["YOLOv8"])
+        run = neptune.init_run(
+            project=trainer.args.project or "Ultralytics",
+            name=trainer.args.name,
+            tags=["Ultralytics"],
+        )
         run["Configuration/Hyperparameters"] = {k: "" if v is None else v for k, v in vars(trainer.args).items()}
     except Exception as e:
         LOGGER.warning(f"WARNING ⚠️ NeptuneAI installed but not initialized correctly, not logging this run. {e}")

ultralytics/utils/callbacks/tensorboard.py

@@ -1,6 +1,5 @@
 # Ultralytics YOLO 🚀, AGPL-3.0 license
 
-import contextlib
 
 from ultralytics.utils import LOGGER, SETTINGS, TESTS_RUNNING, colorstr
 
@@ -45,26 +44,27 @@ def _log_tensorboard_graph(trainer):
         warnings.simplefilter("ignore", category=torch.jit.TracerWarning)  # suppress jit trace warning
 
         # Try simple method first (YOLO)
-        with contextlib.suppress(Exception):
+        try:
             trainer.model.eval()  # place in .eval() mode to avoid BatchNorm statistics changes
             WRITER.add_graph(torch.jit.trace(de_parallel(trainer.model), im, strict=False), [])
             LOGGER.info(f"{PREFIX}model graph visualization added ✅")
             return
 
-        # Fallback to TorchScript export steps (RTDETR)
-        try:
-            model = deepcopy(de_parallel(trainer.model))
-            model.eval()
-            model = model.fuse(verbose=False)
-            for m in model.modules():
-                if hasattr(m, "export"):  # Detect, RTDETRDecoder (Segment and Pose use Detect base class)
-                    m.export = True
-                    m.format = "torchscript"
-            model(im)  # dry run
-            WRITER.add_graph(torch.jit.trace(model, im, strict=False), [])
-            LOGGER.info(f"{PREFIX}model graph visualization added ✅")
-        except Exception as e:
-            LOGGER.warning(f"{PREFIX}WARNING ⚠️ TensorBoard graph visualization failure {e}")
+        except:  # noqa E722
+            # Fallback to TorchScript export steps (RTDETR)
+            try:
+                model = deepcopy(de_parallel(trainer.model))
+                model.eval()
+                model = model.fuse(verbose=False)
+                for m in model.modules():
+                    if hasattr(m, "export"):  # Detect, RTDETRDecoder (Segment and Pose use Detect base class)
+                        m.export = True
+                        m.format = "torchscript"
+                model(im)  # dry run
+                WRITER.add_graph(torch.jit.trace(model, im, strict=False), [])
+                LOGGER.info(f"{PREFIX}model graph visualization added ✅")
+            except Exception as e:
+                LOGGER.warning(f"{PREFIX}WARNING ⚠️ TensorBoard graph visualization failure {e}")
 
 
 def on_pretrain_routine_start(trainer):

ultralytics/utils/callbacks/wb.py

@@ -109,7 +109,7 @@ def _log_plots(plots, step):
 
 def on_pretrain_routine_start(trainer):
     """Initiate and start project if module is present."""
-    wb.run or wb.init(project=trainer.args.project or "YOLOv8", name=trainer.args.name, config=vars(trainer.args))
+    wb.run or wb.init(project=trainer.args.project or "Ultralytics", name=trainer.args.name, config=vars(trainer.args))
 
 
 def on_fit_epoch_end(trainer):

ultralytics/utils/checks.py

@@ -1,6 +1,5 @@
 # Ultralytics YOLO 🚀, AGPL-3.0 license
 
-import contextlib
 import glob
 import inspect
 import math
@@ -271,11 +270,13 @@ def check_latest_pypi_version(package_name="ultralytics"):
     Returns:
         (str): The latest version of the package.
     """
-    with contextlib.suppress(Exception):
+    try:
         requests.packages.urllib3.disable_warnings()  # Disable the InsecureRequestWarning
         response = requests.get(f"https://pypi.org/pypi/{package_name}/json", timeout=3)
         if response.status_code == 200:
             return response.json()["info"]["version"]
+    except:  # noqa E722
+        return None
 
 
 def check_pip_update_available():
@@ -286,7 +287,7 @@ def check_pip_update_available():
         (bool): True if an update is available, False otherwise.
     """
     if ONLINE and IS_PIP_PACKAGE:
-        with contextlib.suppress(Exception):
+        try:
             from ultralytics import __version__
 
             latest = check_latest_pypi_version()
@@ -296,6 +297,8 @@ def check_pip_update_available():
                     f"Update with 'pip install -U ultralytics'"
                 )
                 return True
+        except:  # noqa E722
+            pass
     return False
 
 
@@ -577,10 +580,12 @@ def check_yolo(verbose=True, device=""):
         ram = psutil.virtual_memory().total
         total, used, free = shutil.disk_usage("/")
         s = f"({os.cpu_count()} CPUs, {ram / gib:.1f} GB RAM, {(total - free) / gib:.1f}/{total / gib:.1f} GB disk)"
-        with contextlib.suppress(Exception):  # clear display if ipython is installed
+        try:
             from IPython import display
 
-            display.clear_output()
+            display.clear_output()  # clear display if notebook
+        except ImportError:
+            pass
     else:
         s = ""
 
@@ -619,7 +624,7 @@ def collect_system_info():
     for r in parse_requirements(package="ultralytics"):
         try:
             current = metadata.version(r.name)
-            is_met = "✅ " if check_version(current, str(r.specifier), hard=True) else "❌ "
+            is_met = "✅ " if check_version(current, str(r.specifier), name=r.name, hard=True) else "❌ "
         except metadata.PackageNotFoundError:
             current = "(not installed)"
             is_met = "❌ "
@@ -707,9 +712,10 @@ def check_amp(model):
 
 def git_describe(path=ROOT):  # path must be a directory
     """Return human-readable git description, i.e. v5.0-5-g3e25f1e https://git-scm.com/docs/git-describe."""
-    with contextlib.suppress(Exception):
+    try:
         return subprocess.check_output(f"git -C {path} describe --tags --long --always", shell=True).decode()[:-1]
-    return ""
+    except:  # noqa E722
+        return ""
 
 
 def print_args(args: Optional[dict] = None, show_file=True, show_func=False):

ultralytics/utils/downloads.py

@@ -1,6 +1,5 @@
 # Ultralytics YOLO 🚀, AGPL-3.0 license
 
-import contextlib
 import re
 import shutil
 import subprocess
@@ -53,7 +52,7 @@ def is_url(url, check=False):
         valid = is_url("https://www.example.com")
         ```
     """
-    with contextlib.suppress(Exception):
+    try:
         url = str(url)
         result = parse.urlparse(url)
         assert all([result.scheme, result.netloc])  # check if is url
@@ -61,7 +60,8 @@ def is_url(url, check=False):
             with request.urlopen(url) as response:
                 return response.getcode() == 200  # check if exists online
         return True
-    return False
+    except:  # noqa E722
+        return False
 
 
 def delete_dsstore(path, files_to_delete=(".DS_Store", "__MACOSX")):

ultralytics/utils/plotting.py

@@ -1,6 +1,5 @@
 # Ultralytics YOLO 🚀, AGPL-3.0 license
 
-import contextlib
 import math
 import warnings
 from pathlib import Path
@@ -13,8 +12,8 @@ import torch
 from PIL import Image, ImageDraw, ImageFont
 from PIL import __version__ as pil_version
 
-from ultralytics.utils import IS_JUPYTER, LOGGER, TryExcept, ops, plt_settings, threaded
-from ultralytics.utils.checks import check_font, check_requirements, check_version, is_ascii
+from ultralytics.utils import IS_COLAB, IS_KAGGLE, LOGGER, TryExcept, ops, plt_settings, threaded
+from ultralytics.utils.checks import check_font, check_version, is_ascii
 from ultralytics.utils.files import increment_path
 
 
@@ -525,16 +524,12 @@ class Annotator:
     def show(self, title=None):
         """Show the annotated image."""
         im = Image.fromarray(np.asarray(self.im)[..., ::-1])  # Convert numpy array to PIL Image with RGB to BGR
-        if IS_JUPYTER:
-            check_requirements("ipython")
+        if IS_COLAB or IS_KAGGLE:  # can not use IS_JUPYTER as will run for all ipython environments
             try:
-                from IPython.display import display
-
-                display(im)
+                display(im)  # noqa - display() function only available in ipython environments
             except ImportError as e:
                 LOGGER.warning(f"Unable to display image in Jupyter notebooks: {e}")
         else:
-            # Convert numpy array to PIL Image and show
             im.show(title=title)
 
     def save(self, filename="image.jpg"):
@@ -1119,10 +1114,12 @@ def plot_images(
                             mask = mask.astype(bool)
                         else:
                             mask = image_masks[j].astype(bool)
-                        with contextlib.suppress(Exception):
+                        try:
                             im[y : y + h, x : x + w, :][mask] = (
                                 im[y : y + h, x : x + w, :][mask] * 0.4 + np.array(color) * 0.6
                             )
+                        except:  # noqa E722
+                            pass
                 annotator.fromarray(im)
     if not save:
         return np.asarray(annotator.im)

ultralytics/utils/torch_utils.py

@@ -1,6 +1,5 @@
 # Ultralytics YOLO 🚀, AGPL-3.0 license
 
-import contextlib
 import gc
 import math
 import os
@@ -113,13 +112,15 @@ def get_cpu_info():
     from ultralytics.utils import PERSISTENT_CACHE  # avoid circular import error
 
     if "cpu_info" not in PERSISTENT_CACHE:
-        with contextlib.suppress(Exception):
+        try:
             import cpuinfo  # pip install py-cpuinfo
 
             k = "brand_raw", "hardware_raw", "arch_string_raw"  # keys sorted by preference
             info = cpuinfo.get_cpu_info()  # info dict
             string = info.get(k[0] if k[0] in info else k[1] if k[1] in info else k[2], "unknown")
             PERSISTENT_CACHE["cpu_info"] = string.replace("(R)", "").replace("CPU ", "").replace("@ ", "")
+        except:  # noqa E722
+            pass
     return PERSISTENT_CACHE.get("cpu_info", "unknown")
 
 

{ultralytics-8.3.7.dist-info → ultralytics-8.3.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ultralytics
-Version: 8.3.7
+Version: 8.3.9
 Summary: Ultralytics YOLO for SOTA object detection, multi-object tracking, instance segmentation, pose estimation and image classification.
 Author-email: Glenn Jocher <glenn.jocher@ultralytics.com>, Jing Qiu <jing.qiu@ultralytics.com>
 Maintainer-email: Ultralytics <hello@ultralytics.com>