omlish 0.0.0.dev241__tar.gz → 0.0.0.dev243__tar.gz

{omlish-0.0.0.dev241/omlish.egg-info → omlish-0.0.0.dev243}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: omlish
-Version: 0.0.0.dev241
+Version: 0.0.0.dev243
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev241 → omlish-0.0.0.dev243}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev241'
-__revision__ = '97c9969eb271b44d0d57f2dae10a680aa62c02e8'
+__version__ = '0.0.0.dev243'
+__revision__ = '97467f9facc16b72c3dac69aba18c543dce228b1'
 
 
 #

omlish-0.0.0.dev243/omlish/asyncs/asyncio/sockets.py

@@ -0,0 +1,45 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+import asyncio
+import typing as ta
+
+from ...lite.timeouts import Timeout
+from ...lite.timeouts import TimeoutLike
+
+
+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-0.0.0.dev241 → omlish-0.0.0.dev243}/omlish/lang/__init__.py

@@ -54,18 +54,15 @@ from .cmp import (  # noqa
 
 from .contextmanagers import (  # noqa
     AsyncContextManager,
-    AsyncExitStacked,
     ContextManaged,
     ContextManager,
     ContextWrapped,
     DefaultLockable,
-    ExitStacked,
     Lockable,
     NOP_CONTEXT_MANAGER,
     NopContextManager,
     Timer,
     a_defer,
-    attr_setting,
     breakpoint_on_exception,
     context_var_setting,
     context_wrapped,
@@ -232,6 +229,12 @@ from .typing import (  # noqa
 
 ##
 
+from ..lite.contextmanagers import (  # noqa
+    attr_setting,
+    AsyncExitStacked,
+    ExitStacked,
+)
+
 from ..lite.imports import (  # noqa
     import_attr,
     import_module,

{omlish-0.0.0.dev241 → omlish-0.0.0.dev243}/omlish/lang/contextmanagers.py

@@ -170,103 +170,6 @@ def context_var_setting(var: contextvars.ContextVar[T], val: T) -> ta.Iterator[T
         var.reset(token)
 
 
-@contextlib.contextmanager
-def attr_setting(obj, attr, val, *, default=None):  # noqa
-    not_set = object()
-    orig = getattr(obj, attr, not_set)
-    try:
-        setattr(obj, attr, val)
-        if orig is not not_set:
-            yield orig
-        else:
-            yield default
-    finally:
-        if orig is not_set:
-            delattr(obj, attr)
-        else:
-            setattr(obj, attr, orig)
-
-
-##
-
-
-class ExitStacked:
-    @property
-    def _exit_stack(self) -> contextlib.ExitStack:
-        try:
-            return self.__exit_stack  # type: ignore
-        except AttributeError:
-            es = self.__exit_stack = contextlib.ExitStack()
-            return es
-
-    def _enter_context(self, context_manager: ta.ContextManager[T]) -> T:
-        return self._exit_stack.enter_context(ta.cast(ta.ContextManager, context_manager))
-
-    def __enter__(self) -> ta.Self:
-        try:
-            superfn = super().__enter__  # type: ignore
-        except AttributeError:
-            ret = self
-        else:
-            ret = superfn()
-        self._exit_stack.__enter__()
-        return ret
-
-    def __exit__(
-            self,
-            exc_type: type[BaseException] | None,
-            exc_val: BaseException | None,
-            exc_tb: types.TracebackType | None,
-    ) -> bool | None:
-        self._exit_stack.__exit__(exc_type, exc_val, exc_tb)
-        try:
-            superfn = super().__exit__  # type: ignore
-        except AttributeError:
-            return None
-        else:
-            return superfn(exc_type, exc_val, exc_tb)
-
-
-class AsyncExitStacked:
-    @property
-    def _exit_stack(self) -> contextlib.AsyncExitStack:
-        try:
-            return self.__exit_stack  # type: ignore
-        except AttributeError:
-            es = self.__exit_stack = contextlib.AsyncExitStack()
-            return es
-
-    async def _enter_async_context(self, context_manager: ta.AsyncContextManager[T]) -> T:
-        return await self._exit_stack.enter_async_context(ta.cast(ta.AsyncContextManager, context_manager))
-
-    def _enter_context(self, context_manager: ta.ContextManager[T]) -> T:
-        return self._exit_stack.enter_context(ta.cast(ta.ContextManager, context_manager))
-
-    async def __aenter__(self) -> ta.Self:
-        try:
-            superfn = super().__aenter__  # type: ignore
-        except AttributeError:
-            ret = self
-        else:
-            ret = await superfn()
-        await self._exit_stack.__aenter__()
-        return ret
-
-    async def __aexit__(
-            self,
-            exc_type: type[BaseException] | None,
-            exc_val: BaseException | None,
-            exc_tb: types.TracebackType | None,
-    ) -> bool | None:
-        await self._exit_stack.__aexit__(exc_type, exc_val, exc_tb)
-        try:
-            superfn = super().__aexit__  # type: ignore
-        except AttributeError:
-            return None
-        else:
-            return await superfn(exc_type, exc_val, exc_tb)
-
-
 ##
 
 

omlish-0.0.0.dev243/omlish/lite/contextmanagers.py

@@ -0,0 +1,195 @@
+# ruff: noqa: UP007
+import contextlib
+import sys
+import typing as ta
+
+from .check import check
+
+
+T = ta.TypeVar('T')
+ExitStackedT = ta.TypeVar('ExitStackedT', bound='ExitStacked')
+AsyncExitStackedT = ta.TypeVar('AsyncExitStackedT', bound='AsyncExitStacked')
+
+
+##
+
+
+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:
+        """
+        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
+        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
+
+    def _enter_context(self, cm: ta.ContextManager[T]) -> T:
+        es = check.not_none(self._exit_stack)
+        return es.enter_context(cm)
+
+
+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:
+        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
+        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
+
+    def _enter_context(self, cm: ta.ContextManager[T]) -> T:
+        es = check.not_none(self._exit_stack)
+        return es.enter_context(cm)
+
+    async def _enter_async_context(self, cm: ta.AsyncContextManager[T]) -> T:
+        es = check.not_none(self._exit_stack)
+        return await es.enter_async_context(cm)
+
+
+##
+
+
+@contextlib.contextmanager
+def defer(fn: ta.Callable) -> ta.Generator[ta.Callable, None, None]:
+    try:
+        yield fn
+    finally:
+        fn()
+
+
+@contextlib.asynccontextmanager
+async def adefer(fn: ta.Callable) -> ta.AsyncGenerator[ta.Callable, None]:
+    try:
+        yield fn
+    finally:
+        await fn()
+
+
+##
+
+
+@contextlib.contextmanager
+def attr_setting(obj, attr, val, *, default=None):  # noqa
+    not_set = object()
+    orig = getattr(obj, attr, not_set)
+    try:
+        setattr(obj, attr, val)
+        if orig is not not_set:
+            yield orig
+        else:
+            yield default
+    finally:
+        if orig is not_set:
+            delattr(obj, attr)
+        else:
+            setattr(obj, attr, orig)
+
+
+##
+
+
+class aclosing(contextlib.AbstractAsyncContextManager):  # noqa
+    def __init__(self, thing):
+        self.thing = thing
+
+    async def __aenter__(self):
+        return self.thing
+
+    async def __aexit__(self, *exc_info):
+        await self.thing.aclose()

{omlish-0.0.0.dev241 → omlish-0.0.0.dev243}/omlish/logs/protocol.py

@@ -23,25 +23,25 @@ class Logging(ta.Protocol):
 
     #
 
-    def debug(self, msg: str, *args, **kwargs) -> None:
+    def debug(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
         ...
 
-    def info(self, msg: str, *args, **kwargs) -> None:
+    def info(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
         ...
 
-    def warning(self, msg: str, *args, **kwargs) -> None:
+    def warning(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
         ...
 
-    def error(self, msg: str, *args, **kwargs) -> None:
+    def error(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
         ...
 
-    def exception(self, msg: str, *args, exc_info=True, **kwargs) -> None:
+    def exception(self, msg: str, *args: ta.Any, exc_info: bool = True, **kwargs) -> None:
         ...
 
-    def critical(self, msg: str, *args, **kwargs) -> None:
+    def critical(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
         ...
 
-    def log(self, level: LogLevel, msg: str, *args, **kwargs) -> None:
+    def log(self, level: LogLevel, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
         ...
 
 
@@ -66,30 +66,30 @@ class AbstractLogging(abc.ABC):
 
     #
 
-    def debug(self, msg: str, *args, **kwargs) -> None:
+    def debug(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
         if self.is_enabled_for(logging.DEBUG):
             self.log(logging.DEBUG, msg, args, **kwargs)
 
-    def info(self, msg: str, *args, **kwargs) -> None:
+    def info(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
         if self.is_enabled_for(logging.INFO):
             self.log(logging.INFO, msg, args, **kwargs)
 
-    def warning(self, msg: str, *args, **kwargs) -> None:
+    def warning(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
         if self.is_enabled_for(logging.WARNING):
             self.log(logging.WARNING, msg, args, **kwargs)
 
-    def error(self, msg: str, *args, **kwargs) -> None:
+    def error(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
         if self.is_enabled_for(logging.ERROR):
             self.log(logging.ERROR, msg, args, **kwargs)
 
-    def exception(self, msg: str, *args, exc_info=True, **kwargs) -> None:
+    def exception(self, msg: str, *args: ta.Any, exc_info: bool = True, **kwargs: ta.Any) -> None:
         self.error(msg, *args, exc_info=exc_info, **kwargs)
 
-    def critical(self, msg: str, *args, **kwargs) -> None:
+    def critical(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
         if self.is_enabled_for(logging.CRITICAL):
             self.log(logging.CRITICAL, msg, args, **kwargs)
 
-    def log(self, level: LogLevel, msg: str, *args, **kwargs) -> None:
+    def log(self, level: LogLevel, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
         if not isinstance(level, int):
             raise TypeError('Level must be an integer.')
         if self.is_enabled_for(level):

{omlish-0.0.0.dev241 → omlish-0.0.0.dev243}/omlish/sockets/server/server.py

@@ -2,11 +2,14 @@
 # ruff: noqa: UP006 UP007
 import abc
 import contextlib
+import enum
 import logging
 import selectors
 import threading
 import typing as ta
 
+from ...lite.contextmanagers import ExitStacked
+from ...lite.contextmanagers import defer
 from ..addresses import SocketAndAddress
 from ..bind import SocketBinder
 from ..io import close_socket_immediately
@@ -76,58 +79,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
+
+            # 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
 
-                    # bpo-35017: shutdown() called during select(), exit immediately.
-                    if self._should_shutdown:
-                        break  # type: ignore[unreachable]
+        def poll(self, timeout: ta.Optional[float] = None) -> 'SocketServer.PollResult':
+            if self._server._should_shutdown:  # noqa: SLF001
+                return SocketServer.PollResult.SHUTDOWN
 
-                    if ready:
-                        try:
-                            conn = self._binder.accept()
+            ready = self._selector.select(timeout)
 
-                        except OSError as exc:
-                            self._handle_error(exc)
+            # bpo-35017: shutdown() called during select(), exit immediately.
+            if self._server._should_shutdown:  # noqa: SLF001
+                return SocketServer.PollResult.SHUTDOWN  # type: ignore[unreachable]
 
-                            return
+            if not ready:
+                return SocketServer.PollResult.TIMEOUT
 
-                        try:
-                            self._handler(conn)
+            try:
+                conn = self._server._binder.accept()  # noqa: SLF001
+
+            except OSError as exc:
+                self._server._handle_error(exc)  # noqa: SLF001
 
-                        except Exception as exc:  # noqa
-                            self._handle_error(exc, conn)
+                return SocketServer.PollResult.ERROR
 
-                            close_socket_immediately(conn.socket)
+            try:
+                self._server._handler(conn)  # noqa: SLF001
 
-                    yield bool(ready)
+            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)
+
+    #
+
+    @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
+
+        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()
 

omlish-0.0.0.dev243/omlish/sockets/wait.py

@@ -0,0 +1,39 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+import socket
+import threading
+import typing as ta
+
+from ..lite.timeouts import Timeout
+from ..lite.timeouts import TimeoutLike
+
+
+def socket_wait_until_can_connect(
+        address: ta.Any,
+        *,
+        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,),
+        cancel_event: ta.Optional[threading.Event] = None,
+) -> None:
+    timeout = Timeout.of(timeout)
+
+    if cancel_event is None:
+        cancel_event = threading.Event()
+
+    while not cancel_event.is_set():
+        timeout()
+
+        try:
+            conn = socket.create_connection(address, timeout=timeout.or_(None))
+
+        except exception as e:  # noqa
+            if on_fail is not None:
+                on_fail(e)
+
+        else:
+            conn.close()
+            break
+
+        cancel_event.wait(min(sleep_s, timeout.remaining()))

{omlish-0.0.0.dev241 → omlish-0.0.0.dev243/omlish.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: omlish
-Version: 0.0.0.dev241
+Version: 0.0.0.dev243
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev241 → omlish-0.0.0.dev243}/omlish.egg-info/SOURCES.txt

@@ -111,6 +111,7 @@ omlish/asyncs/asyncio/__init__.py
 omlish/asyncs/asyncio/all.py
 omlish/asyncs/asyncio/asyncio.py
 omlish/asyncs/asyncio/channels.py
+omlish/asyncs/asyncio/sockets.py
 omlish/asyncs/asyncio/streams.py
 omlish/asyncs/asyncio/subprocesses.py
 omlish/asyncs/asyncio/timeouts.py
@@ -575,6 +576,7 @@ omlish/sockets/bind.py
 omlish/sockets/handlers.py
 omlish/sockets/io.py
 omlish/sockets/ports.py
+omlish/sockets/wait.py
 omlish/sockets/server/__init__.py
 omlish/sockets/server/handlers.py
 omlish/sockets/server/server.py

{omlish-0.0.0.dev241 → omlish-0.0.0.dev243}/pyproject.toml

@@ -12,7 +12,7 @@ authors = [
 urls = {source = 'https://github.com/wrmsr/omlish'}
 license = {text = 'BSD-3-Clause'}
 requires-python = '>=3.12'
-version = '0.0.0.dev241'
+version = '0.0.0.dev243'
 classifiers = [
     'License :: OSI Approved :: BSD License',
     'Development Status :: 2 - Pre-Alpha',