fonttools 4.58.5__cp39-cp39-macosx_10_9_universal2.whl → 4.59.1__cp39-cp39-macosx_10_9_universal2.whl

fontTools/misc/filesystem/_base.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+import typing
+from abc import ABC, abstractmethod
+
+from ._copy import copy_dir, copy_file
+from ._errors import (
+    DestinationExists,
+    DirectoryExpected,
+    FileExpected,
+    FilesystemClosed,
+    NoSysPath,
+    ResourceNotFound,
+)
+from ._path import dirname
+from ._walk import BoundWalker
+
+if typing.TYPE_CHECKING:
+    from typing import IO, Any, Collection, Iterator, Self, Type
+
+    from ._info import Info
+    from ._subfs import SubFS
+
+
+class FS(ABC):
+    """Abstract base class for custom filesystems."""
+
+    _closed: bool = False
+
+    @abstractmethod
+    def open(self, path: str, mode: str = "rb", **kwargs) -> IO[Any]: ...
+
+    @abstractmethod
+    def exists(self, path: str) -> bool: ...
+
+    @abstractmethod
+    def isdir(self, path: str) -> bool: ...
+
+    @abstractmethod
+    def isfile(self, path: str) -> bool: ...
+
+    @abstractmethod
+    def listdir(self, path: str) -> list[str]: ...
+
+    @abstractmethod
+    def makedir(self, path: str, recreate: bool = False) -> SubFS: ...
+
+    @abstractmethod
+    def makedirs(self, path: str, recreate: bool = False) -> SubFS: ...
+
+    @abstractmethod
+    def getinfo(self, path: str, namespaces: Collection[str] | None = None) -> Info: ...
+
+    @abstractmethod
+    def remove(self, path: str) -> None: ...
+
+    @abstractmethod
+    def removedir(self, path: str) -> None: ...
+
+    @abstractmethod
+    def removetree(self, path: str) -> None: ...
+
+    @abstractmethod
+    def movedir(self, src: str, dst: str, create: bool = False) -> None: ...
+
+    def getsyspath(self, path: str) -> str:
+        raise NoSysPath(f"the filesystem {self!r} has no system path")
+
+    def close(self):
+        self._closed = True
+
+    def isclosed(self) -> bool:
+        return self._closed
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(self, exc_type, exc, tb):
+        self.close()
+        return False  # never swallow exceptions
+
+    def check(self):
+        if self._closed:
+            raise FilesystemClosed(f"the filesystem {self!r} is closed")
+
+    def opendir(self, path: str, *, factory: Type[SubFS] | None = None) -> SubFS:
+        """Return a sub‑filesystem rooted at `path`."""
+        if factory is None:
+            from ._subfs import SubFS
+
+            factory = SubFS
+        return factory(self, path)
+
+    def scandir(
+        self, path: str, namespaces: Collection[str] | None = None
+    ) -> Iterator[Info]:
+        return (self.getinfo(f"{path}/{p}", namespaces) for p in self.listdir(path))
+
+    @property
+    def walk(self) -> BoundWalker:
+        return BoundWalker(self)
+
+    def readbytes(self, path: str) -> bytes:
+        with self.open(path, "rb") as f:
+            return f.read()
+
+    def writebytes(self, path: str, data: bytes):
+        with self.open(path, "wb") as f:
+            f.write(data)
+
+    def create(self, path: str, wipe: bool = False):
+        if not wipe and self.exists(path):
+            return False
+        with self.open(path, "wb"):
+            pass  # 'touch' empty file
+        return True
+
+    def copy(self, src_path: str, dst_path: str, overwrite=False):
+        if not self.exists(src_path):
+            raise ResourceNotFound(f"{src_path!r} does not exist")
+        elif not self.isfile(src_path):
+            raise FileExpected(f"path {src_path!r} should be a file")
+        if not overwrite and self.exists(dst_path):
+            raise DestinationExists(f"destination {dst_path!r} already exists")
+        if not self.isdir(dirname(dst_path)):
+            raise DirectoryExpected(f"path {dirname(dst_path)!r} should be a directory")
+        copy_file(self, src_path, self, dst_path)
+
+    def copydir(self, src_path: str, dst_path: str, create=False):
+        if not create and not self.exists(dst_path):
+            raise ResourceNotFound(f"{dst_path!r} does not exist")
+        if not self.isdir(src_path):
+            raise DirectoryExpected(f"path {src_path!r} should be a directory")
+        copy_dir(self, src_path, self, dst_path)

fontTools/misc/filesystem/_copy.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import typing
+
+from ._errors import IllegalDestination
+from ._path import combine, frombase, isbase
+from ._tools import copy_file_data
+
+if typing.TYPE_CHECKING:
+    from ._base import FS
+
+
+def copy_file(src_fs: FS, src_path: str, dst_fs: FS, dst_path: str):
+    if src_fs is dst_fs and src_path == dst_path:
+        raise IllegalDestination(f"cannot copy {src_path!r} to itself")
+
+    with src_fs.open(src_path, "rb") as src_file:
+        with dst_fs.open(dst_path, "wb") as dst_file:
+            copy_file_data(src_file, dst_file)
+
+
+def copy_structure(
+    src_fs: FS,
+    dst_fs: FS,
+    src_root: str = "/",
+    dst_root: str = "/",
+):
+    if src_fs is dst_fs and isbase(src_root, dst_root):
+        raise IllegalDestination(f"cannot copy {src_fs!r} to itself")
+
+    dst_fs.makedirs(dst_root, recreate=True)
+    for dir_path in src_fs.walk.dirs(src_root):
+        dst_fs.makedir(combine(dst_root, frombase(src_root, dir_path)), recreate=True)
+
+
+def copy_dir(src_fs: FS, src_path: str, dst_fs: FS, dst_path: str):
+    copy_structure(src_fs, dst_fs, src_path, dst_path)
+
+    for file_path in src_fs.walk.files(src_path):
+        copy_path = combine(dst_path, frombase(src_path, file_path))
+        copy_file(src_fs, file_path, dst_fs, copy_path)
+
+
+def copy_fs(src_fs: FS, dst_fs: FS):
+    copy_dir(src_fs, "/", dst_fs, "/")

fontTools/misc/filesystem/_errors.py

@@ -0,0 +1,54 @@
+class FSError(Exception):
+    pass
+
+
+class CreateFailed(FSError):
+    pass
+
+
+class FilesystemClosed(FSError):
+    pass
+
+
+class MissingInfoNamespace(FSError):
+    pass
+
+
+class NoSysPath(FSError):
+    pass
+
+
+class OperationFailed(FSError):
+    pass
+
+
+class IllegalDestination(OperationFailed):
+    pass
+
+
+class ResourceError(FSError):
+    pass
+
+
+class ResourceNotFound(ResourceError):
+    pass
+
+
+class DirectoryExpected(ResourceError):
+    pass
+
+
+class DirectoryNotEmpty(ResourceError):
+    pass
+
+
+class FileExpected(ResourceError):
+    pass
+
+
+class DestinationExists(ResourceError):
+    pass
+
+
+class ResourceReadOnly(ResourceError):
+    pass

fontTools/misc/filesystem/_info.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+import typing
+from datetime import datetime, timezone
+
+from ._errors import MissingInfoNamespace
+
+if typing.TYPE_CHECKING:
+    from collections.abc import Mapping
+    from typing import Any
+
+
+def epoch_to_datetime(t: int | None) -> datetime | None:
+    """Convert epoch time to a UTC datetime."""
+    if t is None:
+        return None
+    return datetime.fromtimestamp(t, tz=timezone.utc)
+
+
+class Info:
+    __slots__ = ["raw", "namespaces"]
+
+    def __init__(self, raw_info: Mapping[str, Any]):
+        self.raw = raw_info
+        self.namespaces = frozenset(raw_info.keys())
+
+    def get(self, namespace: str, key: str, default: Any | None = None) -> Any | None:
+        try:
+            return self.raw[namespace].get(key, default)
+        except KeyError:
+            raise MissingInfoNamespace(f"Namespace {namespace!r} does not exist")
+
+    @property
+    def name(self) -> str:
+        return self.get("basic", "name")
+
+    @property
+    def is_dir(self) -> bool:
+        return self.get("basic", "is_dir")
+
+    @property
+    def is_file(self) -> bool:
+        return not self.is_dir
+
+    @property
+    def accessed(self) -> datetime | None:
+        return epoch_to_datetime(self.get("details", "accessed"))
+
+    @property
+    def modified(self) -> datetime | None:
+        return epoch_to_datetime(self.get("details", "modified"))
+
+    @property
+    def size(self) -> int | None:
+        return self.get("details", "size")
+
+    @property
+    def type(self) -> int | None:
+        return self.get("details", "type")
+
+    @property
+    def created(self) -> datetime | None:
+        return epoch_to_datetime(self.get("details", "created"))
+
+    @property
+    def metadata_changed(self) -> datetime | None:
+        return epoch_to_datetime(self.get("details", "metadata_changed"))
+
+    def __str__(self) -> str:
+        if self.is_dir:
+            return "<dir '{}'>".format(self.name)
+        else:
+            return "<file '{}'>".format(self.name)
+
+    __repr__ = __str__

fontTools/misc/filesystem/_osfs.py

@@ -0,0 +1,164 @@
+from __future__ import annotations
+
+import errno
+import platform
+import shutil
+import stat
+import typing
+from os import PathLike
+from pathlib import Path
+
+from ._base import FS
+from ._errors import (
+    CreateFailed,
+    DirectoryExpected,
+    DirectoryNotEmpty,
+    FileExpected,
+    IllegalDestination,
+    ResourceError,
+    ResourceNotFound,
+)
+from ._info import Info
+from ._path import isbase
+
+if typing.TYPE_CHECKING:
+    from collections.abc import Collection
+    from typing import IO, Any
+
+    from ._subfs import SubFS
+
+
+_WINDOWS_PLATFORM = platform.system() == "Windows"
+
+
+class OSFS(FS):
+    """Filesystem for a directory on the local disk.
+
+    A thin layer on top of `pathlib.Path`.
+    """
+
+    def __init__(self, root: str | PathLike, create: bool = False):
+        super().__init__()
+        self._root = Path(root).resolve()
+        if create:
+            self._root.mkdir(parents=True, exist_ok=True)
+        else:
+            if not self._root.is_dir():
+                raise CreateFailed(
+                    f"unable to create OSFS: {root!r} does not exist or is not a directory"
+                )
+
+    def _abs(self, rel_path: str) -> Path:
+        self.check()
+        return (self._root / rel_path.strip("/")).resolve()
+
+    def open(self, path: str, mode: str = "rb", **kwargs) -> IO[Any]:
+        try:
+            return self._abs(path).open(mode, **kwargs)
+        except FileNotFoundError:
+            raise ResourceNotFound(f"No such file or directory: {path!r}")
+
+    def exists(self, path: str) -> bool:
+        return self._abs(path).exists()
+
+    def isdir(self, path: str) -> bool:
+        return self._abs(path).is_dir()
+
+    def isfile(self, path: str) -> bool:
+        return self._abs(path).is_file()
+
+    def listdir(self, path: str) -> list[str]:
+        return [p.name for p in self._abs(path).iterdir()]
+
+    def _mkdir(self, path: str, parents: bool = False, exist_ok: bool = False) -> SubFS:
+        self._abs(path).mkdir(parents=parents, exist_ok=exist_ok)
+        return self.opendir(path)
+
+    def makedir(self, path: str, recreate: bool = False) -> SubFS:
+        return self._mkdir(path, parents=False, exist_ok=recreate)
+
+    def makedirs(self, path: str, recreate: bool = False) -> SubFS:
+        return self._mkdir(path, parents=True, exist_ok=recreate)
+
+    def getinfo(self, path: str, namespaces: Collection[str] | None = None) -> Info:
+        path = self._abs(path)
+        if not path.exists():
+            raise ResourceNotFound(f"No such file or directory: {str(path)!r}")
+        info = {
+            "basic": {
+                "name": path.name,
+                "is_dir": path.is_dir(),
+            }
+        }
+        namespaces = namespaces or ()
+        if "details" in namespaces:
+            stat_result = path.stat()
+            details = info["details"] = {
+                "accessed": stat_result.st_atime,
+                "modified": stat_result.st_mtime,
+                "size": stat_result.st_size,
+                "type": stat.S_IFMT(stat_result.st_mode),
+                "created": getattr(stat_result, "st_birthtime", None),
+            }
+            ctime_key = "created" if _WINDOWS_PLATFORM else "metadata_changed"
+            details[ctime_key] = stat_result.st_ctime
+        return Info(info)
+
+    def remove(self, path: str):
+        path = self._abs(path)
+        try:
+            path.unlink()
+        except FileNotFoundError:
+            raise ResourceNotFound(f"No such file or directory: {str(path)!r}")
+        except OSError as e:
+            if path.is_dir():
+                raise FileExpected(f"path {str(path)!r} should be a file")
+            else:
+                raise ResourceError(f"unable to remove {str(path)!r}: {e}")
+
+    def removedir(self, path: str):
+        try:
+            self._abs(path).rmdir()
+        except NotADirectoryError:
+            raise DirectoryExpected(f"path {path!r} should be a directory")
+        except OSError as e:
+            if e.errno == errno.ENOTEMPTY:
+                raise DirectoryNotEmpty(f"Directory not empty: {path!r}")
+            else:
+                raise ResourceError(f"unable to remove {path!r}: {e}")
+
+    def removetree(self, path: str):
+        shutil.rmtree(self._abs(path))
+
+    def movedir(self, src_dir: str, dst_dir: str, create: bool = False):
+        if isbase(src_dir, dst_dir):
+            raise IllegalDestination(f"cannot move {src_dir!r} to {dst_dir!r}")
+        src_path = self._abs(src_dir)
+        if not src_path.exists():
+            raise ResourceNotFound(f"Source {src_dir!r} does not exist")
+        elif not src_path.is_dir():
+            raise DirectoryExpected(f"Source {src_dir!r} should be a directory")
+        dst_path = self._abs(dst_dir)
+        if not create and not dst_path.exists():
+            raise ResourceNotFound(f"Destination {dst_dir!r} does not exist")
+        if dst_path.is_file():
+            raise DirectoryExpected(f"Destination {dst_dir!r} should be a directory")
+        if create:
+            dst_path.parent.mkdir(parents=True, exist_ok=True)
+        if dst_path.exists():
+            if list(dst_path.iterdir()):
+                raise DirectoryNotEmpty(f"Destination {dst_dir!r} is not empty")
+            elif _WINDOWS_PLATFORM:
+                # on Unix os.rename silently replaces an empty dst_dir whereas on
+                # Windows it always raises FileExistsError, empty or not.
+                dst_path.rmdir()
+        src_path.rename(dst_path)
+
+    def getsyspath(self, path: str) -> str:
+        return str(self._abs(path))
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({str(self._root)!r})"
+
+    def __str__(self) -> str:
+        return f"<{self.__class__.__name__.lower()} '{self._root}'>"

fontTools/misc/filesystem/_path.py

@@ -0,0 +1,67 @@
+import os
+import platform
+
+_WINDOWS_PLATFORM = platform.system() == "Windows"
+
+
+def combine(path1: str, path2) -> str:
+    if not path1:
+        return path2
+    return "{}/{}".format(path1.rstrip("/"), path2.lstrip("/"))
+
+
+def split(path: str) -> tuple[str, str]:
+    if "/" not in path:
+        return ("", path)
+    split = path.rsplit("/", 1)
+    return (split[0] or "/", split[1])
+
+
+def dirname(path: str) -> str:
+    return split(path)[0]
+
+
+def basename(path: str) -> str:
+    return split(path)[1]
+
+
+def forcedir(path: str) -> str:
+    # Ensure the path ends with a trailing forward slash.
+    if not path.endswith("/"):
+        return path + "/"
+    return path
+
+
+def abspath(path: str) -> str:
+    # FS objects have no concept of a *current directory*. This simply
+    # ensures the path starts with a forward slash.
+    if not path.startswith("/"):
+        return "/" + path
+    return path
+
+
+def isbase(path1: str, path2: str) -> bool:
+    # Check if `path1` is a base or prefix of `path2`.
+    _path1 = forcedir(abspath(path1))
+    _path2 = forcedir(abspath(path2))
+    return _path2.startswith(_path1)
+
+
+def frombase(path1: str, path2: str) -> str:
+    # Get the final path of `path2` that isn't in `path1`.
+    if not isbase(path1, path2):
+        raise ValueError(f"path1 must be a prefix of path2: {path1!r} vs {path2!r}")
+    return path2[len(path1) :]
+
+
+def relpath(path: str) -> str:
+    return path.lstrip("/")
+
+
+def normpath(path: str) -> str:
+    normalized = os.path.normpath(path)
+    if _WINDOWS_PLATFORM:
+        # os.path.normpath converts backslashes to forward slashes on Windows
+        # but we want forward slashes, so we convert them back
+        normalized = normalized.replace("\\", "/")
+    return normalized

fontTools/misc/filesystem/_subfs.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+import typing
+from pathlib import PurePosixPath
+
+from ._base import FS
+from ._errors import DirectoryExpected, ResourceNotFound
+
+if typing.TYPE_CHECKING:
+    from collections.abc import Collection
+    from typing import IO, Any
+
+    from ._info import Info
+
+
+class SubFS(FS):
+    """Maps a sub-directory of another filesystem."""
+
+    def __init__(self, parent: FS, sub_path: str):
+        super().__init__()
+        self._parent = parent
+        self._prefix = PurePosixPath(sub_path).as_posix().rstrip("/")
+        if not parent.exists(self._prefix):
+            raise ResourceNotFound(f"No such file or directory: {sub_path!r}")
+        elif not parent.isdir(self._prefix):
+            raise DirectoryExpected(f"{sub_path!r} is not a directory")
+
+    def delegate_fs(self):
+        return self._parent
+
+    def _full(self, rel: str) -> str:
+        self.check()
+        return f"{self._prefix}/{PurePosixPath(rel).as_posix()}".lstrip("/")
+
+    def open(self, path: str, mode: str = "rb", **kwargs) -> IO[Any]:
+        return self._parent.open(self._full(path), mode, **kwargs)
+
+    def exists(self, path: str) -> bool:
+        return self._parent.exists(self._full(path))
+
+    def isdir(self, path: str) -> bool:
+        return self._parent.isdir(self._full(path))
+
+    def isfile(self, path: str) -> bool:
+        return self._parent.isfile(self._full(path))
+
+    def listdir(self, path: str) -> list[str]:
+        return self._parent.listdir(self._full(path))
+
+    def makedir(self, path: str, recreate: bool = False):
+        return self._parent.makedir(self._full(path), recreate=recreate)
+
+    def makedirs(self, path: str, recreate: bool = False):
+        return self._parent.makedirs(self._full(path), recreate=recreate)
+
+    def getinfo(self, path: str, namespaces: Collection[str] | None = None) -> Info:
+        return self._parent.getinfo(self._full(path), namespaces=namespaces)
+
+    def remove(self, path: str):
+        return self._parent.remove(self._full(path))
+
+    def removedir(self, path: str):
+        return self._parent.removedir(self._full(path))
+
+    def removetree(self, path: str):
+        return self._parent.removetree(self._full(path))
+
+    def movedir(self, src: str, dst: str, create: bool = False):
+        self._parent.movedir(self._full(src), self._full(dst), create=create)
+
+    def getsyspath(self, path: str) -> str:
+        return self._parent.getsyspath(self._full(path))
+
+    def readbytes(self, path: str) -> bytes:
+        return self._parent.readbytes(self._full(path))
+
+    def writebytes(self, path: str, data: bytes):
+        self._parent.writebytes(self._full(path), data)
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({self._parent!r}, {self._prefix!r})"
+
+    def __str__(self) -> str:
+        return f"{self._parent}/{self._prefix}"
+
+
+class ClosingSubFS(SubFS):
+    """Like SubFS, but auto-closes the parent filesystem when closed."""
+
+    def close(self):
+        super().close()
+        self._parent.close()

fontTools/misc/filesystem/_tempfs.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import shutil
+import tempfile
+
+from ._errors import OperationFailed
+from ._osfs import OSFS
+
+
+class TempFS(OSFS):
+    def __init__(self, auto_clean: bool = True, ignore_clean_errors: bool = True):
+        self.auto_clean = auto_clean
+        self.ignore_clean_errors = ignore_clean_errors
+        self._temp_dir = tempfile.mkdtemp("__temp_fs__")
+        self._cleaned = False
+        super().__init__(self._temp_dir)
+
+    def close(self):
+        if self.auto_clean:
+            self.clean()
+        super().close()
+
+    def clean(self):
+        if self._cleaned:
+            return
+
+        try:
+            shutil.rmtree(self._temp_dir)
+        except Exception as e:
+            if not self.ignore_clean_errors:
+                raise OperationFailed(
+                    f"failed to remove temporary directory: {self._temp_dir!r}"
+                ) from e
+        self._cleaned = True

fontTools/misc/filesystem/_tools.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import typing
+from pathlib import PurePosixPath
+
+from ._errors import DirectoryNotEmpty
+
+if typing.TYPE_CHECKING:
+    from typing import IO
+
+    from ._base import FS
+
+
+def remove_empty(fs: FS, path: str):
+    """Remove all empty parents."""
+    path = PurePosixPath(path)
+    root = PurePosixPath("/")
+    try:
+        while path != root:
+            fs.removedir(path.as_posix())
+            path = path.parent
+    except DirectoryNotEmpty:
+        pass
+
+
+def copy_file_data(src_file: IO, dst_file: IO, chunk_size: int | None = None):
+    """Copy data from one file object to another."""
+    _chunk_size = 1024 * 1024 if chunk_size is None else chunk_size
+    read = src_file.read
+    write = dst_file.write
+    # in iter(callable, sentilel), callable is called until it returns the sentinel;
+    # this allows to copy `chunk_size` bytes at a time.
+    for chunk in iter(lambda: read(_chunk_size) or None, None):
+        write(chunk)