omlish 0.0.0.dev22__py3-none-any.whl → 0.0.0.dev24__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev22'
-__revision__ = '3d902899000237758f62e46319a8da3bccd2d447'
+__version__ = '0.0.0.dev24'
+__revision__ = '4ab439ef967fda27804fe7d241924c6f08757b54'
 
 
 #
@@ -80,7 +80,11 @@ class Project(ProjectBase):
             'sqlalchemy[asyncio] ~= 2.0',
 
             'pg8000 ~= 1.31',
+            # 'psycopg2 ~= 2.9',
+
             'pymysql ~= 1.1',
+            # 'mysql-connector-python ~= 9.0',
+            # 'mysqlclient ~= 2.2',
 
             'aiomysql ~= 0.2',
             'aiosqlite ~= 0.20',
@@ -110,7 +114,10 @@ class SetuptoolsBase:
     include_package_data = False
 
     find_packages = {
-        'exclude': ['*.tests', '*.tests.*'],
+        'exclude': [
+            '*.tests',
+            '*.tests.*',
+        ],
     }
 
 

omlish/asyncs/bridge.py

@@ -8,6 +8,9 @@ KEEP THE SPACE SHUTTLE FLYING.
 
 TODO:
  - reuse greenlet if nested somehow?
+
+See:
+ - https://greenback.readthedocs.io/en/latest/
 """
 import itertools
 import sys

omlish/bootstrap/__init__.py

@@ -1,3 +1,42 @@
+from .base import (  # noqa
+    Bootstrap,
+    ContextBootstrap,
+    SimpleBootstrap,
+)
+
+from .diag import (  # noqa
+    CheckBootstrap,
+    CprofileBootstrap,
+    PycharmBootstrap,
+    ThreadDumpBootstrap,
+    TimebombBootstrap,
+)
+
 from .harness import (  # noqa
     bootstrap,
 )
+
+from .sys import (  # noqa
+    CwdBootstrap,
+    EnvBootstrap,
+    FaulthandlerBootstrap,
+    FdsBootstrap,
+    GcBootstrap,
+    GcDebugFlag,
+    ImportBootstrap,
+    LogBootstrap,
+    NiceBootstrap,
+    PidfileBootstrap,
+    PrctlBootstrap,
+    PrintPidBootstrap,
+    RlimitBootstrap,
+    SetuidBootstrap,
+)
+
+
+##
+
+
+from ..lang.imports import _register_conditional_import  # noqa
+
+_register_conditional_import('..marshal', '.marshal', __package__)

omlish/bootstrap/base.py

@@ -2,6 +2,8 @@ import abc
 import dataclasses as dc
 import typing as ta
 
+from omlish import lang
+
 
 BootstrapConfigT = ta.TypeVar('BootstrapConfigT', bound='Bootstrap.Config')
 
@@ -9,7 +11,7 @@ BootstrapConfigT = ta.TypeVar('BootstrapConfigT', bound='Bootstrap.Config')
 ##
 
 
-class Bootstrap(abc.ABC, ta.Generic[BootstrapConfigT]):
+class Bootstrap(abc.ABC, lang.PackageSealed, ta.Generic[BootstrapConfigT]):
     @dc.dataclass(frozen=True)
     class Config(abc.ABC):  # noqa
         pass

omlish/bootstrap/diag.py

@@ -5,28 +5,56 @@ import signal
 import sys
 import typing as ta
 
+from .. import check
 from .. import lang
 from .base import Bootstrap
 from .base import ContextBootstrap
+from .base import SimpleBootstrap
 
 
 if ta.TYPE_CHECKING:
     import cProfile  # noqa
     import pstats
 
+    from ..diag import pycharm as diagpc
     from ..diag import threads as diagt
 
 else:
     cProfile = lang.proxy_import('cProfile')  # noqa
     pstats = lang.proxy_import('pstats')
 
+    diagpc = lang.proxy_import('..diag.pycharm', __package__)
     diagt = lang.proxy_import('..diag.threads', __package__)
 
 
 ##
 
 
-class ProfilingBootstrap(ContextBootstrap['ProfilingBootstrap.Config']):
+class CheckBootstrap(ContextBootstrap['CheckBootstrap.Config']):
+    @dc.dataclass(frozen=True)
+    class Config(Bootstrap.Config):
+        breakpoint: bool = False
+
+    @staticmethod
+    def _breakpoint(exc: Exception) -> None:  # noqa
+        breakpoint()  # noqa
+
+    @contextlib.contextmanager
+    def enter(self) -> ta.Iterator[None]:
+        if not self._config.breakpoint:
+            return
+
+        check.register_on_raise(CheckBootstrap._breakpoint)
+        try:
+            yield
+        finally:
+            check.unregister_on_raise(CheckBootstrap._breakpoint)
+
+
+##
+
+
+class CprofileBootstrap(ContextBootstrap['CprofileBootstrap.Config']):
     @dc.dataclass(frozen=True)
     class Config(Bootstrap.Config):
         enable: bool = False
@@ -128,3 +156,22 @@ class TimebombBootstrap(ContextBootstrap['TimebombBootstrap.Config']):
             yield
         finally:
             tbt.stop_nowait()
+
+
+##
+
+
+class PycharmBootstrap(SimpleBootstrap['PycharmBootstrap.Config']):
+    @dc.dataclass(frozen=True)
+    class Config(Bootstrap.Config):
+        debug_host: ta.Optional[str] = None
+        debug_port: ta.Optional[int] = None
+        version: ta.Optional[str] = None
+
+    def run(self) -> None:
+        if self._config.debug_port is not None:
+            diagpc.pycharm_remote_debugger_attach(
+                self._config.debug_host,
+                self._config.debug_port,
+                version=self._config.version,
+            )

omlish/bootstrap/main.py

@@ -156,8 +156,9 @@ def _main() -> int:
     with bootstrap(*cfgs):
         tgt = args.target
 
+        sys.argv = [tgt, *(args.args or ())]
+
         if args.module:
-            sys.argv = [tgt, *(args.args or ())]
             runpy._run_module_as_main(tgt)  # type: ignore  # noqa
 
         else:

omlish/bootstrap/marshal.py

@@ -0,0 +1,18 @@
+from .. import lang
+from .. import marshal as msh
+from .base import Bootstrap
+from .harness import BOOTSTRAP_TYPES_BY_NAME
+
+
+@lang.cached_function
+def _install_standard_marshalling() -> None:
+    cfgs_poly = msh.Polymorphism(
+        Bootstrap.Config,
+        [msh.Impl(b.Config, n) for n, b in BOOTSTRAP_TYPES_BY_NAME.items()],
+    )
+
+    msh.STANDARD_MARSHALER_FACTORIES[0:0] = [msh.PolymorphismMarshalerFactory(cfgs_poly)]
+    msh.STANDARD_UNMARSHALER_FACTORIES[0:0] = [msh.PolymorphismUnmarshalerFactory(cfgs_poly)]
+
+
+_install_standard_marshalling()

omlish/check.py

@@ -3,6 +3,7 @@ TODO:
  - def maybe(v: lang.Maybe[T])
 """
 import collections
+import threading
 import typing as ta
 
 
@@ -21,6 +22,65 @@ _callable = callable
 ##
 
 
+_CONFIG_LOCK = threading.RLock()
+
+
+OnRaiseFn: ta.TypeAlias = ta.Callable[[Exception], None]
+_ON_RAISE: ta.Sequence[OnRaiseFn] = []
+
+
+def register_on_raise(fn: OnRaiseFn) -> None:
+    global _ON_RAISE
+    with _CONFIG_LOCK:
+        _ON_RAISE = [*_ON_RAISE, fn]
+
+
+def unregister_on_raise(fn: OnRaiseFn) -> None:
+    global _ON_RAISE
+    with _CONFIG_LOCK:
+        _ON_RAISE = [e for e in _ON_RAISE if e != fn]
+
+
+#
+
+
+_render_args: ta.Callable[..., str | None] | None = None
+
+
+def enable_args_rendering() -> bool:
+    global _render_args
+    if _render_args is not None:
+        return True
+
+    with _CONFIG_LOCK:
+        if _render_args is not None:
+            return True  # type: ignore
+
+        try:
+            from .diag.asts import ArgsRenderer
+
+            ArgsRenderer.smoketest()
+
+        except Exception:  # noqa
+            return False
+
+        def _real_render_args(fmt: str, *args: ta.Any) -> str | None:
+            ra = ArgsRenderer(back=3).render_args(*args)
+            if ra is None:
+                return None
+
+            return fmt % tuple(str(a) for a in ra)
+
+        _render_args = _real_render_args
+        return True
+
+
+enable_args_rendering()
+
+
+#
+
+
 def _default_exception_factory(exc_cls: type[Exception], *args, **kwargs) -> Exception:
     return exc_cls(*args, **kwargs)  # noqa
 
@@ -28,20 +88,45 @@ def _default_exception_factory(exc_cls: type[Exception], *args, **kwargs) -> Exc
 _EXCEPTION_FACTORY = _default_exception_factory
 
 
+class _Args:
+    def __init__(self, *args, **kwargs):
+        self.args = args
+        self.kwargs = kwargs
+
+
 def _raise(
         exception_type: type[Exception],
         default_message: str,
         message: Message,
-        *args: ta.Any,
-        **kwargs: ta.Any,
+        ak: _Args = _Args(),
+        *,
+        render_fmt: str | None = None,
 ) -> ta.NoReturn:
+    exc_args = ()
     if _callable(message):
-        message = ta.cast(ta.Callable, message)(*args, **kwargs)
+        message = ta.cast(ta.Callable, message)(*ak.args, **ak.kwargs)
         if _isinstance(message, tuple):
-            message, *args = message  # type: ignore
+            message, *exc_args = message  # type: ignore
+
     if message is None:
         message = default_message
-    exc = _EXCEPTION_FACTORY(exception_type, message, *args, **kwargs)
+
+    if render_fmt is not None and _render_args is not None:
+        rendered_args = _render_args(render_fmt, *ak.args)
+        if rendered_args is not None:
+            message = f'{message} : {rendered_args}'
+
+    exc = _EXCEPTION_FACTORY(
+        exception_type,
+        message,
+        *exc_args,
+        *ak.args,
+        **ak.kwargs,
+    )
+
+    for fn in _ON_RAISE:
+        fn(exc)
+
     raise exc
 
 
@@ -60,7 +145,14 @@ def _unpack_isinstance_spec(spec: ta.Any) -> tuple:
 
 def isinstance(v: ta.Any, spec: type[T] | tuple, msg: Message = None) -> T:  # noqa
     if not _isinstance(v, _unpack_isinstance_spec(spec)):
-        _raise(TypeError, 'Must be instance', msg, v, spec)
+        _raise(
+            TypeError,
+            'Must be instance',
+            msg,
+            _Args(v, spec),
+            render_fmt='not isinstance(%s, %s)',
+        )
+
     return v
 
 
@@ -73,7 +165,13 @@ def of_isinstance(spec: type[T] | tuple, msg: Message = None) -> ta.Callable[[ta
 
 def cast(v: ta.Any, cls: type[T], msg: Message = None) -> T:  # noqa
     if not _isinstance(v, cls):
-        _raise(TypeError, 'Must be instance', msg, v, cls)
+        _raise(
+            TypeError,
+            'Must be instance',
+            msg,
+            _Args(v, cls),
+        )
+
     return v
 
 
@@ -86,7 +184,14 @@ def of_cast(cls: type[T], msg: Message = None) -> ta.Callable[[T], T]:
 
 def not_isinstance(v: T, spec: ta.Any, msg: Message = None) -> T:  # noqa
     if _isinstance(v, _unpack_isinstance_spec(spec)):
-        _raise(TypeError, 'Must not be instance', msg, v, spec)
+        _raise(
+            TypeError,
+            'Must not be instance',
+            msg,
+            _Args(v, spec),
+            render_fmt='isinstance(%s, %s)',
+        )
+
     return v
 
 
@@ -102,13 +207,27 @@ def of_not_isinstance(spec: ta.Any, msg: Message = None) -> ta.Callable[[T], T]:
 
 def issubclass(v: type[T], spec: ta.Any, msg: Message = None) -> type[T]:  # noqa
     if not _issubclass(v, spec):
-        _raise(TypeError, 'Must be subclass', msg, v, spec)
+        _raise(
+            TypeError,
+            'Must be subclass',
+            msg,
+            _Args(v, spec),
+            render_fmt='not issubclass(%s, %s)',
+        )
+
     return v
 
 
 def not_issubclass(v: type[T], spec: ta.Any, msg: Message = None) -> type[T]:  # noqa
     if _issubclass(v, spec):
-        _raise(TypeError, 'Must not be subclass', msg, v, spec)
+        _raise(
+            TypeError,
+            'Must not be subclass',
+            msg,
+            _Args(v, spec),
+            render_fmt='issubclass(%s, %s)',
+        )
+
     return v
 
 
@@ -117,32 +236,84 @@ def not_issubclass(v: type[T], spec: ta.Any, msg: Message = None) -> type[T]:  #
 
 def in_(v: T, c: ta.Container[T], msg: Message = None) -> T:
     if v not in c:
-        _raise(ValueError, 'Must be in', msg, v, c)
+        _raise(
+            ValueError,
+            'Must be in',
+            msg,
+            _Args(v, c),
+            render_fmt='%s not in %s',
+        )
+
     return v
 
 
 def not_in(v: T, c: ta.Container[T], msg: Message = None) -> T:
     if v in c:
-        _raise(ValueError, 'Must not be in', msg, v, c)
+        _raise(
+            ValueError,
+            'Must not be in',
+            msg,
+            _Args(v, c),
+            render_fmt='%s in %s',
+        )
+
     return v
 
 
 def empty(v: SizedT, msg: Message = None) -> SizedT:
     if len(v) != 0:
-        _raise(ValueError, 'Must be empty', msg, v)
+        _raise(
+            ValueError,
+            'Must be empty',
+            msg,
+            _Args(v),
+            render_fmt='%s',
+        )
+
+    return v
+
+
+def iterempty(v: ta.Iterable[T], msg: Message = None) -> ta.Iterable[T]:
+    it = iter(v)
+    try:
+        next(it)
+    except StopIteration:
+        pass
+    else:
+        _raise(
+            ValueError,
+            'Must be empty',
+            msg,
+            _Args(v),
+            render_fmt='%s',
+        )
+
     return v
 
 
 def not_empty(v: SizedT, msg: Message = None) -> SizedT:
     if len(v) == 0:
-        _raise(ValueError, 'Must not be empty', msg, v)
+        _raise(
+            ValueError,
+            'Must not be empty',
+            msg,
+            _Args(v),
+            render_fmt='%s',
+        )
+
     return v
 
 
 def unique(it: ta.Iterable[T], msg: Message = None) -> ta.Iterable[T]:
     dupes = [e for e, c in collections.Counter(it).items() if c > 1]
     if dupes:
-        _raise(ValueError, 'Must be unique', msg, it, dupes)
+        _raise(
+            ValueError,
+            'Must be unique',
+            msg,
+            _Args(it, dupes),
+        )
+
     return it
 
 
@@ -150,9 +321,15 @@ def single(obj: ta.Iterable[T], message: Message = None) -> T:
     try:
         [value] = obj
     except ValueError:
-        _raise(ValueError, 'Must be single', message, obj)
-    else:
-        return value
+        _raise(
+            ValueError,
+            'Must be single',
+            message,
+            _Args(obj),
+            render_fmt='%s',
+        )
+
+    return value
 
 
 def optional_single(obj: ta.Iterable[T], message: Message = None) -> T | None:
@@ -161,11 +338,19 @@ def optional_single(obj: ta.Iterable[T], message: Message = None) -> T | None:
         value = next(it)
     except StopIteration:
         return None
+
     try:
         next(it)
     except StopIteration:
         return value  # noqa
-    _raise(ValueError, 'Must be empty or single', message, obj)
+
+    _raise(
+        ValueError,
+        'Must be empty or single',
+        message,
+        _Args(obj),
+        render_fmt='%s',
+    )
 
 
 ##
@@ -173,59 +358,142 @@ def optional_single(obj: ta.Iterable[T], message: Message = None) -> T | None:
 
 def none(v: ta.Any, msg: Message = None) -> None:
     if v is not None:
-        _raise(ValueError, 'Must be None', msg, v)
+        _raise(
+            ValueError,
+            'Must be None',
+            msg,
+            _Args(v),
+            render_fmt='%s',
+        )
 
 
 def not_none(v: T | None, msg: Message = None) -> T:
     if v is None:
-        _raise(ValueError, 'Must not be None', msg, v)
+        _raise(
+            ValueError,
+            'Must not be None',
+            msg,
+            _Args(v),
+            render_fmt='%s',
+        )
+
     return v
 
 
 ##
 
 
-def equal(v: T, *os: ta.Any, msg: Message = None) -> T:
-    for o in os:
-        if o != v:
-            _raise(ValueError, 'Must be equal', msg, v, os)
+def equal(v: T, o: ta.Any, msg: Message = None) -> T:
+    if o != v:
+        _raise(
+            ValueError,
+            'Must be equal',
+            msg,
+            _Args(v, o),
+            render_fmt='%s != %s',
+        )
+
     return v
 
 
-def is_(v: T, *os: ta.Any, msg: Message = None) -> T:
-    for o in os:
-        if o is not v:
-            _raise(ValueError, 'Must be the same', msg, v, os)
+def is_(v: T, o: ta.Any, msg: Message = None) -> T:
+    if o is not v:
+        _raise(
+            ValueError,
+            'Must be the same',
+            msg,
+            _Args(v, o),
+            render_fmt='%s is not %s',
+        )
+
     return v
 
 
-def is_not(v: T, *os: ta.Any, msg: Message = None) -> T:
-    for o in os:
-        if o is v:
-            _raise(ValueError, 'Must not be the same', msg, v, os)
+def is_not(v: T, o: ta.Any, msg: Message = None) -> T:
+    if o is v:
+        _raise(
+            ValueError,
+            'Must not be the same',
+            msg,
+            _Args(v, o),
+            render_fmt='%s is %s',
+        )
+
     return v
 
 
 def callable(v: T, msg: Message = None) -> T:  # noqa
     if not _callable(v):
-        _raise(TypeError, 'Must be callable', msg, v)
+        _raise(
+            TypeError,
+            'Must be callable',
+            msg,
+            _Args(v),
+            render_fmt='%s',
+        )
+
     return v  # type: ignore
 
 
 def non_empty_str(v: str | None, msg: Message = None) -> str:
     if not _isinstance(v, str) or not v:
-        _raise(ValueError, 'Must be non-empty str', msg, v)
+        _raise(
+            ValueError,
+            'Must be non-empty str',
+            msg,
+            _Args(v),
+            render_fmt='%s',
+        )
+
     return v
 
 
+def replacing(expected: ta.Any, old: ta.Any, new: T, msg: Message = None) -> T:
+    if old != expected:
+        _raise(
+            ValueError,
+            'Must be replacing',
+            msg,
+            _Args(expected, old, new),
+            render_fmt='%s -> %s -> %s',
+        )
+
+    return new
+
+
+def replacing_none(old: ta.Any, new: T, msg: Message = None) -> T:
+    if old is not None:
+        _raise(
+            ValueError,
+            'Must be replacing None',
+            msg,
+            _Args(old, new),
+            render_fmt='%s -> %s',
+        )
+
+    return new
+
+
 ##
 
 
 def arg(v: bool, msg: Message = None) -> None:
     if not v:
-        _raise(RuntimeError, 'Argument condition not met', msg)
+        _raise(
+            RuntimeError,
+            'Argument condition not met',
+            msg,
+            _Args(v),
+            render_fmt='%s',
+        )
 
 
 def state(v: bool, msg: Message = None) -> None:
     if not v:
-        _raise(RuntimeError, 'State condition not met', msg)
+        _raise(
+            RuntimeError,
+            'State condition not met',
+            msg,
+            _Args(v),
+            render_fmt='%s',
+        )