fonttools 4.58.5__py3-none-any.whl → 4.59.0__py3-none-any.whl

fontTools/__init__.py

@@ -3,6 +3,6 @@ from fontTools.misc.loggingTools import configLogger
 
 log = logging.getLogger(__name__)
 
-version = __version__ = "4.58.5"
+version = __version__ = "4.59.0"
 
 __all__ = ["version", "log", "configLogger"]

fontTools/merge/__init__.py

@@ -196,7 +196,7 @@ def main(args=None):
 
     if len(fontfiles) < 1:
         print(
-            "usage: pyftmerge [font1 ... fontN] [--input-file=filelist.txt] [--output-file=merged.ttf] [--import-file=tables.ttx]",
+            "usage: fonttools merge [font1 ... fontN] [--input-file=filelist.txt] [--output-file=merged.ttf] [--import-file=tables.ttx]",
             file=sys.stderr,
         )
         print(

fontTools/misc/filesystem/__init__.py

@@ -0,0 +1,68 @@
+"""Minimal, stdlib-only replacement for [`pyfilesystem2`][1] API for use by `fontTools.ufoLib`.
+
+This package is a partial reimplementation of the `fs` package by Will McGugan, used under the
+MIT license. See LICENSE.external for details.
+
+Note this only exports a **subset** of the `pyfilesystem2` API, in particular the modules,
+classes and functions that are currently used directly by `fontTools.ufoLib`.
+
+It opportunistically tries to import the relevant modules from the upstream `fs` package
+when this is available. Otherwise it falls back to the replacement modules within this package.
+
+As of version 4.59.0, the `fonttools[ufo]` extra no longer requires the `fs` package, thus
+this `fontTools.misc.filesystem` package is used by default.
+
+Client code can either replace `import fs` with `from fontTools.misc import filesystem as fs`
+if that happens to work (no guarantee), or they can continue to use `fs` but they will have
+to specify it as an explicit dependency of their project.
+
+[1]: https://github.com/PyFilesystem/pyfilesystem2
+"""
+
+from __future__ import annotations
+
+try:
+    __import__("fs")
+except ImportError:
+    from . import _base as base
+    from . import _copy as copy
+    from . import _errors as errors
+    from . import _info as info
+    from . import _osfs as osfs
+    from . import _path as path
+    from . import _subfs as subfs
+    from . import _tempfs as tempfs
+    from . import _tools as tools
+    from . import _walk as walk
+    from . import _zipfs as zipfs
+
+    _haveFS = False
+else:
+    import fs.base as base
+    import fs.copy as copy
+    import fs.errors as errors
+    import fs.info as info
+    import fs.osfs as osfs
+    import fs.path as path
+    import fs.subfs as subfs
+    import fs.tempfs as tempfs
+    import fs.tools as tools
+    import fs.walk as walk
+    import fs.zipfs as zipfs
+
+    _haveFS = True
+
+
+__all__ = [
+    "base",
+    "copy",
+    "errors",
+    "info",
+    "osfs",
+    "path",
+    "subfs",
+    "tempfs",
+    "tools",
+    "walk",
+    "zipfs",
+]

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