omdev 0.0.0.dev242__py3-none-any.whl → 0.0.0.dev243__py3-none-any.whl

omdev/ci/docker/cacheserved/cache.py

@@ -6,6 +6,7 @@ import json
 import os.path
 import typing as ta
 
+from omlish.asyncs.asyncio.sockets import asyncio_wait_until_can_connect
 from omlish.asyncs.asyncio.subprocesses import asyncio_subprocesses
 from omlish.lite.check import check
 from omlish.lite.json import json_dumps_compact
@@ -126,17 +127,14 @@ class CacheServedDockerCache(DockerCache):
             dds_run_task = asyncio.create_task(dds.run())
             try:
                 timeout = Timeout.of(self._config.server_start_timeout)
-                while True:
-                    timeout()
-                    try:
-                        reader, writer = await asyncio.open_connection('localhost', self._config.port)
-                    except Exception as e:  # noqa
-                        log.exception('Failed to connect to cache server - will try again')
-                    else:
-                        writer.close()
-                        await asyncio.wait_for(writer.wait_closed(), timeout=timeout.remaining())
-                        break
-                    await asyncio.sleep(self._config.server_start_sleep)
+
+                await asyncio_wait_until_can_connect(
+                    'localhost',
+                    self._config.port,
+                    timeout=timeout,
+                    on_fail=lambda _: log.exception('Failed to connect to cache server - will try again'),
+                    sleep_s=self._config.server_start_sleep,
+                )
 
                 if (prc := self._config.pull_run_cmd) is not None:
                     pull_cmd = [

omdev/oci/tars.py

@@ -79,11 +79,7 @@ class OciDataTarWriter(ExitStacked):
             tar_sha256=self._tw.sha256(),
         )
 
-    def __enter__(self) -> 'OciDataTarWriter':
-        super().__enter__()
-
-        #
-
+    def _enter_contexts(self) -> None:
         self._cw = self._FileWrapper(self._f)
 
         if self._compression is OciCompression.GZIP:
@@ -112,16 +108,12 @@ class OciDataTarWriter(ExitStacked):
         self._tw = self._FileWrapper(self._cf)
 
         self._tf = self._enter_context(
-            tarfile.open(  # type: ignore
+            tarfile.open(  # type: ignore  # noqa
                 fileobj=self._tw,
                 mode='w',
             ),
         )
 
-        #
-
-        return self
-
     def tar_file(self) -> tarfile.TarFile:
         return self._tf
 

omdev/scripts/ci.py

@@ -2607,6 +2607,48 @@ class ArgparseCli:
             return fn()
 
 
+########################################
+# ../../../omlish/asyncs/asyncio/sockets.py
+
+
+async def asyncio_wait_until_can_connect(
+        host: ta.Any = None,
+        port: ta.Any = None,
+        *,
+        timeout: ta.Optional[TimeoutLike] = None,
+        on_fail: ta.Optional[ta.Callable[[BaseException], None]] = None,
+        sleep_s: float = .1,
+        exception: ta.Union[ta.Type[BaseException], ta.Tuple[ta.Type[BaseException], ...]] = (Exception,),
+) -> None:
+    timeout = Timeout.of(timeout)
+
+    async def inner():
+        while True:
+            timeout()
+
+            try:
+                reader, writer = await asyncio.open_connection(host, port)
+
+            except asyncio.CancelledError:
+                raise
+
+            except exception as e:  # noqa
+                if on_fail is not None:
+                    on_fail(e)
+
+            else:
+                writer.close()
+                await asyncio.wait_for(writer.wait_closed(), timeout=timeout.or_(None))
+                break
+
+            await asyncio.sleep(min(sleep_s, timeout.remaining()))
+
+    if timeout() != float('inf'):
+        await asyncio.wait_for(inner(), timeout=timeout())
+    else:
+        await inner()
+
+
 ########################################
 # ../../../omlish/asyncs/asyncio/timeouts.py
 
@@ -3041,20 +3083,64 @@ class HttpRequestParser:
 
 
 class ExitStacked:
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+
+        for a in ('__enter__', '__exit__'):
+            for b in cls.__bases__:
+                if b is ExitStacked:
+                    continue
+                try:
+                    fn = getattr(b, a)
+                except AttributeError:
+                    pass
+                else:
+                    if fn is not getattr(ExitStacked, a):
+                        raise TypeError(f'ExitStacked subclass {cls} must not not override {a} via {b}')
+
     _exit_stack: ta.Optional[contextlib.ExitStack] = None
 
+    @contextlib.contextmanager
+    def _exit_stacked_init_wrapper(self) -> ta.Iterator[None]:
+        """
+        Overridable wrapper around __enter__ which deliberately does not have access to an _exit_stack yet. Intended for
+        things like wrapping __enter__ in a lock.
+        """
+
+        yield
+
+    @ta.final
     def __enter__(self: ExitStackedT) -> ExitStackedT:
-        check.state(self._exit_stack is None)
-        es = self._exit_stack = contextlib.ExitStack()
-        es.__enter__()
-        return self
+        """
+        Final because any contexts entered during this init must be exited if any exception is thrown, and user
+        overriding would likely interfere with that. Override `_enter_contexts` for such init.
+        """
+
+        with self._exit_stacked_init_wrapper():
+            check.state(self._exit_stack is None)
+            es = self._exit_stack = contextlib.ExitStack()
+            es.__enter__()
+            try:
+                self._enter_contexts()
+            except Exception:  # noqa
+                es.__exit__(*sys.exc_info())
+                raise
+            return self
 
+    @ta.final
     def __exit__(self, exc_type, exc_val, exc_tb):
         if (es := self._exit_stack) is None:
             return None
-        self._exit_contexts()
+        try:
+            self._exit_contexts()
+        except Exception:  # noqa
+            es.__exit__(*sys.exc_info())
+            raise
         return es.__exit__(exc_type, exc_val, exc_tb)
 
+    def _enter_contexts(self) -> None:
+        pass
+
     def _exit_contexts(self) -> None:
         pass
 
@@ -3064,20 +3150,54 @@ class ExitStacked:
 
 
 class AsyncExitStacked:
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+
+        for a in ('__aenter__', '__aexit__'):
+            for b in cls.__bases__:
+                if b is AsyncExitStacked:
+                    continue
+                try:
+                    fn = getattr(b, a)
+                except AttributeError:
+                    pass
+                else:
+                    if fn is not getattr(AsyncExitStacked, a):
+                        raise TypeError(f'AsyncExitStacked subclass {cls} must not not override {a} via {b}')
+
     _exit_stack: ta.Optional[contextlib.AsyncExitStack] = None
 
+    @contextlib.asynccontextmanager
+    async def _async_exit_stacked_init_wrapper(self) -> ta.AsyncGenerator[None, None]:
+        yield
+
+    @ta.final
     async def __aenter__(self: AsyncExitStackedT) -> AsyncExitStackedT:
-        check.state(self._exit_stack is None)
-        es = self._exit_stack = contextlib.AsyncExitStack()
-        await es.__aenter__()
-        return self
+        async with self._async_exit_stacked_init_wrapper():
+            check.state(self._exit_stack is None)
+            es = self._exit_stack = contextlib.AsyncExitStack()
+            await es.__aenter__()
+            try:
+                await self._async_enter_contexts()
+            except Exception:  # noqa
+                await es.__aexit__(*sys.exc_info())
+                raise
+            return self
 
+    @ta.final
     async def __aexit__(self, exc_type, exc_val, exc_tb):
         if (es := self._exit_stack) is None:
             return None
-        await self._async_exit_contexts()
+        try:
+            await self._async_exit_contexts()
+        except Exception:  # noqa
+            await es.__aexit__(*sys.exc_info())
+            raise
         return await es.__aexit__(exc_type, exc_val, exc_tb)
 
+    async def _async_enter_contexts(self) -> None:
+        pass
+
     async def _async_exit_contexts(self) -> None:
         pass
 
@@ -6952,11 +7072,7 @@ class OciDataTarWriter(ExitStacked):
             tar_sha256=self._tw.sha256(),
         )
 
-    def __enter__(self) -> 'OciDataTarWriter':
-        super().__enter__()
-
-        #
-
+    def _enter_contexts(self) -> None:
         self._cw = self._FileWrapper(self._f)
 
         if self._compression is OciCompression.GZIP:
@@ -6985,16 +7101,12 @@ class OciDataTarWriter(ExitStacked):
         self._tw = self._FileWrapper(self._cf)
 
         self._tf = self._enter_context(
-            tarfile.open(  # type: ignore
+            tarfile.open(  # type: ignore  # noqa
                 fileobj=self._tw,
                 mode='w',
             ),
         )
 
-        #
-
-        return self
-
     def tar_file(self) -> tarfile.TarFile:
         return self._tf
 
@@ -8800,58 +8912,88 @@ class SocketServer(abc.ABC):
 
     #
 
-    @contextlib.contextmanager
-    def _listen_context(self) -> ta.Iterator[SelectorProtocol]:
-        with contextlib.ExitStack() as es:
-            es.enter_context(self._lock)
-            es.enter_context(self._binder)
+    class PollResult(enum.Enum):
+        TIMEOUT = enum.auto()
+        CONNECTION = enum.auto()
+        ERROR = enum.auto()
+        SHUTDOWN = enum.auto()
 
-            self._binder.listen()
+    class PollContext(ExitStacked, abc.ABC):
+        @abc.abstractmethod
+        def poll(self, timeout: ta.Optional[float] = None) -> 'SocketServer.PollResult':
+            raise NotImplementedError
 
-            self._is_shutdown.clear()
-            try:
-                # XXX: Consider using another file descriptor or connecting to the socket to wake this up instead of
-                # polling. Polling reduces our responsiveness to a shutdown request and wastes cpu at all other times.
-                with self.Selector() as selector:
-                    selector.register(self._binder.fileno(), selectors.EVENT_READ)
+    class _PollContext(PollContext):
+        def __init__(self, server: 'SocketServer') -> None:
+            super().__init__()
 
-                    yield selector
+            self._server = server
 
-            finally:
-                self._is_shutdown.set()
+        _selector: ta.Any = None
 
-    @contextlib.contextmanager
-    def loop_context(self, poll_interval: ta.Optional[float] = None) -> ta.Iterator[ta.Iterator[bool]]:
-        if poll_interval is None:
-            poll_interval = self._poll_interval
+        def _enter_contexts(self) -> None:
+            self._enter_context(self._server._lock)  # noqa: SLF001
+            self._enter_context(self._server._binder)  # noqa: SLF001
 
-        with self._listen_context() as selector:
-            def loop():
-                while not self._should_shutdown:
-                    ready = selector.select(poll_interval)
+            self._server._binder.listen()  # noqa: SLF001
+
+            self._server._is_shutdown.clear()  # noqa: SLF001
+            self._enter_context(defer(self._server._is_shutdown.set))  # noqa
 
-                    # bpo-35017: shutdown() called during select(), exit immediately.
-                    if self._should_shutdown:
-                        break  # type: ignore[unreachable]
+            # XXX: Consider using another file descriptor or connecting to the socket to wake this up instead of
+            # polling. Polling reduces our responsiveness to a shutdown request and wastes cpu at all other times.
+            self._selector = self._enter_context(self._server.Selector())
+            self._selector.register(self._server._binder.fileno(), selectors.EVENT_READ)  # noqa: SLF001
 
-                    if ready:
-                        try:
-                            conn = self._binder.accept()
+        def poll(self, timeout: ta.Optional[float] = None) -> 'SocketServer.PollResult':
+            if self._server._should_shutdown:  # noqa: SLF001
+                return SocketServer.PollResult.SHUTDOWN
 
-                        except OSError as exc:
-                            self._handle_error(exc)
+            ready = self._selector.select(timeout)
 
-                            return
+            # bpo-35017: shutdown() called during select(), exit immediately.
+            if self._server._should_shutdown:  # noqa: SLF001
+                return SocketServer.PollResult.SHUTDOWN  # type: ignore[unreachable]
 
-                        try:
-                            self._handler(conn)
+            if not ready:
+                return SocketServer.PollResult.TIMEOUT
+
+            try:
+                conn = self._server._binder.accept()  # noqa: SLF001
 
-                        except Exception as exc:  # noqa
-                            self._handle_error(exc, conn)
+            except OSError as exc:
+                self._server._handle_error(exc)  # noqa: SLF001
+
+                return SocketServer.PollResult.ERROR
+
+            try:
+                self._server._handler(conn)  # noqa: SLF001
+
+            except Exception as exc:  # noqa
+                self._server._handle_error(exc, conn)  # noqa: SLF001
+
+                close_socket_immediately(conn.socket)
+
+            return SocketServer.PollResult.CONNECTION
+
+    def poll_context(self) -> PollContext:
+        return self._PollContext(self)
+
+    #
 
-                            close_socket_immediately(conn.socket)
+    @contextlib.contextmanager
+    def loop_context(self, poll_interval: ta.Optional[float] = None) -> ta.Iterator[ta.Iterator[bool]]:
+        if poll_interval is None:
+            poll_interval = self._poll_interval
 
-                    yield bool(ready)
+        with self.poll_context() as pc:
+            def loop():
+                while True:
+                    res = pc.poll(poll_interval)
+                    if res in (SocketServer.PollResult.ERROR, SocketServer.PollResult.SHUTDOWN):
+                        return
+                    else:
+                        yield res == SocketServer.PollResult.CONNECTION
 
             yield loop()
 
@@ -11460,17 +11602,14 @@ class CacheServedDockerCache(DockerCache):
             dds_run_task = asyncio.create_task(dds.run())
             try:
                 timeout = Timeout.of(self._config.server_start_timeout)
-                while True:
-                    timeout()
-                    try:
-                        reader, writer = await asyncio.open_connection('localhost', self._config.port)
-                    except Exception as e:  # noqa
-                        log.exception('Failed to connect to cache server - will try again')
-                    else:
-                        writer.close()
-                        await asyncio.wait_for(writer.wait_closed(), timeout=timeout.remaining())
-                        break
-                    await asyncio.sleep(self._config.server_start_sleep)
+
+                await asyncio_wait_until_can_connect(
+                    'localhost',
+                    self._config.port,
+                    timeout=timeout,
+                    on_fail=lambda _: log.exception('Failed to connect to cache server - will try again'),
+                    sleep_s=self._config.server_start_sleep,
+                )
 
                 if (prc := self._config.pull_run_cmd) is not None:
                     pull_cmd = [

omdev/tools/json/parsing.py

@@ -55,10 +55,8 @@ class DelimitingParser:
 class StreamBuilder(lang.ExitStacked):
     _builder: JsonObjectBuilder | None = None
 
-    def __enter__(self) -> ta.Self:
-        super().__enter__()
+    def _enter_contexts(self) -> None:
         self._builder = self._enter_context(JsonObjectBuilder())
-        return self
 
     def build(self, e: JsonStreamParserEvent) -> ta.Generator[ta.Any, None, None]:
         yield from check.not_none(self._builder)(e)
@@ -69,12 +67,10 @@ class StreamParser(lang.ExitStacked):
     _lex: JsonStreamLexer
     _parse: JsonStreamParser
 
-    def __enter__(self) -> ta.Self:
-        super().__enter__()
+    def _enter_contexts(self) -> None:
         self._decoder = codecs.getincrementaldecoder('utf-8')()
         self._lex = self._enter_context(JsonStreamLexer())
         self._parse = self._enter_context(JsonStreamParser())
-        return self
 
     def parse(self, b: bytes) -> ta.Generator[JsonStreamParserEvent, None, None]:
         for s in self._decoder.decode(b, not b):

{omdev-0.0.0.dev242.dist-info → omdev-0.0.0.dev243.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: omdev
-Version: 0.0.0.dev242
+Version: 0.0.0.dev243
 Summary: omdev
 Author: wrmsr
 License: BSD-3-Clause
@@ -12,7 +12,7 @@ Classifier: Operating System :: OS Independent
 Classifier: Operating System :: POSIX
 Requires-Python: >=3.12
 License-File: LICENSE
-Requires-Dist: omlish==0.0.0.dev242
+Requires-Dist: omlish==0.0.0.dev243
 Provides-Extra: all
 Requires-Dist: black~=25.1; extra == "all"
 Requires-Dist: pycparser~=2.22; extra == "all"

{omdev-0.0.0.dev242.dist-info → omdev-0.0.0.dev243.dist-info}/RECORD

@@ -88,7 +88,7 @@ omdev/ci/docker/packing.py,sha256=Bl0aBkkdwES5ePGE3nmyg1CAQzmMDCVP2KTdZUITpQE,20
 omdev/ci/docker/repositories.py,sha256=ZWfObYdZXPn4BBeg8TsYeNVmH1EVEBadfRuxehAhxMM,1223
 omdev/ci/docker/utils.py,sha256=URioGRzqyqdJBZyOfzsrUwv5hSJ3WM23_sLHES9vamc,1129
 omdev/ci/docker/cacheserved/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-omdev/ci/docker/cacheserved/cache.py,sha256=hQdeRMRO0N3l-B0-2Ykua7CGDJiQ40HzZYnzPmFje9Q,7191
+omdev/ci/docker/cacheserved/cache.py,sha256=9bHrVxBS0tSbpGV-tdANxn-vs3A6HF_WYmRH3CbnTKE,7019
 omdev/ci/docker/cacheserved/manifests.py,sha256=C8VPMJoXEEOoTdzWTZLRBtb-bNxJrT5gcaq_ucsvc0I,3584
 omdev/ci/github/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omdev/ci/github/api.py,sha256=Vqza7Hm1OCSfZYgdXF4exkjneqNjFcdO1pl8qmODskU,5198
@@ -171,7 +171,7 @@ omdev/oci/dataserver.py,sha256=QIiJUZQPxL_yDomBuy9UdH3nL1OE2BkP7JxNz4Q3BxE,1863
 omdev/oci/loading.py,sha256=iDMr7JGYRS6CeVrc-LUVjvUA4a49tpgwpJ3y0IImW54,3855
 omdev/oci/media.py,sha256=PM2w1P3YxyvpfaHEDMD8iyBNJa18oVMOLF7KNb2R-DQ,5351
 omdev/oci/repositories.py,sha256=APNQoJxPlN6vaOmQg-MS6cHwGlpTCoVyG8WBjCIaEak,4513
-omdev/oci/tars.py,sha256=ijy27sJ0r3TtQGvEIk5ol4-kuHDktVQ88-75pvjSnds,3434
+omdev/oci/tars.py,sha256=m2KwGYkvO-HjksFkYPjPdwTmIlryZDITDSeQC5UGAhc,3362
 omdev/oci/pack/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omdev/oci/pack/packing.py,sha256=K00GKBPGYYzFEK0CuQvoI7XRLULNld7_i7XcKdQ35zk,5413
 omdev/oci/pack/repositories.py,sha256=EwCJlngKjqpNgcEeszOOnj3WxlQTgLOKo_rwe2PW8JM,4948
@@ -212,7 +212,7 @@ omdev/pyproject/resources/docker-dev.sh,sha256=DHkz5D18jok_oDolfg2mqrvGRWFoCe9GQ
 omdev/pyproject/resources/python.sh,sha256=rFaN4SiJ9hdLDXXsDTwugI6zsw6EPkgYMmtacZeTbvw,749
 omdev/scripts/__init__.py,sha256=MKCvUAEQwsIvwLixwtPlpBqmkMXLCnjjXyAXvVpDwVk,91
 omdev/scripts/bumpversion.py,sha256=2NnfRsJiZNTg-LubIwXCm2vklG7-kIR8_xFUEZNxtiY,1119
-omdev/scripts/ci.py,sha256=qn0oXxQyXG6TpG8yBeTBkmiKCTkhhoHAN6XboExIR4c,328230
+omdev/scripts/ci.py,sha256=ZmbSdJmiIefgfoRkoZYBqACECyMfZnf5aXpRz5UzfZo,333011
 omdev/scripts/execrss.py,sha256=mR0G0wERBYtQmVIn63lCIIFb5zkCM6X_XOENDFYDBKc,651
 omdev/scripts/exectime.py,sha256=S2O4MgtzTsFOY2IUJxsrnOIame9tEFc6aOlKP-F1JSg,1541
 omdev/scripts/importtrace.py,sha256=oa7CtcWJVMNDbyIEiRHej6ICfABfErMeo4_haIqe18Q,14041
@@ -248,15 +248,15 @@ omdev/tools/json/__main__.py,sha256=wqpkN_NsQyNwKW4qjVj8ADJ4_C98KhrFBtE-Z1UamfU,
 omdev/tools/json/cli.py,sha256=EubIMT-n2XsjWBZjSy2fWXqijlwrIhLsfbkg3SZzi28,9586
 omdev/tools/json/formats.py,sha256=RgtPdcs294o9n9czjafHppg1iSzD-olsIc3v8ApM9Os,1908
 omdev/tools/json/io.py,sha256=sfj2hJS9Hy3aUR8a_lLzOrYcmL9fSKyvOHiofdUASsI,1427
-omdev/tools/json/parsing.py,sha256=YOeTRY6Gd89EfcHvqXO5PRWJ3IgRCpNnI54Lb_N3v2k,2183
+omdev/tools/json/parsing.py,sha256=BNCOcPs6eDvB6wePnjl9H0C-ngHxLRgzLM1EPetWnrQ,2093
 omdev/tools/json/processing.py,sha256=iFm5VqaxJ97WHaun2ed7NEjMxhFeJqf28bLNfoDJft0,1209
 omdev/tools/json/rendering.py,sha256=tMcjOW5edfozcMSTxxvF7WVTsbYLoe9bCKFh50qyaGw,2236
 omdev/tools/pawk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omdev/tools/pawk/__main__.py,sha256=VCqeRVnqT1RPEoIrqHFSu4PXVMg4YEgF4qCQm90-eRI,66
 omdev/tools/pawk/pawk.py,sha256=zsEkfQX0jF5bn712uqPAyBSdJt2dno1LH2oeSMNfXQI,11424
-omdev-0.0.0.dev242.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omdev-0.0.0.dev242.dist-info/METADATA,sha256=-Au1sV0H8LhgFIXx279Cq3wL3EOg6QkIh6MgeNBZR3I,1636
-omdev-0.0.0.dev242.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-omdev-0.0.0.dev242.dist-info/entry_points.txt,sha256=dHLXFmq5D9B8qUyhRtFqTGWGxlbx3t5ejedjrnXNYLU,33
-omdev-0.0.0.dev242.dist-info/top_level.txt,sha256=1nr7j30fEWgLYHW3lGR9pkdHkb7knv1U1ES1XRNVQ6k,6
-omdev-0.0.0.dev242.dist-info/RECORD,,
+omdev-0.0.0.dev243.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omdev-0.0.0.dev243.dist-info/METADATA,sha256=RTZBTdIwM0qlSukFnKc503zmK9nPuDaJ67OuGFWudJ8,1636
+omdev-0.0.0.dev243.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+omdev-0.0.0.dev243.dist-info/entry_points.txt,sha256=dHLXFmq5D9B8qUyhRtFqTGWGxlbx3t5ejedjrnXNYLU,33
+omdev-0.0.0.dev243.dist-info/top_level.txt,sha256=1nr7j30fEWgLYHW3lGR9pkdHkb7knv1U1ES1XRNVQ6k,6
+omdev-0.0.0.dev243.dist-info/RECORD,,