ultralytics 8.0.238__py3-none-any.whl → 8.0.239__py3-none-any.whl

ultralytics/utils/dist.py

@@ -18,13 +18,13 @@ def find_free_network_port() -> int:
     `MASTER_PORT` environment variable.
     """
     with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-        s.bind(('127.0.0.1', 0))
+        s.bind(("127.0.0.1", 0))
         return s.getsockname()[1]  # port
 
 
 def generate_ddp_file(trainer):
     """Generates a DDP file and returns its file name."""
-    module, name = f'{trainer.__class__.__module__}.{trainer.__class__.__name__}'.rsplit('.', 1)
+    module, name = f"{trainer.__class__.__module__}.{trainer.__class__.__name__}".rsplit(".", 1)
 
     content = f"""
 # Ultralytics Multi-GPU training temp file (should be automatically deleted after use)
@@ -39,13 +39,15 @@ if __name__ == "__main__":
     trainer = {name}(cfg=cfg, overrides=overrides)
     results = trainer.train()
 """
-    (USER_CONFIG_DIR / 'DDP').mkdir(exist_ok=True)
-    with tempfile.NamedTemporaryFile(prefix='_temp_',
-                                     suffix=f'{id(trainer)}.py',
-                                     mode='w+',
-                                     encoding='utf-8',
-                                     dir=USER_CONFIG_DIR / 'DDP',
-                                     delete=False) as file:
+    (USER_CONFIG_DIR / "DDP").mkdir(exist_ok=True)
+    with tempfile.NamedTemporaryFile(
+        prefix="_temp_",
+        suffix=f"{id(trainer)}.py",
+        mode="w+",
+        encoding="utf-8",
+        dir=USER_CONFIG_DIR / "DDP",
+        delete=False,
+    ) as file:
         file.write(content)
     return file.name
 
@@ -53,16 +55,17 @@ if __name__ == "__main__":
 def generate_ddp_command(world_size, trainer):
     """Generates and returns command for distributed training."""
     import __main__  # noqa local import to avoid https://github.com/Lightning-AI/lightning/issues/15218
+
     if not trainer.resume:
         shutil.rmtree(trainer.save_dir)  # remove the save_dir
     file = generate_ddp_file(trainer)
-    dist_cmd = 'torch.distributed.run' if TORCH_1_9 else 'torch.distributed.launch'
+    dist_cmd = "torch.distributed.run" if TORCH_1_9 else "torch.distributed.launch"
     port = find_free_network_port()
-    cmd = [sys.executable, '-m', dist_cmd, '--nproc_per_node', f'{world_size}', '--master_port', f'{port}', file]
+    cmd = [sys.executable, "-m", dist_cmd, "--nproc_per_node", f"{world_size}", "--master_port", f"{port}", file]
     return cmd, file
 
 
 def ddp_cleanup(trainer, file):
     """Delete temp file if created."""
-    if f'{id(trainer)}.py' in file:  # if temp_file suffix in file
+    if f"{id(trainer)}.py" in file:  # if temp_file suffix in file
         os.remove(file)

ultralytics/utils/downloads.py

@@ -15,15 +15,17 @@ import torch
 from ultralytics.utils import LOGGER, TQDM, checks, clean_url, emojis, is_online, url2file
 
 # Define Ultralytics GitHub assets maintained at https://github.com/ultralytics/assets
-GITHUB_ASSETS_REPO = 'ultralytics/assets'
-GITHUB_ASSETS_NAMES = [f'yolov8{k}{suffix}.pt' for k in 'nsmlx' for suffix in ('', '-cls', '-seg', '-pose')] + \
-                      [f'yolov5{k}{resolution}u.pt' for k in 'nsmlx' for resolution in ('', '6')] + \
-                      [f'yolov3{k}u.pt' for k in ('', '-spp', '-tiny')] + \
-                      [f'yolo_nas_{k}.pt' for k in 'sml'] + \
-                      [f'sam_{k}.pt' for k in 'bl'] + \
-                      [f'FastSAM-{k}.pt' for k in 'sx'] + \
-                      [f'rtdetr-{k}.pt' for k in 'lx'] + \
-                      ['mobile_sam.pt']
+GITHUB_ASSETS_REPO = "ultralytics/assets"
+GITHUB_ASSETS_NAMES = (
+    [f"yolov8{k}{suffix}.pt" for k in "nsmlx" for suffix in ("", "-cls", "-seg", "-pose", "-obb")]
+    + [f"yolov5{k}{resolution}u.pt" for k in "nsmlx" for resolution in ("", "6")]
+    + [f"yolov3{k}u.pt" for k in ("", "-spp", "-tiny")]
+    + [f"yolo_nas_{k}.pt" for k in "sml"]
+    + [f"sam_{k}.pt" for k in "bl"]
+    + [f"FastSAM-{k}.pt" for k in "sx"]
+    + [f"rtdetr-{k}.pt" for k in "lx"]
+    + ["mobile_sam.pt"]
+)
 GITHUB_ASSETS_STEMS = [Path(k).stem for k in GITHUB_ASSETS_NAMES]
 
 
@@ -56,7 +58,7 @@ def is_url(url, check=True):
     return False
 
 
-def delete_dsstore(path, files_to_delete=('.DS_Store', '__MACOSX')):
+def delete_dsstore(path, files_to_delete=(".DS_Store", "__MACOSX")):
     """
     Deletes all ".DS_store" files under a specified directory.
 
@@ -77,12 +79,12 @@ def delete_dsstore(path, files_to_delete=('.DS_Store', '__MACOSX')):
     """
     for file in files_to_delete:
         matches = list(Path(path).rglob(file))
-        LOGGER.info(f'Deleting {file} files: {matches}')
+        LOGGER.info(f"Deleting {file} files: {matches}")
         for f in matches:
             f.unlink()
 
 
-def zip_directory(directory, compress=True, exclude=('.DS_Store', '__MACOSX'), progress=True):
+def zip_directory(directory, compress=True, exclude=(".DS_Store", "__MACOSX"), progress=True):
     """
     Zips the contents of a directory, excluding files containing strings in the exclude list. The resulting zip file is
     named after the directory and placed alongside it.
@@ -111,17 +113,17 @@ def zip_directory(directory, compress=True, exclude=('.DS_Store', '__MACOSX'), p
         raise FileNotFoundError(f"Directory '{directory}' does not exist.")
 
     # Unzip with progress bar
-    files_to_zip = [f for f in directory.rglob('*') if f.is_file() and all(x not in f.name for x in exclude)]
-    zip_file = directory.with_suffix('.zip')
+    files_to_zip = [f for f in directory.rglob("*") if f.is_file() and all(x not in f.name for x in exclude)]
+    zip_file = directory.with_suffix(".zip")
     compression = ZIP_DEFLATED if compress else ZIP_STORED
-    with ZipFile(zip_file, 'w', compression) as f:
-        for file in TQDM(files_to_zip, desc=f'Zipping {directory} to {zip_file}...', unit='file', disable=not progress):
+    with ZipFile(zip_file, "w", compression) as f:
+        for file in TQDM(files_to_zip, desc=f"Zipping {directory} to {zip_file}...", unit="file", disable=not progress):
             f.write(file, file.relative_to(directory))
 
     return zip_file  # return path to zip file
 
 
-def unzip_file(file, path=None, exclude=('.DS_Store', '__MACOSX'), exist_ok=False, progress=True):
+def unzip_file(file, path=None, exclude=(".DS_Store", "__MACOSX"), exist_ok=False, progress=True):
     """
     Unzips a *.zip file to the specified path, excluding files containing strings in the exclude list.
 
@@ -161,7 +163,7 @@ def unzip_file(file, path=None, exclude=('.DS_Store', '__MACOSX'), exist_ok=Fals
         files = [f for f in zipObj.namelist() if all(x not in f for x in exclude)]
         top_level_dirs = {Path(f).parts[0] for f in files}
 
-        if len(top_level_dirs) > 1 or (len(files) > 1 and not files[0].endswith('/')):
+        if len(top_level_dirs) > 1 or (len(files) > 1 and not files[0].endswith("/")):
             # Zip has multiple files at top level
             path = extract_path = Path(path) / Path(file).stem  # i.e. ../datasets/coco8
         else:
@@ -172,20 +174,20 @@ def unzip_file(file, path=None, exclude=('.DS_Store', '__MACOSX'), exist_ok=Fals
         # Check if destination directory already exists and contains files
         if path.exists() and any(path.iterdir()) and not exist_ok:
             # If it exists and is not empty, return the path without unzipping
-            LOGGER.warning(f'WARNING ⚠️ Skipping {file} unzip as destination directory {path} is not empty.')
+            LOGGER.warning(f"WARNING ⚠️ Skipping {file} unzip as destination directory {path} is not empty.")
             return path
 
-        for f in TQDM(files, desc=f'Unzipping {file} to {Path(path).resolve()}...', unit='file', disable=not progress):
+        for f in TQDM(files, desc=f"Unzipping {file} to {Path(path).resolve()}...", unit="file", disable=not progress):
             # Ensure the file is within the extract_path to avoid path traversal security vulnerability
-            if '..' in Path(f).parts:
-                LOGGER.warning(f'Potentially insecure file path: {f}, skipping extraction.')
+            if ".." in Path(f).parts:
+                LOGGER.warning(f"Potentially insecure file path: {f}, skipping extraction.")
                 continue
             zipObj.extract(f, extract_path)
 
     return path  # return unzip dir
 
 
-def check_disk_space(url='https://ultralytics.com/assets/coco128.zip', sf=1.5, hard=True):
+def check_disk_space(url="https://ultralytics.com/assets/coco128.zip", sf=1.5, hard=True):
     """
     Check if there is sufficient disk space to download and store a file.
 
@@ -199,20 +201,23 @@ def check_disk_space(url='https://ultralytics.com/assets/coco128.zip', sf=1.5, h
     """
     try:
         r = requests.head(url)  # response
-        assert r.status_code < 400, f'URL error for {url}: {r.status_code} {r.reason}'  # check response
+        assert r.status_code < 400, f"URL error for {url}: {r.status_code} {r.reason}"  # check response
     except Exception:
         return True  # requests issue, default to True
 
     # Check file size
     gib = 1 << 30  # bytes per GiB
-    data = int(r.headers.get('Content-Length', 0)) / gib  # file size (GB)
-    total, used, free = (x / gib for x in shutil.disk_usage('/'))  # bytes
+    data = int(r.headers.get("Content-Length", 0)) / gib  # file size (GB)
+    total, used, free = (x / gib for x in shutil.disk_usage(Path.cwd()))  # bytes
+
     if data * sf < free:
         return True  # sufficient space
 
     # Insufficient space
-    text = (f'WARNING ⚠️ Insufficient free disk space {free:.1f} GB < {data * sf:.3f} GB required, '
-            f'Please free {data * sf - free:.1f} GB additional disk space and try again.')
+    text = (
+        f"WARNING ⚠️ Insufficient free disk space {free:.1f} GB < {data * sf:.3f} GB required, "
+        f"Please free {data * sf - free:.1f} GB additional disk space and try again."
+    )
     if hard:
         raise MemoryError(text)
     LOGGER.warning(text)
@@ -238,36 +243,41 @@ def get_google_drive_file_info(link):
         url, filename = get_google_drive_file_info(link)
         ```
     """
-    file_id = link.split('/d/')[1].split('/view')[0]
-    drive_url = f'https://drive.google.com/uc?export=download&id={file_id}'
+    file_id = link.split("/d/")[1].split("/view")[0]
+    drive_url = f"https://drive.google.com/uc?export=download&id={file_id}"
     filename = None
 
     # Start session
     with requests.Session() as session:
         response = session.get(drive_url, stream=True)
-        if 'quota exceeded' in str(response.content.lower()):
+        if "quota exceeded" in str(response.content.lower()):
             raise ConnectionError(
-                emojis(f'❌  Google Drive file download quota exceeded. '
-                       f'Please try again later or download this file manually at {link}.'))
+                emojis(
+                    f"❌  Google Drive file download quota exceeded. "
+                    f"Please try again later or download this file manually at {link}."
+                )
+            )
         for k, v in response.cookies.items():
-            if k.startswith('download_warning'):
-                drive_url += f'&confirm={v}'  # v is token
-        cd = response.headers.get('content-disposition')
+            if k.startswith("download_warning"):
+                drive_url += f"&confirm={v}"  # v is token
+        cd = response.headers.get("content-disposition")
         if cd:
             filename = re.findall('filename="(.+)"', cd)[0]
     return drive_url, filename
 
 
-def safe_download(url,
-                  file=None,
-                  dir=None,
-                  unzip=True,
-                  delete=False,
-                  curl=False,
-                  retry=3,
-                  min_bytes=1E0,
-                  exist_ok=False,
-                  progress=True):
+def safe_download(
+    url,
+    file=None,
+    dir=None,
+    unzip=True,
+    delete=False,
+    curl=False,
+    retry=3,
+    min_bytes=1e0,
+    exist_ok=False,
+    progress=True,
+):
     """
     Downloads files from a URL, with options for retrying, unzipping, and deleting the downloaded file.
 
@@ -294,36 +304,38 @@ def safe_download(url,
         path = safe_download(link)
         ```
     """
-    gdrive = url.startswith('https://drive.google.com/')  # check if the URL is a Google Drive link
+    gdrive = url.startswith("https://drive.google.com/")  # check if the URL is a Google Drive link
     if gdrive:
         url, file = get_google_drive_file_info(url)
 
-    f = Path(dir or '.') / (file or url2file(url))  # URL converted to filename
-    if '://' not in str(url) and Path(url).is_file():  # URL exists ('://' check required in Windows Python<3.10)
+    f = Path(dir or ".") / (file or url2file(url))  # URL converted to filename
+    if "://" not in str(url) and Path(url).is_file():  # URL exists ('://' check required in Windows Python<3.10)
         f = Path(url)  # filename
     elif not f.is_file():  # URL and file do not exist
         desc = f"Downloading {url if gdrive else clean_url(url)} to '{f}'"
-        LOGGER.info(f'{desc}...')
+        LOGGER.info(f"{desc}...")
         f.parent.mkdir(parents=True, exist_ok=True)  # make directory if missing
         check_disk_space(url)
         for i in range(retry + 1):
             try:
                 if curl or i > 0:  # curl download with retry, continue
-                    s = 'sS' * (not progress)  # silent
-                    r = subprocess.run(['curl', '-#', f'-{s}L', url, '-o', f, '--retry', '3', '-C', '-']).returncode
-                    assert r == 0, f'Curl return value {r}'
+                    s = "sS" * (not progress)  # silent
+                    r = subprocess.run(["curl", "-#", f"-{s}L", url, "-o", f, "--retry", "3", "-C", "-"]).returncode
+                    assert r == 0, f"Curl return value {r}"
                 else:  # urllib download
-                    method = 'torch'
-                    if method == 'torch':
+                    method = "torch"
+                    if method == "torch":
                         torch.hub.download_url_to_file(url, f, progress=progress)
                     else:
-                        with request.urlopen(url) as response, TQDM(total=int(response.getheader('Content-Length', 0)),
-                                                                    desc=desc,
-                                                                    disable=not progress,
-                                                                    unit='B',
-                                                                    unit_scale=True,
-                                                                    unit_divisor=1024) as pbar:
-                            with open(f, 'wb') as f_opened:
+                        with request.urlopen(url) as response, TQDM(
+                            total=int(response.getheader("Content-Length", 0)),
+                            desc=desc,
+                            disable=not progress,
+                            unit="B",
+                            unit_scale=True,
+                            unit_divisor=1024,
+                        ) as pbar:
+                            with open(f, "wb") as f_opened:
                                 for data in response:
                                     f_opened.write(data)
                                     pbar.update(len(data))
@@ -334,26 +346,26 @@ def safe_download(url,
                     f.unlink()  # remove partial downloads
             except Exception as e:
                 if i == 0 and not is_online():
-                    raise ConnectionError(emojis(f'❌  Download failure for {url}. Environment is not online.')) from e
+                    raise ConnectionError(emojis(f"❌  Download failure for {url}. Environment is not online.")) from e
                 elif i >= retry:
-                    raise ConnectionError(emojis(f'❌  Download failure for {url}. Retry limit reached.')) from e
-                LOGGER.warning(f'⚠️ Download failure, retrying {i + 1}/{retry} {url}...')
+                    raise ConnectionError(emojis(f"❌  Download failure for {url}. Retry limit reached.")) from e
+                LOGGER.warning(f"⚠️ Download failure, retrying {i + 1}/{retry} {url}...")
 
-    if unzip and f.exists() and f.suffix in ('', '.zip', '.tar', '.gz'):
+    if unzip and f.exists() and f.suffix in ("", ".zip", ".tar", ".gz"):
         from zipfile import is_zipfile
 
         unzip_dir = (dir or f.parent).resolve()  # unzip to dir if provided else unzip in place
         if is_zipfile(f):
             unzip_dir = unzip_file(file=f, path=unzip_dir, exist_ok=exist_ok, progress=progress)  # unzip
-        elif f.suffix in ('.tar', '.gz'):
-            LOGGER.info(f'Unzipping {f} to {unzip_dir}...')
-            subprocess.run(['tar', 'xf' if f.suffix == '.tar' else 'xfz', f, '--directory', unzip_dir], check=True)
+        elif f.suffix in (".tar", ".gz"):
+            LOGGER.info(f"Unzipping {f} to {unzip_dir}...")
+            subprocess.run(["tar", "xf" if f.suffix == ".tar" else "xfz", f, "--directory", unzip_dir], check=True)
         if delete:
             f.unlink()  # remove zip
         return unzip_dir
 
 
-def get_github_assets(repo='ultralytics/assets', version='latest', retry=False):
+def get_github_assets(repo="ultralytics/assets", version="latest", retry=False):
     """
     Retrieve the specified version's tag and assets from a GitHub repository. If the version is not specified, the
     function fetches the latest release assets.
@@ -372,20 +384,20 @@ def get_github_assets(repo='ultralytics/assets', version='latest', retry=False):
         ```
     """
 
-    if version != 'latest':
-        version = f'tags/{version}'  # i.e. tags/v6.2
-    url = f'https://api.github.com/repos/{repo}/releases/{version}'
+    if version != "latest":
+        version = f"tags/{version}"  # i.e. tags/v6.2
+    url = f"https://api.github.com/repos/{repo}/releases/{version}"
     r = requests.get(url)  # github api
-    if r.status_code != 200 and r.reason != 'rate limit exceeded' and retry:  # failed and not 403 rate limit exceeded
+    if r.status_code != 200 and r.reason != "rate limit exceeded" and retry:  # failed and not 403 rate limit exceeded
         r = requests.get(url)  # try again
     if r.status_code != 200:
-        LOGGER.warning(f'⚠️ GitHub assets check failure for {url}: {r.status_code} {r.reason}')
-        return '', []
+        LOGGER.warning(f"⚠️ GitHub assets check failure for {url}: {r.status_code} {r.reason}")
+        return "", []
     data = r.json()
-    return data['tag_name'], [x['name'] for x in data['assets']]  # tag, assets i.e. ['yolov8n.pt', 'yolov8s.pt', ...]
+    return data["tag_name"], [x["name"] for x in data["assets"]]  # tag, assets i.e. ['yolov8n.pt', 'yolov8s.pt', ...]
 
 
-def attempt_download_asset(file, repo='ultralytics/assets', release='v0.0.0', **kwargs):
+def attempt_download_asset(file, repo="ultralytics/assets", release="v0.0.0", **kwargs):
     """
     Attempt to download a file from GitHub release assets if it is not found locally. The function checks for the file
     locally first, then tries to download it from the specified GitHub repository release.
@@ -409,32 +421,32 @@ def attempt_download_asset(file, repo='ultralytics/assets', release='v0.0.0', **
     # YOLOv3/5u updates
     file = str(file)
     file = checks.check_yolov5u_filename(file)
-    file = Path(file.strip().replace("'", ''))
+    file = Path(file.strip().replace("'", ""))
     if file.exists():
         return str(file)
-    elif (SETTINGS['weights_dir'] / file).exists():
-        return str(SETTINGS['weights_dir'] / file)
+    elif (SETTINGS["weights_dir"] / file).exists():
+        return str(SETTINGS["weights_dir"] / file)
     else:
         # URL specified
         name = Path(parse.unquote(str(file))).name  # decode '%2F' to '/' etc.
-        download_url = f'https://github.com/{repo}/releases/download'
-        if str(file).startswith(('http:/', 'https:/')):  # download
-            url = str(file).replace(':/', '://')  # Pathlib turns :// -> :/
+        download_url = f"https://github.com/{repo}/releases/download"
+        if str(file).startswith(("http:/", "https:/")):  # download
+            url = str(file).replace(":/", "://")  # Pathlib turns :// -> :/
             file = url2file(name)  # parse authentication https://url.com/file.txt?auth...
             if Path(file).is_file():
-                LOGGER.info(f'Found {clean_url(url)} locally at {file}')  # file already exists
+                LOGGER.info(f"Found {clean_url(url)} locally at {file}")  # file already exists
             else:
-                safe_download(url=url, file=file, min_bytes=1E5, **kwargs)
+                safe_download(url=url, file=file, min_bytes=1e5, **kwargs)
 
         elif repo == GITHUB_ASSETS_REPO and name in GITHUB_ASSETS_NAMES:
-            safe_download(url=f'{download_url}/{release}/{name}', file=file, min_bytes=1E5, **kwargs)
+            safe_download(url=f"{download_url}/{release}/{name}", file=file, min_bytes=1e5, **kwargs)
 
         else:
             tag, assets = get_github_assets(repo, release)
             if not assets:
                 tag, assets = get_github_assets(repo)  # latest release
             if name in assets:
-                safe_download(url=f'{download_url}/{tag}/{name}', file=file, min_bytes=1E5, **kwargs)
+                safe_download(url=f"{download_url}/{tag}/{name}", file=file, min_bytes=1e5, **kwargs)
 
         return str(file)
 
@@ -464,14 +476,18 @@ def download(url, dir=Path.cwd(), unzip=True, delete=False, curl=False, threads=
     if threads > 1:
         with ThreadPool(threads) as pool:
             pool.map(
-                lambda x: safe_download(url=x[0],
-                                        dir=x[1],
-                                        unzip=unzip,
-                                        delete=delete,
-                                        curl=curl,
-                                        retry=retry,
-                                        exist_ok=exist_ok,
-                                        progress=threads <= 1), zip(url, repeat(dir)))
+                lambda x: safe_download(
+                    url=x[0],
+                    dir=x[1],
+                    unzip=unzip,
+                    delete=delete,
+                    curl=curl,
+                    retry=retry,
+                    exist_ok=exist_ok,
+                    progress=threads <= 1,
+                ),
+                zip(url, repeat(dir)),
+            )
             pool.close()
             pool.join()
     else:

ultralytics/utils/errors.py

@@ -17,6 +17,6 @@ class HUBModelError(Exception):
         The message is automatically processed through the 'emojis' function from the 'ultralytics.utils' package.
     """
 
-    def __init__(self, message='Model not found. Please check model URL and try again.'):
+    def __init__(self, message="Model not found. Please check model URL and try again."):
         """Create an exception for when a model is not found."""
         super().__init__(emojis(message))

ultralytics/utils/files.py

@@ -50,13 +50,13 @@ def spaces_in_path(path):
     """
 
     # If path has spaces, replace them with underscores
-    if ' ' in str(path):
+    if " " in str(path):
         string = isinstance(path, str)  # input type
         path = Path(path)
 
         # Create a temporary directory and construct the new path
         with tempfile.TemporaryDirectory() as tmp_dir:
-            tmp_path = Path(tmp_dir) / path.name.replace(' ', '_')
+            tmp_path = Path(tmp_dir) / path.name.replace(" ", "_")
 
             # Copy file/directory
             if path.is_dir():
@@ -82,7 +82,7 @@ def spaces_in_path(path):
         yield path
 
 
-def increment_path(path, exist_ok=False, sep='', mkdir=False):
+def increment_path(path, exist_ok=False, sep="", mkdir=False):
     """
     Increments a file or directory path, i.e. runs/exp --> runs/exp{sep}2, runs/exp{sep}3, ... etc.
 
@@ -102,11 +102,11 @@ def increment_path(path, exist_ok=False, sep='', mkdir=False):
     """
     path = Path(path)  # os-agnostic
     if path.exists() and not exist_ok:
-        path, suffix = (path.with_suffix(''), path.suffix) if path.is_file() else (path, '')
+        path, suffix = (path.with_suffix(""), path.suffix) if path.is_file() else (path, "")
 
         # Method 1
         for n in range(2, 9999):
-            p = f'{path}{sep}{n}{suffix}'  # increment path
+            p = f"{path}{sep}{n}{suffix}"  # increment path
             if not os.path.exists(p):
                 break
         path = Path(p)
@@ -119,14 +119,14 @@ def increment_path(path, exist_ok=False, sep='', mkdir=False):
 
 def file_age(path=__file__):
     """Return days since last file update."""
-    dt = (datetime.now() - datetime.fromtimestamp(Path(path).stat().st_mtime))  # delta
+    dt = datetime.now() - datetime.fromtimestamp(Path(path).stat().st_mtime)  # delta
     return dt.days  # + dt.seconds / 86400  # fractional days
 
 
 def file_date(path=__file__):
     """Return human-readable file modification date, i.e. '2021-3-26'."""
     t = datetime.fromtimestamp(Path(path).stat().st_mtime)
-    return f'{t.year}-{t.month}-{t.day}'
+    return f"{t.year}-{t.month}-{t.day}"
 
 
 def file_size(path):
@@ -137,11 +137,11 @@ def file_size(path):
         if path.is_file():
             return path.stat().st_size / mb
         elif path.is_dir():
-            return sum(f.stat().st_size for f in path.glob('**/*') if f.is_file()) / mb
+            return sum(f.stat().st_size for f in path.glob("**/*") if f.is_file()) / mb
     return 0.0
 
 
-def get_latest_run(search_dir='.'):
+def get_latest_run(search_dir="."):
     """Return path to most recent 'last.pt' in /runs (i.e. to --resume from)."""
-    last_list = glob.glob(f'{search_dir}/**/last*.pt', recursive=True)
-    return max(last_list, key=os.path.getctime) if last_list else ''
+    last_list = glob.glob(f"{search_dir}/**/last*.pt", recursive=True)
+    return max(last_list, key=os.path.getctime) if last_list else ""