pathlib-next 0.2.1__tar.gz → 0.3.5__tar.gz

{pathlib_next-0.2.1 → pathlib_next-0.3.5}/.gitignore

@@ -1,4 +1,5 @@
 __pycache__
+.pytest_cache
 /_*
 [a-zA-Z]*__
 [a-zA-Z]*__.*

{pathlib_next-0.2.1 → pathlib_next-0.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pathlib_next
-Version: 0.2.1
+Version: 0.3.5
 Summary: Generic Path Protocol based pathlib
 Project-URL: Homepage, https://github.com/jose-pr/pathlib_next/
 Project-URL: Issues, https://github.com/jose-pr/pathlib_next/issues

{pathlib_next-0.2.1 → pathlib_next-0.3.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pathlib_next"
-version = "0.2.1"
+version = "0.3.5"
 authors = [{ name = "Jose A" }]
 description = "Generic Path Protocol based pathlib"
 readme = "README.md"

{pathlib_next-0.2.1 → pathlib_next-0.3.5}/src/example.py

@@ -3,7 +3,7 @@ import os
 from pathlib_next import Path, glob
 from pathlib_next.mempath import MemPath
 from pathlib_next.uri import Query, Source, Uri, UriPath
-from pathlib_next.utils.sync import PathSyncer
+from pathlib_next.utils.sync import PathAndStat, PathSyncer
 
 rootless = Uri("sftp://root@sftpexample")
 rootless.source
@@ -18,8 +18,6 @@ mempath.write_text("test")
 check = mempath.read_text()
 mempath.parent.rm(recursive=True)
 
-test = list(os.scandir(local))
-print(list(local.iterdir()))
 query = Query({"test": "://$#!1", "test2&": [1, 2]})
 q2 = Query(str(query)).to_dict()
 for name, value in query:
@@ -53,17 +51,17 @@ authkeys = sftp_root / "root/.ssh/authorized_keys"
 print(authkeys.as_posix())
 
 
-def checksum(uri: UriPath):
-    stat = uri.stat()
+def checksum(uri: PathAndStat):
+    stat = uri.stat
     return hash(stat.st_size)
 
 
 syncer = PathSyncer(checksum, remove_missing=False)
-syncer.sync((sftp_root / "root/.ssh"), dest, dry_run=True)
+syncer.sync((sftp_root / "root/.ssh"), dest, dry_run=False)
 
 rocky_repo = UriPath("http://dl.rockylinux.org/pub")
 
-glob_test = UriPath("file:./**/*.py")
+glob_test = UriPath("file:src/**/*.py")
 
 for path in glob.glob(glob_test, recursive=True):
     print(path)

{pathlib_next-0.2.1 → pathlib_next-0.3.5}/src/pathlib_next/mempath.py

@@ -4,16 +4,16 @@ from io import IOBase
 from urllib.parse import quote as _urlquote
 
 from .path import Path, Pathname
-from .utils.stat import FileStat, FileStatLike
+from .utils.stat import FileStat
 
 
 class MemPathBackend(dict): ...
 
 
 class MemBytesIO(io.BytesIO):
-    def __init__(self, initial_bytes: bytearray) -> None:
-        self._bytes = initial_bytes
-        super().__init__(initial_bytes)
+    def __init__(self, dest: bytearray) -> None:
+        self._bytes = dest
+        super().__init__()
 
     def close(self) -> None:
         self.seek(0)
@@ -137,7 +137,7 @@ class MemPath(Path):
             raise IsADirectoryError(self)
         parent.pop(name)
 
-    def stat(self, *, follow_symlinks=True) -> FileStatLike:
+    def stat(self, *, follow_symlinks=True):
         parent, name = self._parent_container()
         if not name:
             return FileStat(is_dir=True)

{pathlib_next-0.2.1 → pathlib_next-0.3.5}/src/pathlib_next/path.py

@@ -6,17 +6,14 @@ operating systems.
 """
 
 import abc as _abc
-import io as _io
 import os as _os
 import re as _re
-import shutil as _shutil
-import stat as _stat
 import typing as _ty
-from pathlib import _ignore_error
 
 from . import utils as _utils
+from .protocols import BinaryOpen, Chmod, Stat
 from .utils import glob as _glob
-from .utils.stat import FileStatLike
+from .utils.stat import FileStat
 
 P = _ty.TypeVar("P", bound="Path")
 PN = _ty.TypeVar("PN", bound="Pathname")
@@ -128,7 +125,7 @@ class Pathname(FsPathLike, _ty.Generic[_P]):
 
     @property
     @_abc.abstractmethod
-    def segments(self) -> _ty.Iterable[str]: ...
+    def segments(self) -> _ty.Sequence[str]: ...
 
     @property
     @_abc.abstractmethod
@@ -140,8 +137,7 @@ class Pathname(FsPathLike, _ty.Generic[_P]):
     def with_name(self, name: str) -> _ty.Self:
         if not self.name:
             raise ValueError("%r has an empty name" % (self,))
-        segments = self.segments[:-1] + [name]
-        return self.with_segments(*segments)
+        return self.with_segments(*self.segments[:-1], name)
 
     def with_stem(self, stem: str) -> _ty.Self:
         """Return a new path with the stem changed."""
@@ -191,8 +187,7 @@ class Pathname(FsPathLike, _ty.Generic[_P]):
 
     @_utils.notimplemented
     def is_absolute(self) -> bool:
-        """True if the path is absolute (has both a root and, if applicable,
-        a drive)."""
+        """True if the path is absolute"""
         ...
 
     def match(self, path_pattern: str | _re.Pattern, *, case_sensitive=None):
@@ -204,7 +199,7 @@ class Pathname(FsPathLike, _ty.Generic[_P]):
         path = str(self)
         if not isinstance(path_pattern, _re.Pattern):
             if isinstance(str, path_pattern):
-                path_pattern = type(self)(path_pattern).__path__()
+                path_pattern = type(self)(path_pattern)
             path_pattern = _glob.compile_pattern(path_pattern, case_sensitive)
         return path_pattern.match(path) is not None
 
@@ -221,7 +216,7 @@ class Pathname(FsPathLike, _ty.Generic[_P]):
 PurePathLike = str | Pathname
 
 
-class Path(Pathname):
+class Path(Pathname, Chmod, Stat, BinaryOpen):
     """Base class for manipulating paths with I/O."""
 
     __slots__ = ()
@@ -233,91 +228,9 @@ class Path(Pathname):
             cls = LocalPath
         return Pathname.__new__(cls)
 
-    @_utils.notimplemented
-    def stat(self, *, follow_symlinks=True) -> FileStatLike: ...
-
-    def lstat(self) -> FileStatLike:
-        """
-        Like stat(), except if the path points to a symlink, the symlink's
-        status information is returned, rather than its target's.
-        """
-        return self.stat(follow_symlinks=False)
-
-    def _st_mode(self, *, follow_symlinks=True):
-        try:
-            return self.stat().st_mode
-        except FileNotFoundError:
-            return None
-        except OSError as e:
-            if not _ignore_error(e):
-                raise
-            return None
-        except ValueError:
-            return None
-
-    # Convenience functions for querying the stat results
-    def exists(self, *, follow_symlinks=True):
-        """
-        Whether this path exists.
-        """
-        return self._st_mode(follow_symlinks=follow_symlinks) != None
-
     def is_hidden(self):
         return self.name.startswith(".")
 
-    def is_dir(self):
-        """
-        Whether this path is a directory.
-        """
-        try:
-            return _stat.S_ISDIR(self._st_mode() or 0)
-        except NotImplementedError:
-            pass
-        try:
-            next(self.iterdir(), None)
-            return True
-        except NotADirectoryError:
-            return False
-
-        raise NotImplementedError("is_dir")
-
-    def is_file(self):
-        """
-        Whether this path is a regular file (also True for symlinks pointing
-        to regular files).
-        """
-        return _stat.S_ISREG(self._st_mode() or 0)
-
-    def is_symlink(self):
-        """
-        Whether this path is a symbolic link.
-        """
-        return _stat.S_ISLNK(self._st_mode(follow_symlinks=True) or 0)
-
-    def is_block_device(self):
-        """
-        Whether this path is a block device.
-        """
-        return _stat.S_ISBLK(self._st_mode() or 0)
-
-    def is_char_device(self):
-        """
-        Whether this path is a character device.
-        """
-        return _stat.S_ISCHR(self._st_mode() or 0)
-
-    def is_fifo(self):
-        """
-        Whether this path is a FIFO.
-        """
-        return _stat.S_ISFIFO(self._st_mode() or 0)
-
-    def is_socket(self):
-        """
-        Whether this path is a socket.
-        """
-        return _stat.S_ISSOCK(self._st_mode() or 0)
-
     @_utils.notimplemented
     def samefile(self, other_path: str | _ty.Self):
         """Return whether other_path is the same or not as this file
@@ -325,72 +238,6 @@ class Path(Pathname):
         """
         ...
 
-    @_utils.notimplemented
-    def _open(
-        self,
-        mode="r",
-        buffering=-1,
-    ) -> _io.IOBase:
-        """
-        All operations should be binary
-        To be used only by UriPath.open() to obtain binary stream
-        """
-        ...
-
-    def open(
-        self,
-        mode="r",
-        buffering=-1,
-        encoding: str = None,
-        errors: str = None,
-        newline: str = None,
-    ) -> _io.IOBase:
-        """
-        Open the file pointed by this path and return a file object, as
-        the built-in open() function does.
-        """
-        fh = self._open(mode.replace("b", ""), buffering)
-        if "b" not in mode:
-            encoding = _io.text_encoding(encoding)
-            fh = _io.TextIOWrapper(fh, encoding, errors, newline)
-        return fh
-
-    def read_bytes(self) -> bytes:
-        """
-        Open the file in bytes mode, read it, and close the file.
-        """
-        with self.open(mode="rb") as f:
-            return f.read()
-
-    def read_text(self, encoding: str = None, errors: str = None) -> str:
-        """
-        Open the file in text mode, read it, and close the file.
-        """
-        with self.open(mode="r", encoding=encoding, errors=errors) as f:
-            return f.read()
-
-    def write_bytes(self, data: bytes):
-        """
-        Open the file in bytes mode, write to it, and close the file.
-        """
-        # type-check for the buffer interface before truncating the file
-        view = memoryview(data)
-        with self.open(mode="wb") as f:
-            return f.write(view)
-
-    def write_text(
-        self, data: str, encoding: str = None, errors: str = None, newline: str = None
-    ):
-        """
-        Open the file in text mode, write to it, and close the file.
-        """
-        if not isinstance(data, str):
-            raise TypeError("data must be str, not %s" % data.__class__.__name__)
-        with self.open(
-            mode="w", encoding=encoding, errors=errors, newline=newline
-        ) as f:
-            return f.write(data)
-
     def __iter__(self):
         return self.iterdir()
 
@@ -448,13 +295,13 @@ class Path(Pathname):
             filenames: "list[str]" = []
             for entry in scandir_it:
                 try:
-                    is_symlink = entry.is_symlink()
-                    is_dir = entry.is_dir()
+                    stat = FileStat.from_path(entry, follow_symlink=follow_symlinks)
+                    is_dir = stat.is_dir()
                 except OSError:
                     # Carried over from os.path.isdir().
                     is_dir = False
 
-                if is_dir and (follow_symlinks or not is_symlink):
+                if is_dir:
                     dirnames.append(entry.name)
                 else:
                     filenames.append(entry.name)
@@ -494,28 +341,12 @@ class Path(Pathname):
         except FileNotFoundError:
             if not parents or self.parent == self:
                 raise
-            self.parent.mkdir(parents=True, exist_ok=True)
-            self.mkdir(mode, parents=False, exist_ok=exist_ok)
-        except OSError:
-            # Cannot rely on checking for EEXIST, since the operating system
-            # could give priority to other errors like EACCES or EROFS
+            self.parent.mkdir(parents=True, exist_ok=False)
+            self.mkdir(mode, parents=False, exist_ok=False)
+        except FileExistsError:
             if not exist_ok or not self.is_dir():
                 raise
 
-    @_utils.notimplemented
-    def chmod(self, mode: int, *, follow_symlinks=True):
-        """
-        Change the permissions of the path, like os.chmod().
-        """
-        ...
-
-    def lchmod(self, mode: int):
-        """
-        Like chmod(), except if the path points to a symlink, the symlink's
-        permissions are changed, rather than its target's.
-        """
-        self.chmod(mode, follow_symlinks=False)
-
     @_utils.notimplemented
     def unlink(self, missing_ok=False):
         """
@@ -540,11 +371,11 @@ class Path(Pathname):
             ignore_error if not callable(ignore_error) else ignore_error
         )
         try:
-            if not self.exists():
-                if missing_ok:
-                    return
-                raise FileNotFoundError(self)
-            if self.is_dir():
+            stat = FileStat.from_path(self)
+            if stat is None:
+                if not missing_ok:
+                    raise FileNotFoundError(self)
+            elif stat.is_dir():
                 if recursive:
                     for child in self.iterdir():
                         child.rm(recursive=recursive, ignore_error=ignore_error)
@@ -570,9 +401,7 @@ class Path(Pathname):
                 target.unlink()
             else:
                 raise FileExistsError(target)
-
-        with target.open("wb") as output, src.open("rb") as input:
-            _shutil.copyfileobj(input, output)
+        BinaryOpen.copy(src, target)
 
         try:
             stat = src.stat()
@@ -598,7 +427,7 @@ class Path(Pathname):
         except NotImplementedError:
             pass
 
-        src.copy(target)
+        BinaryOpen.copy(src, target)
         src.unlink()
 
 

pathlib_next-0.3.5/src/pathlib_next/protocols/__init__.py

@@ -0,0 +1,2 @@
+from .fs import *
+from .io import *

pathlib_next-0.3.5/src/pathlib_next/protocols/fs.py

@@ -0,0 +1,117 @@
+import abc as _abc
+import stat as _stat
+import typing as _ty
+
+from .. import utils as _utils
+
+
+class FileStatLike(_ty.Protocol):
+    """Minimum properties stat like object shouuld provide"""
+
+    __slots__ = ()
+
+    @property
+    @_abc.abstractmethod
+    def st_mode(self) -> int: ...
+    @property
+    @_abc.abstractmethod
+    def st_size(self) -> int: ...
+    @property
+    @_abc.abstractmethod
+    def st_mtime(self) -> int: ...
+
+
+class Stat(_ty.Protocol):
+    """Any object that can implement Stat and utilities functions based on it"""
+
+    __slots__ = ()
+
+    @_utils.notimplemented
+    def stat(self, *, follow_symlinks=True) -> FileStatLike: ...
+
+    def lstat(self) -> FileStatLike:
+        """
+        Like stat(), except if the path points to a symlink, the symlink's
+        status information is returned, rather than its target's.
+        """
+        return self.stat(follow_symlinks=False)
+
+    def _st_mode(self, *, follow_symlinks=True):
+        """
+        Utility function only for internal use if this object,
+        not required nor to be expected in any implementations of the protocol
+        """
+        try:
+            return self.stat().st_mode
+        except FileNotFoundError:
+            return None
+        except ValueError:
+            return None
+
+    # Convenience functions for querying the stat results
+    def exists(self, *, follow_symlinks=True):
+        """
+        Whether this path exists.
+        """
+        return self._st_mode(follow_symlinks=follow_symlinks) != None
+
+    def is_dir(self):
+        """
+        Whether this path is a directory.
+        """
+        return _stat.S_ISDIR(self._st_mode() or 0)
+
+    def is_file(self):
+        """
+        Whether this path is a regular file (also True for symlinks pointing
+        to regular files).
+        """
+        return _stat.S_ISREG(self._st_mode() or 0)
+
+    def is_symlink(self):
+        """
+        Whether this path is a symbolic link.
+        """
+        return _stat.S_ISLNK(self._st_mode(follow_symlinks=False) or 0)
+
+    def is_block_device(self):
+        """
+        Whether this path is a block device.
+        """
+        return _stat.S_ISBLK(self._st_mode() or 0)
+
+    def is_char_device(self):
+        """
+        Whether this path is a character device.
+        """
+        return _stat.S_ISCHR(self._st_mode() or 0)
+
+    def is_fifo(self):
+        """
+        Whether this path is a FIFO.
+        """
+        return _stat.S_ISFIFO(self._st_mode() or 0)
+
+    def is_socket(self):
+        """
+        Whether this path is a socket.
+        """
+        return _stat.S_ISSOCK(self._st_mode() or 0)
+
+
+class Chmod(_ty.Protocol):
+    __slots__ = ()
+
+    @_utils.notimplemented
+    def chmod(self, mode: int, *, follow_symlinks=True):
+        """
+        Change the permissions of the path, like os.chmod().
+        """
+        ...
+
+    def lchmod(self, mode: int):
+        """
+        Like chmod(), except if the path points to a symlink, the symlink's
+        permissions are changed, rather than its target's.
+        """
+        self.chmod(mode, follow_symlinks=False)

pathlib_next-0.3.5/src/pathlib_next/protocols/io.py

@@ -0,0 +1,80 @@
+import io as _io
+import shutil as _shutil
+import typing as _ty
+
+from .. import utils as _utils
+
+
+class BinaryOpen(_ty.Protocol):
+    """Protocol for objects that support open->io.IoBase"""
+
+    __slots__ = ()
+
+    @_utils.notimplemented
+    def _open(
+        self,
+        mode="r",
+        buffering=-1,
+    ) -> _io.IOBase:
+        """
+        All operations should be binary
+        To be used only by open() to obtain binary stream to provide implementations for all methods
+        """
+        ...
+
+    def open(
+        self,
+        mode="r",
+        buffering=-1,
+        encoding: str = None,
+        errors: str = None,
+        newline: str = None,
+    ) -> _io.IOBase:
+        """
+        Open the a handle to an object that implement io.IOBase
+        """
+        fh = self._open(mode.replace("b", ""), buffering)
+        if "b" not in mode:
+            encoding = _io.text_encoding(encoding)
+            fh = _io.TextIOWrapper(fh, encoding, errors, newline)
+        return fh
+
+    def read_bytes(self) -> bytes:
+        """
+        Open in bytes mode, read it, and close the file.
+        """
+        with self.open(mode="rb") as f:
+            return f.read()
+
+    def read_text(self, encoding: str = None, errors: str = None) -> str:
+        """
+        Open in text mode, read it, and close the file.
+        """
+        with self.open(mode="r", encoding=encoding, errors=errors) as f:
+            return f.read()
+
+    def write_bytes(self, data: bytes):
+        """
+        Open in bytes mode, write to it, and close the file.
+        """
+        # type-check for the buffer interface before truncating the file
+        view = memoryview(data)
+        with self.open(mode="wb") as f:
+            return f.write(view)
+
+    def write_text(
+        self, data: str, encoding: str = None, errors: str = None, newline: str = None
+    ):
+        """
+        Open in text mode, write to it, and close the file.
+        """
+        if not isinstance(data, str):
+            raise TypeError("data must be str, not %s" % data.__class__.__name__)
+        with self.open(
+            mode="w", encoding=encoding, errors=errors, newline=newline
+        ) as f:
+            return f.write(data)
+
+    def copy(self, target: "BinaryOpen"):
+        with target.open("wb") as output, self.open("rb") as input:
+            _shutil.copyfileobj(input, output)

{pathlib_next-0.2.1 → pathlib_next-0.3.5}/src/pathlib_next/uri/schemes/http.py

@@ -6,6 +6,9 @@ import bs4 as _bs4
 import requests as _req
 from htmllistparse import parse as _htmlparse
 
+if _ty.TYPE_CHECKING:
+    from urllib3.response import HTTPResponse
+
 from ... import utils as _utils
 from ...utils.stat import FileStat
 from .. import UriPath
@@ -119,10 +122,12 @@ class HttpPath(UriPath):
             raise NotImplementedError(mode)
         buffer_size = _io.DEFAULT_BUFFER_SIZE if buffering < 0 else buffering
         req = self.backend.request("GET", self.as_uri(), stream=True)
+        resp: "HTTPResponse" = req.raw
+        resp.auto_close = False
         return (
-            req.raw
+            resp
             if buffer_size == 0
-            else _io.BufferedReader(req.raw, buffer_size=buffer_size)
+            else _io.BufferedReader(resp, buffer_size=buffer_size)
         )
 
     def is_dir(self):

{pathlib_next-0.2.1 → pathlib_next-0.3.5}/src/pathlib_next/utils/stat.py

@@ -3,6 +3,7 @@ import stat as _stat
 import typing as _ty
 
 from .. import utils as _utils
+from ..protocols import FileStatLike as _FStat
 
 if _ty.TYPE_CHECKING:
     from os import stat_result as _os_stat
@@ -10,21 +11,7 @@ if _ty.TYPE_CHECKING:
     from ..path import Path
 
 
-class FileStatLike(_ty.Protocol):
-    __slots__ = ()
-
-    @property
-    @_abc.abstractmethod
-    def st_mode(self) -> int: ...
-    @property
-    @_abc.abstractmethod
-    def st_size(self) -> int: ...
-    @property
-    @_abc.abstractmethod
-    def st_mtime(self) -> int: ...
-
-
-class FileStat(FileStatLike):
+class FileStat(_FStat):
     __slots__ = (
         "st_mode",
         "st_nlink",

pathlib_next-0.3.5/src/pathlib_next/utils/sync.py

@@ -0,0 +1,258 @@
+import enum as _enum
+import typing as _ty
+
+from ..path import Path
+from ..utils.stat import FileStat
+
+
+class SyncEvent(_enum.Enum):
+    Copy = 1
+    RemovedMissing = 2
+    TypeMismatch = 6
+    SyncStart = 5
+    Synced = 3
+    CreatedDirectory = 4
+    CheckTargetChild = _enum.auto()
+    CheckTargetChildren = _enum.auto()
+    SyncChild = _enum.auto()
+    SyncChildren = _enum.auto()
+
+
+class PathAndStat(object):
+    __slots__ = ("_path", "_stat")
+
+    def __init__(self, path: Path, *, follow_symlink=None) -> None:
+        self._path = path
+        self.refresh(follow_symlink)
+
+    def __str__(self) -> str:
+        return str(self.path)
+
+    def __repr__(self) -> str:
+        return str((self.path, self._stat))
+
+    @property
+    def path(self):
+        return self._path
+
+    @property
+    def stat(self):
+        return self._stat
+
+    def exists(self):
+        return self.stat != None
+
+    def refresh(self, follow_symlink: bool):
+        self._stat = FileStat.from_path(self.path, follow_symlink=follow_symlink)
+
+    def __getattr__(self, name: str):
+        if name.startswith("is_"):
+            if self.stat:
+                return getattr(self.stat, name)
+            else:
+                return lambda *args, **kwargs: False
+
+
+if _ty.TYPE_CHECKING:
+
+    class PathAndStat(PathAndStat, FileStat): ...
+
+
+class _OnPathSyncerError(_ty.Protocol):
+    def __call__(
+        self,
+        error: Exception,
+        source: PathAndStat,
+        target: PathAndStat,
+        event: SyncEvent,
+    ) -> bool: ...
+
+
+class PathSyncer(object):
+    __slots__ = (
+        "checksum",
+        "_hook",
+        "remove_missing",
+        "follow_symlinks",
+        "ignore_error",
+    )
+    EVENT_LOG_FORMAT = "[{event}] Source:{source} Target:{target} DryRun:{dry_run}"
+
+    def __init__(
+        self,
+        checksum: _ty.Callable[[PathAndStat], int],
+        /,
+        remove_missing: bool = False,
+        follow_symlinks: bool = True,
+        hook: _ty.Callable[[PathAndStat, PathAndStat, SyncEvent, bool], None] = None,
+        ignore_error: _OnPathSyncerError | bool = False,
+    ) -> None:
+        self.checksum = checksum
+        self.remove_missing = remove_missing
+        self._hook = hook
+        self.follow_symlinks = follow_symlinks
+        if not callable(ignore_error):
+            _ignore_error = lambda *args, **kwargs: bool(ignore_error)
+        else:
+            _ignore_error = ignore_error
+        self.ignore_error = _ty.cast(_OnPathSyncerError, _ignore_error)
+
+    def log(self, msg: str, **kwargs: str):
+        print(msg.format_map(kwargs))
+
+    def hook(
+        self,
+        source: PathAndStat,
+        target: PathAndStat,
+        event: SyncEvent,
+        dry_run: bool,
+        do: _ty.Callable[[], None] = None,
+    ):
+        if not dry_run and do:
+            try:
+                do()
+            except Exception as e:
+                if self.ignore_error(e, source, target, event):
+                    return e
+                raise
+        if self._hook:
+            self._hook(source, target, event, dry_run)
+        self.log(
+            self.EVENT_LOG_FORMAT,
+            event=event,
+            source=source,
+            target=target,
+            dry_run=dry_run,
+        )
+
+    def sync(
+        self,
+        source: Path | PathAndStat,
+        target: Path | PathAndStat,
+        /,
+        dry_run: bool = False,
+        ignore_error: (
+            bool | _ty.Callable[[Exception, PathAndStat, PathAndStat], None]
+        ) = False,
+    ):
+        checksum = self.checksum
+
+        def start():
+            nonlocal source, target
+            source = (
+                PathAndStat(source, follow_symlink=self.follow_symlinks)
+                if not isinstance(source, PathAndStat)
+                else source
+            )
+            target = (
+                PathAndStat(target, follow_symlink=self.follow_symlinks)
+                if not isinstance(target, PathAndStat)
+                else target
+            )
+
+        if self.hook(source, target, SyncEvent.SyncStart, False, start):
+            return
+
+        if not source.exists():
+            if self.remove_missing:
+                if self.hook(
+                    source,
+                    target,
+                    SyncEvent.RemovedMissing,
+                    dry_run,
+                    lambda: target.path.rm(recursive=True, missing_ok=True),
+                ):
+                    return
+        elif source.is_symlink():
+            error = NotImplementedError("symlink sync not implemented yet")
+            if not ignore_error(error, source, target, None):
+                raise error
+            return
+        elif source.is_file():
+            synced = False
+            if target.is_file():
+                if checksum(target) == checksum(source):
+                    synced = True
+            if not synced:
+
+                def copy():
+                    if target.is_file() or target.is_symlink():
+                        target.path.unlink()
+                    else:
+                        if target.exists():
+                            target.path.rm(recursive=target.is_dir())
+                    source.path.copy(target.path)
+
+                if self.hook(source, target, SyncEvent.Copy, dry_run, copy):
+                    return
+        else:
+            if target.is_file():
+                if self.hook(
+                    source,
+                    target,
+                    SyncEvent.TypeMismatch,
+                    dry_run,
+                    lambda: target.path.unlink(),
+                ):
+                    return
+
+                target._stat = None
+
+            if not target.exists():
+                if self.hook(
+                    source,
+                    target,
+                    SyncEvent.CreatedDirectory,
+                    dry_run,
+                    lambda: target.path.mkdir(),
+                ):
+                    return
+
+            if self.remove_missing:
+
+                def checkchildren():
+                    for child in target.path.iterdir():
+
+                        def checkchild():
+                            if not (source.path / child.name).exists():
+                                self.hook(
+                                    source,
+                                    target,
+                                    SyncEvent.RemovedMissing,
+                                    dry_run,
+                                    lambda: child.rm(recursive=True),
+                                )
+
+                        self.hook(
+                            source,
+                            target,
+                            SyncEvent.CheckTargetChild,
+                            False,
+                            checkchild,
+                        )
+
+                self.hook(
+                    source,
+                    target,
+                    SyncEvent.CheckTargetChildren,
+                    False,
+                    checkchildren,
+                )
+
+            def sync_children():
+                for child in source.path.iterdir():
+                    self.hook(
+                        source,
+                        target,
+                        SyncEvent.SyncChild,
+                        False,
+                        lambda: self.sync(
+                            child,
+                            target.path / (child.name or child.parent.name),
+                            dry_run,
+                        ),
+                    )
+
+            self.hook(source, target, SyncEvent.SyncChildren, False, sync_children)
+
+        self.hook(source, target, SyncEvent.Synced, dry_run)

pathlib_next-0.2.1/src/pathlib_next/utils/sync.py

@@ -1,104 +0,0 @@
-import enum as _enum
-import typing as _ty
-
-from ..path import Path
-from ..utils.stat import FileStat
-
-
-class SyncEvent(_enum.Enum):
-    Copy = 1
-    RemovedMissing = 2
-    SyncStart = 5
-    Synced = 3
-    CreatedDirectory = 4
-
-
-class PathSyncer(object):
-    __slots__ = ("checksum", "_hook", "remove_missing", "follow_symlinks")
-    EVENT_LOG_FORMAT = "[{event}] Source:{source} Target:{target} DryRun:{dry_run}"
-
-    def __init__(
-        self,
-        checksum: _ty.Callable[[Path], int],
-        /,
-        remove_missing: bool = False,
-        follow_symlinks: bool = True,
-        hook: _ty.Callable[[Path, Path, SyncEvent, bool], None] = None,
-    ) -> None:
-        self.checksum = checksum
-        self.remove_missing = remove_missing
-        self._hook = hook
-        self.follow_symlinks = follow_symlinks
-
-    def log(self, msg: str, **kwargs: str):
-        print(msg.format_map(kwargs))
-
-    def hook(
-        self,
-        source: Path,
-        target: Path,
-        event: SyncEvent,
-        dry_run: bool,
-    ):
-        if self._hook:
-            self._hook(source, target, event, dry_run)
-        self.log(
-            self.EVENT_LOG_FORMAT,
-            event=event,
-            source=source,
-            target=target,
-            dry_run=dry_run,
-        )
-
-    def sync(self, source: Path, target: Path, /, dry_run: bool = False):
-        checksum = self.checksum
-        self.hook(source, target, SyncEvent.SyncStart, dry_run)
-
-        src_stat = FileStat.from_path(source, follow_symlink=self.follow_symlinks)
-        tgt_stat = FileStat.from_path(target, follow_symlink=self.follow_symlinks)
-
-        if src_stat is None:
-            if self.remove_missing:
-                if not dry_run:
-                    target.rm(recursive=True, missing_ok=True)
-                self.hook(source, target, SyncEvent.RemovedMissing, dry_run)
-        elif src_stat.is_symlink():
-            raise NotImplementedError("symlink sync not implemented yet")
-        elif src_stat.is_file():
-            synced = False
-            if tgt_stat and tgt_stat.is_file():
-                if checksum(target) == checksum(source):
-                    synced = True
-            if not synced:
-                if not dry_run:
-                    if tgt_stat:
-                        if tgt_stat.is_file() or tgt_stat.is_symlink():
-                            target.unlink()
-                        else:
-                            if target:
-                                target.rm(recursive=tgt_stat.is_dir())
-                    source.copy(target)
-                self.hook(source, target, SyncEvent.Copy, dry_run)
-        else:
-            t_exists = tgt_stat != None
-            if tgt_stat and tgt_stat.is_file():
-                if not dry_run:
-                    target.unlink()
-                t_exists = False
-
-            if not t_exists:
-                if not dry_run:
-                    target.mkdir()
-                self.hook(source, target, SyncEvent.CreatedDirectory, dry_run)
-
-            if self.remove_missing:
-                for child in target.iterdir():
-                    if not (source / child.name).exists():
-                        if not dry_run:
-                            child.rm(recursive=True)
-                        self.hook(source, target, SyncEvent.RemovedMissing, dry_run)
-
-            for child in source.iterdir():
-                self.sync(child, target / child.name, dry_run)
-
-        self.hook(source, target, SyncEvent.Synced, dry_run)