omlish 0.0.0.dev223__py3-none-any.whl → 0.0.0.dev225__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev223'
-__revision__ = '383167fabe843d406905492267a5c570dae7cba3'
+__version__ = '0.0.0.dev225'
+__revision__ = '99eb1740a6c8647c20c80278b6d0bedff0f7c103'
 
 
 #

omlish/asyncs/asyncio/subprocesses.py

@@ -10,9 +10,9 @@ import sys
 import typing as ta
 
 from ...lite.check import check
-from ...subprocesses import AbstractAsyncSubprocesses
-from ...subprocesses import SubprocessRun
-from ...subprocesses import SubprocessRunOutput
+from ...subprocesses.async_ import AbstractAsyncSubprocesses
+from ...subprocesses.run import SubprocessRun
+from ...subprocesses.run import SubprocessRunOutput
 from .timeouts import asyncio_maybe_timeout
 
 
@@ -157,19 +157,19 @@ class AsyncioSubprocesses(AbstractAsyncSubprocesses):
             timeout: ta.Optional[float] = None,
             **kwargs: ta.Any,
     ) -> ta.AsyncGenerator[asyncio.subprocess.Process, None]:
-        fac: ta.Any
-        if shell:
-            fac = functools.partial(
-                asyncio.create_subprocess_shell,
-                check.single(cmd),
-            )
-        else:
-            fac = functools.partial(
-                asyncio.create_subprocess_exec,
-                *cmd,
-            )
-
         with self.prepare_and_wrap( *cmd, shell=shell, **kwargs) as (cmd, kwargs):  # noqa
+            fac: ta.Any
+            if shell:
+                fac = functools.partial(
+                    asyncio.create_subprocess_shell,
+                    check.single(cmd),
+                )
+            else:
+                fac = functools.partial(
+                    asyncio.create_subprocess_exec,
+                    *cmd,
+                )
+
             proc: asyncio.subprocess.Process = await fac(**kwargs)
             try:
                 yield proc

omlish/asyncs/asyncs.py

@@ -55,7 +55,6 @@ async def async_list(fn: ta.Callable[..., ta.AsyncIterator[T]], *args, **kwargs)
 
 
 class SyncableIterable(ta.Generic[T]):
-
     def __init__(self, obj) -> None:
         super().__init__()
         self._obj = obj

omlish/bootstrap/sys.py

@@ -23,13 +23,13 @@ if ta.TYPE_CHECKING:
     from .. import libc
     from ..formats import dotenv
     from ..logs import all as logs
-    from ..os import pidfile
+    from ..os.pidfiles import pidfile
 
 else:
     libc = lang.proxy_import('..libc', __package__)
     logs = lang.proxy_import('..logs', __package__)
     dotenv = lang.proxy_import('..formats.dotenv', __package__)
-    pidfile = lang.proxy_import('..os.pidfile', __package__)
+    pidfile = lang.proxy_import('..os.pidfiles.pidfile', __package__)
 
 
 ##

omlish/dataclasses/impl/metaclass.py

@@ -188,8 +188,13 @@ class Data(
     metaclass=DataMeta,
 ):
     def __init__(self, *args, **kwargs):
+        # Typechecking barrier
         super().__init__(*args, **kwargs)
 
+    def __init_subclass__(cls, **kwargs):
+        # Typechecking barrier
+        super().__init_subclass__(**kwargs)
+
     def __post_init__(self, *args, **kwargs) -> None:
         try:
             spi = super().__post_init__  # type: ignore  # noqa

omlish/http/coro/server.py

@@ -65,8 +65,6 @@ import typing as ta
 
 from ...lite.check import check
 from ...sockets.addresses import SocketAddress
-from ...sockets.handlers import SocketHandler_
-from ...sockets.io import SocketIoPair
 from ..handlers import HttpHandler
 from ..handlers import HttpHandlerRequest
 from ..handlers import HttpHandlerResponseData
@@ -423,6 +421,9 @@ class CoroHttpServer:
     def coro_handle(self) -> ta.Generator[Io, ta.Optional[bytes], None]:
         return self._coro_run_handler(self._coro_handle_one())
 
+    class Close(Exception):  # noqa
+        pass
+
     def _coro_run_handler(
             self,
             gen: ta.Generator[
@@ -462,7 +463,7 @@ class CoroHttpServer:
 
                 try:
                     o = gen.send(i)
-                except EOFError:
+                except self.Close:
                     return
                 except StopIteration:
                     break
@@ -491,7 +492,7 @@ class CoroHttpServer:
                 break
 
         if isinstance(parsed, EmptyParsedHttpResult):
-            raise EOFError  # noqa
+            raise self.Close
 
         if isinstance(parsed, ParseHttpRequestError):
             err = self._build_error(
@@ -581,53 +582,3 @@ class CoroHttpServer:
             handler_response.close()
 
             raise
-
-
-##
-
-
-class CoroHttpServerSocketHandler(SocketHandler_):
-    def __init__(
-            self,
-            server_factory: CoroHttpServerFactory,
-            *,
-            log_handler: ta.Optional[ta.Callable[[CoroHttpServer, CoroHttpServer.AnyLogIo], None]] = None,
-    ) -> None:
-        super().__init__()
-
-        self._server_factory = server_factory
-        self._log_handler = log_handler
-
-    def __call__(self, client_address: SocketAddress, fp: SocketIoPair) -> None:
-        server = self._server_factory(client_address)
-
-        gen = server.coro_handle()
-
-        o = next(gen)
-        while True:
-            if isinstance(o, CoroHttpServer.AnyLogIo):
-                i = None
-                if self._log_handler is not None:
-                    self._log_handler(server, o)
-
-            elif isinstance(o, CoroHttpServer.ReadIo):
-                i = fp.r.read(o.sz)
-
-            elif isinstance(o, CoroHttpServer.ReadLineIo):
-                i = fp.r.readline(o.sz)
-
-            elif isinstance(o, CoroHttpServer.WriteIo):
-                i = None
-                fp.w.write(o.data)
-                fp.w.flush()
-
-            else:
-                raise TypeError(o)
-
-            try:
-                if i is not None:
-                    o = gen.send(i)
-                else:
-                    o = next(gen)
-            except StopIteration:
-                break

omlish/http/coro/simple.py

@@ -21,7 +21,7 @@ from ..parsing import HttpRequestParser
 from ..versions import HttpProtocolVersion
 from ..versions import HttpProtocolVersions
 from .server import CoroHttpServer
-from .server import CoroHttpServerSocketHandler
+from .sockets import CoroHttpServerSocketHandler
 
 
 if ta.TYPE_CHECKING:

omlish/http/coro/sockets.py

@@ -0,0 +1,59 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+import typing as ta
+
+from ...sockets.addresses import SocketAddress
+from ...sockets.handlers import SocketHandler_
+from ...sockets.io import SocketIoPair
+from .server import CoroHttpServer
+from .server import CoroHttpServerFactory
+
+
+##
+
+
+class CoroHttpServerSocketHandler(SocketHandler_):
+    def __init__(
+            self,
+            server_factory: CoroHttpServerFactory,
+            *,
+            log_handler: ta.Optional[ta.Callable[[CoroHttpServer, CoroHttpServer.AnyLogIo], None]] = None,
+    ) -> None:
+        super().__init__()
+
+        self._server_factory = server_factory
+        self._log_handler = log_handler
+
+    def __call__(self, client_address: SocketAddress, fp: SocketIoPair) -> None:
+        server = self._server_factory(client_address)
+
+        gen = server.coro_handle()
+
+        o = next(gen)
+        while True:
+            if isinstance(o, CoroHttpServer.AnyLogIo):
+                i = None
+                if self._log_handler is not None:
+                    self._log_handler(server, o)
+
+            elif isinstance(o, CoroHttpServer.ReadIo):
+                i = fp.r.read(o.sz)
+
+            elif isinstance(o, CoroHttpServer.ReadLineIo):
+                i = fp.r.readline(o.sz)
+
+            elif isinstance(o, CoroHttpServer.WriteIo):
+                i = None
+                fp.w.write(o.data)
+                fp.w.flush()
+
+            else:
+                raise TypeError(o)
+
+            try:
+                if i is not None:
+                    o = gen.send(i)
+                else:
+                    o = next(gen)
+            except StopIteration:
+                break

omlish/http/handlers.py

@@ -63,14 +63,65 @@ class HttpHandler_(abc.ABC):  # noqa
         raise NotImplementedError
 
 
+##
+
+
 @dc.dataclass(frozen=True)
 class LoggingHttpHandler(HttpHandler_):
     handler: HttpHandler
     log: logging.Logger
-    level: int = logging.INFO
+    level: int = logging.DEBUG
 
     def __call__(self, req: HttpHandlerRequest) -> HttpHandlerResponse:
         self.log.log(self.level, '%r', req)
         resp = self.handler(req)
         self.log.log(self.level, '%r', resp)
         return resp
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class BytesResponseHttpHandler(HttpHandler_):
+    data: bytes
+
+    status: ta.Union[http.HTTPStatus, int] = 200
+    content_type: ta.Optional[str] = 'application/octet-stream'
+    headers: ta.Optional[ta.Mapping[str, str]] = None
+    close_connection: bool = True
+
+    def __call__(self, req: HttpHandlerRequest) -> HttpHandlerResponse:
+        return HttpHandlerResponse(
+            status=self.status,
+            headers={
+                **({'Content-Type': self.content_type} if self.content_type else {}),
+                'Content-Length': str(len(self.data)),
+                **(self.headers or {}),
+            },
+            data=self.data,
+            close_connection=self.close_connection,
+        )
+
+
+@dc.dataclass(frozen=True)
+class StringResponseHttpHandler(HttpHandler_):
+    data: str
+
+    status: ta.Union[http.HTTPStatus, int] = 200
+    content_type: ta.Optional[str] = 'text/plain; charset=utf-8'
+    headers: ta.Optional[ta.Mapping[str, str]] = None
+    close_connection: bool = True
+
+    def __call__(self, req: HttpHandlerRequest) -> HttpHandlerResponse:
+        data = self.data.encode('utf-8')
+        return HttpHandlerResponse(
+            status=self.status,
+            headers={
+                **({'Content-Type': self.content_type} if self.content_type else {}),
+                'Content-Length': str(len(data)),
+                **(self.headers or {}),
+            },
+            data=data,
+            close_connection=self.close_connection,
+        )

omlish/lang/__init__.py

@@ -138,6 +138,7 @@ from .generators import (  # noqa
 from .imports import (  # noqa
     can_import,
     import_all,
+    import_attr,
     import_module,
     import_module_attr,
     lazy_import,

omlish/lang/imports.py

@@ -108,6 +108,28 @@ def import_module_attr(dotted_path: str) -> ta.Any:
         raise AttributeError(f'Module {module_name!r} has no attr {class_name!r}') from None
 
 
+def import_attr(dotted_path: str) -> ta.Any:
+    parts = dotted_path.split('.')
+    mod: ta.Any = None
+    mod_pos = 0
+    while mod_pos < len(parts):
+        mod_name = '.'.join(parts[:mod_pos + 1])
+        try:
+            mod = importlib.import_module(mod_name)
+        except ImportError:
+            break
+        mod_pos += 1
+    if mod is None:
+        raise ImportError(dotted_path)
+    obj = mod
+    for att_pos in range(mod_pos, len(parts)):
+        obj = getattr(obj, parts[att_pos])
+    return obj
+
+
+##
+
+
 SPECIAL_IMPORTABLE: ta.AbstractSet[str] = frozenset([
     '__init__.py',
     '__main__.py',

omlish/libc.py

@@ -392,6 +392,14 @@ if LINUX or DARWIN:
         return CMSG_ALIGN(ct.sizeof(cmsghdr)) + sz
 
     def sendfd(sock, fd, data='.'):
+        """
+        Note: stdlib as of 3.7:
+
+          https://github.com/python/cpython/blob/84ed9a68bd9a13252b376b21a9167dabae254325/Lib/multiprocessing/reduction.py#L141
+
+        But still kept around due to other use of cmsg machinery.
+        """  # noqa
+
         if not data:
             raise ValueError(data)
 
@@ -424,6 +432,8 @@ if LINUX or DARWIN:
         return libc.sendmsg(sock, msgh, 0)
 
     def recvfd(sock, buf_len=4096):
+        """See sendfd."""
+
         if buf_len < 1:
             raise ValueError(buf_len)
 

omlish/lite/timing.py

@@ -0,0 +1,8 @@
+from ..logs.timing import LogTimingContext
+from ..logs.timing import log_timing_context
+from .logs import log
+
+
+LogTimingContext.DEFAULT_LOG = log
+
+log_timing_context = log_timing_context  # noqa

omlish/logs/timing.py

@@ -0,0 +1,58 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+import logging
+import time
+import typing as ta
+
+
+##
+
+
+class LogTimingContext:
+    DEFAULT_LOG: ta.ClassVar[ta.Optional[logging.Logger]] = None
+
+    class _NOT_SPECIFIED:  # noqa
+        def __new__(cls, *args, **kwargs):  # noqa
+            raise TypeError
+
+    def __init__(
+            self,
+            description: str,
+            *,
+            log: ta.Union[logging.Logger, ta.Type[_NOT_SPECIFIED], None] = _NOT_SPECIFIED,  # noqa
+            level: int = logging.DEBUG,
+    ) -> None:
+        super().__init__()
+
+        self._description = description
+        if log is self._NOT_SPECIFIED:
+            log = self.DEFAULT_LOG  # noqa
+        self._log: ta.Optional[logging.Logger] = log  # type: ignore
+        self._level = level
+
+    def set_description(self, description: str) -> 'LogTimingContext':
+        self._description = description
+        return self
+
+    _begin_time: float
+    _end_time: float
+
+    def __enter__(self) -> 'LogTimingContext':
+        self._begin_time = time.time()
+
+        if self._log is not None:
+            self._log.log(self._level, f'Begin : {self._description}')  # noqa
+
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self._end_time = time.time()
+
+        if self._log is not None:
+            self._log.log(
+                self._level,
+                f'End : {self._description} - {self._end_time - self._begin_time:0.2f} s elapsed',
+            )
+
+
+log_timing_context = LogTimingContext

omlish/multiprocessing/__init__.py

@@ -4,13 +4,6 @@ import typing as _ta
 from .. import lang as _lang
 
 
-from .death import (  # noqa
-    BaseDeathpact,
-    Deathpact,
-    NopDeathpact,
-    PipeDeathpact,
-)
-
 from .proxies import (  # noqa
     DummyValueProxy,
     ValueProxy,

omlish/os/pidfiles/manager.py

@@ -0,0 +1,97 @@
+# ruff: noqa: UP007
+# @omlish-lite
+import contextlib
+import os
+import threading
+import typing as ta
+import weakref
+
+from ...lite.check import check
+from .pidfile import Pidfile
+
+
+##
+
+
+class _PidfileManager:
+    def __new__(cls, *args, **kwargs):  # noqa
+        raise TypeError
+
+    _lock: ta.ClassVar[threading.Lock] = threading.Lock()
+    _installed: ta.ClassVar[bool] = False
+    _pidfile_threads: ta.ClassVar[ta.MutableMapping[Pidfile, threading.Thread]] = weakref.WeakKeyDictionary()
+
+    @classmethod
+    def _before_fork(cls) -> None:
+        cls._lock.acquire()
+
+    @classmethod
+    def _after_fork_in_parent(cls) -> None:
+        cls._lock.release()
+
+    @classmethod
+    def _after_fork_in_child(cls) -> None:
+        th = threading.current_thread()
+        for pf, pf_th in list(cls._pidfile_threads.items()):
+            if pf_th is not th:
+                pf.close()
+                del cls._pidfile_threads[pf]
+
+        cls._lock.release()
+
+    #
+
+    @classmethod
+    def _install(cls) -> None:
+        check.state(not cls._installed)
+
+        os.register_at_fork(
+            before=cls._before_fork,
+            after_in_parent=cls._after_fork_in_parent,
+            after_in_child=cls._after_fork_in_child,
+        )
+
+        cls._installed = True
+
+    @classmethod
+    def install(cls) -> bool:
+        with cls._lock:
+            if cls._installed:
+                return False
+
+            cls._install()
+            return True
+
+    @classmethod
+    @contextlib.contextmanager
+    def inheritable_pidfile_context(
+            cls,
+            path: str,
+            *,
+            inheritable: bool = True,
+            **kwargs: ta.Any,
+    ) -> ta.Iterator[Pidfile]:
+        check.arg(inheritable)
+
+        cls.install()
+
+        pf = Pidfile(
+            path,
+            inheritable=False,
+            **kwargs,
+        )
+
+        with cls._lock:
+            cls._pidfile_threads[pf] = threading.current_thread()
+        try:
+            with pf:
+                os.set_inheritable(check.not_none(pf.fileno()), True)
+                yield pf
+
+        finally:
+            with cls._lock:
+                del cls._pidfile_threads[pf]
+
+
+def open_inheritable_pidfile(path: str, **kwargs: ta.Any) -> ta.ContextManager[Pidfile]:
+    return _PidfileManager.inheritable_pidfile_context(path, **kwargs)  # noqa