kisstdlib 0.0.11__tar.gz → 0.0.12__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: kisstdlib
-Version: 0.0.11
+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.11 → kisstdlib-0.0.12}/kisstdlib/fs.py

@@ -67,7 +67,7 @@ def realdir(path: _t.AnyStr, strict: bool = False) -> _t.AnyStr:
     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)
+    dn, bn = _op.split(_op.abspath(path))
     return _op.join(_op.realpath(dn, strict=strict), bn)
 
 
@@ -468,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]
 
 
@@ -611,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__}
@@ -625,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).
@@ -803,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,
@@ -925,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,
@@ -1056,54 +1104,6 @@ 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:

{kisstdlib-0.0.11 → kisstdlib-0.0.12}/kisstdlib/io/adapter.py

@@ -23,8 +23,15 @@
 """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:
@@ -73,7 +80,7 @@ class ReadAdapter(IOAdapter):
                 self._buffer += self._handle_data(data)
 
         if len(self._buffer) == 0:
-            return b""
+            return self._buffer
 
         if size == -1 or len(self._buffer) == size:
             res = self._buffer
@@ -89,7 +96,7 @@ class ReadAdapter(IOAdapter):
 
 
 class UpdateFinalizeReader(ReadAdapter):
-    def __init__(self, preprocessor: _t.Any, fobj: _t.Any, block_size: int) -> None:
+    def __init__(self, fobj: _t.Any, preprocessor: _t.Any, block_size: int = 4096) -> None:
         super().__init__(fobj, block_size)
         self._preprocessor = preprocessor
 
@@ -114,6 +121,26 @@ class UpdateFinalizeWriter(IOAdapter):
             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)

{kisstdlib-0.0.11 → 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.11 → 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.11 → 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.11 → kisstdlib-0.0.12}/kisstdlib.egg-info/PKG-INFO

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

@@ -36,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.11 → kisstdlib-0.0.12}/pyproject.toml

@@ -9,7 +9,7 @@ namespaces = true
 "kisstdlib" = ["py.typed"]
 [project]
 name = "kisstdlib"
-version = "0.0.11"
+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.11 → 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.11 → 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"