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

omlish/daemons/waiting.py

@@ -0,0 +1,95 @@
+import abc
+import functools
+import socket
+import typing as ta
+
+from .. import dataclasses as dc
+
+
+##
+
+
+class Wait(dc.Case):
+    pass
+
+
+class Waiter(abc.ABC):
+    @abc.abstractmethod
+    def do_wait(self) -> bool:
+        raise NotImplementedError
+
+
+@functools.singledispatch
+def waiter_for(wait: Wait) -> Waiter:
+    raise TypeError(wait)
+
+
+##
+
+
+class SequentialWait(Wait):
+    waits: ta.Sequence[Wait]
+
+
+class SequentialWaiter(Waiter):
+    def __init__(self, waiters: ta.Sequence[Waiter]) -> None:
+        super().__init__()
+
+        self._waiters = waiters
+        self._idx = 0
+
+    def do_wait(self) -> bool:
+        while self._idx < len(self._waiters):
+            if not self._waiters[self._idx].do_wait():
+                return False
+            self._idx += 1
+        return True
+
+
+@waiter_for.register
+def _(wait: SequentialWait) -> SequentialWaiter:
+    return SequentialWaiter([waiter_for(c) for c in wait.waits])
+
+
+##
+
+
+class FnWait(Wait):
+    fn: ta.Callable[[], bool]
+
+
+class FnWaiter(Waiter, dc.Frozen):
+    wait: FnWait
+
+    def do_wait(self) -> bool:
+        return self.wait.fn()
+
+
+@waiter_for.register
+def _(wait: FnWait) -> FnWaiter:
+    return FnWaiter(wait)
+
+
+##
+
+
+class ConnectWait(Wait):
+    address: ta.Any
+
+
+class ConnectWaiter(Waiter, dc.Frozen):
+    wait: ConnectWait
+
+    def do_wait(self) -> bool:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            try:
+                s.connect(self.wait.address)
+            except ConnectionRefusedError:
+                return False
+            else:
+                return True
+
+
+@waiter_for.register
+def _(wait: ConnectWait) -> ConnectWaiter:
+    return ConnectWaiter(wait)

omlish/dispatch/dispatch.py

@@ -31,7 +31,10 @@ def get_impl_func_cls_set(func: ta.Callable) -> frozenset[type]:
         else:
             return check.isinstance(a, type)
 
-    _, cls = next(iter(ta.get_type_hints(func).items()))
+    # Exclude 'return' to support difficult to handle return types - they are unimportant.
+    # TODO: only get hints for first arg - requires inspection, which requires chopping off `self`, which can be tricky.
+    _, cls = next(iter(rfl.get_filtered_type_hints(func, exclude=['return']).items()))
+
     rty = rfl.type_(cls)
     if isinstance(rty, rfl.Union):
         ret = frozenset(erase(arg) for arg in rty.args)

omlish/dispatch/methods.py

@@ -81,6 +81,10 @@ class Method:
         mro_dct = lang.build_mro_dict(instance_cls, owner_cls)
         seen: ta.Mapping[ta.Any, str] = {}
         for nam, att in mro_dct.items():
+            try:
+                hash(att)
+            except TypeError:
+                continue
             if att in self._impls:
                 try:
                     ex_nam = seen[att]

omlish/formats/json/__init__.py

@@ -1,4 +1,9 @@
 # ruff: noqa: I001
+"""
+TODO:
+ - delimited.py / jsonl
+  - + record separators ala https://en.wikipedia.org/wiki/JSON_streaming
+"""
 import typing as _ta
 
 from ... import lang as _lang

omlish/io/compress/brotli.py

@@ -27,9 +27,9 @@ class BrotliCompression(Compression):
         return brotli.compress(
             d,
             **(dict(mode=self.mode) if self.mode is not None else {}),
-            **(dict(mode=self.quality) if self.quality is not None else {}),
-            **(dict(mode=self.lgwin) if self.lgwin is not None else {}),
-            **(dict(mode=self.lgblock) if self.lgblock is not None else {}),
+            **(dict(quality=self.quality) if self.quality is not None else {}),
+            **(dict(lgwin=self.lgwin) if self.lgwin is not None else {}),
+            **(dict(lgblock=self.lgblock) if self.lgblock is not None else {}),
         )
 
     def decompress(self, d: bytes) -> bytes:

omlish/io/fdio/__init__.py

@@ -1 +1,4 @@
 # @omlish-lite
+"""
+Basically the old asyncore system, which still has usecases over asyncio (such as single-threaded, forking code).
+"""

omlish/lang/__init__.py

@@ -61,9 +61,7 @@ from .contextmanagers import (  # noqa
     DefaultLockable,
     ExitStacked,
     Lockable,
-    NOP_CONTEXT_MANAGED,
     NOP_CONTEXT_MANAGER,
-    NopContextManaged,
     NopContextManager,
     Timer,
     a_defer,

omlish/lang/contextmanagers.py

@@ -18,6 +18,11 @@ T = ta.TypeVar('T')
 ##
 
 
+class _NOT_SET:  # noqa
+    def __new__(cls, *args, **kwargs):  # noqa
+        raise TypeError
+
+
 class ContextManaged:
     def __enter__(self) -> ta.Self:
         return self
@@ -31,21 +36,21 @@ class ContextManaged:
         return None
 
 
-class NopContextManaged(ContextManaged):
-    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
-        raise TypeError
-
+class NopContextManager(ContextManaged):
+    def __init__(self, /, value: ta.Any = _NOT_SET) -> None:
+        super().__init__()
 
-NOP_CONTEXT_MANAGED = NopContextManaged()
+        self._value = value
 
+    def __enter__(self):
+        if (value := self._value) is _NOT_SET:
+            return self
+        else:
+            return value
 
-class NopContextManager:
     def __init_subclass__(cls, **kwargs: ta.Any) -> None:
         raise TypeError
 
-    def __call__(self, *args, **kwargs):
-        return NOP_CONTEXT_MANAGED
-
 
 NOP_CONTEXT_MANAGER = NopContextManager()
 
@@ -350,7 +355,7 @@ def default_lock(value: DefaultLockable, default: DefaultLockable = None) -> Loc
         return lambda: lock
 
     elif value is False or value is None:
-        return NOP_CONTEXT_MANAGER
+        return lambda: NOP_CONTEXT_MANAGER
 
     elif callable(value):
         return value

omlish/libc.py

@@ -62,7 +62,6 @@ libc.free.argtypes = [ct.c_void_p]
 
 
 class Malloc:
-
     def __init__(self, sz: int) -> None:
         super().__init__()
 
@@ -174,7 +173,6 @@ if LINUX:
 
 
 class Mmap:
-
     def __init__(
             self,
             length: int,
@@ -537,14 +535,14 @@ elif DARWIN:
 
 
 if LINUX:
-    def gettid():
+    def gettid() -> int:
         syscalls = {
             'i386': 224,  # unistd_32.h: #define __NR_gettid 224
             'x86_64': 186,  # unistd_64.h: #define __NR_gettid 186
             'aarch64': 178,  # asm-generic/unistd.h: #define __NR_gettid 178
         }
         try:
-            tid = ct.CDLL('libc.so.6').syscall(syscalls[platform.machine()])
+            tid = libc.syscall(syscalls[platform.machine()])
         except Exception:  # noqa
             tid = -1
         return tid

omlish/lite/timeouts.py

@@ -8,7 +8,7 @@ import time
 import typing as ta
 
 
-TimeoutLike = ta.Union['Timeout', 'Timeout.Default', ta.Iterable['TimeoutLike'], float]  # ta.TypeAlias
+TimeoutLike = ta.Union['Timeout', ta.Type['Timeout.Default'], ta.Iterable['TimeoutLike'], float]  # ta.TypeAlias
 
 
 ##

omlish/marshal/__init__.py

@@ -34,11 +34,6 @@ from .exceptions import (  # noqa
     UnhandledTypeError,
 )
 
-from .forbidden import (  # noqa
-    ForbiddenTypeMarshalerFactory,
-    ForbiddenTypeUnmarshalerFactory,
-)
-
 from .global_ import (  # noqa
     GLOBAL_REGISTRY,
 
@@ -54,11 +49,6 @@ from .naming import (  # noqa
     translate_name,
 )
 
-from .nop import (  # noqa
-    NOP_MARSHALER_UNMARSHALER,
-    NopMarshalerUnmarshaler,
-)
-
 from .objects.helpers import (  # noqa
     update_field_metadata,
     update_fields_metadata,
@@ -127,6 +117,16 @@ from .standard import (  # noqa
     new_standard_unmarshaler_factory,
 )
 
+from .trivial.forbidden import (  # noqa
+    ForbiddenTypeMarshalerFactory,
+    ForbiddenTypeUnmarshalerFactory,
+)
+
+from .trivial.nop import (  # noqa
+    NOP_MARSHALER_UNMARSHALER,
+    NopMarshalerUnmarshaler,
+)
+
 from .values import (  # noqa
     Value,
 )

omlish/marshal/base.py

@@ -95,9 +95,9 @@ from .exceptions import UnhandledTypeError
 from .factories import RecursiveTypeFactory
 from .factories import TypeCacheFactory
 from .factories import TypeMapFactory
+from .proxy import _Proxy
 from .registries import Registry
 from .registries import RegistryItem
-from .utils import _Proxy
 from .values import Value
 
 

omlish/marshal/standard.py

@@ -23,8 +23,6 @@ from .objects.namedtuples import NamedtupleMarshalerFactory
 from .objects.namedtuples import NamedtupleUnmarshalerFactory
 from .polymorphism.unions import PrimitiveUnionMarshalerFactory
 from .polymorphism.unions import PrimitiveUnionUnmarshalerFactory
-from .singular.any import ANY_MARSHALER_FACTORY
-from .singular.any import ANY_UNMARSHALER_FACTORY
 from .singular.base64 import BASE64_MARSHALER_FACTORY
 from .singular.base64 import BASE64_UNMARSHALER_FACTORY
 from .singular.datetimes import DATETIME_MARSHALER_FACTORY
@@ -37,6 +35,8 @@ from .singular.primitives import PRIMITIVE_MARSHALER_FACTORY
 from .singular.primitives import PRIMITIVE_UNMARSHALER_FACTORY
 from .singular.uuids import UUID_MARSHALER_FACTORY
 from .singular.uuids import UUID_UNMARSHALER_FACTORY
+from .trivial.any import ANY_MARSHALER_FACTORY
+from .trivial.any import ANY_UNMARSHALER_FACTORY
 
 
 ##

omlish/marshal/{forbidden.py → trivial/forbidden.py}

@@ -1,13 +1,13 @@
 import dataclasses as dc
 import typing as ta
 
-from .. import reflect as rfl
-from ..funcs import match as mfs
-from .base import MarshalContext
-from .base import Marshaler
-from .base import UnmarshalContext
-from .base import Unmarshaler
-from .exceptions import ForbiddenTypeError
+from ... import reflect as rfl
+from ...funcs import match as mfs
+from ..base import MarshalContext
+from ..base import Marshaler
+from ..base import UnmarshalContext
+from ..base import Unmarshaler
+from ..exceptions import ForbiddenTypeError
 
 
 C = ta.TypeVar('C')

omlish/marshal/{nop.py → trivial/nop.py}

@@ -1,10 +1,10 @@
 import typing as ta
 
-from .base import MarshalContext
-from .base import Marshaler
-from .base import UnmarshalContext
-from .base import Unmarshaler
-from .values import Value
+from ..base import MarshalContext
+from ..base import Marshaler
+from ..base import UnmarshalContext
+from ..base import Unmarshaler
+from ..values import Value
 
 
 class NopMarshalerUnmarshaler(Marshaler, Unmarshaler):

omlish/os/deathpacts/__init__.py

@@ -0,0 +1,15 @@
+from .base import (  # noqa
+    Deathpact,
+    NopDeathpact,
+
+    BaseDeathpact,
+)
+
+from .heartbeatfile import (  # noqa
+    HeartbeatFileDeathpact,
+)
+
+from .pipe import (  # noqa
+    PipeDeathpact,
+    ForkAwarePipeDeathpact,
+)

omlish/os/deathpacts/base.py

@@ -0,0 +1,76 @@
+import abc
+import os
+import signal
+import sys
+import time
+import typing as ta
+
+
+##
+
+
+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,  # noqa
+            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()

omlish/os/deathpacts/heartbeatfile.py

@@ -0,0 +1,85 @@
+"""
+TODO:
+ - chaining
+"""
+import os
+import time
+import typing as ta
+
+from ... import check
+from ..forkhooks import ProcessOriginTracker
+from ..temp import make_temp_file
+from .base import BaseDeathpact
+
+
+##
+
+
+class HeartbeatFileDeathpact(BaseDeathpact):
+    def __init__(
+            self,
+            path: str,
+            ttl_s: float = 10.,
+            **kwargs: ta.Any,
+    ) -> None:
+        super().__init__(**kwargs)
+
+        self._path = path
+        self._ttl_s = ttl_s
+
+        self._process_origin = ProcessOriginTracker()
+
+    @property
+    def path(self) -> str:
+        return self._path
+
+    def is_parent(self) -> bool:
+        return self._process_origin.is_in_origin_process()
+
+    #
+
+    def __enter__(self) -> ta.Self:
+        check.state(self.is_parent())
+
+        self.update()
+
+        return self
+
+    def close(self) -> None:
+        if self.is_parent():
+            try:
+                os.unlink(self._path)
+            except FileNotFoundError:
+                pass
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+    #
+
+    @classmethod
+    def _now(cls) -> float:
+        return time.monotonic()
+
+    def update(self) -> None:
+        check.state(self.is_parent())
+
+        new = make_temp_file()
+        with open(new, 'w') as f:
+            f.write(str(self._now()))
+
+        # FIXME: same filesystem
+        os.replace(new, self._path)
+
+    def read(self) -> float:
+        try:
+            with open(self._path) as f:
+                return float(f.read())
+        except FileNotFoundError:
+            return float('-inf')
+
+    def age(self) -> float:
+        return self._now() - self.read()
+
+    def should_die(self) -> bool:
+        return self.age() >= self._ttl_s