ominfra 0.0.0.dev438__py3-none-any.whl → 0.0.0.dev483__py3-none-any.whl

ominfra/scripts/journald2aws.py

@@ -54,6 +54,57 @@ if sys.version_info < (3, 8):
     raise OSError(f'Requires python (3, 8), got {sys.version_info} from {sys.executable}')  # noqa
 
 
+def __omlish_amalg__():  # noqa
+    return dict(
+        src_files=[
+            dict(path='../../../../omlish/configs/types.py', sha1='f7a5584cd6eccb77d18d729796072a162e9a8790'),
+            dict(path='../../../../omlish/formats/ini/sections.py', sha1='731c92cce82e183d1d4bdc23fc781fad62187394'),
+            dict(path='../../../../omlish/formats/toml/parser.py', sha1='73dac82289350ab951c4bcdbfe61167fa221f26f'),
+            dict(path='../../../../omlish/formats/toml/writer.py', sha1='6ea41d7e724bb1dcf6bd84b88993ff4e8798e021'),
+            dict(path='../../../../omlish/io/readers.py', sha1='4b19ab4a87f2fa2a6f6c3cad7e1f3892b7cbd3a4'),
+            dict(path='../../../../omlish/lite/abstract.py', sha1='a2fc3f3697fa8de5247761e9d554e70176f37aac'),
+            dict(path='../../../../omlish/lite/attrops.py', sha1='c1ebfb8573d766d34593c452a2377208d02726dc'),
+            dict(path='../../../../omlish/lite/cached.py', sha1='0c33cf961ac8f0727284303c7a30c5ea98f714f2'),
+            dict(path='../../../../omlish/lite/check.py', sha1='bb6b6b63333699b84462951a854d99ae83195b94'),
+            dict(path='../../../../omlish/lite/contextmanagers.py', sha1='993f5ed96d3410f739a20363f55670d5e5267fa3'),
+            dict(path='../../../../omlish/lite/json.py', sha1='57eeddc4d23a17931e00284ffa5cb6e3ce089486'),
+            dict(path='../../../../omlish/lite/objects.py', sha1='9566bbf3530fd71fcc56321485216b592fae21e9'),
+            dict(path='../../../../omlish/lite/reflect.py', sha1='c4fec44bf144e9d93293c996af06f6c65fc5e63d'),
+            dict(path='../../../../omlish/lite/strings.py', sha1='89831ecbc34ad80e118a865eceb390ed399dc4d6'),
+            dict(path='../../../../omlish/logs/levels.py', sha1='91405563d082a5eba874da82aac89d83ce7b6152'),
+            dict(path='../../../../omlish/logs/std/filters.py', sha1='f36aab646d84d31e295b33aaaaa6f8b67ff38b3d'),
+            dict(path='../../../../omlish/logs/std/proxy.py', sha1='3e7301a2aa351127f9c85f61b2f85dcc3f15aafb'),
+            dict(path='../../../../omlish/logs/warnings.py', sha1='c4eb694b24773351107fcc058f3620f1dbfb6799'),
+            dict(path='../../../../omlish/os/pidfiles/pidfile.py', sha1='7c3c6d4674855bfc4f1d7fd77b8fa40f36581535'),
+            dict(path='../../../../omlish/subprocesses/utils.py', sha1='2210d90ab1bfc75642aa2f4caad662368900aa1c'),
+            dict(path='../auth.py', sha1='b1ac1a5e03d4e9e38957a54e346943c6dcc964a1'),
+            dict(path='../dataclasses.py', sha1='8e950d7815904588fed284889392cbb0b1002605'),
+            dict(path='../../../../omlish/configs/formats.py', sha1='9bc4f953b4b8700f6f109e6f49e2d70f8e48ce7c'),
+            dict(path='../../../../omlish/io/buffers.py', sha1='45a5f79c6d71f02ab82082a48d63ebbd10959031'),
+            dict(path='../../../../omlish/lite/marshal.py', sha1='96348f5f2a26dc27d842d33cc3927e9da163436b'),
+            dict(path='../../../../omlish/lite/runtime.py', sha1='2e752a27ae2bf89b1bb79b4a2da522a3ec360c70'),
+            dict(path='../../../../omlish/logs/infos.py', sha1='4dd104bd468a8c438601dd0bbda619b47d2f1620'),
+            dict(path='../../../../omlish/logs/std/json.py', sha1='2a75553131e4d5331bb0cedde42aa183f403fc3b'),
+            dict(path='../logs.py', sha1='5a4fad522508bdc1b790f1d5234a87f319c9da2d'),
+            dict(path='../../../../omlish/lite/configs.py', sha1='c8602e0e197ef1133e7e8e248935ac745bfd46cb'),
+            dict(path='../../../../omlish/logs/contexts.py', sha1='7456964ade9ac66460e9ade4e242dbdc24b39501'),
+            dict(path='../../../../omlish/logs/standard.py', sha1='818b674f7d15012f25b79f52f6e8e7368b633038'),
+            dict(path='../../../../omlish/subprocesses/wrap.py', sha1='8a9b7d2255481fae15c05f5624b0cdc0766f4b3f'),
+            dict(path='../../../../omlish/logs/base.py', sha1='a376460b11b9dc0555fd4ead5437af62c2109a4b'),
+            dict(path='../../../../omlish/logs/std/records.py', sha1='8bbf6ef9eccb3a012c6ca416ddf3969450fd8fc9'),
+            dict(path='../../../../omlish/logs/std/loggers.py', sha1='daa35bdc4adea5006e442688017f0de3392579b7'),
+            dict(path='../../../../omlish/logs/modules.py', sha1='99e73cde6872fd5eda6af3dbf0fc9322bdeb641a'),
+            dict(path='cursor.py', sha1='00f1c62e16e4c85b20658eaf33c0bedf22c9e18f'),
+            dict(path='../../../journald/messages.py', sha1='6f2d2eeedb71723b1c6631ad2e634b473b297696'),
+            dict(path='../../../threadworkers.py', sha1='e3413436070b66faeb3e6974dc9a75cd8a949ad7'),
+            dict(path='poster.py', sha1='275770a4e60ea5777053c9044e37d71397c3ed20'),
+            dict(path='../../../journald/tailer.py', sha1='1c37a6bbde32e8556d26b94b439f14869731ac01'),
+            dict(path='driver.py', sha1='a9353a417fc4e57f29e7f04038c3bf4668f36dbd'),
+            dict(path='main.py', sha1='e051dbef37e026f887b6084cfaa811ccfa543ee7'),
+        ],
+    )
+
+
 ########################################
 
 
@@ -68,7 +119,7 @@ TomlParseFloat = ta.Callable[[str], ta.Any]  # ta.TypeAlias
 TomlKey = ta.Tuple[str, ...]  # ta.TypeAlias
 TomlPos = int  # ta.TypeAlias
 
-# ../../../../omlish/lite/attrops.py
+# ../../../../omlish/lite/abstract.py
 T = ta.TypeVar('T')
 
 # ../../../../omlish/lite/cached.py
@@ -1200,6 +1251,36 @@ class TomlWriter:
         return out.getvalue()
 
 
+########################################
+# ../../../../../omlish/io/readers.py
+
+
+##
+
+
+class RawBytesReader(ta.Protocol):
+    def read1(self, n: int = -1, /) -> bytes: ...
+
+
+class BufferedBytesReader(RawBytesReader, ta.Protocol):
+    def read(self, n: int = -1, /) -> bytes: ...
+
+    def readall(self) -> bytes: ...
+
+
+#
+
+
+class AsyncRawBytesReader(ta.Protocol):
+    def read1(self, n: int = -1, /) -> ta.Awaitable[bytes]: ...
+
+
+class AsyncBufferedBytesReader(AsyncRawBytesReader, ta.Protocol):
+    def read(self, n: int = -1, /) -> ta.Awaitable[bytes]: ...
+
+    def readall(self) -> ta.Awaitable[bytes]: ...
+
+
 ########################################
 # ../../../../../omlish/lite/abstract.py
 
@@ -1215,25 +1296,49 @@ def is_abstract_method(obj: ta.Any) -> bool:
     return bool(getattr(obj, _IS_ABSTRACT_METHOD_ATTR, False))
 
 
-def update_abstracts(cls, *, force=False):
+def compute_abstract_methods(cls: type) -> ta.FrozenSet[str]:
+    # ~> https://github.com/python/cpython/blob/f3476c6507381ca860eec0989f53647b13517423/Modules/_abc.c#L358
+
+    # Stage 1: direct abstract methods
+
+    abstracts = {
+        a
+        # Get items as a list to avoid mutation issues during iteration
+        for a, v in list(cls.__dict__.items())
+        if is_abstract_method(v)
+    }
+
+    # Stage 2: inherited abstract methods
+
+    for base in cls.__bases__:
+        # Get __abstractmethods__ from base if it exists
+        if (base_abstracts := getattr(base, _ABSTRACT_METHODS_ATTR, None)) is None:
+            continue
+
+        # Iterate over abstract methods in base
+        for key in base_abstracts:
+            # Check if this class has an attribute with this name
+            try:
+                value = getattr(cls, key)
+            except AttributeError:
+                # Attribute not found in this class, skip
+                continue
+
+            # Check if it's still abstract
+            if is_abstract_method(value):
+                abstracts.add(key)
+
+    return frozenset(abstracts)
+
+
+def update_abstracts(cls: ta.Type[T], *, force: bool = False) -> ta.Type[T]:
     if not force and not hasattr(cls, _ABSTRACT_METHODS_ATTR):
         # Per stdlib: We check for __abstractmethods__ here because cls might by a C implementation or a python
         # implementation (especially during testing), and we want to handle both cases.
         return cls
 
-    abstracts: ta.Set[str] = set()
-
-    for scls in cls.__bases__:
-        for name in getattr(scls, _ABSTRACT_METHODS_ATTR, ()):
-            value = getattr(cls, name, None)
-            if getattr(value, _IS_ABSTRACT_METHOD_ATTR, False):
-                abstracts.add(name)
-
-    for name, value in cls.__dict__.items():
-        if getattr(value, _IS_ABSTRACT_METHOD_ATTR, False):
-            abstracts.add(name)
-
-    setattr(cls, _ABSTRACT_METHODS_ATTR, frozenset(abstracts))
+    abstracts = compute_abstract_methods(cls)
+    setattr(cls, _ABSTRACT_METHODS_ATTR, abstracts)
     return cls
 
 
@@ -1287,23 +1392,26 @@ class Abstract:
         super().__init_subclass__(**kwargs)
 
         if not (Abstract in cls.__bases__ or abc.ABC in cls.__bases__):
-            ams = {a: cls for a, o in cls.__dict__.items() if is_abstract_method(o)}
-
-            seen = set(cls.__dict__)
-            for b in cls.__bases__:
-                ams.update({a: b for a in set(getattr(b, _ABSTRACT_METHODS_ATTR, [])) - seen})  # noqa
-                seen.update(dir(b))
+            if ams := compute_abstract_methods(cls):
+                amd = {
+                    a: mcls
+                    for mcls in cls.__mro__[::-1]
+                    for a in ams
+                    if a in mcls.__dict__
+                }
 
-            if ams:
                 raise AbstractTypeError(
                     f'Cannot subclass abstract class {cls.__name__} with abstract methods: ' +
                     ', '.join(sorted([
                         '.'.join([
-                            *([m] if (m := getattr(c, '__module__')) else []),
-                            getattr(c, '__qualname__', getattr(c, '__name__')),
+                            *([
+                                *([m] if (m := getattr(c, '__module__')) else []),
+                                getattr(c, '__qualname__', getattr(c, '__name__')),
+                            ] if c is not None else '?'),
                             a,
                         ])
-                        for a, c in ams.items()
+                        for a in ams
+                        for c in [amd.get(a)]
                     ])),
                 )
 
@@ -1328,6 +1436,8 @@ TODO:
  - per-attr repr transform / filter
  - __ne__ ? cases where it still matters
  - ordering ?
+ - repr_filter: ta.Union[ta.Callable[[ta.Any], ta.Optional[str]], ta.Literal['not_none', 'truthy']]] ?
+  - unify repr/repr_fn/repr_filter
 """
 
 
@@ -1345,6 +1455,8 @@ class AttrOps(ta.Generic[T]):
                 display: ta.Optional[str] = None,
 
                 repr: bool = True,  # noqa
+                repr_fn: ta.Optional[ta.Callable[[ta.Any], ta.Optional[str]]] = None,
+
                 hash: bool = True,  # noqa
                 eq: bool = True,
         ) -> None:
@@ -1359,6 +1471,8 @@ class AttrOps(ta.Generic[T]):
             self._display = display
 
             self._repr = repr
+            self._repr_fn = repr_fn
+
             self._hash = hash
             self._eq = eq
 
@@ -1366,21 +1480,30 @@ class AttrOps(ta.Generic[T]):
         def of(
                 cls,
                 o: ta.Union[
-                    str,
-                    ta.Tuple[str, str],
                     'AttrOps.Attr',
+                    str,
+                    ta.Tuple[str, ta.Union[str, ta.Mapping[str, ta.Any]]],
+                    ta.Mapping[str, ta.Any],
                 ],
         ) -> 'AttrOps.Attr':
             if isinstance(o, AttrOps.Attr):
                 return o
             elif isinstance(o, str):
                 return cls(o)
+            elif isinstance(o, tuple):
+                name, x = o
+                kw: ta.Mapping[str, ta.Any]
+                if isinstance(x, str):
+                    kw = dict(display=x)
+                elif isinstance(x, ta.Mapping):
+                    kw = x
+                else:
+                    raise TypeError(x)
+                return cls(name, **kw)
+            elif isinstance(o, ta.Mapping):
+                return cls(**o)
             else:
-                name, disp = o
-                return cls(
-                    name,
-                    display=disp,
-                )
+                raise TypeError(o)
 
         @property
         def name(self) -> str:
@@ -1398,19 +1521,34 @@ class AttrOps(ta.Generic[T]):
         def eq(self) -> bool:
             return self._eq
 
+    @staticmethod
+    def opt_repr(o: ta.Any) -> ta.Optional[str]:
+        return repr(o) if o is not None else None
+
+    @staticmethod
+    def truthy_repr(o: ta.Any) -> ta.Optional[str]:
+        return repr(o) if o else None
+
+    #
+
     @ta.overload
     def __init__(
             self,
             *attrs: ta.Sequence[ta.Union[
                 str,
-                ta.Tuple[str, str],
+                ta.Tuple[str, ta.Union[str, ta.Mapping[str, ta.Any]]],
+                ta.Mapping[str, ta.Any],
                 Attr,
             ]],
+
             with_module: bool = False,
             use_qualname: bool = False,
             with_id: bool = False,
+            terse: bool = False,
             repr_filter: ta.Optional[ta.Callable[[ta.Any], bool]] = None,
             recursive: bool = False,
+
+            cache_hash: ta.Union[bool, str] = False,
             subtypes_eq: bool = False,
     ) -> None:
         ...
@@ -1420,16 +1558,20 @@ class AttrOps(ta.Generic[T]):
             self,
             attrs_fn: ta.Callable[[T], ta.Tuple[ta.Union[
                 ta.Any,
-                ta.Tuple[str, ta.Any],
+                ta.Tuple[ta.Any, ta.Union[str, ta.Mapping[str, ta.Any]]],
                 Attr,
             ], ...]],
             /,
             *,
+
             with_module: bool = False,
             use_qualname: bool = False,
             with_id: bool = False,
+            terse: bool = False,
             repr_filter: ta.Optional[ta.Callable[[ta.Any], bool]] = None,
             recursive: bool = False,
+
+            cache_hash: ta.Union[bool, str] = False,
             subtypes_eq: bool = False,
     ) -> None:
         ...
@@ -1437,11 +1579,15 @@ class AttrOps(ta.Generic[T]):
     def __init__(
             self,
             *args,
+
             with_module=False,
             use_qualname=False,
             with_id=False,
+            terse=False,
             repr_filter=None,
             recursive=False,
+
+            cache_hash=False,
             subtypes_eq=False,
     ) -> None:
         if args and len(args) == 1 and callable(args[0]):
@@ -1452,8 +1598,11 @@ class AttrOps(ta.Generic[T]):
         self._with_module: bool = with_module
         self._use_qualname: bool = use_qualname
         self._with_id: bool = with_id
+        self._terse: bool = terse
         self._repr_filter: ta.Optional[ta.Callable[[ta.Any], bool]] = repr_filter
         self._recursive: bool = recursive
+
+        self._cache_hash: ta.Union[bool, str] = cache_hash
         self._subtypes_eq: bool = subtypes_eq
 
     @property
@@ -1488,20 +1637,27 @@ class AttrOps(ta.Generic[T]):
 
         attrs: ta.List[AttrOps.Attr] = []
         for o in raw:
-            if isinstance(o, AttrOps.Attr):
-                attrs.append(o)
+            if isinstance(o, (AttrOps.Attr, ta.Mapping)):
+                attrs.append(AttrOps.Attr.of(o))
                 continue
 
+            kw: ta.Mapping[str, ta.Any]
             if isinstance(o, tuple):
-                disp, cap, = o
+                cap, x = o
+                if isinstance(x, str):
+                    kw = dict(display=x)
+                elif isinstance(x, ta.Mapping):
+                    kw = x
+                else:
+                    raise TypeError(x)
             else:
-                disp, cap = None, o
+                cap, kw = o, {}
 
             path = tuple(rec(cap))
 
             attrs.append(AttrOps.Attr(
                 '.'.join(path),
-                display=disp,
+                **kw,
             ))
 
         return attrs
@@ -1518,19 +1674,27 @@ class AttrOps(ta.Generic[T]):
             pass
 
         def _repr(o: T) -> str:
-            vs = ', '.join(
-                f'{a._display}={v!r}'  # noqa
-                for a in self._attrs
-                if a._repr  # noqa
-                for v in [getattr(o, a._name)]  # noqa
-                if self._repr_filter is None or self._repr_filter(v)
-            )
+            vs: ta.List[str] = []
+            for a in self._attrs:
+                if not a._repr:  # noqa
+                    continue
+                v = getattr(o, a._name)  # noqa
+                if self._repr_filter is not None and not self._repr_filter(v):
+                    continue
+                if (rfn := a._repr_fn) is None:  # noqa
+                    rfn = repr
+                if (vr := rfn(v)) is None:
+                    continue
+                if self._terse:
+                    vs.append(vr)
+                else:
+                    vs.append(f'{a._display}={vr}')  # noqa
 
             return (
                 f'{o.__class__.__module__ + "." if self._with_module else ""}'
                 f'{o.__class__.__qualname__ if self._use_qualname else o.__class__.__name__}'
                 f'{("@" + hex(id(o))[2:]) if self._with_id else ""}'  # noqa
-                f'({vs})'
+                f'({", ".join(vs)})'
             )
 
         if self._recursive:
@@ -1555,6 +1719,8 @@ class AttrOps(ta.Generic[T]):
 
     #
 
+    _DEFAULT_CACHED_HASH_ATTR: ta.ClassVar[str] = '__cached_hash__'
+
     _hash: ta.Callable[[T], int]
 
     @property
@@ -1564,13 +1730,33 @@ class AttrOps(ta.Generic[T]):
         except AttributeError:
             pass
 
-        def _hash(o: T) -> int:
+        def _calc_hash(o: T) -> int:
             return hash(tuple(
                 getattr(o, a._name)  # noqa
                 for a in self._attrs
                 if a._hash  # noqa
             ))
 
+        if (ch := self._cache_hash) is not False:
+            if ch is True:
+                cha = self._DEFAULT_CACHED_HASH_ATTR
+            elif isinstance(ch, str):
+                cha = ch
+            else:
+                raise TypeError(ch)
+
+            def _cached_hash(o: T) -> int:
+                try:
+                    return object.__getattribute__(o, cha)
+                except AttributeError:
+                    object.__setattr__(o, cha, h := _calc_hash(o))
+                return h
+
+            _hash = _cached_hash
+
+        else:
+            _hash = _calc_hash
+
         self._hash = _hash
         return _hash
 
@@ -1711,6 +1897,62 @@ def async_cached_nullary(fn):  # ta.Callable[..., T]) -> ta.Callable[..., T]:
     return _AsyncCachedNullary(fn)
 
 
+##
+
+
+cached_property = functools.cached_property
+
+
+class _cached_property:  # noqa
+    """Backported to pick up https://github.com/python/cpython/commit/056dfc71dce15f81887f0bd6da09d6099d71f979 ."""
+
+    def __init__(self, func):
+        self.func = func
+        self.attrname = None  # noqa
+        self.__doc__ = func.__doc__
+        self.__module__ = func.__module__
+
+    _NOT_FOUND = object()
+
+    def __set_name__(self, owner, name):
+        if self.attrname is None:
+            self.attrname = name  # noqa
+        elif name != self.attrname:
+            raise TypeError(
+                f'Cannot assign the same cached_property to two different names ({self.attrname!r} and {name!r}).',
+            )
+
+    def __get__(self, instance, owner=None):
+        if instance is None:
+            return self
+        if self.attrname is None:
+            raise TypeError('Cannot use cached_property instance without calling __set_name__ on it.')
+
+        try:
+            cache = instance.__dict__
+        except AttributeError:  # not all objects have __dict__ (e.g. class defines slots)
+            raise TypeError(
+                f"No '__dict__' attribute on {type(instance).__name__!r} instance to cache {self.attrname!r} property.",
+            ) from None
+
+        val = cache.get(self.attrname, self._NOT_FOUND)
+
+        if val is self._NOT_FOUND:
+            val = self.func(instance)
+            try:
+                cache[self.attrname] = val
+            except TypeError:
+                raise TypeError(
+                    f"The '__dict__' attribute on {type(instance).__name__!r} instance does not support item "
+                    f"assignment for caching {self.attrname!r} property.",
+                ) from None
+
+        return val
+
+
+globals()['cached_property'] = _cached_property
+
+
 ########################################
 # ../../../../../omlish/lite/check.py
 """
@@ -2250,7 +2492,7 @@ class ExitStacked:
             es.__enter__()
             try:
                 self._enter_contexts()
-            except Exception:  # noqa
+            except BaseException:  # noqa
                 es.__exit__(*sys.exc_info())
                 raise
             return self
@@ -2261,7 +2503,7 @@ class ExitStacked:
             return None
         try:
             self._exit_contexts()
-        except Exception:  # noqa
+        except BaseException:  # noqa
             es.__exit__(*sys.exc_info())
             raise
         return es.__exit__(exc_type, exc_val, exc_tb)
@@ -2309,7 +2551,7 @@ class AsyncExitStacked:
             await es.__aenter__()
             try:
                 await self._async_enter_contexts()
-            except Exception:  # noqa
+            except BaseException:  # noqa
                 await es.__aexit__(*sys.exc_info())
                 raise
             return self
@@ -2320,7 +2562,7 @@ class AsyncExitStacked:
             return None
         try:
             await self._async_exit_contexts()
-        except Exception:  # noqa
+        except BaseException:  # noqa
             await es.__aexit__(*sys.exc_info())
             raise
         return await es.__aexit__(exc_type, exc_val, exc_tb)
@@ -3747,6 +3989,10 @@ DEFAULT_CONFIG_RENDERER = SwitchedConfigRenderer(DEFAULT_CONFIG_RENDERERS)
 
 ########################################
 # ../../../../../omlish/io/buffers.py
+"""
+TODO:
+ - overhaul and just coro-ify pyio?
+"""
 
 
 ##
@@ -3925,6 +4171,9 @@ class ReadableListBuffer:
 
         self._lst: list[bytes] = []
 
+    def __bool__(self) -> ta.NoReturn:
+        raise TypeError("Use 'buf is not None' or 'len(buf)'.")
+
     def __len__(self) -> int:
         return sum(map(len, self._lst))
 
@@ -3950,6 +4199,9 @@ class ReadableListBuffer:
 
     def read(self, n: ta.Optional[int] = None) -> ta.Optional[bytes]:
         if n is None:
+            if not self._lst:
+                return b''
+
             o = b''.join(self._lst)
             self._lst = []
             return o
@@ -3988,6 +4240,110 @@ class ReadableListBuffer:
         r = self.read_until_(delim)
         return r if isinstance(r, bytes) else None
 
+    #
+
+    DEFAULT_BUFFERED_READER_CHUNK_SIZE: ta.ClassVar[int] = -1
+
+    @ta.final
+    class _BufferedBytesReader(BufferedBytesReader):
+        def __init__(
+                self,
+                raw: RawBytesReader,
+                buf: 'ReadableListBuffer',
+                *,
+                chunk_size: ta.Optional[int] = None,
+        ) -> None:
+            self._raw = raw
+            self._buf = buf
+            self._chunk_size = chunk_size or ReadableListBuffer.DEFAULT_BUFFERED_READER_CHUNK_SIZE
+
+        def read1(self, n: int = -1, /) -> bytes:
+            if n < 0:
+                n = self._chunk_size
+            if not n:
+                return b''
+            if 0 < n <= len(self._buf):
+                return self._buf.read(n) or b''
+            return self._raw.read1(n)
+
+        def read(self, /, n: int = -1) -> bytes:
+            if n < 0:
+                return self.readall()
+            while len(self._buf) < n:
+                if not (b := self._raw.read1(n)):
+                    break
+                self._buf.feed(b)
+            return self._buf.read(n) or b''
+
+        def readall(self) -> bytes:
+            buf = io.BytesIO()
+            buf.write(self._buf.read() or b'')
+            while (b := self._raw.read1(self._chunk_size)):
+                buf.write(b)
+            return buf.getvalue()
+
+    def new_buffered_reader(
+            self,
+            raw: RawBytesReader,
+            *,
+            chunk_size: ta.Optional[int] = None,
+    ) -> BufferedBytesReader:
+        return self._BufferedBytesReader(
+            raw,
+            self,
+            chunk_size=chunk_size,
+        )
+
+    @ta.final
+    class _AsyncBufferedBytesReader(AsyncBufferedBytesReader):
+        def __init__(
+                self,
+                raw: AsyncRawBytesReader,
+                buf: 'ReadableListBuffer',
+                *,
+                chunk_size: ta.Optional[int] = None,
+        ) -> None:
+            self._raw = raw
+            self._buf = buf
+            self._chunk_size = chunk_size or ReadableListBuffer.DEFAULT_BUFFERED_READER_CHUNK_SIZE
+
+        async def read1(self, n: int = -1, /) -> bytes:
+            if n < 0:
+                n = self._chunk_size
+            if not n:
+                return b''
+            if 0 < n <= len(self._buf):
+                return self._buf.read(n) or b''
+            return await self._raw.read1(n)
+
+        async def read(self, /, n: int = -1) -> bytes:
+            if n < 0:
+                return await self.readall()
+            while len(self._buf) < n:
+                if not (b := await self._raw.read1(n)):
+                    break
+                self._buf.feed(b)
+            return self._buf.read(n) or b''
+
+        async def readall(self) -> bytes:
+            buf = io.BytesIO()
+            buf.write(self._buf.read() or b'')
+            while b := await self._raw.read1(self._chunk_size):
+                buf.write(b)
+            return buf.getvalue()
+
+    def new_async_buffered_reader(
+            self,
+            raw: AsyncRawBytesReader,
+            *,
+            chunk_size: ta.Optional[int] = None,
+    ) -> AsyncBufferedBytesReader:
+        return self._AsyncBufferedBytesReader(
+            raw,
+            self,
+            chunk_size=chunk_size,
+        )
+
 
 ##