omdev 0.0.0.dev542__tar.gz → 0.0.0.dev543__tar.gz

{omdev-0.0.0.dev542/omdev.egg-info → omdev-0.0.0.dev543}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omdev
-Version: 0.0.0.dev542
+Version: 0.0.0.dev543
 Summary: omdev
 Author: wrmsr
 License-Expression: BSD-3-Clause
@@ -14,7 +14,7 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: omlish==0.0.0.dev542
+Requires-Dist: omlish==0.0.0.dev543
 Provides-Extra: all
 Requires-Dist: black~=26.3; extra == "all"
 Requires-Dist: pycparser~=3.0; extra == "all"

{omdev-0.0.0.dev542 → omdev-0.0.0.dev543}/omdev/scripts/ci.py

@@ -93,7 +93,7 @@ def __omlish_amalg__():  # noqa
             dict(path='github/env.py', sha1='c7a2389048f008f46f59f6bcc11e0d15655f2b1c'),
             dict(path='shell.py', sha1='a59e59b812394d0502837f4c198e1cf604f90227'),
             dict(path='../oci/compression.py', sha1='7d165bc51a77db13ff45927daecc42839cfd75ea'),
-            dict(path='../../omlish/asyncs/asyncio/utils.py', sha1='1ab917e62b40dae3744ba2eb3d10c85ddffe08a4'),
+            dict(path='../../omlish/asyncs/asyncio/utils.py', sha1='a093aa6b49e25b3206f59b703b281d569c386838'),
             dict(path='../../omlish/docker/ports.py', sha1='a3202c69b85bc4f1034479df3400fddc86130e5c'),
             dict(path='../../omlish/http/urllib.py', sha1='25431c5bdc7dd5cbecfcb8c0bdffaabf8c1691b9'),
             dict(path='../../omlish/http/versions.py', sha1='5b1659b81eb197c6880fbe78684a1348595ec804'),
@@ -497,41 +497,74 @@ async def asyncio_wait_maybe_concurrent(
 ##
 
 
-@contextlib.asynccontextmanager
-async def asyncio_shielded_finally(
-    fn: ta.Callable[[], ta.Awaitable[ta.Any]],
-    *,
-    timeout: ta.Optional[float] = 5,
-) -> ta.AsyncIterator[None]:
-    try:
-        yield
+async def _asyncio_await_finalizer_shielded(
+        awaitable: ta.Awaitable[ta.Any],
+        *,
+        timeout: ta.Optional[float] = None,
+) -> None:
+    task = asyncio.create_task(awaitable)  # type: ignore  # noqa
 
-    finally:
-        end_task = asyncio.create_task(fn())  # type: ignore  # noqa
+    if timeout is None:
+        try:
+            await asyncio.shield(task)
+        except asyncio.CancelledError:
+            try:
+                await task
+            finally:
+                raise
+
+    else:
+        deadline = time.monotonic() + timeout
 
-        if timeout is None:
+        def remaining() -> float:
+            return max(0., deadline - time.monotonic())
+
+        try:
+            await asyncio.wait_for(asyncio.shield(task), timeout=remaining())
+        except asyncio.CancelledError:
             try:
-                await asyncio.shield(end_task)
+                await asyncio.wait_for(task, timeout=remaining())
+            finally:
+                raise
 
-            except asyncio.CancelledError:
-                try:
-                    await end_task
 
-                finally:
-                    raise
+@dc.dataclass()
+class AsyncioShieldedFinallyCancelledError(asyncio.CancelledError):
+    cleanup_exc: BaseException
 
-        else:
-            dl = time.monotonic() + timeout
 
-            try:
-                await asyncio.wait_for(asyncio.shield(end_task), timeout=time.monotonic() - dl)
+@contextlib.asynccontextmanager
+async def asyncio_shielded_finally(
+        fn: ta.Callable[[], ta.Awaitable[ta.Any]],
+        *,
+        timeout: ta.Optional[float] = None,
+) -> ta.AsyncIterator[None]:
+    raised = False
 
-            except asyncio.CancelledError:
-                try:
-                    await asyncio.wait_for(end_task, timeout=time.monotonic() - dl)
+    try:
+        yield
 
-                finally:
-                    raise
+    except asyncio.CancelledError as e:
+        raised = True
+        try:
+            await _asyncio_await_finalizer_shielded(fn(), timeout=timeout)
+        except BaseException as e2:  # noqa
+            raise AsyncioShieldedFinallyCancelledError(e2) from e
+        else:
+            raise
+
+    except Exception as e:  # noqa
+        raised = True
+        try:
+            await _asyncio_await_finalizer_shielded(fn(), timeout=timeout)
+        except BaseException as e2:  # noqa
+            raise e2 from e
+        else:
+            raise
+
+    finally:
+        if not raised:
+            await _asyncio_await_finalizer_shielded(fn(), timeout=timeout)
 
 
 ########################################

{omdev-0.0.0.dev542 → omdev-0.0.0.dev543}/omdev/scripts/lib/io/pipelines.py

@@ -61,7 +61,7 @@ def __omlish_amalg__():  # noqa
             dict(path='../../logs/contexts.py', sha1='1000a6d5ddfb642865ca532e34b1d50759781cf0'),
             dict(path='../../logs/utils.py', sha1='9b879044cbdc3172fd7282c7f2a4880b81261cdd'),
             dict(path='bytes/queues.py', sha1='ea3b53a155622376836ba9e3499b85220f37b1fd'),
-            dict(path='handlers/flatmap.py', sha1='7c9957c9e5136d1fa8ca51997914b4e9a5065843'),
+            dict(path='handlers/flatmap.py', sha1='118478ac94449a9a0b5ba44f5f3e8a5d69bb6f65'),
             dict(path='../streams/direct.py', sha1='b01937212493e9a41644ac4e366e4cbab10332ce'),
             dict(path='../streams/scanning.py', sha1='00522802dff772689be66151430754d4f9706dbc'),
             dict(path='../../logs/base.py', sha1='eaa2ce213235815e2f86c50df6c41cfe26a43ba2'),
@@ -71,7 +71,7 @@ def __omlish_amalg__():  # noqa
             dict(path='../../logs/std/loggers.py', sha1='dbdfc66188e6accb75d03454e43221d3fba0f011'),
             dict(path='bytes/decoders.py', sha1='6f6d8bc1adc6a5277543389814bc26ef63e34561'),
             dict(path='../../logs/modules.py', sha1='dd7d5f8e63fe8829dfb49460f3929ab64b68ee14'),
-            dict(path='drivers/asyncio.py', sha1='59e80c4ac127e727676f17e956783f3aa39b4088'),
+            dict(path='drivers/asyncio.py', sha1='44e86ab5b903ea2780fc586aed267f72d501d21f'),
             dict(path='_amalg.py', sha1='14b67747b1e3b3c1483050a7948a29888d732ed9'),
         ],
     )
@@ -5521,12 +5521,13 @@ class FlatMapIoPipelineHandlers(NamespaceClass):
     )
 
     @classmethod
-    def _add_drop_filters(
+    def add_filters(
             cls,
             fn: FlatMapIoPipelineHandlerFn,
             *,
             filter_type: ta.Optional[ta.Union[type, ta.Tuple[type, ...]]] = None,
             filter: ta.Optional[IoPipelineHandlerFn[ta.Any, bool]] = None,  # noqa
+            not_must_propagate: bool = False,
     ) -> FlatMapIoPipelineHandlerFn:
         if filter is not None:
             fn = FlatMapIoPipelineHandlerFns.filter(filter, fn)
@@ -5534,10 +5535,13 @@ class FlatMapIoPipelineHandlers(NamespaceClass):
         if filter_type is not None:
             fn = FlatMapIoPipelineHandlerFns.filter_type(filter_type, fn)
 
-        fn = FlatMapIoPipelineHandlerFns.filter(cls._NOT_MUST_PROPAGATE, fn)
+        if not_must_propagate:
+            fn = FlatMapIoPipelineHandlerFns.filter(cls._NOT_MUST_PROPAGATE, fn)
 
         return fn
 
+    #
+
     @classmethod
     def drop(
             cls,
@@ -5548,10 +5552,33 @@ class FlatMapIoPipelineHandlers(NamespaceClass):
     ) -> IoPipelineHandler:
         return cls.new(
             direction,
-            cls._add_drop_filters(
+            cls.add_filters(
                 FlatMapIoPipelineHandlerFns.drop(),
                 filter=filter,
                 filter_type=filter_type,
+                not_must_propagate=True,
+            ),
+        )
+
+    @classmethod
+    def apply_and_drop(
+            cls,
+            direction: IoPipelineDirectionOrDuplex,
+            fn: IoPipelineHandlerFn[ta.Any, None],
+            *,
+            filter_type: ta.Optional[ta.Union[type, ta.Tuple[type, ...]]] = None,
+            filter: ta.Optional[IoPipelineHandlerFn[ta.Any, bool]] = None,  # noqa
+    ) -> IoPipelineHandler:
+        return cls.new(
+            direction,
+            cls.add_filters(
+                FlatMapIoPipelineHandlerFns.compose(
+                    FlatMapIoPipelineHandlerFns.apply(fn),
+                    FlatMapIoPipelineHandlerFns.drop(),
+                ),
+                filter=filter,
+                filter_type=filter_type,
+                not_must_propagate=True,
             ),
         )
 
@@ -5564,13 +5591,14 @@ class FlatMapIoPipelineHandlers(NamespaceClass):
     ) -> IoPipelineHandler:
         return cls.new(
             'inbound',
-            cls._add_drop_filters(
+            cls.add_filters(
                 FlatMapIoPipelineHandlerFns.compose(
                     FlatMapIoPipelineHandlerFns.feed_out(),
                     FlatMapIoPipelineHandlerFns.drop(),
                 ),
                 filter=filter,
                 filter_type=filter_type,
+                not_must_propagate=True,
             ),
         )
 
@@ -8169,14 +8197,14 @@ class AsyncioStreamIoPipelineDriver(Abstract):
             fut.set_exception(e)
             raise
 
-    async def feed_in(self, *msgs: ta.Any) -> None:
+    def enqueue_waitable(self, *msgs: ta.Any) -> 'asyncio.Future[None]':
         check.state(not self._shutdown_event.is_set())
 
         fut: asyncio.Future[None] = asyncio.Future()
         self._command_queue.put_nowait(AsyncioStreamIoPipelineDriver._FeedInCommand(msgs, fut=fut))
-        await fut
+        return fut
 
-    def feed_in_nowait(self, *msgs: ta.Any) -> None:
+    def enqueue(self, *msgs: ta.Any) -> None:
         check.state(not self._shutdown_event.is_set())
 
         self._command_queue.put_nowait(AsyncioStreamIoPipelineDriver._FeedInCommand(msgs))

{omdev-0.0.0.dev542 → omdev-0.0.0.dev543}/omdev/scripts/lib/io/streams.py

@@ -9,7 +9,6 @@
 import abc
 import io
 import sys
-import time
 import typing as ta
 
 
@@ -33,7 +32,7 @@ def __omlish_amalg__():  # noqa
             dict(path='utils.py', sha1='eb08fa1d56284b078f973eea6796747b9bbdffdf'),
             dict(path='direct.py', sha1='b01937212493e9a41644ac4e366e4cbab10332ce'),
             dict(path='scanning.py', sha1='00522802dff772689be66151430754d4f9706dbc'),
-            dict(path='adapters.py', sha1='f38f33ef312c68ecda06ddee928e679fc86bd49e'),
+            dict(path='adapters.py', sha1='c86a3999392fbc2ed76c0c319277b3f903b31e4c'),
             dict(path='linear.py', sha1='82d8d806abd708e8d471f32cb49813be150bcf6a'),
             dict(path='segmented.py', sha1='025cdf30e582a5a2b923e1859fbb4d3f367b811c'),
             dict(path='_amalg.py', sha1='9c88a055447d7b37da1b356e6a1e00b7c4a9a3cb'),
@@ -53,6 +52,12 @@ BytesLike = ta.Union[bytes, bytearray, memoryview]  # ta.TypeAlias
 # utils.py
 CanByteStreamBuffer = ta.Union[BytesLike, 'ByteStreamBufferLike']  # ta.TypeAlias
 
+# adapters.py
+BytesOrAwaitableBytes = ta.TypeVar('BytesOrAwaitableBytes', bound=ta.Union[bytes, ta.Awaitable[bytes]])
+BytesOrAwaitableBytes_co = ta.TypeVar('BytesOrAwaitableBytes_co', bound=ta.Union[bytes, ta.Awaitable[bytes]], covariant=True)  # noqa
+BoolOrAwaitableBool = ta.TypeVar('BoolOrAwaitableBool', bound=ta.Union[bool, ta.Awaitable[bool]])
+BoolOrAwaitableBool_co = ta.TypeVar('BoolOrAwaitableBool_co', bound=ta.Union[bool, ta.Awaitable[bool]], covariant=True)
+
 
 ########################################
 # ../errors.py
@@ -1513,112 +1518,302 @@ class ScanningByteStreamBuffer(BaseByteStreamBufferLike, MutableByteStreamBuffer
 ##
 
 
-class ByteStreamBufferReaderAdapter:
+BaseByteStreamBufferBytesReaderAdapterPolicy = ta.Literal[  # ta.TypeAlias  # omlish-amalg-typing-no-move
+    'raise',
+    'return_partial',
+    'fill',
+]
+
+
+class BaseByteStreamBufferBytesReaderAdapter(Abstract, ta.Generic[BytesOrAwaitableBytes, BoolOrAwaitableBool]):
     """
-    Adapter: ByteStreamBuffer -> file-like reader methods (`read1`, `read`, `readall`).
+    Adapter: ByteStreamBuffer -> file-like buffered reader methods (`read1`, `read`).
 
     This adapter is policy-driven for how it behaves when insufficient bytes are available. The core buffer is
     intentionally non-blocking; blocking behavior (if desired) must be provided via a `fill` callback that supplies more
     bytes into the buffer.
 
     `policy`:
-      - 'raise': raise NeedMoreDataByteStreamBufferError if fewer than `n` bytes are available (for n >= 0).
+      - 'raise': raise `NeedMoreDataByteStreamBufferError` if fewer than `n` bytes are available (for `n >= 0`).
       - 'return_partial': return whatever is available (possibly b'') up to `n`.
-      - 'block': repeatedly call `fill()` until satisfied or until `fill()` signals EOF.
+      - 'fill': repeatedly call `fill()` until satisfied or until `fill()` signals EOF - effectively blocking mode.
 
     `fill`:
-      - Callable that writes more bytes into the underlying MutableByteStreamBuffer and returns:
-          * True  -> made progress / more data may be available
-          * False -> EOF / no more data will arrive
-      - Only used when policy == 'block'.
+      - Callable that writes more bytes into the underlying buffer.
 
     This adapter exists for interop with legacy code that expects file-like objects, but the core design remains
     independent from `io` and blocking semantics.
     """
 
+    DEFAULT_POLICY: ta.Final = 'raise'
+
+    class Filler(ta.Protocol[BoolOrAwaitableBool_co]):
+        def __call__(self, n: int, single: bool) -> BoolOrAwaitableBool_co:
+            """
+            Called when more data needs to be written into the underlying buffer.
+
+            - If `n > 0` then at least `n` bytes are requested - extra bytes will be buffered.
+            - If `single` then the user has requested that at most one underlying read operation should be performed.
+            - If `n < 1` and `single` then any amount of data is requested.
+            - If `n < 1` and not `single` then all remaining data is requested.
+
+            Returns `True` if it made progress or more data may be available, or `False` if no more data will arrive.
+
+            If not `single` returning `True` then at least 1 new byte mut have been written to the buffer (otherwise
+            it would infinite loop).
+
+            This function may or may not sleep / loop / block / etc. as it sees fit.
+            """
+
     def __init__(
             self,
             buf: ByteStreamBuffer,
             *,
-            policy: ta.Literal['raise', 'return_partial', 'block'] = 'raise',
-            fill: ta.Optional[ta.Callable[[], bool]] = None,
-            block_sleep: ta.Union[ta.Callable[[], None], float, None] = None,
+            policy: ta.Optional[BaseByteStreamBufferBytesReaderAdapterPolicy] = None,
+            fill: ta.Optional[Filler[BoolOrAwaitableBool]] = None,
     ) -> None:
         super().__init__()
 
         self._buf = buf
+        if fill is not None:
+            if policy is None:
+                policy = 'fill'
+            elif policy != 'fill':
+                raise ValueError('fill callback only valid with policy=fill')
+        elif policy is None:
+            policy = self.DEFAULT_POLICY
         self._policy = policy
         self._fill = fill
-        self._block_sleep = block_sleep
 
-        if self._policy == 'block' and self._fill is None:
-            raise ValueError('policy=block requires fill')
+    #
+
+    class RawBytesReader(ta.Protocol[BytesOrAwaitableBytes_co]):
+        def read1(self, n: ta.Any) -> BytesOrAwaitableBytes_co: ...
+
+    class BytesReader(RawBytesReader[BytesOrAwaitableBytes_co], ta.Protocol[BytesOrAwaitableBytes_co]):
+        def read(self, n: ta.Any) -> BytesOrAwaitableBytes_co: ...
+
+    @classmethod
+    @abc.abstractmethod
+    def wrap(
+            cls,
+            obj: RawBytesReader[BytesOrAwaitableBytes],
+            buf: MutableByteStreamBuffer,
+            *,
+            policy: ta.Optional[BaseByteStreamBufferBytesReaderAdapterPolicy] = None,
+    ) -> 'BaseByteStreamBufferBytesReaderAdapter[BytesOrAwaitableBytes, BoolOrAwaitableBool]':
+        raise NotImplementedError
+
+    #
+
+    @abc.abstractmethod
+    def read1(self, n: int = -1, /) -> BytesOrAwaitableBytes:
+        raise NotImplementedError
+
+    def _inner_read(self, n: int) -> ta.Union[bytes, ta.Literal['fill']]:
+        buf = self._buf
+        if (ln := len(buf)) >= n:
+            return buf.split_to(n).tobytes()
+
+        pol = self._policy
+        if pol == 'return_partial':
+            if not ln:
+                return b''
+            return buf.split_to(ln).tobytes()
+
+        elif pol == 'raise':
+            raise NeedMoreDataByteStreamBufferError
+
+        elif pol == 'fill':
+            return 'fill'
 
-    def _on_block(self) -> None:
-        if (bs := self._block_sleep) is None:
-            return
-        elif callable(bs):
-            bs()
         else:
-            time.sleep(bs)
+            raise RuntimeError(f'invalid policy: {pol!r}')
+
+    @abc.abstractmethod
+    def read(self, n: int = -1, /) -> BytesOrAwaitableBytes:
+        raise NotImplementedError
+
+
+#
+
+
+class ByteStreamBufferBytesReaderAdapter(BaseByteStreamBufferBytesReaderAdapter[bytes, bool]):
+    @classmethod
+    def wrap(
+            cls,
+            obj: BaseByteStreamBufferBytesReaderAdapter.RawBytesReader[bytes],
+            buf: MutableByteStreamBuffer,
+            *,
+            policy: ta.Optional[BaseByteStreamBufferBytesReaderAdapterPolicy] = None,
+    ) -> 'BaseByteStreamBufferBytesReaderAdapter[bytes, bool]':
+        if not hasattr(obj, 'read1'):
+            raise TypeError(obj)
+
+        elif hasattr(obj, 'read'):
+            def br_fill(n: int, single: bool) -> bool:
+                if single:
+                    b = obj.read1(n)
+                else:
+                    b = obj.read(n)
+                if not b:
+                    return False
+                buf.write(b)
+                return True
+
+            fill = br_fill
+
+        else:
+            def rbr_fill(n: int, single: bool) -> bool:
+                b = obj.read1(n)
+                if not b:
+                    return False
+                buf.write(b)
+                return True
+
+            fill = rbr_fill
+
+        return cls(
+            buf,
+            policy=policy,
+            fill=fill,
+        )
 
     def read1(self, n: int = -1, /) -> bytes:
-        return self.read(n)
+        if not n:
+            return b''
 
-    def read(self, n: int = -1, /) -> bytes:
         buf = self._buf
+        if not (ln := len(buf)):
+            if (fill := self._fill) is None:
+                return b''
 
-        if n is None or n < 0:
-            return self.readall()
+            fill(n, True)
+            ln = len(buf)
+
+        if not ln:
+            return b''
+
+        return buf.split_to(min(n, ln) if n > 0 else ln).tobytes()
+
+    def read(self, n: int = -1, /) -> bytes:
+        if n < 0:
+            if (fill := self._fill) is not None:
+                while fill(-1, False):
+                    pass
+
+            buf = self._buf
+            return buf.split_to(len(buf)).tobytes()
 
         if not n:
             return b''
 
+        buf = self._buf
         while True:
-            ln = len(buf)
-            if ln >= n:
-                v = buf.split_to(n)
-                return v.tobytes()
+            if (out := self._inner_read(n)) != 'fill':
+                return out
 
-            if self._policy == 'return_partial':
-                if not ln:
+            ln = len(buf)
+            if not self._fill(n - ln, False):  # type: ignore[misc]
+                # EOF
+                if not (ln := len(buf)):
                     return b''
-                v = buf.split_to(ln)
-                return v.tobytes()
+                return buf.split_to(ln).tobytes()
 
-            if self._policy == 'raise':
-                raise NeedMoreDataByteStreamBufferError
+            if len(buf) == ln:
+                raise RuntimeError('fill did not produce data')
 
-            # block
-            if not ta.cast('ta.Callable[[], bool]', self._fill)():
-                # EOF
-                if not ln:
-                    return b''
-                v = buf.split_to(ln)
-                return v.tobytes()
 
-            self._on_block()
+#
+
+
+class ByteStreamBufferAsyncBytesReaderAdapter(BaseByteStreamBufferBytesReaderAdapter[ta.Awaitable[bytes], ta.Awaitable[bool]]):  # noqa
+    @classmethod
+    def wrap(
+            cls,
+            obj: BaseByteStreamBufferBytesReaderAdapter.RawBytesReader[ta.Awaitable[bytes]],
+            buf: MutableByteStreamBuffer,
+            *,
+            policy: ta.Optional[BaseByteStreamBufferBytesReaderAdapterPolicy] = None,
+    ) -> 'BaseByteStreamBufferBytesReaderAdapter[ta.Awaitable[bytes], ta.Awaitable[bool]]':
+        if not hasattr(obj, 'read1'):
+            raise TypeError(obj)
+
+        elif hasattr(obj, 'read'):
+            async def br_fill(n: int, single: bool) -> bool:
+                if single:
+                    b = await obj.read1(n)
+                else:
+                    b = await obj.read(n)
+                if not b:
+                    return False
+                buf.write(b)
+                return True
+
+            fill = br_fill
+
+        else:
+            async def rbr_fill(n: int, single: bool) -> bool:
+                b = await obj.read1(n)
+                if not b:
+                    return False
+                buf.write(b)
+                return True
+
+            fill = rbr_fill
+
+        return cls(
+            buf,
+            policy=policy,
+            fill=fill,
+        )
+
+    async def read1(self, n: int = -1, /) -> bytes:
+        if not n:
+            return b''
 
-    def readall(self) -> bytes:
         buf = self._buf
-        parts: ta.List[bytes] = []
+        if not (ln := len(buf)):
+            if (fill := self._fill) is None:
+                return b''
+
+            await fill(n, True)
+            ln = len(buf)
+
+        if not ln:
+            return b''
+
+        return buf.split_to(min(n, ln) if n > 0 else ln).tobytes()
+
+    async def read(self, n: int = -1, /) -> bytes:
+        if n < 0:
+            if (fill := self._fill) is not None:
+                while await fill(-1, False):
+                    pass
 
+            buf = self._buf
+            return buf.split_to(len(buf)).tobytes()
+
+        if not n:
+            return b''
+
+        buf = self._buf
         while True:
+            if (out := self._inner_read(n)) != 'fill':
+                return out
+
             ln = len(buf)
-            if ln:
-                v = buf.split_to(ln)
-                parts.append(v.tobytes())
-                continue
+            if not await self._fill(n - ln, False):  # type: ignore[misc]
+                # EOF
+                if not (ln := len(buf)):
+                    return b''
+                return buf.split_to(ln).tobytes()
 
-            if self._policy == 'block':
-                if not ta.cast('ta.Callable[[], bool]', self._fill)():
-                    break
-                self._on_block()
-                continue
+            if len(buf) == ln:
+                raise RuntimeError('fill did not produce data')
 
-            break
 
-        return b''.join(parts)
+##
 
 
 class ByteStreamBufferWriterAdapter:

{omdev-0.0.0.dev542 → omdev-0.0.0.dev543/omdev.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omdev
-Version: 0.0.0.dev542
+Version: 0.0.0.dev543
 Summary: omdev
 Author: wrmsr
 License-Expression: BSD-3-Clause
@@ -14,7 +14,7 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: omlish==0.0.0.dev542
+Requires-Dist: omlish==0.0.0.dev543
 Provides-Extra: all
 Requires-Dist: black~=26.3; extra == "all"
 Requires-Dist: pycparser~=3.0; extra == "all"

{omdev-0.0.0.dev542 → omdev-0.0.0.dev543}/omdev.egg-info/requires.txt

@@ -1,4 +1,4 @@
-omlish==0.0.0.dev542
+omlish==0.0.0.dev543
 
 [all]
 black~=26.3

{omdev-0.0.0.dev542 → omdev-0.0.0.dev543}/pyproject.toml

@@ -13,7 +13,7 @@ urls = {source = 'https://github.com/wrmsr/omlish'}
 license = 'BSD-3-Clause'
 readme = 'README.md'
 requires-python = '>=3.13'
-version = '0.0.0.dev542'
+version = '0.0.0.dev543'
 classifiers = [
     'Development Status :: 2 - Pre-Alpha',
     'Intended Audience :: Developers',
@@ -24,7 +24,7 @@ classifiers = [
 ]
 description = 'omdev'
 dependencies = [
-    'omlish == 0.0.0.dev542',
+    'omlish == 0.0.0.dev543',
 ]
 
 [project.optional-dependencies]