omlish 0.0.0.dev228__py3-none-any.whl → 0.0.0.dev230__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,28 +51,34 @@ 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
 
     #
 
     def __getstate__(self):
-        return dict(
+        return {
             **self.__dict__,
-            _wfd=None,
-            _cookie=None,
-            _fork_depth=None,
-        )
+            **dict(
+                _wfd=None,
+            ),
+        }
 
     def __setstate__(self, state):
         self.__dict__.update(state)

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/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,

omlish/sql/queries/rendering2.py

@@ -0,0 +1,248 @@
+"""
+TODO:
+ - minimal parens
+ - text.parts
+ - QuoteStyle
+ - ParamStyle
+
+==
+
+def needs_parens(self, e: Expr) -> bool:
+    if isinstance(e, (Literal, Ident, Name)):
+        return True
+    elif isinstance(e, Expr):
+        return False
+    else:
+        raise TypeError(e)
+"""
+import dataclasses as dc
+import typing as ta
+
+from ... import dispatch
+from ... import lang
+from ...text import parts as tp
+from ..params import ParamStyle
+from ..params import make_params_preparer
+from .base import Node
+from .binary import Binary
+from .binary import BinaryOp
+from .binary import BinaryOps
+from .exprs import Literal
+from .exprs import NameExpr
+from .idents import Ident
+from .inserts import Insert
+from .inserts import Values
+from .multi import Multi
+from .multi import MultiKind
+from .names import Name
+from .params import Param
+from .relations import Join
+from .relations import JoinKind
+from .relations import Table
+from .selects import Select
+from .selects import SelectItem
+from .unary import Unary
+from .unary import UnaryOp
+from .unary import UnaryOps
+
+
+@dc.dataclass(frozen=True)
+class RenderedQuery(lang.Final):
+    t: tp.Part
+    args: lang.Args
+
+
+class Renderer(lang.Abstract):
+    def __init__(
+            self,
+            *,
+            param_style: ParamStyle | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._param_style = param_style if param_style is not None else self.default_param_style
+
+        self._params_preparer = make_params_preparer(self._param_style)
+
+    default_param_style: ta.ClassVar[ParamStyle] = ParamStyle.PYFORMAT
+
+    def args(self) -> lang.Args:
+        return self._params_preparer.prepare()
+
+    @dispatch.method
+    def render(self, o: ta.Any) -> tp.Part:
+        raise TypeError(o)
+
+
+class StdRenderer(Renderer):
+    # parens
+
+    NEEDS_PAREN_TYPES: ta.AbstractSet[type[Node]] = {
+        Binary,
+        # IsNull,
+        # SelectExpr,
+    }
+
+    def needs_paren(self, node: Node) -> bool:
+        return type(node) in self.NEEDS_PAREN_TYPES
+
+    def paren(self, node: Node) -> tp.Part:
+        return tp.Wrap(self.render(node)) if self.needs_paren(node) else self.render(node)
+
+    # binary
+
+    BINARY_OP_TO_STR: ta.ClassVar[ta.Mapping[BinaryOp, str]] = {
+        BinaryOps.EQ: '=',
+        BinaryOps.NE: '!=',
+        BinaryOps.LT: '<',
+        BinaryOps.LE: '<=',
+        BinaryOps.GT: '>',
+        BinaryOps.GE: '>=',
+
+        BinaryOps.ADD: '+',
+        BinaryOps.SUB: '-',
+        BinaryOps.MUL: '*',
+        BinaryOps.DIV: '/',
+        BinaryOps.MOD: '%',
+
+        BinaryOps.CONCAT: '||',
+    }
+
+    @Renderer.render.register
+    def render_binary(self, o: Binary) -> tp.Part:
+        return [
+            self.paren(o.l),
+            self.BINARY_OP_TO_STR[o.op],
+            self.paren(o.r),
+        ]
+
+    # exprs
+
+    @Renderer.render.register
+    def render_literal(self, o: Literal) -> tp.Part:
+        return repr(o.v)
+
+    @Renderer.render.register
+    def render_name_expr(self, o: NameExpr) -> tp.Part:
+        return self.render(o.n)
+
+    @Renderer.render.register
+    def render_param(self, o: Param) -> tp.Part:
+        return self._params_preparer.add(o.n if o.n is not None else id(o))
+
+    # idents
+
+    @Renderer.render.register
+    def render_ident(self, o: Ident) -> tp.Part:
+        return f'"{o.s}"'
+
+    # inserts
+
+    @Renderer.render.register
+    def render_values(self, o: Values) -> tp.Part:
+        return [
+            'values',
+            tp.Wrap(tp.List([self.render(v) for v in o.vs])),
+        ]
+
+    @Renderer.render.register
+    def render_insert(self, o: Insert) -> tp.Part:
+        return [
+            'insert into',
+            self.render(o.into),
+            tp.Wrap(tp.List([self.render(c) for c in o.columns])),
+        ]
+
+    # multis
+
+    MULTI_KIND_TO_STR: ta.ClassVar[ta.Mapping[MultiKind, str]] = {
+        MultiKind.AND: 'and',
+        MultiKind.OR: 'or',
+    }
+
+    @Renderer.render.register
+    def render_multi(self, o: Multi) -> tp.Part:
+        return tp.Wrap(tp.List(
+            [self.render(e) for e in o.es],
+            delimiter=' ' + self.MULTI_KIND_TO_STR[o.k],  # FIXME: Part
+        ))
+
+    # names
+
+    @Renderer.render.register
+    def render_name(self, o: Name) -> tp.Part:
+        out: list[tp.Part] = []
+        for n, i in enumerate(o.ps):
+            if n:
+                out.append('.')
+            out.append(self.render(i))
+        return tp.Concat(out)
+
+    # relations
+
+    @Renderer.render.register
+    def render_table(self, o: Table) -> tp.Part:
+        return [
+            self.render(o.n),
+            *(['as', self.render(o.a)] if o.a is not None else []),
+        ]
+
+    JOIN_KIND_TO_STR: ta.ClassVar[ta.Mapping[JoinKind, str]] = {
+        JoinKind.DEFAULT: 'join',
+        JoinKind.INNER: 'inner join',
+        JoinKind.LEFT: 'left join',
+        JoinKind.LEFT_OUTER: 'left outer join',
+        JoinKind.RIGHT: 'right join',
+        JoinKind.RIGHT_OUTER: 'right outer join',
+        JoinKind.FULL: 'full join',
+        JoinKind.FULL_OUTER: 'full outer join',
+        JoinKind.CROSS: 'cross join',
+        JoinKind.NATURAL: 'natural join',
+    }
+
+    @Renderer.render.register
+    def render_join(self, o: Join) -> tp.Part:
+        return [
+            self.render(o.l),
+            self.JOIN_KIND_TO_STR[o.k],
+            self.render(o.r),
+            *(['on', self.render(o.c)] if o.c is not None else []),
+        ]
+
+    # selects
+
+    @Renderer.render.register
+    def render_select_item(self, o: SelectItem) -> tp.Part:
+        return [
+            self.render(o.v),
+            *(['as', self.render(o.a)] if o.a is not None else []),
+        ]
+
+    @Renderer.render.register
+    def render_select(self, o: Select) -> tp.Part:
+        return [
+            'select',
+            tp.List([self.render(i) for i in o.items]),
+            *(['from', self.render(o.from_)] if o.from_ is not None else []),
+            *(['where', self.render(o.where)] if o.where is not None else []),
+        ]
+
+    # unary
+
+    UNARY_OP_TO_STR: ta.ClassVar[ta.Mapping[UnaryOp, tuple[str, str]]] = {
+        UnaryOps.NOT: ('not ', ''),
+        UnaryOps.IS_NULL: ('', ' is null'),
+        UnaryOps.IS_NOT_NULL: ('', ' is not null'),
+
+        UnaryOps.POS: ('+', ''),
+        UnaryOps.NEG: ('-', ''),
+    }
+
+    @Renderer.render.register
+    def render_unary(self, o: Unary) -> tp.Part:
+        pfx, sfx = self.UNARY_OP_TO_STR[o.op]
+        return tp.Concat([
+            pfx,
+            self.render(o.v),
+            sfx,
+        ])