kisstdlib 0.0.9__tar.gz → 0.0.11__tar.gz

{kisstdlib-0.0.9 → kisstdlib-0.0.11}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: kisstdlib
-Version: 0.0.9
+Version: 0.0.11
 Summary: System programming with conceptually and algebraically simple primitives.
 Author-email: Jan Malakhovski <oxij@oxij.org>
 Project-URL: Homepage, https://oxij.org/software/kisstdlib/

{kisstdlib-0.0.9 → kisstdlib-0.0.11}/kisstdlib/__init__.py

@@ -36,11 +36,15 @@ from .io.stdio import *
 from .logging_ext import *
 from .signal_ext import *
 
+from .fs import setup_fs as _setup_fs
+
 
 def setup_kisstdlib(
     prog: str | None = None,
+    *,
     do_setup_stdio: bool = True,
-    signals: list[str] | None = None,
+    do_setup_delay_signals: bool = True,
+    do_setup_fs: bool = True,
     **kwargs: _t.Any,
 ) -> tuple[LogCounter, ANSILogHandler]:
     """Run all `setup_*` functions of all other `kisstdlib.*` modules and setup
@@ -50,9 +54,12 @@ def setup_kisstdlib(
         prog = _op.basename(_sys.argv[0])
     if do_setup_stdio:
         setup_stdio()
-    res = setup_logging(prog, **kwargs)
     setup_delay_signal_messages(prog + ": ")
-    setup_delay_signals(signals)
+    if do_setup_delay_signals:
+        setup_delay_signals()
+    if do_setup_fs:
+        _setup_fs(prog)
+    res = setup_logging(prog, **kwargs)
     return res
 
 
@@ -102,9 +109,18 @@ def run_kisstdlib_main(
         for be in flat_exceptions(excs):
             critical(gettext("Uncaught exception: %s"), str(be), exc_info=be)
 
-    logger.flush()
-    stdout.flush()
-    stderr.flush()
+    try:
+        logger.flush()
+    except BrokenPipeError:
+        pass
+    try:
+        stdout.flush()
+    except BrokenPipeError:
+        pass
+    try:
+        stderr.flush()
+    except BrokenPipeError:
+        pass
 
     num_warnings = counter.warnings
     num_errors = counter.errors

{kisstdlib-0.0.9 → kisstdlib-0.0.11}/kisstdlib/argparse_ext.py

@@ -159,16 +159,16 @@ class MarkdownBetterHelpFormatter(BetterHelpFormatter):
             return join(["\n", heading, item_help, "\n"])
 
 
-class OptionallyMarkdownHelpAction(Action):
+class _OptionallyMarkdownHelpAction(Action):
     def __init__(
         self,
         option_strings: list[str],
         dest: str = SUPPRESS,
         default: _t.Any = SUPPRESS,
-        help: str | None = None,  # pylint: disable=redefined-builtin
+        **kwargs: _t.Any,
     ) -> None:
         super().__init__(
-            option_strings=option_strings, dest=dest, default=default, nargs=0, help=help
+            option_strings=option_strings, dest=dest, default=default, nargs=0, **kwargs
         )
 
     def show_help(self, parser: "BetterArgumentParser", namespace: Namespace) -> None:
@@ -225,6 +225,8 @@ class BetterArgumentParser(ArgumentParser):
             **kwargs,
         )
 
+        self.register("action", "help_omd", _OptionallyMarkdownHelpAction)
+
         self.add_version = add_version
         self.add_help = add_help
         self.additional_sections = additional_sections
@@ -249,12 +251,10 @@ class BetterArgumentParser(ArgumentParser):
             )
 
         if add_help:
-            self.register("action", "help", OptionallyMarkdownHelpAction)
-
             self.add_argument(
                 default_prefix + "h",
                 default_prefix * 2 + "help",
-                action="help",
+                action="help_omd",
                 default=SUPPRESS,
                 help=_gettext("show this help message and exit"),
             )

{kisstdlib-0.0.9 → kisstdlib-0.0.11}/kisstdlib/base.py

@@ -30,6 +30,7 @@ import traceback as _traceback
 import typing as _t
 
 from decimal import Decimal
+from functools import partial, partialmethod  # pylint: disable=unused-import
 
 
 ### Primitive types

{kisstdlib-0.0.9 → kisstdlib-0.0.11}/kisstdlib/fs.py

@@ -36,41 +36,39 @@ import stat as _stat
 import sys as _sys
 import typing as _t
 
+from os import fsencode, fsdecode
+
 from .base import POSIX as _POSIX, identity as _identity
-from .string_ext import escaper as _escaper
 from .io.base import *
+from .string_ext import escape_path as _escape_path
 from .time import Timestamp as _Timestamp
 
 sep = _op.sep
 sepb = _os.fsencode(_op.sep)
 
 
-def fsdecode_maybe(x: str | bytes) -> str:
-    """Apply `os.fsdecode` if `bytes`."""
-    if isinstance(x, bytes):
-        return _os.fsdecode(x)
-    return x
-
-
-def fsencode_maybe(x: str | bytes) -> bytes:
-    """Apply `os.fsencode` if `str`."""
-    if isinstance(x, str):
-        return _os.fsencode(x)
-    return x
-
-
-def dirname_dot(x: _t.AnyStr) -> tuple[_t.AnyStr, bool]:
+def dirname_dot(path: _t.AnyStr) -> tuple[_t.AnyStr, bool]:
     """Apply `os.path.dirname` to the given argument, but if it's empty, return "." instead.
     The second element of the tuple is `False` if the above replacement was performed, `True` otherwise.
     """
-    x = _os.path.dirname(x)
-    if isinstance(x, bytes):
-        if x == b"":
+    path = _os.path.dirname(path)
+    if isinstance(path, bytes):
+        if path == b"":
             return b".", False
-        return x, True
-    if x == "":
+        return path, True
+    if path == "":
         return ".", False
-    return x, True
+    return path, True
+
+
+def realdir(path: _t.AnyStr, strict: bool = False) -> _t.AnyStr:
+    """Apply `os.path.realpath` to the `dirname` part of `path`.
+
+    Essentially, this returns the canonical path of the inode the `path` points to, even when that
+    inode is a symlink.
+    """
+    dn, bn = _op.split(path)
+    return _op.join(_op.realpath(dn, strict=strict), bn)
 
 
 def read_file_maybe(path: str | bytes) -> bytes | None:
@@ -100,8 +98,8 @@ def same_file_data(path1: str | bytes, path2: str | bytes) -> bool:
 
 def same_symlink_data(path1: str | bytes, path2: str | bytes) -> bool:
     """Check if two given symlinks have exactly the same content."""
-    a = _os.readlink(fsencode_maybe(path1))
-    b = _os.readlink(fsencode_maybe(path2))
+    a = _os.readlink(fsencode(path1))
+    b = _os.readlink(fsencode(path2))
     return a == b
 
 
@@ -204,9 +202,9 @@ def iter_subtree(
             fstat = _os.stat(path, follow_symlinks=follow_symlinks)
         except OSError as exc:
             if handle_error is not None:
-                eno = exc.errno
+                eno = exc.errno or 0
                 handle_error(
-                    "failed to stat `%s`: [Errno %d, %s] %s: %s",
+                    "failed to `stat`: [Errno %d, %s] %s: %s",
                     eno,
                     _errno.errorcode.get(eno, "?"),
                     _os.strerror(eno),
@@ -230,7 +228,7 @@ def iter_subtree(
         scandir_it = _os.scandir(path)
     except OSError as exc:
         if handle_error is not None:
-            eno = exc.errno
+            eno = exc.errno or 0
             handle_error(
                 "failed to `scandir`: [Errno %d, %s] %s: %s",
                 eno,
@@ -252,7 +250,7 @@ def iter_subtree(
                 break
             except OSError as exc:
                 if handle_error is not None:
-                    eno = exc.errno
+                    eno = exc.errno or 0
                     handle_error(
                         "failed in `scandir`: [Errno %d, %s] %s: %s",
                         eno,
@@ -267,7 +265,7 @@ def iter_subtree(
                     entry_is_dir = entry.is_dir(follow_symlinks=follow_symlinks)
                 except OSError as exc:
                     if handle_error is not None:
-                        eno = exc.errno
+                        eno = exc.errno or 0
                         handle_error(
                             "failed to `stat`: [Errno %d, %s] %s: %s",
                             eno,
@@ -410,12 +408,12 @@ def describe_forest(
     """Produce a simple `find .`+`stat`-like description of walks of given `paths`.
     See `describe-forest` script for more info.
     """
-    escape: _t.Callable[[str], str] = _identity if literal else _escaper("\\").escape  # type: ignore
+    escape: _t.Callable[[str], str] = _identity if literal else _escape_path
     seen: dict[tuple[int, int], tuple[_t.AnyStr, int, str]] = {}
     for i, dirpath in enumerate(paths):
         for fpath, _eps, _edir in iter_subtree(dirpath, follow_symlinks=follow_symlinks):
             abs_path = _op.abspath(fpath)
-            rpath = fsdecode_maybe(_op.relpath(fpath, dirpath))
+            rpath = fsdecode(_op.relpath(fpath, dirpath))
             epath: str
             if numbers is False or numbers is None and len(paths) == 1:
                 epath = escape(rpath)
@@ -434,7 +432,7 @@ def describe_forest(
                 if relative_hardlinks and hi == i:
                     # within the same `dirpath`
                     dirname = _op.dirname(abs_path)
-                    target = escape(fsdecode_maybe(_op.relpath(habs_path, dirname)))
+                    target = escape(fsdecode(_op.relpath(habs_path, dirname)))
                     yield [epath, "ref", "=>", target]
                 else:
                     yield [epath, "ref", "==>", hepath]
@@ -464,7 +462,7 @@ def describe_forest(
                     sha256 = sha256[:hash_length]
                 yield [epath, "reg"] + emode + emtime + esize + ["sha256", sha256]  # fmt: skip
             elif _stat.S_ISLNK(stat.st_mode):
-                esymlink = escape(fsdecode_maybe(_os.readlink(abs_path)))
+                esymlink = escape(fsdecode(_os.readlink(abs_path)))
                 yield [epath, "sym"] + emode + emtime + ["->", esymlink]
             else:
                 yield [epath, "???"] + emode + emtime + esize
@@ -588,6 +586,7 @@ class DeferredSync(_t.Generic[_t.AnyStr]):
     Doing this can improve disk performance considerably.
     """
 
+    defer: bool
     tmp_file: set[_t.AnyStr]
     unlink_file: set[_t.AnyStr]
     fsync_file: set[_t.AnyStr]
@@ -598,7 +597,8 @@ class DeferredSync(_t.Generic[_t.AnyStr]):
     # if all of the above succeed, also do these
     _after: _t.Optional["DeferredSync[_t.AnyStr]"]
 
-    def __init__(self) -> None:
+    def __init__(self, defer: bool) -> None:
+        self.defer = defer
         self.reset()
 
     def reset(self) -> None:
@@ -628,14 +628,14 @@ after="""
     @property
     def after(self) -> "DeferredSync[_t.AnyStr]":
         if self._after is None:
-            self._after = DeferredSync()
+            self._after = DeferredSync(self.defer)
         return self._after
 
     def copy(self) -> "DeferredSync[_t.AnyStr]":
         """Return a shallow copy of this object (elements describing operations are not
         copied, only the structure is).
         """
-        res: DeferredSync[_t.AnyStr] = DeferredSync()
+        res: DeferredSync[_t.AnyStr] = DeferredSync(self.defer)
         res.tmp_file = set(self.tmp_file)
         res.unlink_file = set(self.unlink_file)
         res.fsync_file = set(self.fsync_file)
@@ -654,20 +654,18 @@ after="""
             unlink_many(self.tmp_file)
         self.reset()
 
-    def commit(
-        self, strict: bool = True, simulate: list[list[str]] | None = None
-    ) -> list[Exception]:
+    def sync(self, strict: bool = True, simulate: list[list[str]] | None = None) -> list[Exception]:
         """Perform all deferred operations and return a list of raised exceptions.
 
         Operations that fail will be left sitting in the corresponding fields.
 
         With `simulate` argument set, this function instead simulates the
-        `commit` and writes the log of things it would do into that argument.
+        `sync` and writes the log of things it would do into that argument.
         """
         exceptions: list[Exception] = []
 
         if simulate is not None:
-            simulate += [["unlink", fsdecode_maybe(f)] for f in sorted(self.unlink_file)]
+            simulate += [["unlink", fsdecode(f)] for f in sorted(self.unlink_file)]
             self.unlink_file = set()
         elif self.unlink_file:
             self.unlink_file = set(unlink_many(sorted(self.unlink_file), exceptions))
@@ -689,7 +687,7 @@ after="""
 
         while self.fsync_file or self.fsync_dir or self.fsync_dir2 or self.rename_file:
             if simulate is not None:
-                simulate += [["fsync", fsdecode_maybe(f)] for f in sorted(self.fsync_file)]
+                simulate += [["fsync", fsdecode(f)] for f in sorted(self.fsync_file)]
                 self.fsync_file = set()
             elif self.fsync_file:
                 fsync_file_left.update(fsync_many_files(sorted(self.fsync_file), 0, exceptions))
@@ -723,7 +721,7 @@ after="""
 
                     try:
                         if simulate is not None:
-                            simulate.append(["replace" if allow_overwrites else "rename", fsdecode_maybe(src_path), fsdecode_maybe(dst_path)])  # fmt: skip
+                            simulate.append(["replace" if allow_overwrites else "rename", fsdecode(src_path), fsdecode(dst_path)])  # fmt: skip
                         else:
                             rename(src_path, dst_path, allow_overwrites, makedirs=False, dst_dir=dst_dir)  # fmt: skip
                     except Exception as exc:
@@ -751,14 +749,14 @@ after="""
                         return exceptions
 
             if simulate is not None:
-                simulate += [["fsync_win", fsdecode_maybe(f)] for f in sorted(self.fsync_file)]
+                simulate += [["fsync_win", fsdecode(f)] for f in sorted(self.fsync_file)]
                 self.fsync_file = set()
             elif self.fsync_file:
                 fsync_file_left.update(fsync_many_files(sorted(self.fsync_file), 0, exceptions))
                 self.fsync_file = set()
 
             if simulate is not None:
-                simulate += [["fsync_dir", fsdecode_maybe(f)] for f in sorted(self.fsync_dir)]
+                simulate += [["fsync_dir", fsdecode(f)] for f in sorted(self.fsync_dir)]
                 self.fsync_dir = set()
             elif self.fsync_dir:
                 if _POSIX:
@@ -766,7 +764,7 @@ after="""
                 self.fsync_dir = set()
 
             if simulate is not None:
-                simulate += [["fsync_dir", fsdecode_maybe(f)] for f in sorted(self.fsync_dir2)]
+                simulate += [["fsync_dir", fsdecode(f)] for f in sorted(self.fsync_dir2)]
                 self.fsync_dir2 = set()
             elif self.fsync_dir2:
                 if _POSIX:
@@ -785,7 +783,7 @@ after="""
             return exceptions
 
         if self._after is not None:
-            excs = self._after.commit(strict, simulate)
+            excs = self._after.sync(strict, simulate)
             if len(excs) > 0:
                 exceptions += excs
             else:
@@ -793,12 +791,12 @@ after="""
 
         return exceptions
 
-    def finish(self, strict: bool = True) -> None:
-        """Like `commit` but raises collected exceptions as an exception group and calls
+    def flush(self, strict: bool = True) -> None:
+        """Like `sync` but raises collected exceptions as an exception group and calls
         `.clear` in that case.
         """
         try:
-            excs = self.commit(strict)
+            excs = self.sync(strict)
             if len(excs) > 0:
                 raise ExceptionGroup("failed to sync", excs)
         finally:
@@ -811,7 +809,7 @@ def atomic_rename(
     allow_overwrites: bool,
     *,
     makedirs: bool = True,
-    dsync: DeferredSync[_t.AnyStr] | None = None,
+    sync: DeferredSync[_t.AnyStr] | bool = True,
 ) -> None:
     """Atomically rename a file, performing all necesary `fsync`s."""
 
@@ -821,19 +819,24 @@ def atomic_rename(
     if makedirs and nondot:
         _os.makedirs(dst_dir, exist_ok=True)
 
-    if dsync is not None:
-        dsync.rename_file.append((src_path, dst_path, allow_overwrites, src_dir, dst_dir))
+    if isinstance(sync, DeferredSync) and sync.defer:
+        sync.rename_file.append((src_path, dst_path, allow_overwrites, src_dir, dst_dir))
         return
 
     rename(src_path, dst_path, allow_overwrites, makedirs=False, dst_dir=dst_dir)
 
-    if _POSIX:
-        fsync_file(dst_dir, _os.O_DIRECTORY)
-        if src_dir != dst_dir:
-            fsync_file(src_dir, _os.O_DIRECTORY)
-    else:
-        # on Windows, some docs claim, this helps
-        fsync_file(dst_path)
+    if isinstance(sync, DeferredSync):
+        sync.fsync_dir.add(dst_dir)
+        return
+
+    if sync:
+        if _POSIX:
+            fsync_file(dst_dir, _os.O_DIRECTORY)
+            if src_dir != dst_dir:
+                fsync_file(src_dir, _os.O_DIRECTORY)
+        else:
+            # on Windows, some docs claim, this helps
+            fsync_file(dst_path)
 
 
 def make_file(
@@ -842,7 +845,7 @@ def make_file(
     allow_overwrites: bool = False,
     *,
     makedirs: bool = True,
-    dsync: DeferredSync[_t.AnyStr] | None = None,
+    sync: DeferredSync[_t.AnyStr] | bool = True,
 ) -> None:
     """Create a file using a given `make_dst` function."""
 
@@ -854,24 +857,28 @@ def make_file(
 
     if makedirs and nondot:
         _os.makedirs(dst_dir, exist_ok=True)
-    make_dst(dst_path, dsync is None)
+    make_dst(dst_path, isinstance(sync, bool))
 
-    if dsync is not None:
-        dsync.fsync_file.add(dst_path)
-        dsync.fsync_dir.add(dst_dir)
+    if isinstance(sync, DeferredSync):
+        sync.fsync_file.add(dst_path)
+        sync.fsync_dir.add(dst_dir)
         return
 
-    if _POSIX:
+    if sync and _POSIX:
         fsync_file(dst_dir, _os.O_DIRECTORY)
 
 
+_dot_part = ".part"
+_dot_partb = b".part"
+
+
 def atomic_make_file(
     make_dst: _t.Callable[[_t.AnyStr, bool], None],
     dst_path: _t.AnyStr,
     allow_overwrites: bool = False,
     *,
     makedirs: bool = True,
-    dsync: DeferredSync[_t.AnyStr] | None = None,
+    sync: DeferredSync[_t.AnyStr] | bool = True,
 ) -> None:
     """Atomically create a file using a given `make_dst` function. This
     runs `make_dst` on a `.part` path first, `fsync`s it, then does
@@ -885,29 +892,35 @@ def atomic_make_file(
         raise FileExistsError(_errno.EEXIST, _os.strerror(_errno.EEXIST), dst_path)
 
     if isinstance(dst_path, str):
-        tmp_path = dst_path + ".part"
+        tmp_path = dst_path + _dot_part
     else:
-        tmp_path = dst_path + b".part"
+        tmp_path = dst_path + _dot_partb
 
     dst_dir, nondot = dirname_dot(dst_path)
 
     if makedirs and nondot:
         _os.makedirs(dst_dir, exist_ok=True)
-    make_dst(tmp_path, dsync is None)
+    make_dst(tmp_path, isinstance(sync, bool) and sync)
 
-    if dsync is not None:
-        dsync.tmp_file.add(tmp_path)
-        dsync.fsync_file.add(tmp_path)
-        dsync.rename_file.append((tmp_path, dst_path, allow_overwrites, dst_dir, dst_dir))
+    if isinstance(sync, DeferredSync) and sync.defer:
+        sync.tmp_file.add(tmp_path)
+        sync.fsync_file.add(tmp_path)
+        sync.rename_file.append((tmp_path, dst_path, allow_overwrites, dst_dir, dst_dir))
         return
 
     try:
+        if sync:
+            fsync_file(tmp_path)
         rename(tmp_path, dst_path, allow_overwrites, dst_dir=dst_dir)
     except Exception:
         unlink_maybe(tmp_path)
         raise
 
-    if _POSIX:
+    if isinstance(sync, DeferredSync):
+        sync.fsync_dir.add(dst_dir)
+        return
+
+    if sync and _POSIX:
         fsync_file(dst_dir, _os.O_DIRECTORY)
         # NB: src_dir == dst_dir
 
@@ -919,7 +932,7 @@ def atomic_copy2(
     *,
     follow_symlinks: bool = True,
     makedirs: bool = True,
-    dsync: DeferredSync[_t.AnyStr] | None = None,
+    sync: DeferredSync[_t.AnyStr] | bool = True,
 ) -> None:
     """Atomically copy `src_path` to `dst_path`."""
 
@@ -942,7 +955,7 @@ def atomic_copy2(
 
     # always use the atomic version here, like rsync does,
     # since copying can be interrupted in the middle
-    atomic_make_file(make_dst, dst_path, allow_overwrites, makedirs=makedirs, dsync=dsync)
+    atomic_make_file(make_dst, dst_path, allow_overwrites, makedirs=makedirs, sync=sync)
 
 
 def atomic_link(
@@ -952,7 +965,7 @@ def atomic_link(
     *,
     follow_symlinks: bool = True,
     makedirs: bool = True,
-    dsync: DeferredSync[_t.AnyStr] | None = None,
+    sync: DeferredSync[_t.AnyStr] | bool = True,
 ) -> None:
     """Atomically hardlink `src_path` to `dst_path`."""
 
@@ -963,10 +976,10 @@ def atomic_link(
         _os.link(src_path, dst_path, follow_symlinks=follow_symlinks)
 
     # _os.link is atomic, so non-atomic make_file is ok
-    if allow_overwrites:
-        atomic_make_file(make_dst, dst_path, allow_overwrites, makedirs=makedirs, dsync=dsync)
+    if allow_overwrites or (isinstance(sync, DeferredSync) and sync.defer):
+        atomic_make_file(make_dst, dst_path, allow_overwrites, makedirs=makedirs, sync=sync)
     else:
-        make_file(make_dst, dst_path, allow_overwrites, makedirs=makedirs, dsync=dsync)
+        make_file(make_dst, dst_path, allow_overwrites, makedirs=makedirs, sync=sync)
 
 
 def atomic_symlink(
@@ -976,7 +989,7 @@ def atomic_symlink(
     *,
     follow_symlinks: bool = True,
     makedirs: bool = True,
-    dsync: DeferredSync[_t.AnyStr] | None = None,
+    sync: DeferredSync[_t.AnyStr] | bool = True,
 ) -> None:
     """Atomically symlink `src_path` to `dst_path`."""
 
@@ -987,10 +1000,10 @@ def atomic_symlink(
         _os.symlink(src_path, dst_path)
 
     # _os.symlink is atomic, so non-atomic make_file is ok
-    if allow_overwrites:
-        atomic_make_file(make_dst, dst_path, allow_overwrites, makedirs=makedirs, dsync=dsync)
+    if allow_overwrites or (isinstance(sync, DeferredSync) and sync.defer):
+        atomic_make_file(make_dst, dst_path, allow_overwrites, makedirs=makedirs, sync=sync)
     else:
-        make_file(make_dst, dst_path, allow_overwrites, makedirs=makedirs, dsync=dsync)
+        make_file(make_dst, dst_path, allow_overwrites, makedirs=makedirs, sync=sync)
 
 
 def atomic_link_or_copy2(
@@ -1000,16 +1013,16 @@ def atomic_link_or_copy2(
     *,
     follow_symlinks: bool = True,
     makedirs: bool = True,
-    dsync: DeferredSync[_t.AnyStr] | None = None,
+    sync: DeferredSync[_t.AnyStr] | bool = True,
 ) -> None:
     """Atomically hardlink or copy `src_path` to `dst_path`."""
 
     try:
-        atomic_link(src_path, dst_path, allow_overwrites, follow_symlinks=follow_symlinks, makedirs=makedirs, dsync=dsync)  # fmt: skip
+        atomic_link(src_path, dst_path, allow_overwrites, follow_symlinks=follow_symlinks, makedirs=makedirs, sync=sync)  # fmt: skip
     except OSError as exc:
         if exc.errno != _errno.EXDEV:
             raise
-        atomic_copy2(src_path, dst_path, allow_overwrites, follow_symlinks=follow_symlinks, makedirs=makedirs, dsync=dsync)  # fmt: skip
+        atomic_copy2(src_path, dst_path, allow_overwrites, follow_symlinks=follow_symlinks, makedirs=makedirs, sync=sync)  # fmt: skip
 
 
 def atomic_move(
@@ -1019,7 +1032,7 @@ def atomic_move(
     *,
     follow_symlinks: bool = False,
     makedirs: bool = True,
-    dsync: DeferredSync[_t.AnyStr] | None = None,
+    sync: DeferredSync[_t.AnyStr] | bool = True,
 ) -> None:
     """Atomically move `src_path` to `dst_path`.
 
@@ -1029,17 +1042,17 @@ def atomic_move(
 
     src_dir, _ = dirname_dot(src_path)
 
-    atomic_link_or_copy2(src_path, dst_path, allow_overwrites, follow_symlinks=follow_symlinks, makedirs=makedirs, dsync=dsync)  # fmt: skip
+    atomic_link_or_copy2(src_path, dst_path, allow_overwrites, follow_symlinks=follow_symlinks, makedirs=makedirs, sync=sync)  # fmt: skip
 
-    if dsync is not None:
-        after = dsync.after
+    if isinstance(sync, DeferredSync):
+        after = sync.after
         after.unlink_file.add(src_path)
         after.fsync_dir.add(src_dir)
         return
 
     _os.unlink(src_path)
 
-    if _POSIX:
+    if sync and _POSIX:
         fsync_file(src_dir, _os.O_DIRECTORY)
 
 
@@ -1049,7 +1062,7 @@ def atomic_write(
     allow_overwrites: bool = False,
     *,
     makedirs: bool = True,
-    dsync: DeferredSync[_t.AnyStr] | None = None,
+    sync: DeferredSync[_t.AnyStr] | bool = True,
 ) -> None:
     """Atomically write given `data` to `dst_path`."""
 
@@ -1064,4 +1077,39 @@ def atomic_write(
             unlink_maybe(tmp_path)
             raise
 
-    atomic_make_file(make_dst, dst_path, allow_overwrites, makedirs=makedirs, dsync=dsync)
+    atomic_make_file(make_dst, dst_path, allow_overwrites, makedirs=makedirs, sync=sync)
+
+
+def atomic_unlink(
+    path: _t.AnyStr,
+    *,
+    sync: DeferredSync[_t.AnyStr] | bool = True,
+) -> None:
+    """Atomically unlink `path`."""
+
+    dirname, _ = dirname_dot(path)
+
+    if isinstance(sync, DeferredSync) and sync.defer:
+        sync.unlink_file.add(path)
+        sync.fsync_dir.add(dirname)
+        return
+
+    _os.unlink(path)
+
+    if isinstance(sync, DeferredSync):
+        sync.fsync_dir.add(dirname)
+        return
+
+    if sync and _POSIX:
+        fsync_file(dirname, _os.O_DIRECTORY)
+
+
+def setup_fs(prog: str | None = None, ext: str = ".part", add_pid: bool = True) -> None:
+    """Setup temporary files prefix."""
+    if prog is None:
+        prog = _op.basename(_sys.argv[0])
+
+    global _dot_part, _dot_partb
+    pid = f"{_os.getpid()}." if add_pid else ""
+    _dot_part = f".{pid}{prog}{ext}"
+    _dot_partb = _dot_part.encode("ascii")