kisstdlib 0.0.10__tar.gz → 0.0.12__tar.gz

{kisstdlib-0.0.10 → kisstdlib-0.0.12}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: kisstdlib
-Version: 0.0.10
+Version: 0.0.12
 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.10 → kisstdlib-0.0.12}/kisstdlib/argparse_ext.py

@@ -194,38 +194,6 @@ class _OptionallyMarkdownHelpAction(Action):
         parser.post_parse_args = self.show_help
 
 
-class _StoreMapAction(Action):
-    def __init__(self, func: _t.Callable[[_t.Any], _t.Any] = _identity, **kwargs: _t.Any) -> None:
-        super().__init__(**kwargs)
-        self.func = func
-
-    def __call__(
-        self,
-        parser: _t.Any,
-        namespace: Namespace,
-        values: _t.Any,
-        option_string: str | None = None,
-    ) -> None:
-        setattr(namespace, self.dest, self.func(values))
-
-
-class _AppendMapAction(Action):
-    def __init__(self, func: _t.Callable[[_t.Any], _t.Any] = _identity, **kwargs: _t.Any) -> None:
-        super().__init__(default=[], **kwargs)
-        self.func = func
-
-    def __call__(
-        self,
-        parser: _t.Any,
-        namespace: Namespace,
-        values: _t.Any,
-        option_string: str | None = None,
-    ) -> None:
-        v = getattr(namespace, self.dest)
-        v.append(self.func(values))
-        setattr(namespace, self.dest, v)
-
-
 class BetterArgumentParser(ArgumentParser):
     """Like `argparse.ArgumentParser`, but uses `BetterHelpFormatter` by default,
     and implements `format_help` that recurses into subcommands and appends
@@ -257,8 +225,6 @@ class BetterArgumentParser(ArgumentParser):
             **kwargs,
         )
 
-        self.register("action", "store_map", _StoreMapAction)
-        self.register("action", "append_map", _AppendMapAction)
         self.register("action", "help_omd", _OptionallyMarkdownHelpAction)
 
         self.add_version = add_version

{kisstdlib-0.0.10 → kisstdlib-0.0.12}/kisstdlib/fs.py

@@ -61,6 +61,16 @@ def dirname_dot(path: _t.AnyStr) -> tuple[_t.AnyStr, bool]:
     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(_op.abspath(path))
+    return _op.join(_op.realpath(dn, strict=strict), bn)
+
+
 def read_file_maybe(path: str | bytes) -> bytes | None:
     """Return contents of the given file path, or `None` if it does not exist."""
     try:
@@ -192,7 +202,7 @@ 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`: [Errno %d, %s] %s: %s",
                     eno,
@@ -218,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,
@@ -240,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,
@@ -255,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,
@@ -398,7 +408,7 @@ 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 _escape_path  # 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):
@@ -458,111 +468,6 @@ def describe_forest(
                 yield [epath, "???"] + emode + emtime + esize
 
 
-def unlink_maybe(path: str | bytes) -> None:
-    """Try to `os.unlink` and ignore `Exception`s."""
-    try:
-        _os.unlink(path)
-    except Exception:
-        pass
-
-
-def fsync_maybe(fd: int) -> None:
-    """Try to `os.fsync` and ignore `errno.EINVAL` errors."""
-    try:
-        _os.fsync(fd)
-    except OSError as exc:
-        if exc.errno == _errno.EINVAL:
-            # EINVAL means fd is not attached to a file, so we
-            # ignore this error
-            return
-        raise
-
-
-def fsync_file(path: str | bytes, flags: int = 0) -> None:
-    """Run `os.fsync` on a given `path`."""
-    oflags = _os.O_RDONLY | _os.O_NOFOLLOW | _os.O_CLOEXEC if _POSIX else _os.O_RDWR
-    try:
-        fd = _os.open(path, oflags | flags)
-    except OSError as exc:
-        if exc.errno == _errno.ELOOP:
-            # ignore symlinks; doing it this way insead of `stat`ing the path to
-            # ensure atomicity
-            return
-        raise
-    try:
-        _os.fsync(fd)
-    except OSError as exc:
-        exc.filename = path
-        raise exc
-    finally:
-        _os.close(fd)
-
-
-def unlink_many(
-    paths: _t.Iterable[_t.AnyStr], exceptions: list[Exception] | None = None
-) -> list[_t.AnyStr]:
-    """`os.unlink` many paths, optionally collecting exceptions.
-    Returns the paths for which `os.unlink` failed.
-    """
-    left = []
-    for path in paths:
-        try:
-            _os.unlink(path)
-        except Exception as exc:
-            if exceptions is None:
-                raise
-            left.append(path)
-            exceptions.append(exc)
-    return left
-
-
-def fsync_many_files(
-    paths: _t.Iterable[_t.AnyStr], flags: int = 0, exceptions: list[Exception] | None = None
-) -> list[_t.AnyStr]:
-    """`os.fsync` many paths, optionally collecting exceptions.
-    Returns the paths for which `os.fsync` failed.
-    """
-    left = []
-    for path in paths:
-        try:
-            fsync_file(path, flags)
-        except Exception as exc:
-            if exceptions is None:
-                raise
-            left.append(path)
-            exceptions.append(exc)
-    return left
-
-
-def rename(
-    src_path: _t.AnyStr,
-    dst_path: _t.AnyStr,
-    allow_overwrites: bool,
-    *,
-    makedirs: bool = True,
-    dst_dir: _t.AnyStr | None = None,
-) -> None:
-    if dst_dir is None:
-        dst_dir, nondot = dirname_dot(dst_path)
-        makedirs = makedirs and nondot
-
-    if makedirs:
-        _os.makedirs(dst_dir, exist_ok=True)
-
-    if allow_overwrites:
-        _os.replace(src_path, dst_path)
-    elif _POSIX:
-        with Directory(dst_dir) as d:
-            d.flock()
-            # this is now atomic
-            if _os.path.lexists(dst_path):
-                raise FileExistsError(_errno.EEXIST, _os.strerror(_errno.EEXIST), dst_path)
-            _os.rename(src_path, dst_path)
-    else:
-        # this is both atomic and fails with `FileExistsError` on Windows
-        _os.rename(src_path, dst_path)
-
-
 DeferredRename = tuple[_t.AnyStr, _t.AnyStr, bool, _t.AnyStr, _t.AnyStr]
 
 
@@ -601,6 +506,12 @@ class DeferredSync(_t.Generic[_t.AnyStr]):
         self.rename_file = _c.deque()
         self._after = None
 
+    @property
+    def after(self) -> "DeferredSync[_t.AnyStr]":
+        if self._after is None:
+            self._after = DeferredSync(self.defer)
+        return self._after
+
     def __repr__(self) -> str:
         return (
             f"""<{self.__class__.__name__}
@@ -615,12 +526,6 @@ after="""
             + ">"
         )
 
-    @property
-    def after(self) -> "DeferredSync[_t.AnyStr]":
-        if self._after is None:
-            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).
@@ -793,6 +698,135 @@ after="""
             self.clear()
 
 
+def fsync_maybe(fd: int) -> None:
+    """Try to `os.fsync` and ignore `errno.EINVAL` errors."""
+    try:
+        _os.fsync(fd)
+    except OSError as exc:
+        if exc.errno == _errno.EINVAL:
+            # EINVAL means fd is not attached to a file, so we
+            # ignore this error
+            return
+        raise
+
+
+def fsync_file(path: str | bytes, flags: int = 0) -> None:
+    """Run `os.fsync` on a given `path`."""
+    oflags = _os.O_RDONLY | _os.O_NOFOLLOW | _os.O_CLOEXEC if _POSIX else _os.O_RDWR
+    try:
+        fd = _os.open(path, oflags | flags)
+    except OSError as exc:
+        if exc.errno == _errno.ELOOP:
+            # ignore symlinks; doing it this way insead of `stat`ing the path to
+            # ensure atomicity
+            return
+        raise
+    try:
+        _os.fsync(fd)
+    except OSError as exc:
+        exc.filename = path
+        raise exc
+    finally:
+        _os.close(fd)
+
+
+def fsync_many_files(
+    paths: _t.Iterable[_t.AnyStr], flags: int = 0, exceptions: list[Exception] | None = None
+) -> list[_t.AnyStr]:
+    """`os.fsync` many paths, optionally collecting exceptions.
+    Returns the paths for which `os.fsync` failed.
+    """
+    left = []
+    for path in paths:
+        try:
+            fsync_file(path, flags)
+        except Exception as exc:
+            if exceptions is None:
+                raise
+            left.append(path)
+            exceptions.append(exc)
+    return left
+
+
+def unlink_maybe(path: str | bytes) -> None:
+    """Try to `os.unlink` and ignore `Exception`s."""
+    try:
+        _os.unlink(path)
+    except Exception:
+        pass
+
+
+def unlink_many(
+    paths: _t.Iterable[_t.AnyStr], exceptions: list[Exception] | None = None
+) -> list[_t.AnyStr]:
+    """`os.unlink` many paths, optionally collecting exceptions.
+    Returns the paths for which `os.unlink` failed.
+    """
+    left = []
+    for path in paths:
+        try:
+            _os.unlink(path)
+        except Exception as exc:
+            if exceptions is None:
+                raise
+            left.append(path)
+            exceptions.append(exc)
+    return left
+
+
+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 rename(
+    src_path: _t.AnyStr,
+    dst_path: _t.AnyStr,
+    allow_overwrites: bool,
+    *,
+    makedirs: bool = True,
+    dst_dir: _t.AnyStr | None = None,
+) -> None:
+    if dst_dir is None:
+        dst_dir, nondot = dirname_dot(dst_path)
+        makedirs = makedirs and nondot
+
+    if makedirs:
+        _os.makedirs(dst_dir, exist_ok=True)
+
+    if allow_overwrites:
+        _os.replace(src_path, dst_path)
+    elif _POSIX:
+        with Directory(dst_dir) as d:
+            d.flock()
+            # this is now atomic
+            if _os.path.lexists(dst_path):
+                raise FileExistsError(_errno.EEXIST, _os.strerror(_errno.EEXIST), dst_path)
+            _os.rename(src_path, dst_path)
+    else:
+        # this is both atomic and fails with `FileExistsError` on Windows
+        _os.rename(src_path, dst_path)
+
+
 def atomic_rename(
     src_path: _t.AnyStr,
     dst_path: _t.AnyStr,
@@ -915,6 +949,30 @@ def atomic_make_file(
         # NB: src_dir == dst_dir
 
 
+def atomic_write(
+    data: bytes,
+    dst_path: _t.AnyStr,
+    allow_overwrites: bool = False,
+    *,
+    makedirs: bool = True,
+    sync: DeferredSync[_t.AnyStr] | bool = True,
+) -> None:
+    """Atomically write given `data` to `dst_path`."""
+
+    def make_dst(tmp_path: _t.AnyStr, fsync_immediately: bool) -> None:
+        try:
+            with open(tmp_path, "xb") as fdst:
+                fdst.write(data)
+                fdst.flush()
+                if fsync_immediately:
+                    _os.fsync(fdst.fileno())
+        except Exception:
+            unlink_maybe(tmp_path)
+            raise
+
+    atomic_make_file(make_dst, dst_path, allow_overwrites, makedirs=makedirs, sync=sync)
+
+
 def atomic_copy2(
     src_path: _t.AnyStr,
     dst_path: _t.AnyStr,
@@ -1046,60 +1104,12 @@ def atomic_move(
         fsync_file(src_dir, _os.O_DIRECTORY)
 
 
-def atomic_write(
-    data: bytes,
-    dst_path: _t.AnyStr,
-    allow_overwrites: bool = False,
-    *,
-    makedirs: bool = True,
-    sync: DeferredSync[_t.AnyStr] | bool = True,
-) -> None:
-    """Atomically write given `data` to `dst_path`."""
-
-    def make_dst(tmp_path: _t.AnyStr, fsync_immediately: bool) -> None:
-        try:
-            with open(tmp_path, "xb") as fdst:
-                fdst.write(data)
-                fdst.flush()
-                if fsync_immediately:
-                    _os.fsync(fdst.fileno())
-        except Exception:
-            unlink_maybe(tmp_path)
-            raise
-
-    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".{prog}{pid}{ext}"
+    pid = f"{_os.getpid()}." if add_pid else ""
+    _dot_part = f".{pid}{prog}{ext}"
     _dot_partb = _dot_part.encode("ascii")

kisstdlib-0.0.12/kisstdlib/io/adapter.py

@@ -0,0 +1,167 @@
+# Copyright (c) 2018-2025 Jan Malakhovski <oxij@oxij.org>
+#
+# This file is a part of `kisstdlib` project.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+"""Adapt almost any folding function into `IOBase` interface."""
+
+import typing as _t
+
+from zlib import compressobj as _compressobj, decompressobj as _decompressobj
+
+from ..parsing import (
+    BytesTransformer as _BytesTransformer,
+    LF2CRLF as _LF2CRLF,
+    CRLF2LF as _CRLF2LF,
+)
+
+
+class IOAdapter:
+    def __init__(self, fobj: _t.Any) -> None:
+        self._fobj = fobj
+
+    def close(self) -> None:
+        self._fobj.close()
+
+    def flush(self) -> None:
+        self._fobj.flush()
+
+    def __enter__(self) -> _t.Any:
+        return self
+
+    def __exit__(self, exc_type: _t.Any, exc_value: _t.Any, exc_tb: _t.Any) -> None:
+        self.close()
+
+    def fileno(self) -> int:
+        return self._fobj.fileno()  # type: ignore
+
+    @property
+    def closed(self) -> bool:
+        return self._fobj.closed  # type: ignore
+
+
+class ReadAdapter(IOAdapter):
+    def __init__(self, fobj: _t.Any, block_size: int) -> None:
+        super().__init__(fobj)
+        self._block_size = block_size
+        self._buffer = b""
+        self._eof = False
+
+    def _handle_eof(self) -> bytes:
+        raise NotImplementedError()
+
+    def _handle_data(self, data: bytes) -> bytes:
+        raise NotImplementedError()
+
+    def read(self, size: int = -1) -> bytes:
+        while not self._eof and (size == -1 or len(self._buffer) < size):
+            data = self._fobj.read(self._block_size)
+            if len(data) == 0:
+                self._buffer += self._handle_eof()
+                self._eof = True
+            else:
+                self._buffer += self._handle_data(data)
+
+        if len(self._buffer) == 0:
+            return self._buffer
+
+        if size == -1 or len(self._buffer) == size:
+            res = self._buffer
+            self._buffer = b""
+            return res
+
+        res = self._buffer[:size]
+        self._buffer = self._buffer[len(res) :]
+        return res
+
+    def tell(self) -> int:
+        return self._fobj.tell()  # type: ignore
+
+
+class UpdateFinalizeReader(ReadAdapter):
+    def __init__(self, fobj: _t.Any, preprocessor: _t.Any, block_size: int = 4096) -> None:
+        super().__init__(fobj, block_size)
+        self._preprocessor = preprocessor
+
+    def _handle_eof(self) -> bytes:
+        return self._preprocessor.finalize()  # type: ignore
+
+    def _handle_data(self, data: bytes) -> bytes:
+        return self._preprocessor.update(data)  # type: ignore
+
+
+class UpdateFinalizeWriter(IOAdapter):
+    def __init__(self, fobj: _t.Any, preprocessor: _t.Any) -> None:
+        super().__init__(fobj)
+        self._preprocessor = preprocessor
+
+    def write(self, data: bytes) -> None:
+        self._fobj.write(self._preprocessor.update(data))
+
+    def close(self) -> None:
+        if not self.closed:
+            self._fobj.write(self._preprocessor.finalize())
+            self._fobj.close()
+
+
+class DOS2UNIXReader(UpdateFinalizeReader):
+    def __init__(self, fobj: _t.Any, block_size: int = 4096) -> None:
+        super().__init__(fobj, _BytesTransformer(_CRLF2LF), block_size)
+
+
+class UNIX2DOSReader(UpdateFinalizeReader):
+    def __init__(self, fobj: _t.Any, block_size: int = 4096) -> None:
+        super().__init__(fobj, _BytesTransformer(_LF2CRLF), block_size)
+
+
+class DOS2UNIXWriter(UpdateFinalizeWriter):
+    def __init__(self, fobj: _t.Any) -> None:
+        super().__init__(fobj, _BytesTransformer(_CRLF2LF))
+
+
+class UNIX2DOSWriter(UpdateFinalizeWriter):
+    def __init__(self, fobj: _t.Any) -> None:
+        super().__init__(fobj, _BytesTransformer(_LF2CRLF))
+
+
+class ZlibDecompressor(ReadAdapter):
+    def __init__(self, fobj: _t.Any, block_size: int, **kwargs: _t.Any) -> None:
+        super().__init__(fobj, block_size)
+        self._decompressor = _decompressobj(**kwargs)
+
+    def _handle_eof(self) -> bytes:
+        return self._decompressor.flush()
+
+    def _handle_data(self, data: bytes) -> bytes:
+        return self._decompressor.decompress(data)
+
+
+class ZlibCompressor(IOAdapter):
+    def __init__(self, fobj: _t.Any, **kwargs: _t.Any) -> None:
+        super().__init__(fobj)
+        self._compressor = _compressobj(**kwargs)
+
+    def write(self, data: bytes) -> None:
+        self._fobj.write(self._compressor.compress(data))
+
+    def close(self) -> None:
+        if not self.closed:
+            self._fobj.write(self._compressor.flush())
+            self._fobj.close()

{kisstdlib-0.0.10 → kisstdlib-0.0.12}/kisstdlib/itertools_ext.py

@@ -95,7 +95,7 @@ def nth(n: int, iterable: _t.Iterable[_AType], default: _AType | Missing = MISSI
         for e in iterable:
             if i == 0:
                 return e
-            i -= i
+            i -= 1
     if default is MISSING:
         raise IndexError("not enough elements")
     return _t.cast(_AType, default)

{kisstdlib-0.0.10 → kisstdlib-0.0.12}/kisstdlib/parsing.py

@@ -20,13 +20,131 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-"""Parsec-like parser combinator, but using regexes a lot."""
+"""Parsing of `str`ings and `bytes`."""
 
 import re as _re
 import typing as _t
 
+from itertools import islice as _islice
+
 from .failure import ParsingFailure
 
+
+# A state transition function, see `BytesTransformer` below.
+ByteTransitions: _t.TypeAlias = _t.Callable[[int, int], tuple[int, bytes] | None]
+
+
+def LF2CRLF(_s: int, c: int) -> tuple[int, bytes] | None:
+    "Map all LF to CR LF."
+    if c == 10:
+        # LF
+        return 0, b"\r\n"
+    return None
+
+
+def CRLF2LF(s: int, c: int) -> tuple[int, bytes] | None:
+    "Map all CR LF sequences to LF."
+    if s == 0:
+        if c == 13:
+            # CR
+            return 1, b""
+        return None
+
+    if c == 10:
+        # CR LF
+        return 0, b"\n"
+    if c == 13:
+        # CR CR
+        return 1, b"\r"
+    if c == -1:
+        # CR EOF
+        return 0, b"\r"
+
+    # CR other
+    return 0, bytes([13, c])
+
+
+class BytesTransformer:
+    """Transform some `bytes` using a given `ByteTransitions` somewhat similarly to
+    `bytearray.transform`, but with more expressive power.
+
+    This class implements the same `update` + `finalize` API as most cryptographic libraries.
+
+    `ByteTransitions` is a function from old state number (the first `int`) and a char (the second
+    `int`) to new state number and generated `bytes` output. The `None` result means "keep the same
+    state, output the input byte". The initial state is `0`, EOF is represented by a `-1` byte.
+
+    See, e.g. `UNIX2DOS*` and `DOS2UNIX*` in `kisstdlib.io.adapter` for example usages.
+    """
+
+    def __init__(self, transitions: ByteTransitions) -> None:
+        self._transitions = transitions
+        self._stateno = 0
+
+    def update(self, data: bytes) -> bytes:
+        i = 0
+        dlen = len(data)
+
+        stateno = self._stateno
+        tf = self._transitions
+
+        c: int
+        t: tuple[int, bytes] | None
+
+        # skip noops
+        while i < dlen:
+            c = data[i]
+            t = tf(stateno, c)
+            if t is None:
+                i += 1
+                continue
+            # nstateno, nout = t
+            # if nstateno == stateno and len(nout) == 0 and nout[0] == c:
+            #     i += 1
+            #     continue
+            break
+        else:
+            return data
+
+        if i == dlen:
+            # there were only noops
+            return data
+
+        # copy the noop part
+        res = bytearray(_islice(data, i))
+
+        # update on the current char
+        stateno, nout = t
+        res.extend(nout)
+        i += 1
+
+        # update on the rest
+        while i < dlen:
+            c = data[i]
+            t = tf(stateno, c)
+            if t is None:
+                res.append(c)
+            else:
+                stateno, nout = t
+                res.extend(nout)
+            i += 1
+
+        self._stateno = stateno
+        return bytes(res)
+
+    def finalize(self) -> bytes:
+        t = self._transitions(self._stateno, -1)
+        if t is None:
+            self._stateno, nout = 0, b""
+        else:
+            self._stateno, nout = t
+
+        # ensure it gets reset properly
+        assert self._stateno == 0
+
+        return nout
+
+
 word_re = _re.compile(r"(\S+)")
 natural_re = _re.compile(r"([0-9]+)")
 integer_re = _re.compile(r"(-?[0-9]+)")
@@ -40,7 +158,7 @@ ParserParamSpec = _t.ParamSpec("ParserParamSpec")
 
 
 class Parser:
-    """Parser combinator with regexes."""
+    """Parsec-like parser combinator with regexes."""
 
     def __init__(self, data: str) -> None:
         self.buffer = data

{kisstdlib-0.0.10 → kisstdlib-0.0.12}/kisstdlib/sqlite3_ext.py

@@ -340,7 +340,7 @@ class AppDB(_t.Generic[SettingsType]):
                 self.commit()
 
             self.logger.debug(
-                "`%s`: opened at version %d with settings of `%s`",
+                "`%s`: finished init at version %d with settings of `%s`",
                 path,
                 self._version,
                 str(self._settings),

{kisstdlib-0.0.10 → kisstdlib-0.0.12}/kisstdlib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: kisstdlib
-Version: 0.0.10
+Version: 0.0.12
 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.10 → kisstdlib-0.0.12}/kisstdlib.egg-info/SOURCES.txt

@@ -27,6 +27,7 @@ kisstdlib.egg-info/entry_points.txt
 kisstdlib.egg-info/requires.txt
 kisstdlib.egg-info/top_level.txt
 kisstdlib/io/__init__.py
+kisstdlib/io/adapter.py
 kisstdlib/io/base.py
 kisstdlib/io/encoder.py
 kisstdlib/io/stdio.py
@@ -35,5 +36,6 @@ kisstdlib_bin/describe_forest.py
 test/test_basics.py
 test/test_fs.py
 test/test_io.py
+test/test_parsing.py
 test/test_sorted.py
 test/test_time.py

{kisstdlib-0.0.10 → kisstdlib-0.0.12}/pyproject.toml

@@ -9,7 +9,7 @@ namespaces = true
 "kisstdlib" = ["py.typed"]
 [project]
 name = "kisstdlib"
-version = "0.0.10"
+version = "0.0.12"
 authors = [{ name = "Jan Malakhovski", email = "oxij@oxij.org" }]
 description = "System programming with conceptually and algebraically simple primitives."
 readme = "README.md"

{kisstdlib-0.0.10 → kisstdlib-0.0.12}/test/test_basics.py

@@ -48,6 +48,7 @@ def test_basics() -> None:
     assert first([123], None) == first((123,), None) == 123
     assert last([123], None) == last((123,), None) == 123
     assert nth(0, [], None) == nth(0, (), None) == None
+    assert nth(0, [123], None) == 123
 
     e: _t.Any
     for e in ((), []):
@@ -78,8 +79,8 @@ def test_basics() -> None:
         for i in range(0, len(l) + 1):
             assert drop(i, l) == l[i:]
 
-        assert nth(0, l, None) == nth(0, t, None) == l[0]
-        assert nth(1, l, None) == nth(1, t, None) == (l[1] if len(l) > 1 else None)
+        for i in range(0, len(l) + 1):
+            assert nth(i, l, None) == nth(i, t, None) == (l[i] if i < len(l) else None)
 
         l.pop()
 

{kisstdlib-0.0.10 → kisstdlib-0.0.12}/test/test_io.py

@@ -26,9 +26,24 @@ import io as _io
 import typing as _t
 
 from kisstdlib.io.base import *
+from kisstdlib.io.adapter import *
 from kisstdlib.io.wrapper import *
 
 
+def test_adapters() -> None:
+    buf = _io.BytesIO()
+
+    u2d = UNIX2DOSWriter(buf)
+    orig = b"Hello, World!\nFoo\rBar\r"
+    u2d.write(orig)
+    assert buf.getvalue() == b"Hello, World!\r\nFoo\rBar\r"
+
+    buf.seek(0)
+
+    d2u = DOS2UNIXReader(buf)
+    assert d2u.read() == orig
+
+
 def test_ansi_set() -> None:
     def check(*args: _t.Any, **kwargs: _t.Any) -> bytes:
         x = TIOWrappedWriter(_io.BytesIO(), ansi=True)

kisstdlib-0.0.12/test/test_parsing.py

@@ -0,0 +1,49 @@
+# Copyright (c) 2025 Jan Malakhovski <oxij@oxij.org>
+#
+# This file is a part of `kisstdlib` project.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+"""Testing `kisstdlib.parsing` module."""
+
+import typing as _t
+
+from kisstdlib.parsing import *
+
+
+def test_BytesTransformer() -> None:
+    unix2dos = BytesTransformer(LF2CRLF)
+    dos2unix = BytesTransformer(CRLF2LF)
+
+    def check(a: bytes, b: bytes) -> None:
+        assert unix2dos.update(a) == b
+        assert dos2unix.update(b) == a
+
+    check(b"", b"")
+    check(b"\n", b"\r\n")
+    check(b"foo\n", b"foo\r\n")
+    check(b"foo\nbar", b"foo\r\nbar")
+    check(b"foo\r\n", b"foo\r\r\n")
+    check(b"foo\r\nbar", b"foo\r\r\nbar")
+
+    assert dos2unix.update(b"foo\r") == b"foo"
+    assert dos2unix.update(b"bar") == b"\rbar"
+
+    assert dos2unix.update(b"foo\r") == b"foo"
+    assert dos2unix.update(b"\n") == b"\n"