omlish 0.0.0.dev224__py3-none-any.whl → 0.0.0.dev226__py3-none-any.whl

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/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,
@@ -225,14 +226,6 @@ from .sys import (  # noqa
     is_gil_enabled,
 )
 
-from .timeouts import (  # noqa
-    DeadlineTimeout,
-    InfiniteTimeout,
-    Timeout,
-    TimeoutLike,
-    timeout,
-)
-
 from .typing import (  # noqa
     BytesLike,
     SequenceNotStr,
@@ -243,6 +236,13 @@ from .typing import (  # noqa
 
 ##
 
+from ..lite.timeouts import (  # noqa
+    DeadlineTimeout,
+    InfiniteTimeout,
+    Timeout,
+    TimeoutLike,
+)
+
 from ..lite.types import (  # noqa
     BUILTIN_SCALAR_ITERABLE_TYPES,
 )

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/dataclasses.py

@@ -42,3 +42,26 @@ def dataclass_maybe_post_init(sup: ta.Any) -> bool:
         return False
     fn()
     return True
+
+
+def dataclass_repr_filtered(
+        obj: ta.Any,
+        fn: ta.Callable[[ta.Any, dc.Field, ta.Any], bool],
+) -> str:
+    return (
+        f'{obj.__class__.__qualname__}(' +
+        ', '.join([
+            f'{f.name}={v!r}'
+            for f in dc.fields(obj)
+            if fn(obj, f, v := getattr(obj, f.name))
+        ]) +
+        ')'
+    )
+
+
+def dataclass_repr_omit_none(obj: ta.Any) -> str:
+    return dataclass_repr_filtered(obj, lambda o, f, v: v is not None)
+
+
+def dataclass_repr_omit_falsey(obj: ta.Any) -> str:
+    return dataclass_repr_filtered(obj, lambda o, f, v: bool(v))

omlish/lite/timeouts.py

@@ -0,0 +1,202 @@
+# ruff: noqa: UP006 UP007
+"""
+TODO:
+ - Event (/ Predicate)
+"""
+import abc
+import time
+import typing as ta
+
+
+TimeoutLike = ta.Union['Timeout', 'Timeout.Default', ta.Iterable['TimeoutLike'], float]  # ta.TypeAlias
+
+
+##
+
+
+class Timeout(abc.ABC):
+    @property
+    @abc.abstractmethod
+    def can_expire(self) -> bool:
+        """Indicates whether or not this timeout will ever expire."""
+
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def expired(self) -> bool:
+        """Return whether or not this timeout has expired."""
+
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def remaining(self) -> float:
+        """Returns the time (in seconds) remaining until the timeout expires. May be negative and/or infinite."""
+
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def __call__(self) -> float:
+        """Returns the time (in seconds) remaining until the timeout expires, or raises if the timeout has expired."""
+
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def or_(self, o: ta.Any) -> ta.Any:
+        """Evaluates time remaining via remaining() if this timeout can expire, otherwise returns `o`."""
+
+        raise NotImplementedError
+
+    #
+
+    @classmethod
+    def _now(cls) -> float:
+        return time.time()
+
+    #
+
+    class Default:
+        def __new__(cls, *args, **kwargs):  # noqa
+            raise TypeError
+
+    class _NOT_SPECIFIED:  # noqa
+        def __new__(cls, *args, **kwargs):  # noqa
+            raise TypeError
+
+    @classmethod
+    def of(
+            cls,
+            obj: ta.Optional[TimeoutLike],
+            default: ta.Union[TimeoutLike, ta.Type[_NOT_SPECIFIED]] = _NOT_SPECIFIED,
+    ) -> 'Timeout':
+        if obj is None:
+            return InfiniteTimeout()
+
+        elif isinstance(obj, Timeout):
+            return obj
+
+        elif isinstance(obj, (float, int)):
+            return DeadlineTimeout(cls._now() + obj)
+
+        elif isinstance(obj, ta.Iterable):
+            return CompositeTimeout(*[Timeout.of(c) for c in obj])
+
+        elif obj is Timeout.Default:
+            if default is Timeout._NOT_SPECIFIED or default is Timeout.Default:
+                raise RuntimeError('Must specify a default timeout')
+
+            else:
+                return Timeout.of(default)  # type: ignore[arg-type]
+
+        else:
+            raise TypeError(obj)
+
+    @classmethod
+    def of_deadline(cls, deadline: float) -> 'DeadlineTimeout':
+        return DeadlineTimeout(deadline)
+
+    @classmethod
+    def of_predicate(cls, expired_fn: ta.Callable[[], bool]) -> 'PredicateTimeout':
+        return PredicateTimeout(expired_fn)
+
+
+class DeadlineTimeout(Timeout):
+    def __init__(
+            self,
+            deadline: float,
+            exc: ta.Union[ta.Type[BaseException], BaseException] = TimeoutError,
+    ) -> None:
+        super().__init__()
+
+        self.deadline = deadline
+        self.exc = exc
+
+    @property
+    def can_expire(self) -> bool:
+        return True
+
+    def expired(self) -> bool:
+        return not (self.remaining() > 0)
+
+    def remaining(self) -> float:
+        return self.deadline - self._now()
+
+    def __call__(self) -> float:
+        if (rem := self.remaining()) > 0:
+            return rem
+        raise self.exc
+
+    def or_(self, o: ta.Any) -> ta.Any:
+        return self()
+
+
+class InfiniteTimeout(Timeout):
+    @property
+    def can_expire(self) -> bool:
+        return False
+
+    def expired(self) -> bool:
+        return False
+
+    def remaining(self) -> float:
+        return float('inf')
+
+    def __call__(self) -> float:
+        return float('inf')
+
+    def or_(self, o: ta.Any) -> ta.Any:
+        return o
+
+
+class CompositeTimeout(Timeout):
+    def __init__(self, *children: Timeout) -> None:
+        super().__init__()
+
+        self.children = children
+
+    @property
+    def can_expire(self) -> bool:
+        return any(c.can_expire for c in self.children)
+
+    def expired(self) -> bool:
+        return any(c.expired() for c in self.children)
+
+    def remaining(self) -> float:
+        return min(c.remaining() for c in self.children)
+
+    def __call__(self) -> float:
+        return min(c() for c in self.children)
+
+    def or_(self, o: ta.Any) -> ta.Any:
+        if self.can_expire:
+            return self()
+        return o
+
+
+class PredicateTimeout(Timeout):
+    def __init__(
+            self,
+            expired_fn: ta.Callable[[], bool],
+            exc: ta.Union[ta.Type[BaseException], BaseException] = TimeoutError,
+    ) -> None:
+        super().__init__()
+
+        self.expired_fn = expired_fn
+        self.exc = exc
+
+    @property
+    def can_expire(self) -> bool:
+        return True
+
+    def expired(self) -> bool:
+        return self.expired_fn()
+
+    def remaining(self) -> float:
+        return float('inf')
+
+    def __call__(self) -> float:
+        if not self.expired_fn():
+            return float('inf')
+        raise self.exc
+
+    def or_(self, o: ta.Any) -> ta.Any:
+        return self()

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/fcntl.py

@@ -0,0 +1,59 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+import dataclasses as dc
+import os
+import struct
+import sys
+import typing as ta
+
+
+@dc.dataclass(frozen=True)
+class FcntlLockData:
+    # cmd = {F_SETLK, F_SETLKW, F_GETLK}
+
+    type: int  # {F_RDLCK, F_WRLCK, F_UNLCK}
+    whence: int = os.SEEK_SET
+    start: int = 0
+    len: int = 0
+    pid: int = 0
+
+    #
+
+    _STRUCT_PACK_BY_PLATFORM: ta.ClassVar[ta.Mapping[str, ta.Sequence[ta.Tuple[str, str]]]] = {
+        'linux': [
+            ('type', 'h'),
+            ('whence', 'h'),
+            ('start', 'q'),
+            ('len', 'q'),
+            ('pid', 'i'),
+        ],
+        'darwin': [
+            ('start', 'q'),
+            ('len', 'q'),
+            ('pid', 'i'),
+            ('type', 'h'),
+            ('whence', 'h'),
+        ],
+    }
+
+    def pack(self) -> bytes:
+        try:
+            pack = self._STRUCT_PACK_BY_PLATFORM[sys.platform]
+        except KeyError:
+            raise OSError from None
+
+        fmt = ''.join(f for _, f in pack)
+        tup = [getattr(self, a) for a, _ in pack]
+        return struct.pack(fmt, *tup)
+
+    @classmethod
+    def unpack(cls, data: bytes) -> 'FcntlLockData':
+        try:
+            pack = cls._STRUCT_PACK_BY_PLATFORM[sys.platform]
+        except KeyError:
+            raise OSError from None
+
+        fmt = ''.join(f for _, f in pack)
+        tup = struct.unpack(fmt, data)
+        kw = {a: v for (a, _), v in zip(pack, tup)}
+        return FcntlLockData(**kw)

omlish/os/pidfiles/manager.py

@@ -0,0 +1,111 @@
+# 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:
+    """
+    Manager for controlled inheritance of Pidfiles across forks.
+
+    Not implemented as an instantiated class as there is no way to unregister at_fork listeners, and because Pidfiles
+    may be pickled and there must be no possibility of accidentally unpickling and instantiating a new instance of the
+    manager.
+    """
+
+    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]:
+        """
+        A contextmanager for creating and managing a Pidfile which will only be inherited by forks of the calling /
+        creating thread.
+        """
+
+        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