Skip to content

Référence pour ultralytics/utils/files.py

Note

Ce fichier est disponible à l'adresse https://github.com/ultralytics/ ultralytics/blob/main/ ultralytics/utils/files .py. Si tu repères un problème, aide à le corriger en contribuant à une Pull Request 🛠️. Merci 🙏 !



ultralytics.utils.files.WorkingDirectory

Bases : ContextDecorator

Utilisation : DĂ©corateur @WorkingDirectory(dir) ou 'avec WorkingDirectory(dir):' gestionnaire de contexte.

Code source dans ultralytics/utils/files.py
class WorkingDirectory(contextlib.ContextDecorator):
    """Usage: @WorkingDirectory(dir) decorator or 'with WorkingDirectory(dir):' context manager."""

    def __init__(self, new_dir):
        """Sets the working directory to 'new_dir' upon instantiation."""
        self.dir = new_dir  # new dir
        self.cwd = Path.cwd().resolve()  # current dir

    def __enter__(self):
        """Changes the current directory to the specified directory."""
        os.chdir(self.dir)

    def __exit__(self, exc_type, exc_val, exc_tb):  # noqa
        """Restore the current working directory on context exit."""
        os.chdir(self.cwd)

__enter__()

Change le répertoire actuel pour le répertoire spécifié.

Code source dans ultralytics/utils/files.py
def __enter__(self):
    """Changes the current directory to the specified directory."""
    os.chdir(self.dir)

__exit__(exc_type, exc_val, exc_tb)

Restaure le répertoire de travail actuel à la sortie du contexte.

Code source dans ultralytics/utils/files.py
def __exit__(self, exc_type, exc_val, exc_tb):  # noqa
    """Restore the current working directory on context exit."""
    os.chdir(self.cwd)

__init__(new_dir)

Définit le répertoire de travail à 'new_dir' lors de l'instanciation.

Code source dans ultralytics/utils/files.py
def __init__(self, new_dir):
    """Sets the working directory to 'new_dir' upon instantiation."""
    self.dir = new_dir  # new dir
    self.cwd = Path.cwd().resolve()  # current dir



ultralytics.utils.files.spaces_in_path(path)

Gestionnaire de contexte pour gérer les chemins d'accès dont le nom contient des espaces. Si un chemin d'accès contient des espaces, il les remplace par des caractères de soulignement. souligne, copie le fichier/répertoire dans le nouveau chemin, exécute le bloc de code contextuel, puis recopie le fichier/répertoire à son emplacement d'origine. fichier/répertoire à son emplacement d'origine.

Paramètres :

Nom Type Description DĂ©faut
path str | Path

Le chemin original.

requis

Rendement :

Type Description
Path

Chemin temporaire avec les espaces remplacés par des traits de soulignement si des espaces étaient présents, sinon le chemin d'origine.

Exemple
with ultralytics.utils.files import spaces_in_path

with spaces_in_path('/path/with spaces') as new_path:
    # Your code here
Code source dans ultralytics/utils/files.py
@contextmanager
def spaces_in_path(path):
    """
    Context manager to handle paths with spaces in their names. If a path contains spaces, it replaces them with
    underscores, copies the file/directory to the new path, executes the context code block, then copies the
    file/directory back to its original location.

    Args:
        path (str | Path): The original path.

    Yields:
        (Path): Temporary path with spaces replaced by underscores if spaces were present, otherwise the original path.

    Example:
        ```python
        with ultralytics.utils.files import spaces_in_path

        with spaces_in_path('/path/with spaces') as new_path:
            # Your code here
        ```
    """

    # If path has spaces, replace them with underscores
    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(" ", "_")

            # Copy file/directory
            if path.is_dir():
                # tmp_path.mkdir(parents=True, exist_ok=True)
                shutil.copytree(path, tmp_path)
            elif path.is_file():
                tmp_path.parent.mkdir(parents=True, exist_ok=True)
                shutil.copy2(path, tmp_path)

            try:
                # Yield the temporary path
                yield str(tmp_path) if string else tmp_path

            finally:
                # Copy file/directory back
                if tmp_path.is_dir():
                    shutil.copytree(tmp_path, path, dirs_exist_ok=True)
                elif tmp_path.is_file():
                    shutil.copy2(tmp_path, path)  # Copy back the file

    else:
        # If there are no spaces, just yield the original path
        yield path



ultralytics.utils.files.increment_path(path, exist_ok=False, sep='', mkdir=False)

Incrémente le chemin d'un fichier ou d'un répertoire, c'est-à-dire runs/exp --> runs/exp{sep}2, runs/exp{sep}3, ... etc.

Si le chemin existe et que exist_ok ne vaut pas True, le chemin sera incrémenté en ajoutant un nombre et un sep à la fin du chemin. à la fin du chemin. Si le chemin est un fichier, l'extension du fichier sera conservée. Si le chemin est un répertoire, le numéro sera ajouté directement à la fin du chemin. Si mkdir a la valeur True, le chemin sera créé en tant que répertoire s'il n'existe pas déjà. s'il n'existe pas déjà.

Paramètres :

Nom Type Description DĂ©faut
path (str, Path)

Chemin vers l'incrémentation.

requis
exist_ok bool

Si True, le chemin ne sera pas incrémenté et sera renvoyé tel quel. La valeur par défaut est False.

False
sep str

Séparateur à utiliser entre le chemin et le numéro d'incrémentation. La valeur par défaut est ''.

''
mkdir bool

Crée un répertoire s'il n'existe pas. La valeur par défaut est False.

False

Retourne :

Type Description
Path

Chemin incrémenté.

Code source dans ultralytics/utils/files.py
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.

    If the path exists and exist_ok is not set to True, the path will be incremented by appending a number and sep to
    the end of the path. If the path is a file, the file extension will be preserved. If the path is a directory, the
    number will be appended directly to the end of the path. If mkdir is set to True, the path will be created as a
    directory if it does not already exist.

    Args:
        path (str, pathlib.Path): Path to increment.
        exist_ok (bool, optional): If True, the path will not be incremented and returned as-is. Defaults to False.
        sep (str, optional): Separator to use between the path and the incrementation number. Defaults to ''.
        mkdir (bool, optional): Create a directory if it does not exist. Defaults to False.

    Returns:
        (pathlib.Path): Incremented path.
    """
    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, "")

        # Method 1
        for n in range(2, 9999):
            p = f"{path}{sep}{n}{suffix}"  # increment path
            if not os.path.exists(p):
                break
        path = Path(p)

    if mkdir:
        path.mkdir(parents=True, exist_ok=True)  # make directory

    return path



ultralytics.utils.files.file_age(path=__file__)

Retourne les jours écoulés depuis la dernière mise à jour du fichier.

Code source dans ultralytics/utils/files.py
def file_age(path=__file__):
    """Return days since last file update."""
    dt = datetime.now() - datetime.fromtimestamp(Path(path).stat().st_mtime)  # delta
    return dt.days  # + dt.seconds / 86400  # fractional days



ultralytics.utils.files.file_date(path=__file__)

Renvoie la date de modification du fichier lisible par l'homme, c'est-Ă -dire '2021-3-26'.

Code source dans ultralytics/utils/files.py
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}"



ultralytics.utils.files.file_size(path)

Retourne la taille du fichier/répertoire (MB).

Code source dans ultralytics/utils/files.py
def file_size(path):
    """Return file/dir size (MB)."""
    if isinstance(path, (str, Path)):
        mb = 1 << 20  # bytes to MiB (1024 ** 2)
        path = Path(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 0.0



ultralytics.utils.files.get_latest_run(search_dir='.')

Renvoie le chemin d'accès au plus récent 'last.pt' dans /runs (c.-à-d. pour --reprendre à partir de).

Code source dans ultralytics/utils/files.py
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 ""





Créé le 2023-11-12, Mis à jour le 2023-11-25
Auteurs : glenn-jocher (3), Laughing-q (1)