omlish 0.0.0.dev243__py3-none-any.whl → 0.0.0.dev245__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev243'
-__revision__ = '97467f9facc16b72c3dac69aba18c543dce228b1'
+__version__ = '0.0.0.dev245'
+__revision__ = 'c3979ac75a1b25b3c679bc0310afb6364c124c4c'
 
 
 #

omlish/cached.py

@@ -9,11 +9,12 @@ builtins and thus not distinguish it from a normal property.
         def p(self) -> str: ...
 
 """
-from .lang.cached import _CachedProperty  # noqa
-from .lang.cached import cached_function as _cached_function
+from .lang.cached.function import cached_function as _cached_function
+from .lang.cached.property import cached_property as _cached_property
+
 
 function = _cached_function
 
 property = property  # noqa
 
-globals()['property'] = _CachedProperty  # noqa
+globals()['property'] = _cached_property  # noqa

omlish/daemons/daemon.py

@@ -48,7 +48,9 @@ class Daemon:
 
         #
 
+        # TODO: None, defaults, figure out from spawn method
         reparent_process: bool = False
+
         launched_timeout_s: float = 5.
 
         #
@@ -126,7 +128,7 @@ class Daemon:
 
     #
 
-    def launch_no_wait(self) -> None:
+    def launch_no_wait(self) -> bool:
         launcher = Launcher(
             target=self._target,
             spawning=check.not_none(self._config.spawning),
@@ -136,7 +138,7 @@ class Daemon:
             launched_timeout_s=self._config.launched_timeout_s,
         )
 
-        launcher.launch()
+        return launcher.launch()
 
     def launch(self, timeout: lang.TimeoutLike = lang.Timeout.Default) -> None:
         self.launch_no_wait()

omlish/daemons/launching.py

@@ -53,8 +53,10 @@ class Launcher:
             self,
             *,
             pidfile_manager: ta.ContextManager | None,
-            launched_callback: ta.Callable[[], None] | None = None,
+            callback: ta.Callable[[], None] | None = None,
     ) -> None:
+        callback_called = False
+
         try:
             if self._reparent_process:
                 log.info('Reparenting')
@@ -66,15 +68,16 @@ class Launcher:
                     pidfile = check.isinstance(es.enter_context(pidfile_manager), Pidfile)
                     pidfile.write()
 
-                if launched_callback is not None:
-                    launched_callback()
+                if callback is not None:
+                    callback_called = True
+                    callback()
 
                 runner = target_runner_for(self._target)
                 runner.run()
 
         finally:
-            if launched_callback is not None:
-                launched_callback()
+            if callback is not None and not callback_called:
+                callback()
 
     def launch(self) -> bool:
         with contextlib.ExitStack() as es:
@@ -110,8 +113,9 @@ class Launcher:
                 functools.partial(
                     self._inner_launch,
                     pidfile_manager=pidfile_manager,
-                    launched_callback=launched_event.set if launched_event is not None else None,
+                    callback=launched_event.set if launched_event is not None else None,
                 ),
+                target=self._target,
                 inherit_fds=inherit_fds,
             ))
 

omlish/daemons/reparent.py

@@ -2,7 +2,10 @@ import os
 import sys
 
 
-def reparent_process() -> None:
+def reparent_process(
+        *,
+        no_close_stdio: bool = False,
+) -> None:
     if (pid := os.fork()):  # noqa
         sys.exit(0)
         raise RuntimeError('Unreachable')  # noqa
@@ -12,5 +15,15 @@ def reparent_process() -> None:
     if (pid := os.fork()):  # noqa
         sys.exit(0)
 
+    if not no_close_stdio:
+        rn_fd = os.open('/dev/null', os.O_RDONLY)
+        os.dup2(rn_fd, 0)
+        os.close(rn_fd)
+
+        wn_fd = os.open('/dev/null', os.O_WRONLY)
+        os.dup2(wn_fd, 1)
+        os.dup2(wn_fd, 2)
+        os.close(wn_fd)
+
     sys.stdout.flush()
     sys.stderr.flush()

omlish/daemons/services.py

@@ -1,4 +1,5 @@
 import abc
+import threading
 import typing as ta
 
 from .. import cached
@@ -12,6 +13,7 @@ from .targets import TargetRunner
 from .targets import target_runner_for
 
 
+ServiceT = ta.TypeVar('ServiceT', bound='Service')
 ServiceConfigT = ta.TypeVar('ServiceConfigT', bound='Service.Config')
 
 
@@ -82,27 +84,53 @@ def _(target: ServiceConfigTarget) -> ServiceConfigTargetRunner:
 
 
 @dc.dataclass(frozen=True)
-class ServiceDaemon(lang.Final):
-    service: Service | Service.Config
+class ServiceDaemon(lang.Final, ta.Generic[ServiceT, ServiceConfigT]):
+    service: ServiceT | ServiceConfigT
 
     @cached.function
-    def service_(self) -> Service:
-        if isinstance(self.service, Service):
-            return self.service
-        elif isinstance(self.service, Service.Config):
-            return Service.from_config(self.service)
-        else:
-            raise TypeError(self.service)
+    def service_config(self) -> ServiceConfigT:
+        with self._lock:
+            if isinstance(self.service, Service):
+                return self.service.config
+            elif isinstance(self.service, Service.Config):
+                return self.service
+            else:
+                raise TypeError(self.service)
+
+    @cached.function
+    def service_(self) -> ServiceT:
+        with self._lock:
+            if isinstance(self.service, Service):
+                return self.service  # type: ignore[return-value]
+            elif isinstance(self.service, Service.Config):
+                return Service.from_config(self.service)  # type: ignore[return-value]
+            else:
+                raise TypeError(self.service)
 
     #
 
     daemon: Daemon | Daemon.Config = Daemon.Config()
 
+    @cached.function
+    def daemon_config(self) -> Daemon.Config:
+        with self._lock:
+            if isinstance(self.daemon, Daemon):
+                return self.daemon.config
+            elif isinstance(self.daemon, Daemon.Config):
+                return self.daemon
+            else:
+                raise TypeError(self.daemon)
+
     @cached.function
     def daemon_(self) -> Daemon:
-        if isinstance(self.daemon, Daemon):
-            return self.daemon
-        elif isinstance(self.daemon, Daemon.Config):
-            return Daemon(Target.of(self.service_()), self.daemon)
-        else:
-            raise TypeError(self.daemon)
+        with self._lock:
+            if isinstance(self.daemon, Daemon):
+                return self.daemon
+            elif isinstance(self.daemon, Daemon.Config):
+                return Daemon(Target.of(self.service_()), self.daemon)
+            else:
+                raise TypeError(self.daemon)
+
+    #
+
+    _lock: threading.RLock = dc.field(default_factory=lambda: threading.RLock(), init=False)

omlish/daemons/spawning.py

@@ -1,4 +1,5 @@
 import abc
+import enum
 import functools
 import os
 import sys
@@ -9,6 +10,7 @@ from .. import check
 from .. import dataclasses as dc
 from .. import lang
 from ..diag import pydevd
+from .targets import Target
 
 
 if ta.TYPE_CHECKING:
@@ -37,6 +39,8 @@ class Spawn(dc.Frozen, final=True):
 
     _: dc.KW_ONLY
 
+    target: Target | None = None
+
     inherit_fds: ta.Collection[int] | None = None
 
 
@@ -59,10 +63,29 @@ def spawner_for(spawning: Spawning) -> Spawner:
 
 
 class MultiprocessingSpawning(Spawning, kw_only=True):
+    class StartMethod(enum.Enum):
+        SPAWN = enum.auto()
+        FORK = enum.auto()
+        # TODO: FORK_SERVER
+
     # Defaults to 'fork' if under pydevd, else 'spawn'
-    start_method: str | None = None
+    start_method: StartMethod | None = None
+
+    #
+
+    # Note: Per multiprocessing docs, `no_linger=True` processes (corresponding to `Process(daemon=True)`) cannot spawn
+    # subprocesses, and thus will fail if `Daemon.Config.reparent_process` is set.
+    no_linger: bool = False
 
-    non_daemon: bool = False
+    #
+
+    @dc.dataclass(frozen=True, kw_only=True)
+    class EntrypointArgs:
+        spawning: 'MultiprocessingSpawning'
+        spawn: Spawn
+        start_method: 'MultiprocessingSpawning.StartMethod'
+
+    entrypoint: ta.Callable[[EntrypointArgs], None] | None = None
 
 
 class MultiprocessingSpawner(Spawner):
@@ -72,20 +95,26 @@ class MultiprocessingSpawner(Spawner):
         self._spawning = spawning
         self._process: ta.Optional['mp.process.BaseProcess'] = None  # noqa
 
+    @lang.cached_function
+    def _determine_start_method(self) -> 'MultiprocessingSpawning.StartMethod':
+        if (start_method := self._spawning.start_method) is not None:
+            return start_method
+
+        # Unfortunately, pydevd forces the use of the 'fork' start_method, which cannot be mixed with 'spawn':
+        #   https://github.com/python/cpython/blob/a7427f2db937adb4c787754deb4c337f1894fe86/Lib/multiprocessing/spawn.py#L102  # noqa
+        if pydevd.is_running():
+            return MultiprocessingSpawning.StartMethod.FORK
+
+        return MultiprocessingSpawning.StartMethod.SPAWN
+
     def _process_cls(self, spawn: Spawn) -> type['mp.process.BaseProcess']:
-        if (start_method := self._spawning.start_method) is None:
-            # Unfortunately, pydevd forces the use of the 'fork' start_method, which cannot be mixed with 'spawn':
-            #   https://github.com/python/cpython/blob/a7427f2db937adb4c787754deb4c337f1894fe86/Lib/multiprocessing/spawn.py#L102  # noqa
-            if pydevd.is_running():
-                start_method = 'fork'
-            else:
-                start_method = 'spawn'
+        start_method = self._determine_start_method()
 
         ctx: 'mp.context.BaseContext'  # noqa
-        if start_method == 'fork':
-            ctx = mp.get_context(check.non_empty_str(start_method))
+        if start_method == MultiprocessingSpawning.StartMethod.FORK:
+            ctx = mp.get_context(check.non_empty_str('fork'))
 
-        elif start_method == 'spawn':
+        elif start_method == MultiprocessingSpawning.StartMethod.SPAWN:
             ctx = omp_spawn.ExtrasSpawnContext(omp_spawn.SpawnExtras(
                 pass_fds=frozenset(spawn.inherit_fds) if spawn.inherit_fds is not None else None,
             ))
@@ -97,9 +126,20 @@ class MultiprocessingSpawner(Spawner):
 
     def spawn(self, spawn: Spawn) -> None:
         check.none(self._process)
+
+        target: ta.Callable[[], None]
+        if (ep := self._spawning.entrypoint) is not None:
+            target = functools.partial(ep, MultiprocessingSpawning.EntrypointArgs(
+                spawning=self._spawning,
+                spawn=spawn,
+                start_method=self._determine_start_method(),
+            ))
+        else:
+            target = spawn.fn
+
         self._process = self._process_cls(spawn)(
-            target=spawn.fn,
-            daemon=not self._spawning.non_daemon,
+            target=target,
+            daemon=self._spawning.no_linger,
         )
         self._process.start()
 
@@ -142,7 +182,7 @@ def _(spawning: ForkSpawning) -> ForkSpawner:
 
 
 class ThreadSpawning(Spawning, kw_only=True):
-    non_daemon: bool = False
+    linger: bool = False
 
 
 class ThreadSpawner(InProcessSpawner):
@@ -156,7 +196,7 @@ class ThreadSpawner(InProcessSpawner):
         check.none(self._thread)
         self._thread = threading.Thread(
             target=spawn.fn,
-            daemon=not self._spawning.non_daemon,
+            daemon=not self._spawning.linger,
         )
         self._thread.start()
 

omlish/http/coro/simple.py

@@ -43,6 +43,7 @@ def make_simple_http_server(
         ignore_ssl_errors: bool = False,
         executor: ta.Optional[cf.Executor] = None,
         use_threads: bool = False,
+        **kwargs: ta.Any,
 ) -> ta.Iterator[SocketServer]:
     check.arg(not (executor is not None and use_threads))
 
@@ -107,6 +108,7 @@ def make_simple_http_server(
         server = es.enter_context(SocketServer(
             SocketBinder.of(bind),
             server_handler,
+            **kwargs,
         ))
 
         yield server

omlish/lang/__init__.py

@@ -1,39 +1,63 @@
-from .cached import (  # noqa
+from .attrs import (  # noqa
+    AttrOps,
+    STD_ATTR_OPS,
+    StdAttrOps,
+    TRANSIENT_ATTR_OPS,
+    TransientAttrOps,
+    TransientDict,
+    transient_delattr,
+    transient_getattr,
+    transient_setattr,
+)
+
+from .cached.function import (  # noqa
     cached_function,
-    cached_property,
     static_init,
 )
 
-from .classes import (  # noqa
+from .cached.property import (  # noqa
+    cached_property,
+)
+
+from .classes.abstract import (  # noqa
     Abstract,
     AbstractTypeError,
+    get_abstract_methods,
+    is_abstract,
+    is_abstract_class,
+    is_abstract_method,
+    make_abstract,
+    unabstract_class,
+)
+
+from .classes.restrict import (  # noqa
     AnySensitive,
-    Callable,
-    Descriptor,
     Final,
     FinalTypeError,
-    LazySingleton,
-    Marker,
-    Namespace,
     NoBool,
     NotInstantiable,
     NotPicklable,
     PackageSealed,
-    Picklable,
     SENSITIVE_ATTR,
     Sealed,
     SealedError,
     Sensitive,
+    no_bool,
+)
+
+from .classes.simple import (  # noqa
+    LazySingleton,
+    Marker,
+    Namespace,
     SimpleMetaDict,
     Singleton,
+)
+
+from .classes.virtual import (  # noqa
+    Callable,
+    Descriptor,
+    Picklable,
     Virtual,
-    get_abstract_methods,
-    is_abstract,
-    is_abstract_class,
-    is_abstract_method,
-    make_abstract,
-    no_bool,
-    unabstract_class,
     virtual_check,
 )
 

omlish/lang/attrs.py

@@ -0,0 +1,132 @@
+import abc
+import collections.abc
+import typing as ta
+
+
+##
+
+
+class AttrOps(abc.ABC):
+    class NOT_SET:  # noqa
+        def __new__(cls, *args, **kwargs):  # noqa
+            raise TypeError
+
+    @abc.abstractmethod
+    def getattr(self, obj: ta.Any, name: str, default: ta.Any = NOT_SET) -> ta.Any:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def setattr(self, obj: ta.Any, name: str, value: ta.Any) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def delattr(self, obj: ta.Any, name: str) -> None:
+        raise NotImplementedError
+
+
+##
+
+
+class StdAttrOps(AttrOps):
+    def getattr(self, obj: ta.Any, name: str, default: ta.Any = AttrOps.NOT_SET) -> ta.Any:
+        if default is AttrOps.NOT_SET:
+            return getattr(obj, name)
+        else:
+            return getattr(obj, name, default)
+
+    def setattr(self, obj: ta.Any, name: str, value: ta.Any) -> None:
+        setattr(obj, name, value)
+
+    def delattr(self, obj: ta.Any, name: str) -> None:
+        delattr(obj, name)
+
+
+STD_ATTR_OPS = StdAttrOps()
+
+
+##
+
+
+class TransientDict(collections.abc.MutableMapping):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._dct: dict = {}
+
+    def __reduce__(self):
+        return (TransientDict, ())
+
+    def __getitem__(self, item):
+        return self._dct[item]
+
+    def __setitem__(self, key, value):
+        self._dct[key] = value
+
+    def __delitem__(self, key):
+        del self._dct[key]
+
+    def __len__(self):
+        return len(self._dct)
+
+    def __iter__(self):
+        return iter(self._dct)
+
+    def clear(self):
+        self._dct.clear()
+
+    def items(self):
+        return self._dct.items()
+
+    def keys(self):
+        return self._dct.keys()
+
+    def values(self):
+        return self._dct.values()
+
+    def __contains__(self, key, /):
+        return super().__contains__(key)
+
+    def __eq__(self, other, /):
+        raise TypeError(self)
+
+
+#
+
+
+_TRANSIENT_DICT_ATTR = '__transient_dict__'
+
+
+def _get_object_transient_dict(obj: ta.Any) -> TransientDict:
+    try:
+        return obj.__dict__[_TRANSIENT_DICT_ATTR]
+    except KeyError:
+        return obj.__dict__.setdefault(_TRANSIENT_DICT_ATTR, TransientDict())
+
+
+class TransientAttrOps(AttrOps):
+    def getattr(self, obj: ta.Any, name: str, default: ta.Any = AttrOps.NOT_SET) -> ta.Any:
+        td = _get_object_transient_dict(obj)
+        try:
+            return td[name]
+        except KeyError:
+            if default is not AttrOps.NOT_SET:
+                return default
+            raise AttributeError(name) from None
+
+    def setattr(self, obj: ta.Any, name: str, value: ta.Any) -> None:
+        td = _get_object_transient_dict(obj)
+        td[name] = value
+
+    def delattr(self, obj: ta.Any, name: str) -> None:
+        td = _get_object_transient_dict(obj)
+        try:
+            del td[name]
+        except KeyError:
+            raise AttributeError(name) from None
+
+
+TRANSIENT_ATTR_OPS = TransientAttrOps()
+
+transient_getattr = TRANSIENT_ATTR_OPS.getattr
+transient_setattr = TRANSIENT_ATTR_OPS.setattr
+transient_delattr = TRANSIENT_ATTR_OPS.delattr

omlish/lang/{cached.py → cached/function.py}

@@ -2,37 +2,42 @@
 TODO:
  - integrate / expose with collections.cache
  - weakrefs (selectable by arg)
- - locks
+ - more rigorous descriptor pickling
+  - must support free functions (which have no instance nor owner)
+  - 'staticmethod' or effective equiv - which must resolve to the shared instance
+   - and must be transient?
 """
 import dataclasses as dc
 import functools
 import inspect
 import typing as ta
 
-from .contextmanagers import DefaultLockable
-from .contextmanagers import default_lock
-from .descriptors import unwrap_func
-from .descriptors import unwrap_func_with_partials
+from ..classes.abstract import Abstract
+from ..contextmanagers import DefaultLockable
+from ..contextmanagers import default_lock
+from ..descriptors import unwrap_func
+from ..descriptors import unwrap_func_with_partials
 
 
 P = ta.ParamSpec('P')
 T = ta.TypeVar('T')
 CallableT = ta.TypeVar('CallableT', bound=ta.Callable)
 
-_IGNORE = object()
+
+##
 
 
-def _nullary_cache_keyer():
+def _nullary_cache_key_maker():
     return ()
 
 
-def _simple_cache_keyer(*args, **kwargs):
+def _simple_cache_key_maker(*args, **kwargs):
     return (args, tuple(sorted(kwargs.items())))
 
 
-def _make_cache_keyer(fn, *, simple=False, bound=False):
+def _make_cache_key_maker(fn, *, simple=False, bound=False):
     if simple:
-        return _simple_cache_keyer
+        return _simple_cache_key_maker
 
     fn, partials = unwrap_func_with_partials(fn)
 
@@ -42,7 +47,7 @@ def _make_cache_keyer(fn, *, simple=False, bound=False):
     sig = inspect.signature(fn)
     sig_params = list(sig.parameters.values())[1 if bound else 0:]
     if not sig_params:
-        return _nullary_cache_keyer
+        return _nullary_cache_key_maker
 
     ns = {}
     src_params = []
@@ -92,19 +97,23 @@ def _make_cache_keyer(fn, *, simple=False, bound=False):
     return kfn
 
 
-class _CachedFunction(ta.Generic[T]):
+##
+
+
+class _CachedFunction(ta.Generic[T], Abstract):
     @dc.dataclass(frozen=True)
     class Opts:
         map_maker: ta.Callable[[], ta.MutableMapping] = dict
         simple_key: bool = False
         lock: DefaultLockable = None
+        transient: bool = False
 
     def __init__(
             self,
             fn: ta.Callable[P, T],
             *,
             opts: Opts = Opts(),
-            keyer: ta.Callable[..., tuple] | None = None,
+            key_maker: ta.Callable[..., tuple] | None = None,
             values: ta.MutableMapping | None = None,
             value_fn: ta.Callable[P, T] | None = None,
     ) -> None:
@@ -112,7 +121,7 @@ class _CachedFunction(ta.Generic[T]):
 
         self._fn = (fn,)
         self._opts = opts
-        self._keyer = keyer if keyer is not None else _make_cache_keyer(fn, simple=opts.simple_key)
+        self._key_maker = key_maker if key_maker is not None else _make_cache_key_maker(fn, simple=opts.simple_key)
 
         self._lock = default_lock(opts.lock, False)() if opts.lock is not None else None
         self._values = values if values is not None else opts.map_maker()
@@ -134,7 +143,7 @@ class _CachedFunction(ta.Generic[T]):
         raise TypeError
 
     def __call__(self, *args, **kwargs) -> T:
-        k = self._keyer(*args, **kwargs)
+        k = self._key_maker(*args, **kwargs)
 
         try:
             return self._values[k]
@@ -157,11 +166,42 @@ class _CachedFunction(ta.Generic[T]):
         return value
 
 
-class _CachedFunctionDescriptor(_CachedFunction[T]):
+#
+
+
+class _FreeCachedFunction(_CachedFunction[T]):
+    @classmethod
+    def _unpickle(
+            cls,
+            fn,
+            opts,
+            values,
+    ):
+        return cls(
+            fn,
+            opts=opts,
+            values=values,
+        )
+
+    def __reduce__(self):
+        return (
+            _FreeCachedFunction._unpickle,
+            (
+                self._fn,
+                self._opts,
+                self._values if not self._opts.transient else None,
+            ),
+        )
+
+
+#
+
+
+class _DescriptorCachedFunction(_CachedFunction[T]):
     def __init__(
             self,
             fn: ta.Callable[P, T],
-            scope: ta.Any,
+            scope: ta.Any,  # classmethod | None
             *,
             instance: ta.Any = None,
             owner: ta.Any = None,
@@ -174,9 +214,61 @@ class _CachedFunctionDescriptor(_CachedFunction[T]):
         self._instance = instance
         self._owner = owner
         self._name = name if name is not None else unwrap_func(fn).__name__
-        self._bound_keyer = None
+        self._bound_key_maker = None
 
-    def __get__(self, instance, owner=None):
+    @classmethod
+    def _unpickle(
+            cls,
+            scope,
+            instance,
+            owner,
+            name,
+            values,
+    ):
+        if scope is not None:
+            raise NotImplementedError
+
+        if instance is None:
+            raise RuntimeError
+        obj = type(instance)
+
+        desc: _DescriptorCachedFunction = object.__getattribute__(obj, name)
+        if not isinstance(desc, cls):
+            raise TypeError(desc)
+        if (desc._instance is not None or desc._owner is not None):
+            raise RuntimeError
+
+        return desc._bind(
+            instance,
+            owner,
+            values=values,
+        )
+
+    def __reduce__(self):
+        if self._scope is not None:
+            raise NotImplementedError
+
+        if not (self._instance is not None or self._owner is not None):
+            raise RuntimeError
+
+        return (
+            _DescriptorCachedFunction._unpickle,
+            (
+                self._scope,
+                self._instance,
+                self._owner,
+                self._name,
+                self._values if not self._opts.transient else None,
+            ),
+        )
+
+    def _bind(
+            self,
+            instance,
+            owner=None,
+            *,
+            values: ta.MutableMapping | None = None,
+    ):
         scope = self._scope
         if owner is self._owner and (instance is self._instance or scope is classmethod):
             return self
@@ -184,8 +276,8 @@ class _CachedFunctionDescriptor(_CachedFunction[T]):
         fn, = self._fn
         name = self._name
         bound_fn = fn.__get__(instance, owner)
-        if self._bound_keyer is None:
-            self._bound_keyer = _make_cache_keyer(fn, simple=self._opts.simple_key, bound=True)
+        if self._bound_key_maker is None:
+            self._bound_key_maker = _make_cache_key_maker(fn, simple=self._opts.simple_key, bound=True)
 
         bound = self.__class__(
             fn,
@@ -194,8 +286,9 @@ class _CachedFunctionDescriptor(_CachedFunction[T]):
             instance=instance,
             owner=owner,
             name=name,
-            keyer=self._bound_keyer,
-            # values=None if scope is classmethod else self._values,
+            key_maker=self._bound_key_maker,
+            # values=None if scope is classmethod else self._values,  # FIXME: ?
+            values=values,
             value_fn=bound_fn,
         )
 
@@ -206,76 +299,24 @@ class _CachedFunctionDescriptor(_CachedFunction[T]):
 
         return bound
 
+    def __get__(self, instance, owner=None):
+        return self._bind(instance, owner)
+
+
+#
+
 
 def cached_function(fn=None, **kwargs):  # noqa
     if fn is None:
         return functools.partial(cached_function, **kwargs)
     opts = _CachedFunction.Opts(**kwargs)
     if isinstance(fn, staticmethod):
-        return _CachedFunction(fn, opts=opts, value_fn=unwrap_func(fn))
+        return _FreeCachedFunction(fn, opts=opts, value_fn=unwrap_func(fn))
     scope = classmethod if isinstance(fn, classmethod) else None
-    return _CachedFunctionDescriptor(fn, scope, opts=opts)
+    return _DescriptorCachedFunction(fn, scope, opts=opts)
 
 
 def static_init(fn: CallableT) -> CallableT:
     fn = cached_function(fn)
     fn()
     return fn
-
-
-##
-
-
-class _CachedProperty(property):
-    def __init__(
-            self,
-            fn,
-            *,
-            name=None,
-            ignore_if=lambda _: False,
-            clear_on_init=False,
-    ):
-        if isinstance(fn, property):
-            fn = fn.fget
-        super().__init__(fn)
-        self._fn = fn
-        self._ignore_if = ignore_if
-        self._name = name
-        self._clear_on_init = clear_on_init
-
-    def __set_name__(self, owner, name):
-        if self._name is None:
-            self._name = name
-
-    def __get__(self, instance, owner=None):
-        if instance is None:
-            return self
-        if self._name is None:
-            raise TypeError(self)
-
-        try:
-            return instance.__dict__[self._name]
-        except KeyError:
-            pass
-
-        value = self._fn.__get__(instance, owner)()
-        if value is _IGNORE:
-            return None
-        instance.__dict__[self._name] = value
-        return value
-
-    def __set__(self, instance, value):
-        if self._ignore_if(value):
-            return
-        if instance.__dict__[self._name] == value:
-            return
-        raise TypeError(self._name)
-
-    def __delete__(self, instance):
-        raise TypeError
-
-
-def cached_property(fn=None, **kwargs):  # noqa
-    if fn is None:
-        return functools.partial(cached_property, **kwargs)
-    return _CachedProperty(fn, **kwargs)

omlish/lang/cached/property.py

@@ -0,0 +1,118 @@
+import abc
+import functools
+import typing as ta
+
+from ..attrs import transient_getattr
+from ..attrs import transient_setattr
+from ..classes.abstract import Abstract
+
+
+_IGNORE = object()
+
+
+##
+
+
+class _CachedProperty(property, Abstract):
+    def __init__(
+            self,
+            fn,
+            *,
+            name=None,
+            ignore_if=lambda _: False,
+    ):
+        if isinstance(fn, property):
+            fn = fn.fget
+
+        super().__init__(fn)
+
+        self._fn = fn
+        self._ignore_if = ignore_if
+
+        self._name = name
+
+    def __set_name__(self, owner, name):
+        if self._name is None:
+            self._name = name
+
+    @abc.abstractmethod
+    def _instance_get(self, instance: ta.Any) -> tuple[ta.Any, bool]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def _instance_set(self, instance: ta.Any, value: ta.Any) -> None:
+        raise NotImplementedError
+
+    def __get__(self, instance, owner=None):
+        if instance is None:
+            return self
+        if self._name is None:
+            raise TypeError(self)
+
+        value, ok = self._instance_get(instance)
+        if ok:
+            return value
+
+        value = self._fn.__get__(instance, owner)()
+        if value is _IGNORE:
+            return None
+
+        self._instance_set(instance, value)
+        return value
+
+    def __set__(self, instance, value):
+        if self._ignore_if(value):
+            return
+
+        ev, ok = self._instance_get(instance)
+        if ok and ev == value:
+            return
+
+        raise TypeError(self._name)
+
+    def __delete__(self, instance):
+        raise TypeError
+
+
+#
+
+
+class _DictCachedProperty(_CachedProperty):
+    def _instance_get(self, instance: ta.Any) -> tuple[ta.Any, bool]:
+        try:
+            value = instance.__dict__[self._name]
+        except KeyError:
+            return None, False
+        else:
+            return value, True
+
+    def _instance_set(self, instance: ta.Any, value: ta.Any) -> None:
+        instance.__dict__[self._name] = value
+
+
+#
+
+
+class _TransientCachedProperty(_CachedProperty):
+    def _instance_get(self, instance: ta.Any) -> tuple[ta.Any, bool]:
+        try:
+            value = transient_getattr(instance, self._name)
+        except AttributeError:
+            return None, False
+        else:
+            return value, True
+
+    def _instance_set(self, instance: ta.Any, value: ta.Any) -> None:
+        transient_setattr(instance, self._name, value)
+
+
+#
+
+
+def cached_property(fn=None, *, transient=False, **kwargs):  # noqa
+    if fn is None:
+        return functools.partial(cached_property, transient=transient, **kwargs)
+    if transient:
+        return _TransientCachedProperty(fn, **kwargs)
+    else:
+        return _DictCachedProperty(fn, **kwargs)

omlish/lang/classes/__init__.py

@@ -1,41 +0,0 @@
-from .abstract import (  # noqa
-    Abstract,
-    AbstractTypeError,
-    get_abstract_methods,
-    is_abstract,
-    is_abstract_class,
-    is_abstract_method,
-    make_abstract,
-    unabstract_class,
-)
-
-from .restrict import (  # noqa
-    AnySensitive,
-    Final,
-    FinalTypeError,
-    NoBool,
-    NotInstantiable,
-    NotPicklable,
-    PackageSealed,
-    SENSITIVE_ATTR,
-    Sealed,
-    SealedError,
-    Sensitive,
-    no_bool,
-)
-
-from .simple import (  # noqa
-    LazySingleton,
-    Marker,
-    Namespace,
-    SimpleMetaDict,
-    Singleton,
-)
-
-from .virtual import (  # noqa
-    Callable,
-    Descriptor,
-    Picklable,
-    Virtual,
-    virtual_check,
-)

omlish/sockets/wait.py

@@ -8,13 +8,38 @@ from ..lite.timeouts import Timeout
 from ..lite.timeouts import TimeoutLike
 
 
+##
+
+
+def socket_can_connect(
+        address: ta.Any,
+        *,
+        timeout: ta.Optional[TimeoutLike] = None,
+        on_fail: ta.Optional[ta.Callable[[BaseException], None]] = None,
+        exception: ta.Union[ta.Type[BaseException], ta.Tuple[ta.Type[BaseException], ...]] = (ConnectionRefusedError,),
+) -> bool:
+    timeout = Timeout.of(timeout)
+
+    try:
+        conn = socket.create_connection(address, timeout=timeout.or_(None))
+
+    except exception as e:  # noqa
+        if on_fail is not None:
+            on_fail(e)
+        return False
+
+    else:
+        conn.close()
+        return True
+
+
 def socket_wait_until_can_connect(
         address: ta.Any,
         *,
         timeout: ta.Optional[TimeoutLike] = None,
         on_fail: ta.Optional[ta.Callable[[BaseException], None]] = None,
         sleep_s: float = .1,
-        exception: ta.Union[ta.Type[BaseException], ta.Tuple[ta.Type[BaseException], ...]] = (Exception,),
+        exception: ta.Union[ta.Type[BaseException], ta.Tuple[ta.Type[BaseException], ...]] = (ConnectionRefusedError,),
         cancel_event: ta.Optional[threading.Event] = None,
 ) -> None:
     timeout = Timeout.of(timeout)
@@ -25,15 +50,12 @@ def socket_wait_until_can_connect(
     while not cancel_event.is_set():
         timeout()
 
-        try:
-            conn = socket.create_connection(address, timeout=timeout.or_(None))
-
-        except exception as e:  # noqa
-            if on_fail is not None:
-                on_fail(e)
-
-        else:
-            conn.close()
+        if socket_can_connect(
+            address,
+            timeout=timeout,
+            on_fail=on_fail,
+            exception=exception,
+        ):
             break
 
         cancel_event.wait(min(sleep_s, timeout.remaining()))

{omlish-0.0.0.dev243.dist-info → omlish-0.0.0.dev245.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: omlish
-Version: 0.0.0.dev243
+Version: 0.0.0.dev245
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev243.dist-info → omlish-0.0.0.dev245.dist-info}/RECORD

@@ -1,8 +1,8 @@
 omlish/.manifests.json,sha256=vQTAIvR8OblSq-uP2GUfnbei0RnmAnM5j0T1-OToh9E,8253
-omlish/__about__.py,sha256=3c_F9MxYda9rfa68tINgteoJ57COTQpld-0xkq1JRwY,3380
+omlish/__about__.py,sha256=igneh_Z18EcRdtPlDRmK5tHmRK3NpxQPFoUopKrrNtw,3380
 omlish/__init__.py,sha256=SsyiITTuK0v74XpKV8dqNaCmjOlan1JZKrHQv5rWKPA,253
 omlish/c3.py,sha256=ubu7lHwss5V4UznbejAI0qXhXahrU01MysuHOZI9C4U,8116
-omlish/cached.py,sha256=UI-XTFBwA6YXWJJJeBn-WkwBkfzDjLBBaZf4nIJA9y0,510
+omlish/cached.py,sha256=MLap_p0rdGoDIMVhXVHm1tsbcWobJF0OanoodV03Ju8,542
 omlish/check.py,sha256=THqm6jD1a0skAO5EC8SOVg58yq96Vk5wcuruBkCYxyU,2016
 omlish/datetimes.py,sha256=HajeM1kBvwlTa-uR1TTZHmZ3zTPnnUr1uGGQhiO1XQ0,2152
 omlish/defs.py,sha256=9uUjJuVIbCBL3g14fyzAp-9gH935MFofvlfOGwcBIaM,4913
@@ -180,11 +180,11 @@ omlish/configs/processing/names.py,sha256=weHmaTclzgM9lUn3aBtw-kwZ3mc2N-CZlFg3Kd
 omlish/configs/processing/rewriting.py,sha256=v7PfHtuTn5v_5Y6Au7oMN2Z0nxAMy1iYyO5CXnTvZhs,4226
 omlish/configs/processing/strings.py,sha256=qFS2oh6z02IaM_q4lTKLdufzkJqAJ6J-Qjrz5S-QJoM,826
 omlish/daemons/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-omlish/daemons/daemon.py,sha256=ykdbCPbpxKrdZVZc892SnedTdftTAYt_YdDpYchKcUE,3410
-omlish/daemons/launching.py,sha256=mhtkuAO16STcznUl3rrX9pacfrKbPQRCP2AllKL4B70,3664
-omlish/daemons/reparent.py,sha256=UaG2X6VJHJPOlUwHPNRH3aWGgF0Fg771jjO9IRPLlyY,280
-omlish/daemons/services.py,sha256=UAzzdP4jG0-piVzz6CsSTPIjTGt4VFXtbzP7KczMCho,2354
-omlish/daemons/spawning.py,sha256=cx00xeqSrfhlFbjCtKqaBHvMuHwB9hdjuKNHzAAo_dw,4030
+omlish/daemons/daemon.py,sha256=3Wkvu8M_EaCKSpKI5UN5OayRXV0oVdF62tBss9_hlr0,3479
+omlish/daemons/launching.py,sha256=sNOYW939IGI4ZlLQ0bKxzXj6EyeOiwV7Upqhd5XfoHc,3747
+omlish/daemons/reparent.py,sha256=7uJ9oPGt9Ud7uA8bDl_SHcuqjcsmXa3kkjp9jf29wOw,585
+omlish/daemons/services.py,sha256=jIlGWhiWoqQlm_OFeffkSs9jjr-icDF1-I-SNMEgg9Y,3406
+omlish/daemons/spawning.py,sha256=psR73zOYjMKTqNpx1bMib8uU9wAZz62tw5TaWHrTdyY,5337
 omlish/daemons/targets.py,sha256=00KmtlknMhQ5PyyVAhWl3rpeTMPym0GxvHHq6mYPZ7c,3051
 omlish/daemons/waiting.py,sha256=RfgD1L33QQVbD2431dkKZGE4w6DUcGvYeRXXi8puAP4,1676
 omlish/dataclasses/__init__.py,sha256=b7EZCIfHnEHCHWwgD3YXxkdsU-uYd9iD4hM36RgpI1g,1598
@@ -333,7 +333,7 @@ omlish/http/wsgi.py,sha256=czZsVUX-l2YTlMrUjKN49wRoP4rVpS0qpeBn4O5BoMY,948
 omlish/http/coro/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/http/coro/fdio.py,sha256=bd9K4EYVWbXV3e3npDPXI9DuDAruJiyDmrgFpgNcjzY,4035
 omlish/http/coro/server.py,sha256=30FTcJG8kuFeThf0HJYpTzMZN-giLTBP7wr5Wl3b9X0,18285
-omlish/http/coro/simple.py,sha256=_ZKFlfLda9Gatd3bNBNGJpITNQl4tuTAbL3P-Mr5j5w,3152
+omlish/http/coro/simple.py,sha256=inWA_ss6Nz5Rqmy4dL9_SGah4anYoDecDTRQqVIGYeY,3200
 omlish/http/coro/sockets.py,sha256=rtpZZ-XCOfC5tXr4Fmo1HSn-8f5nxfIOlJaPUkQeDyU,1654
 omlish/inject/__init__.py,sha256=n0RC9UDGsBQQ39cST39-XJqJPq2M0tnnh9yJubW9azo,1891
 omlish/inject/binder.py,sha256=DAbc8TZi5w8Mna0TUtq0mT4jeDVA7i7SlBtOFrh2swc,4185
@@ -399,8 +399,8 @@ omlish/iterators/iterators.py,sha256=ghI4dO6WPyyFOLTIIMaHQ_IOy2xXaFpGPqveZ5YGIBU
 omlish/iterators/recipes.py,sha256=53mkexitMhkwXQZbL6DrhpT0WePQ_56uXd5Jaw3DfzI,467
 omlish/iterators/tools.py,sha256=Pi4ybXytUXVZ3xwK89xpPImQfYYId9p1vIFQvVqVLqA,2551
 omlish/iterators/unique.py,sha256=0jAX3kwzVfRNhe0Tmh7kVP_Q2WBIn8POo_O-rgFV0rQ,1390
-omlish/lang/__init__.py,sha256=T_hx_ygi-IqmeDPQ-uto2U4ZuAUDs-agOSAsF6WWLVI,4193
-omlish/lang/cached.py,sha256=tQaqMu1LID0q4NSTk5vPXsgxIBWSFAmjs5AhQoEHoCQ,7833
+omlish/lang/__init__.py,sha256=0LNdzzVTKiDEmjCzT9wUPbimcAu21KYe-EwD4xDgtRM,4592
+omlish/lang/attrs.py,sha256=vGYdGnS7ZAbSz0ZSZkkZKHCK1tKoNjZY0JdzFraHiUw,3105
 omlish/lang/clsdct.py,sha256=sJYadm-fwzti-gsi98knR5qQUxriBmOqQE_qz3RopNk,1743
 omlish/lang/cmp.py,sha256=5vbzWWbqdzDmNKAGL19z6ZfUKe5Ci49e-Oegf9f4BsE,1346
 omlish/lang/contextmanagers.py,sha256=UPH6daYwSP9cH5AfSVsJyEHk1UURMGhVPM5ZRhp_Hvw,7576
@@ -418,7 +418,10 @@ omlish/lang/resources.py,sha256=N64KeVE-rYMxqBBRp91qzgVqpOVR2uX7k1WlS_bo5hM,2681
 omlish/lang/strings.py,sha256=egdv8PxLNG40-5V93agP5j2rBUDIsahCx048zV7uEbU,4690
 omlish/lang/sys.py,sha256=UoZz_PJYVKLQAKqYxxn-LHz1okK_38I__maZgnXMcxU,406
 omlish/lang/typing.py,sha256=Zdad9Zv0sa-hIaUXPrzPidT7sDVpRcussAI7D-j-I1c,3296
-omlish/lang/classes/__init__.py,sha256=HY9UD3Tg8_sH59emZUKgP1Kb8-8r0GCw5hUOumxwKlM,658
+omlish/lang/cached/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+omlish/lang/cached/function.py,sha256=k3jRNuDtFh9Mk97oonC7nq5XRros2qmRJVWviMFrx74,8728
+omlish/lang/cached/property.py,sha256=kzbao_35PlszdK_9oJBWrMmFFlVK_Xhx7YczHhTJ6cc,2764
+omlish/lang/classes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/lang/classes/abstract.py,sha256=bIcuAetV_aChhpSURypmjjcqP07xi20uVYPKh1kvQNU,3710
 omlish/lang/classes/restrict.py,sha256=QvM-GqXvO8vpCONkcr0QpgVPfzZmgDo7o8d9kUwOzlo,3941
 omlish/lang/classes/simple.py,sha256=XQ8b86WvQA0qtSYqlbMOJS7tHgE8sv9onda33uQmbkM,3294
@@ -566,7 +569,7 @@ omlish/sockets/bind.py,sha256=J1SfFFFnVf3H5nqESDX2NGEY8DmjyIMUXZciZM33zQY,8003
 omlish/sockets/handlers.py,sha256=Gj6xZoo4vommge8XvkehYw3B7O4aql2P4qzZIIa0p24,462
 omlish/sockets/io.py,sha256=lfhTkB7NnAIx9kuQhAkwgsEUXY78Mp1_WtYrIQNS_k8,1408
 omlish/sockets/ports.py,sha256=Wm4mRFFz5MdD8KbdaEfT1c4PbJnsuK_iyJlZJE_-8jo,1402
-omlish/sockets/wait.py,sha256=FSHzLR66RESMwHCV-Bu_mZWNNskRGfEwvM9q1arapV0,1049
+omlish/sockets/wait.py,sha256=aznyOzGa9oNBc31xnyk1S7TylO8hGx7vFyOVsdY3zFE,1585
 omlish/sockets/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/sockets/server/handlers.py,sha256=PPsb1X5oU9dN8jfztaMGsRiqWTyEANT-1aSLbS6bUVg,3867
 omlish/sockets/server/server.py,sha256=FkaishIxJuU4it9tTI7wzlGqJYzFGXzDrd_HgV0jAmU,6253
@@ -729,9 +732,9 @@ omlish/text/mangle.py,sha256=kfzFLfvepH-chl1P89_mdc5vC4FSqyPA2aVtgzuB8IY,1133
 omlish/text/minja.py,sha256=jZC-fp3Xuhx48ppqsf2Sf1pHbC0t8XBB7UpUUoOk2Qw,5751
 omlish/text/parts.py,sha256=JkNZpyR2tv2CNcTaWJJhpQ9E4F0yPR8P_YfDbZfMtwQ,6182
 omlish/text/random.py,sha256=jNWpqiaKjKyTdMXC-pWAsSC10AAP-cmRRPVhm59ZWLk,194
-omlish-0.0.0.dev243.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev243.dist-info/METADATA,sha256=dvum371m78Sb6B5v3K-C8hyOFzA8rEjIQUyy8GZH2G0,4176
-omlish-0.0.0.dev243.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-omlish-0.0.0.dev243.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev243.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev243.dist-info/RECORD,,
+omlish-0.0.0.dev245.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev245.dist-info/METADATA,sha256=JjIb3VY1vdwMkndkHrbTmD72X00OMiCJVwBpn07rc88,4176
+omlish-0.0.0.dev245.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+omlish-0.0.0.dev245.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
+omlish-0.0.0.dev245.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev245.dist-info/RECORD,,

{omlish-0.0.0.dev243.dist-info → omlish-0.0.0.dev245.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.2)
+Generator: setuptools (76.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any