omlish 0.0.0.dev229__py3-none-any.whl → 0.0.0.dev231__py3-none-any.whl

omlish/os/{death.py → deathpacts/pipe.py}

@@ -1,84 +1,11 @@
-import abc
 import os
-import signal
-import sys
-import time
 import typing as ta
 import weakref
 
-from .. import check
-from .forkhooks import ForkHook
-from .forkhooks import get_fork_depth
-
-
-##
-
-
-class Deathpact(abc.ABC):
-    @abc.abstractmethod
-    def poll(self) -> None:
-        raise NotImplementedError
-
-
-class NopDeathpact(Deathpact):
-    def poll(self) -> None:
-        pass
-
-
-##
-
-
-class BaseDeathpact(Deathpact, abc.ABC):
-    def __init__(
-            self,
-            *,
-            interval_s: float = .5,
-            signal: int | None = signal.SIGTERM,
-            output: ta.Literal['stdout', 'stderr'] | None = 'stderr',
-            on_die: ta.Callable[[], None] | None = None,
-    ) -> None:
-        super().__init__()
-
-        self._interval_s = interval_s
-        self._signal = signal
-        self._output = output
-        self._on_die = on_die
-
-        self._last_check_t: float | None = None
-
-    def _print(self, msg: str) -> None:
-        match self._output:
-            case 'stdout':
-                f = sys.stdout
-            case 'stderr':
-                f = sys.stderr
-            case _:
-                return
-        print(f'{self} pid={os.getpid()}: {msg}', file=f)
-
-    def die(self) -> None:
-        self._print('Triggered! Process terminating!')
-
-        if self._on_die is not None:
-            self._on_die()
-
-        if self._signal is not None:
-            os.kill(os.getpid(), self._signal)
-
-        sys.exit(1)
-
-    @abc.abstractmethod
-    def should_die(self) -> bool:
-        raise NotImplementedError
-
-    def maybe_die(self) -> None:
-        if self.should_die():
-            self.die()
-
-    def poll(self) -> None:
-        if self._last_check_t is None or (time.monotonic() - self._last_check_t) >= self._interval_s:
-            self.maybe_die()
-            self._last_check_t = time.monotonic()
+from ... import check
+from ..forkhooks import ForkHook
+from ..forkhooks import ProcessOriginTracker
+from .base import BaseDeathpact
 
 
 ##
@@ -92,16 +19,13 @@ class PipeDeathpact(BaseDeathpact):
           handle such cases.
     """
 
-    _COOKIE: ta.ClassVar[bytes] = os.urandom(16)
-
     def __init__(self, **kwargs: ta.Any) -> None:
         super().__init__(**kwargs)
 
         self._rfd: int | None = None
         self._wfd: int | None = None
 
-        self._cookie: bytes | None = self._COOKIE
-        self._fork_depth: int | None = get_fork_depth()
+        self._process_origin = ProcessOriginTracker()
 
     def __repr__(self) -> str:
         return f'{self.__class__.__name__}(rfd={self._rfd}, wfd={self._wfd})'
@@ -111,11 +35,13 @@ class PipeDeathpact(BaseDeathpact):
         return check.not_none(self._rfd)
 
     def is_parent(self) -> bool:
-        return (self._COOKIE, get_fork_depth()) == (self._cookie, self._fork_depth)
+        return self._process_origin.is_in_origin_process()
 
     #
 
     def __enter__(self) -> ta.Self:
+        check.state(self.is_parent())
+
         check.none(self._rfd)
         check.none(self._wfd)
 
@@ -125,18 +51,24 @@ class PipeDeathpact(BaseDeathpact):
 
         return self
 
-    def _close_wfd_if_not_parent(self) -> None:
+    def close(self) -> None:
+        if self._rfd is not None:
+            os.close(self._rfd)
+            self._rfd = None
+
         if self._wfd is not None:
-            if not self.is_parent():
+            if self.is_parent():
                 os.close(check.not_none(self._wfd))
             self._wfd = None
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        if self._rfd is not None:
-            os.close(self._rfd)
-            self._rfd = None
+        self.close()
 
-        self._close_wfd_if_not_parent()
+    def _close_wfd_if_not_parent(self) -> None:
+        if self._wfd is not None:
+            if not self.is_parent():
+                os.close(check.not_none(self._wfd))
+            self._wfd = None
 
     #
 
@@ -145,8 +77,6 @@ class PipeDeathpact(BaseDeathpact):
             **self.__dict__,
             **dict(
                 _wfd=None,
-                _cookie=None,
-                _fork_depth=None,
             ),
         }
 

omlish/os/forkhooks.py

@@ -1,9 +1,5 @@
 # ruff: noqa: UP006 UP007
 # @omlish-lite
-"""
-TODO:
- - ForkHook base class? all classmethods? prevents pickling
-"""
 import abc
 import os
 import threading
@@ -29,31 +25,6 @@ class _ForkHookManager:
 
     #
 
-    _installed: ta.ClassVar[bool] = False
-
-    @classmethod
-    def _install(cls) -> bool:
-        if cls._installed:
-            return False
-
-        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
-        return True
-
-    @classmethod
-    def install(cls) -> bool:
-        with cls._lock:
-            return cls._install()
-
-    #
-
     class Hook(ta.NamedTuple):
         key: ta.Any
         priority: int
@@ -74,8 +45,8 @@ class _ForkHookManager:
     def _rebuild_hook_collections(cls) -> None:
         cls._hook_keys = frozenset(cls._hooks_by_key)
 
-        # Uses on dict order preservation for insertion-order of hooks of equal priority (although that shouldn't be
-        # depended upon for usecase correctness.
+        # Uses dict order preservation to retain insertion-order of hooks of equal priority (although that shouldn't be
+        # depended upon for usecase correctness).
         cls._priority_ordered_hooks = sorted(cls._hooks_by_key.values(), key=lambda h: h.priority)
 
     #
@@ -121,6 +92,31 @@ class _ForkHookManager:
 
     #
 
+    _installed: ta.ClassVar[bool] = False
+
+    @classmethod
+    def _install(cls) -> bool:
+        if cls._installed:
+            return False
+
+        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
+        return True
+
+    @classmethod
+    def install(cls) -> bool:
+        with cls._lock:
+            return cls._install()
+
+    #
+
     @classmethod
     def _before_fork(cls) -> None:
         cls._lock.acquire()
@@ -213,3 +209,31 @@ class _ForkDepthTracker(ForkHook):
 
 def get_fork_depth() -> int:
     return _ForkDepthTracker.get_fork_depth()
+
+
+##
+
+
+class ProcessOriginTracker:
+    _PROCESS_COOKIE: ta.ClassVar[bytes] = os.urandom(16)
+
+    def __init__(self, **kwargs: ta.Any) -> None:
+        super().__init__(**kwargs)
+
+        self._process_cookie: bytes | None = self._PROCESS_COOKIE
+        self._fork_depth: int | None = get_fork_depth()
+
+    def is_in_origin_process(self) -> bool:
+        return (self._PROCESS_COOKIE, get_fork_depth()) == (self._process_cookie, self._fork_depth)
+
+    def __getstate__(self):
+        return {
+            **self.__dict__,
+            **dict(
+                _cookie=None,
+                _fork_depth=None,
+            ),
+        }
+
+    def __setstate__(self, state):
+        self.__dict__.update(state)

omlish/os/pidfiles/manager.py

@@ -7,71 +7,38 @@ import typing as ta
 import weakref
 
 from ...lite.check import check
+from ..forkhooks import ForkHook
 from .pidfile import Pidfile
 
 
 ##
 
 
-class _PidfileManager:
+class _PidfileManager(ForkHook):
     """
     Manager for controlled inheritance of Pidfiles across forks in the presence of multiple threads. There is of course
     no safe or correct way to mix the use of fork and multiple active threads, and one should never write code which
     does so, but in the Real World one may still find oneself in such a situation outside of their control (such as when
     running under Pycharm's debugger which forces the use of forked multiprocessing).
-
-    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()
+    _num_kills: ta.ClassVar[int] = 0
 
     @classmethod
-    def _before_fork(cls) -> None:
-        cls._lock.acquire()
-
-    @classmethod
-    def _after_fork_in_parent(cls) -> None:
-        cls._lock.release()
+    def num_kills(cls) -> int:
+        return cls._num_kills
 
     @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
+            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._num_kills += 1
 
     @classmethod
     @contextlib.contextmanager

omlish/os/pidfiles/pidfile.py

@@ -56,8 +56,25 @@ class Pidfile:
 
     #
 
+    _fd_to_dup: int
+
+    def dup(self) -> 'Pidfile':
+        fd = self._f.fileno()
+        dup = Pidfile(
+            self._path,
+            inheritable=self._inheritable,
+        )
+        dup._fd_to_dup = fd  # noqa
+        return dup
+
+    #
+
     def __enter__(self) -> 'Pidfile':
-        fd = os.open(self._path, os.O_RDWR | os.O_CREAT, 0o600)
+        if hasattr(self, '_fd_to_dup'):
+            fd = os.dup(self._fd_to_dup)
+            del self._fd_to_dup
+        else:
+            fd = os.open(self._path, os.O_RDWR | os.O_CREAT, 0o600)
 
         try:
             if self._inheritable:

omlish/reflect/__init__.py

@@ -1,5 +1,6 @@
 from .inspect import (  # noqa
     get_annotations,
+    get_filtered_type_hints,
 )
 
 from .ops import (  # noqa

omlish/reflect/inspect.py

@@ -4,6 +4,7 @@ TODO:
 """
 import typing as ta
 
+from .. import check
 from .. import lang
 
 
@@ -16,8 +17,50 @@ else:
 annotationlib = lang.lazy_import('annotationlib', optional=True, cache_failure=True)
 
 
+##
+
+
 def get_annotations(obj: ta.Any) -> ta.Mapping[str, ta.Any]:
     if (al := annotationlib()) is not None:
         return al.get_annotations(obj, format=al.Format.FORWARDREF)  # noqa
     else:
         return inspect.get_annotations(obj)
+
+
+##
+
+
+class _TypeHintsTarget:
+    def __init__(self, obj, annotations):
+        super().__init__()
+
+        self.obj = obj
+        self.__annotations__ = annotations
+        self.__globals__ = obj.__globals__
+        self.__type_params__ = obj.__type_params__
+
+
+def get_filtered_type_hints(
+        obj: ta.Any,
+        *,
+        include: ta.Container[str] | None = None,
+        exclude: ta.Container[str] | None = None,
+) -> ta.Mapping[str, ta.Any]:
+    """
+    Gross hack: get_type_hints doesn't support recursive types, but it's nice to support functions with, at least,
+    recursive return types.
+
+    This is consciously constrained in what it supports - basically just functions.
+    """
+
+    check.not_isinstance(include, str)
+    check.not_isinstance(exclude, str)
+
+    anns = {
+        k: v
+        for k, v in obj.__annotations__.items()
+        if (include is None or k in include)
+        and not (exclude is not None and k in exclude)
+    }
+
+    return ta.get_type_hints(_TypeHintsTarget(obj, anns))

omlish/sql/queries/__init__.py

@@ -11,10 +11,6 @@ from .binary import (  # noqa
     BinaryOps,
 )
 
-from .building import (  # noqa
-    StdBuilder,
-)
-
 from .exprs import (  # noqa
     CanExpr,
     CanLiteral,
@@ -76,6 +72,10 @@ from .selects import (  # noqa
     SelectItem,
 )
 
+from .std import (  # noqa
+    StdBuilder,
+)
+
 from .stmts import (  # noqa
     CanExpr,
     ExprStmt,