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

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev22'
-__revision__ = '3d902899000237758f62e46319a8da3bccd2d447'
+__version__ = '0.0.0.dev23'
+__revision__ = '1d019b6879a9552ea31622e40f50d260d6b08824'
 
 
 #
@@ -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
+        debug_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.debug_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,62 @@ _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
+
+
+#
+
+
 def _default_exception_factory(exc_cls: type[Exception], *args, **kwargs) -> Exception:
     return exc_cls(*args, **kwargs)  # noqa
 
@@ -28,20 +85,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 +142,7 @@ 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))
     return v
 
 
@@ -73,7 +155,7 @@ 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 +168,7 @@ 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))
     return v
 
 
@@ -102,13 +184,13 @@ 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))
     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))
     return v
 
 
@@ -117,32 +199,43 @@ 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))
     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))
     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))
+    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))
     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))
     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,7 +243,7 @@ def single(obj: ta.Iterable[T], message: Message = None) -> T:
     try:
         [value] = obj
     except ValueError:
-        _raise(ValueError, 'Must be single', message, obj)
+        _raise(ValueError, 'Must be single', message, _Args(obj))
     else:
         return value
 
@@ -165,7 +258,7 @@ def optional_single(obj: ta.Iterable[T], message: Message = None) -> T | None:
         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))
 
 
 ##
@@ -173,48 +266,45 @@ 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))
 
 
 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))
     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))
     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))
     return v
 
 

omlish/diag/asts.py

@@ -0,0 +1,132 @@
+import ast
+import dataclasses as dc
+import inspect
+import pprint
+import textwrap
+import types
+import typing as ta
+
+from .. import lang
+
+
+if ta.TYPE_CHECKING:
+    import executing
+else:
+    executing = lang.proxy_import('executing')
+
+
+class ArgsRenderer:
+    """
+    TODO:
+     - kwargs
+     - recursion
+     - whatever pytest looks like
+     - make sure not leaking sensitive data
+    """
+
+    def __init__(
+            self,
+            origin: types.TracebackType | types.FrameType | None = None,
+            back: int = 1,
+    ) -> None:
+        super().__init__()
+
+        self._origin = origin
+
+        self._frame: types.FrameType | None
+        if isinstance(origin, types.TracebackType):
+            self._frame = origin.tb_frame
+        elif isinstance(origin, types.FrameType):
+            self._frame = origin
+        elif origin is None:
+            frame = inspect.currentframe()
+            for _ in range(back + 1):
+                if frame is None:
+                    break
+                frame = frame.f_back
+            self._frame = frame
+        else:
+            raise TypeError(origin)
+
+    def _get_indented_text(
+            self,
+            src: executing.Source,
+            node: ast.AST,
+    ) -> str:
+        result = src.asttokens().get_text(node)
+        if '\n' in result:
+            result = ' ' * node.first_token.start[1] + result  # type: ignore
+            result = textwrap.dedent(result)
+        result = result.strip()
+        return result
+
+    def _val_to_string(self, obj: ta.Any) -> str:
+        s = pprint.pformat(obj)
+        s = s.replace('\\n', '\n')
+        return s
+
+    def _is_literal_expr(self, s: str) -> bool:
+        try:
+            ast.literal_eval(s)
+        except Exception:  # noqa
+            return False
+        return True
+
+    @dc.dataclass(frozen=True)
+    class RenderedArg:
+        val: str
+        expr: str
+        is_literal_expr: bool
+
+        def __str__(self) -> str:
+            if self.is_literal_expr:
+                return self.val
+            else:
+                return f'({self.expr} = {self.val})'
+
+    def render_args(
+            self,
+            *vals: ta.Any,
+    ) -> ta.Sequence[RenderedArg] | None:
+        if self._frame is None:
+            return None
+
+        call_node = executing.Source.executing(self._frame).node
+        if not isinstance(call_node, ast.Call):
+            return None
+
+        source = executing.Source.for_frame(self._frame)
+
+        exprs = [
+            self._get_indented_text(source, arg)  # noqa
+            for arg in call_node.args
+        ]
+        if len(exprs) != len(vals):
+            return None
+
+        return [
+            self.RenderedArg(
+                val=self._val_to_string(val),
+                expr=expr,
+                is_literal_expr=self._is_literal_expr(expr),
+            )
+            for val, expr in zip(vals, exprs)
+        ]
+
+    @classmethod
+    def smoketest(cls) -> bool:
+        def bar(z):
+            return z + 1
+
+        def foo(x, y):
+            return cls().render_args(x, y)
+
+        r = foo(1, bar(2))
+        if r is None:
+            return False
+
+        x, y = r
+        return (
+            x == cls.RenderedArg(val='1', expr='1', is_literal_expr=True) and
+            y == cls.RenderedArg(val='3', expr='bar(2)', is_literal_expr=False)
+        )

omlish/diag/pycharm.py

@@ -0,0 +1,80 @@
+import os.path
+import plistlib
+import subprocess
+import sys
+import typing as ta
+
+from .. import check
+from .. import lang
+
+
+if ta.TYPE_CHECKING:
+    docker = lang.proxy_import('omlish.docker')
+else:
+    from omlish import docker
+
+
+##
+
+
+PYCHARM_HOME = '/Applications/PyCharm.app'
+
+
+def read_pycharm_info_plist() -> ta.Mapping[str, ta.Any] | None:
+    plist_file = os.path.join(PYCHARM_HOME, 'Contents', 'Info.plist')
+    if not os.path.isfile(plist_file):
+        return None
+
+    with open(plist_file, 'rb') as f:
+        root = plistlib.load(f)
+
+    return root
+
+
+@lang.cached_function
+def get_pycharm_version() -> str | None:
+    plist = read_pycharm_info_plist()
+    if plist is None:
+        return None
+
+    ver = check.non_empty_str(plist['CFBundleVersion'])
+    check.state(ver.startswith('PY-'))
+    return ver[3:]
+
+
+##
+
+
+def pycharm_remote_debugger_attach(
+        host: str | None,
+        port: int,
+        *,
+        version: str | None = None,
+) -> None:
+    # if version is None:
+    #     version = get_pycharm_version()
+    # check.non_empty_str(version)
+
+    if host is None:
+        if sys.platform == 'linux' and docker.is_likely_in_docker():
+            host = docker.DOCKER_FOR_MAC_HOSTNAME
+        else:
+            host = 'localhost'
+
+    try:
+        import pydevd_pycharm  # noqa
+    except ImportError:
+        subprocess.check_call([
+            sys.executable,
+            '-mpip',
+            'install',
+            'pydevd-pycharm' + (f'~={version}' if version is not None else ''),
+        ])
+
+    import pydevd_pycharm  # noqa
+    pydevd_pycharm.settrace(
+        host,
+        port=port,
+        stdoutToServer=True,
+        stderrToServer=True,
+    )

omlish/docker.py

@@ -174,6 +174,9 @@ def timebomb_payload(delay_s: float, name: str = 'omlish-docker-timebomb') -> st
 ##
 
 
+DOCKER_FOR_MAC_HOSTNAME = 'docker.for.mac.localhost'
+
+
 _LIKELY_IN_DOCKER_PATTERN = re.compile(r'^overlay / .*/docker/')
 
 

omlish/genmachine.py

@@ -0,0 +1,58 @@
+"""
+https://github.com/pytransitions/transitions
+"""
+import typing as ta
+
+
+I = ta.TypeVar('I')
+O = ta.TypeVar('O')
+
+# MachineGen: ta.TypeAlias = ta.Generator[ta.Iterable[O] | None, I, ta.Optional[MachineGen[I, O]]]
+MachineGen: ta.TypeAlias = ta.Generator[ta.Any, ta.Any, ta.Any]
+
+
+##
+
+
+class IllegalStateError(Exception):
+    pass
+
+
+class GenMachine(ta.Generic[I, O]):
+    """
+    Generator-powered state machine. Generators are sent an `I` object and yield any number of `O` objects in response,
+    until they yield a `None` by accepting new input. Generators may return a new generator to switch states, or return
+    `None` to terminate.
+    """
+
+    def __init__(self, initial: MachineGen) -> None:
+        super().__init__()
+        self._advance(initial)
+
+    @property
+    def state(self) -> str | None:
+        if self._gen is not None:
+            return self._gen.gi_code.co_qualname
+        return None
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}@{hex(id(self))[2:]}<{self.state}>'
+
+    _gen: MachineGen | None
+
+    def _advance(self, gen: MachineGen) -> None:
+        self._gen = gen
+        if (n := next(self._gen)) is not None:  # noqa
+            raise IllegalStateError
+
+    def __call__(self, i: I) -> ta.Iterable[O]:
+        if self._gen is None:
+            raise IllegalStateError
+        try:
+            while (o := self._gen.send(i)) is not None:
+                yield from o
+        except StopIteration as s:
+            if s.value is None:
+                self._gen = None
+                return None
+            self._advance(s.value)

omlish/marshal/__init__.py

@@ -65,6 +65,10 @@ from .polymorphism import (  # noqa
     polymorphism_from_subclasses,
 )
 
+from .primitives import (  # noqa
+    PRIMITIVE_TYPES,
+)
+
 from .registries import (  # noqa
     Registry,
 )

omlish/marshal/base64.py

@@ -1,3 +1,7 @@
+"""
+FIXME:
+ - don't base64 by default, only for json-esque targets
+"""
 import base64
 import typing as ta
 

omlish/marshal/primitives.py

@@ -9,6 +9,9 @@ from .base import Unmarshaler
 from .values import Value
 
 
+##
+
+
 PRIMITIVE_TYPES: tuple[type, ...] = (
     bool,
     int,
@@ -19,6 +22,9 @@ PRIMITIVE_TYPES: tuple[type, ...] = (
 )
 
 
+##
+
+
 class PrimitiveMarshalerUnmarshaler(Marshaler, Unmarshaler):
     def marshal(self, ctx: MarshalContext, o: ta.Any) -> Value:
         if isinstance(o, PRIMITIVE_TYPES):

omlish/marshal/standard.py

@@ -27,6 +27,8 @@ from .optionals import OptionalMarshalerFactory
 from .optionals import OptionalUnmarshalerFactory
 from .primitives import PRIMITIVE_MARSHALER_FACTORY
 from .primitives import PRIMITIVE_UNMARSHALER_FACTORY
+from .unions import PrimitiveUnionMarshalerFactory
+from .unions import PrimitiveUnionUnmarshalerFactory
 from .uuids import UUID_MARSHALER_FACTORY
 from .uuids import UUID_UNMARSHALER_FACTORY
 
@@ -37,6 +39,7 @@ from .uuids import UUID_UNMARSHALER_FACTORY
 STANDARD_MARSHALER_FACTORIES: list[MarshalerFactory] = [
     PRIMITIVE_MARSHALER_FACTORY,
     OptionalMarshalerFactory(),
+    PrimitiveUnionMarshalerFactory(),
     DataclassMarshalerFactory(),
     EnumMarshalerFactory(),
     NUMBERS_MARSHALER_FACTORY,
@@ -66,6 +69,7 @@ def new_standard_marshaler_factory() -> MarshalerFactory:
 STANDARD_UNMARSHALER_FACTORIES: list[UnmarshalerFactory] = [
     PRIMITIVE_UNMARSHALER_FACTORY,
     OptionalUnmarshalerFactory(),
+    PrimitiveUnionUnmarshalerFactory(),
     DataclassUnmarshalerFactory(),
     EnumUnmarshalerFactory(),
     NUMBERS_UNMARSHALER_FACTORY,

omlish/marshal/unions.py

@@ -0,0 +1,101 @@
+import dataclasses as dc
+import typing as ta
+
+from .. import check
+from .. import matchfns as mfs
+from .. import reflect as rfl
+from .base import MarshalContext
+from .base import Marshaler
+from .base import MarshalerFactory
+from .base import UnmarshalContext
+from .base import Unmarshaler
+from .base import UnmarshalerFactory
+from .values import Value
+
+
+##
+
+
+class MatchUnionMarshaler(Marshaler):
+    mmf: mfs.MultiMatchFn[[UnmarshalContext, Value], ta.Any]
+
+    def marshal(self, ctx: MarshalContext, o: ta.Any) -> Value:
+        try:
+            m = self.mmf.match(ctx, o)
+        except mfs.AmbiguousMatchesError:
+            raise ValueError(o)  # noqa
+        return m.fn(ctx, o)
+
+
+class MatchUnionUnmarshaler(Unmarshaler):
+    mmf: mfs.MultiMatchFn[[UnmarshalContext, Value], ta.Any]
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
+        try:
+            m = self.mmf.match(ctx, v)
+        except mfs.AmbiguousMatchesError:
+            raise ValueError(v)  # noqa
+        return m.fn(ctx, v)
+
+
+##
+
+
+PRIMITIVE_UNION_TYPES: tuple[type, ...] = (
+    float,
+    int,
+    str,
+)
+
+
+#
+
+
+@dc.dataclass(frozen=True)
+class PrimitiveUnionMarshaler(Marshaler):
+    tys: ta.Sequence[type]
+
+    def marshal(self, ctx: MarshalContext, o: ta.Any) -> Value:
+        raise NotImplementedError
+
+
+@dc.dataclass(frozen=True)
+class PrimitiveUnionMarshalerFactory(MarshalerFactory):
+    tys: ta.Sequence[type] = PRIMITIVE_UNION_TYPES
+
+    def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
+        return isinstance(rty, rfl.Union) and all(a in self.tys for a in rty.args)
+
+    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
+        args = check.isinstance(rty, rfl.Union).args
+        return PrimitiveUnionMarshaler([t for t in self.tys if t in args])
+
+
+#
+
+
+@dc.dataclass(frozen=True)
+class PrimitiveUnionUnmarshaler(Unmarshaler):
+    tys: ta.Sequence[type]
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
+        raise NotImplementedError
+
+
+@dc.dataclass(frozen=True)
+class PrimitiveUnionUnmarshalerFactory(UnmarshalerFactory):
+    tys: ta.Sequence[type] = PRIMITIVE_UNION_TYPES
+
+    def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
+        return isinstance(rty, rfl.Union) and all(a in self.tys for a in rty.args)
+
+    def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
+        args = check.isinstance(rty, rfl.Union).args
+        return PrimitiveUnionUnmarshaler([t for t in self.tys if t in args])
+
+
+#
+
+
+PRIMITIVE_UNION_MARSHALER_FACTORY = PrimitiveUnionMarshalerFactory()
+PRIMITIVE_UNION_UNMARSHALER_FACTORY = PrimitiveUnionUnmarshalerFactory()

omlish/matchfns.py

@@ -93,7 +93,7 @@ class MultiMatchFn(MatchFn[P, T]):
     children: ta.Sequence[MatchFn[P, T]]
     strict: bool = False
 
-    def _match(self, *args: P.args, **kwargs: P.kwargs) -> MatchFn[P, T] | None:
+    def match(self, *args: P.args, **kwargs: P.kwargs) -> MatchFn[P, T] | None:
         matches = []
         for cur in self.children:
             if cur.guard(*args, **kwargs):
@@ -109,10 +109,10 @@ class MultiMatchFn(MatchFn[P, T]):
             return matches[0]
 
     def guard(self, *args: P.args, **kwargs: P.kwargs) -> bool:
-        return self._match(*args, **kwargs) is not None
+        return self.match(*args, **kwargs) is not None
 
     def fn(self, *args: P.args, **kwargs: P.kwargs) -> T:
-        if (m := self._match(*args, **kwargs)) is None:
+        if (m := self.match(*args, **kwargs)) is None:
             raise MatchGuardError(*args, **kwargs)
         return m.fn(*args, **kwargs)
 

omlish/sql/__init__.py

@@ -7,3 +7,21 @@ from .asyncs import (  # noqa
     AsyncTransactionLike,
     async_adapt,
 )
+
+from .dbs import (  # noqa
+    DbLoc,
+    DbSpec,
+    DbType,
+    DbTypes,
+    HostDbLoc,
+    UrlDbLoc,
+)
+
+from .exprs import (  # noqa
+    paren,
+)
+
+from .qualifiedname import (  # noqa
+    QualifiedName,
+    qn,
+)

omlish/sql/qualifiedname.py

@@ -0,0 +1,82 @@
+import collections.abc
+import dataclasses as dc
+import typing as ta
+
+
+@dc.dataclass(frozen=True)
+class QualifiedName(ta.Sequence[str]):
+    parts: ta.Sequence[str]
+
+    def __post_init__(self) -> None:
+        if not (
+                self.parts and
+                not isinstance(self.parts, str) and
+                all(self.parts) and
+                all(isinstance(p, str) for p in self.parts)
+        ):
+            raise ValueError(self)
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}([{", ".join(map(repr, self.parts))}])'
+
+    @property
+    def dotted(self) -> str:
+        return '.'.join(self.parts)
+
+    def prefixed(self, sz: int) -> tuple[str | None, ...]:
+        if len(self) > sz:
+            raise ValueError(self)
+        return ((None,) * (sz - len(self))) + tuple(self.parts)
+
+    @property
+    def pair(self) -> tuple[str | None, str]:
+        return self.prefixed(2)  # type: ignore
+
+    @property
+    def triple(self) -> tuple[str | None, str | None, str]:
+        return self.prefixed(3)  # type: ignore
+
+    @property
+    def quad(self) -> tuple[str | None, str | None, str | None, str]:
+        return self.prefixed(4)  # type: ignore
+
+    def __iter__(self) -> ta.Iterator[str]:
+        return iter(self.parts)
+
+    def __len__(self) -> int:
+        return len(self.parts)
+
+    def __getitem__(self, idx: int) -> str:  # type: ignore
+        return self.parts[idx]
+
+    @classmethod
+    def of_dotted(cls, dotted: str) -> 'QualifiedName':
+        return cls(dotted.split('.'))
+
+    @classmethod
+    def of(
+            cls,
+            obj: ta.Union['QualifiedName', ta.Iterable[str]],
+    ) -> 'QualifiedName':
+        if isinstance(obj, QualifiedName):
+            return obj
+        elif isinstance(obj, str):
+            raise TypeError(obj)
+        elif isinstance(obj, collections.abc.Iterable):
+            return cls(list(obj))
+        else:
+            raise TypeError(obj)
+
+    @classmethod
+    def of_optional(
+            cls,
+            obj: ta.Union['QualifiedName', ta.Iterable[str], None],
+    ) -> ta.Optional['QualifiedName']:
+        if obj is None:
+            return None
+        else:
+            return cls.of(obj)
+
+
+def qn(*args: str) -> QualifiedName:
+    return QualifiedName(args)

{omlish-0.0.0.dev22.dist-info → omlish-0.0.0.dev23.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev22
+Version: 0.0.0.dev23
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev22.dist-info → omlish-0.0.0.dev23.dist-info}/RECORD

@@ -1,17 +1,18 @@
-omlish/__about__.py,sha256=V2bnCKc-3aJwdTP1xtp2ipVCaAqOuhGj6P8aqD-yHvs,2380
+omlish/__about__.py,sha256=KiGBpOncoW1f9W1y130G59BNQdvfrd0cRxVrJ-_d5JA,2532
 omlish/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/argparse.py,sha256=QRQmX9G0-L_nATkFtGHvpd4qrpYzKATdjuFLbBqzJPM,6224
 omlish/c3.py,sha256=W5EwYx9Por3rWYLkKUitJ6OoRMLLgVTfLTyroOz41Y0,8047
 omlish/cached.py,sha256=UAizxlH4eMWHPzQtmItmyE6FEpFEUFzIkxaO2BHWZ5s,196
-omlish/check.py,sha256=o3UJnIEmmRsv9ggIIDtz8fDSudW1CatxbwxP42M4dno,5543
+omlish/check.py,sha256=18vZWH9qEVMs62LTfn_XC0U5GPeaOotKLmL41qecyNQ,7560
 omlish/datetimes.py,sha256=HajeM1kBvwlTa-uR1TTZHmZ3zTPnnUr1uGGQhiO1XQ0,2152
 omlish/defs.py,sha256=T3bq_7h_tO3nDB5RAFBn7DkdeQgqheXzkFColbOHZko,4890
-omlish/docker.py,sha256=5WyXJyFwqIJJ11QWwPIjHjDHnsaOVZszZAjyTvg3xew,4693
+omlish/docker.py,sha256=Nwyk4jpUmpd4NE0H1JeMQ42WC9NymJDZ8TPLQ9P24MY,4748
 omlish/dynamic.py,sha256=35C_cCX_Vq2HrHzGk5T-zbrMvmUdiIiwDzDNixczoDo,6541
 omlish/fnpairs.py,sha256=hVuLqQFdRNNze3FYH2cAQO3GC7nK5yQP_GWPUSbL7nE,10601
+omlish/genmachine.py,sha256=LDIMOc5OXnJ5IBzRyHX4ZR6FqViVKowuiGVWamexP9k,1595
 omlish/iterators.py,sha256=GGLC7RIT86uXMjhIIIqnff_Iu5SI_b9rXYywYGFyzmo,7292
 omlish/libc.py,sha256=u0481imCiTFqP_e-v9g0pD-0WD249j5vYzhtn-fnNkY,15308
-omlish/matchfns.py,sha256=o2evI7q0CAMHR8RQ_Jks6L0UoNpEDltnLjOiamJDtmU,6155
+omlish/matchfns.py,sha256=ygqbqthRxgF9I1PJaw9Xl7FoZnAVMmnKBrYgimKQ0ag,6152
 omlish/math.py,sha256=AVqp5Y8yxKA-wO0BgrzaxA0Ga3PZiCXnYcwivMneC-0,3804
 omlish/multiprocessing.py,sha256=QZT4C7I-uThCAjaEY3xgUYb-5GagUlnE4etN01LDyU4,5186
 omlish/os.py,sha256=cz4nL2ujaxH_-XRq3JUD8af8mSe1JXGPIoXP9XAEd0M,2607
@@ -23,16 +24,17 @@ omlish/asyncs/__init__.py,sha256=uUz9ziKh4_QrgmdhKFMgq6j7mFbiZd3LiogguDCQsGI,587
 omlish/asyncs/anyio.py,sha256=Hqdi1iCopKoaAWGx-AYTRLEwnavLWx1esfJISK1IVF0,8024
 omlish/asyncs/asyncio.py,sha256=JfM59QgB3asgEbrps0zoVbNjWD4kL2XdsEkRMEIoFos,971
 omlish/asyncs/asyncs.py,sha256=Tf7ZodTGepkM7HAuFcDNh9lLzzrMw6rELWvopGmFkh4,2035
-omlish/asyncs/bridge.py,sha256=dTVJrubiPlP0PlgJQT1Pj0jNDXFuPADtWymwSsgbl4k,8575
+omlish/asyncs/bridge.py,sha256=fkMQWG2TNmPB9BfIxtXrE50W5FJw0ma44GleOXbcSKw,8628
 omlish/asyncs/flavors.py,sha256=1mNxGNRVmjUHzA13K5ht8vdJv4CLEmzYTQ6BZXr1520,4866
 omlish/asyncs/trio.py,sha256=GKG3wgelFr7gIKKHZhcflvMyCvxXHNZe862KB0Xw2uA,370
 omlish/asyncs/trio_asyncio.py,sha256=oqdOHy0slj9PjVxaDf3gJkq9AAgg7wYZbB469jOftVw,1327
-omlish/bootstrap/__init__.py,sha256=Nii56mGsr1MsrQPQTX45kS6NsU0APK5t13Wlb1n8jlo,48
+omlish/bootstrap/__init__.py,sha256=-Rtsg7uPQNhh1dIT9nqrz96XlqizwoLnWf-FwOEstJI,730
 omlish/bootstrap/__main__.py,sha256=d23loR_cKfTYZwYiqpt_CmKI7dd5WcYFgIYzqMep75E,68
-omlish/bootstrap/base.py,sha256=nyf2PYCoYzNEX_78Rm8szqpdTdhhSbSJEt3hf7OncvA,1032
-omlish/bootstrap/diag.py,sha256=BQf1MkhT-cY2vJGoSauOMZZagTc73tPV-NqmP5-AGWQ,3107
+omlish/bootstrap/base.py,sha256=koELbK6UmsZaRj-6Bng5_zPVmEBqDpFCduEdR5BddOs,1077
+omlish/bootstrap/diag.py,sha256=8ajcsuY__5TlYzpbO6m4T87jw8uLcQ0wuJKdtQ7350w,4396
 omlish/bootstrap/harness.py,sha256=vQCIhCQY_N0NHWvDh8rG6Lo57U1qHkQf2egifbXzN-8,2027
-omlish/bootstrap/main.py,sha256=ZNzbT1t_dI4MhCB7so0glINw5XONTehIO5cv3hyXN44,5218
+omlish/bootstrap/main.py,sha256=9ZbgXaRNZwt_hXdg8W4YjpP0v0Si_qqlfu86jfgRz04,5215
+omlish/bootstrap/marshal.py,sha256=qKewGVs-3i2p5W9nywkXSo1pcbVxmOAlTvfLjyo0xpo,554
 omlish/bootstrap/sys.py,sha256=U0MFxO9tLFV3cdN5Y-Zrink6_45sFvzPUYQXyBk7-ns,8741
 omlish/collections/__init__.py,sha256=h7gXQNMI_46hRRlIAI3PTaewMV8H381FV_KlONReg9s,1660
 omlish/collections/_abc.py,sha256=sP7BpTVhx6s6C59mTFeosBi4rHOWC6tbFBYbxdZmvh0,2365
@@ -89,9 +91,11 @@ omlish/dataclasses/impl/simple.py,sha256=EovA-GpmQYtB_svItO2byTAWqbKGF4njz0MdQts
 omlish/dataclasses/impl/slots.py,sha256=_sm-x9v1tPnXEHBHNUMTHZocgVyhZaPdvamIPPBUVyk,2635
 omlish/dataclasses/impl/utils.py,sha256=aER2iL3UAtgS1BdLuEvTr9Tr2wC28wk1kiOeO-jIymw,6138
 omlish/diag/__init__.py,sha256=BYQoq12W2qU0O7m2Z-RLCX6YLIYEW9MmfN7_i9--Yk0,132
+omlish/diag/asts.py,sha256=BveUUNUcaAm4Hg55f4ZxGSI313E4L8cCZ5XjHpEkKVI,3325
 omlish/diag/procfs.py,sha256=ggIeFoaNZ4j6HvKTiXD6Q3b9apgto7j55pwswCrIHXE,9581
 omlish/diag/procstats.py,sha256=9uQMvVL7Yzf_1F8dW55pcZeCFtP5yUbK1KuGn9bt2Qg,502
 omlish/diag/ps.py,sha256=1JWxZen3fVG-20R6ZZ8BtO_gpzw_5bhHZiKdoHkgxoU,1004
+omlish/diag/pycharm.py,sha256=HgPvABfgzNU3rb77B5W8hZ4_5sP6l3W5hg8R6vM1Yr4,1686
 omlish/diag/pydevd.py,sha256=Fsx9rfCOnwLD6RLBqH0uAdtq75rbNeBAQfiDvIBd3e0,7295
 omlish/diag/threads.py,sha256=1-x02VCDZ407gfbtXm1pWK-ubqhqfePm9PMqkHCVoqk,3642
 omlish/diag/replserver/__init__.py,sha256=uLo6V2aQ29v9z3IMELlPDSlG3_2iOT4-_X8VniF-EgE,235
@@ -206,10 +210,10 @@ omlish/logs/formatters.py,sha256=AFs9C6-qrFkgXZ0nL39wih_LGck1Tc79alvGyibBdQo,720
 omlish/logs/handlers.py,sha256=nyuFgmO05By_Xwq7es58ClzS51-F53lJL7gD0x5IqAg,228
 omlish/logs/noisy.py,sha256=8JORjI1dH38yU2MddM54OB6qt32Xozfocdb88vY4wro,335
 omlish/logs/utils.py,sha256=MgGovbP0zUrZ3FGD3qYNQWn-l0jy0Y0bStcQvv5BOmQ,391
-omlish/marshal/__init__.py,sha256=Co5UUlCyd3eDToQTOvTURmCICKzuULnR5B6ylgb2nFM,1515
+omlish/marshal/__init__.py,sha256=Oqp0e27zj3YsI5Ek0CPvyH8Rfm3hWU0wzXJcjeu5HdQ,1573
 omlish/marshal/any.py,sha256=e82OyYK3Emm1P1ClnsnxP7fIWC2iNVyW0H5nK4mLmWM,779
 omlish/marshal/base.py,sha256=EIgrqsQ1OQ4mVUMuDH5zRBCwJpn8ijVS98Nmoka_Mrs,6025
-omlish/marshal/base64.py,sha256=Q3ibujdhgFgDaeHahSe7WdcqvOyalWigwUlV-U-2ckQ,1018
+omlish/marshal/base64.py,sha256=F-3ogJdcFCtWINRgJgWT0rErqgx6f4qahhcg8OrkqhE,1089
 omlish/marshal/dataclasses.py,sha256=cqHfzkQe7T-A_eAx-xZm6AIOZLnqE-alMUXMtRTYxuI,3910
 omlish/marshal/datetimes.py,sha256=0ffg8cEvx9SMKIXZGD9b7MqpLfmgw0uKKdn6YTfoqok,3714
 omlish/marshal/enums.py,sha256=-0fKutBbyz8ygEaA0_P_8IOJrI9jMGigmnPbutV9Bg4,1464
@@ -226,9 +230,10 @@ omlish/marshal/numbers.py,sha256=oY_yMNJEnJhjfLh89gpPXvKqeUyhQcaTcQB6ecyHiG8,170
 omlish/marshal/objects.py,sha256=T3prlm0HESpOLXHWcdsYekfmythJRZQOvaoL0is8J_o,3097
 omlish/marshal/optionals.py,sha256=r0XB5rqfasvgZJNrKYd6Unq2U4nHt3JURi26j0dYHlw,1499
 omlish/marshal/polymorphism.py,sha256=gyvNYUAkmQVhWrcXBLzXINxqx6RHyulf9n16Iv38PFI,5597
-omlish/marshal/primitives.py,sha256=-gLR_RTPTM8YP6t6PL5sNM1lAtwcZDHc9lxkimoQ9jw,1097
+omlish/marshal/primitives.py,sha256=wcvcs5GH_TWVmzAszh3dvyKibJgBxnXke-AlAXiwrrI,1107
 omlish/marshal/registries.py,sha256=GI2KogcxawMkk02Ky7-TsnijChoe1I7YTOPIbUNwSAI,1665
-omlish/marshal/standard.py,sha256=059gc16ycgqFbBz1F3rCkbi5lgxH9sQt9We-ghiLpBs,2803
+omlish/marshal/standard.py,sha256=uQZIGiCwihmhB1tmhpKnZWZly0DDkdGjCnN0d41WHho,2985
+omlish/marshal/unions.py,sha256=m9uVp2HrkZKY9lDyGoWQGXFgan8mRuBaKimtWNksl64,2635
 omlish/marshal/utils.py,sha256=puKJpwPpuDlMOIrKMcLTRLJyMiL6n_Xs-p59AuDEymA,543
 omlish/marshal/uuids.py,sha256=H4B7UX_EPNmP2tC8bubcKrPLTS4aQu98huvbXQ3Zv2g,910
 omlish/marshal/values.py,sha256=ssHiWdg_L6M17kAn8GiGdPW7UeQOm3RDikWkvwblf5I,263
@@ -257,12 +262,13 @@ omlish/specs/jsonschema/keywords/validation.py,sha256=ghewVUSG5qPYnmexy1Ylc-Xoui
 omlish/specs/jsonschema/schemas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/specs/jsonschema/schemas/draft202012/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/specs/jsonschema/schemas/draft202012/vocabularies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-omlish/sql/__init__.py,sha256=pLv2EQmAwcGXN0Y3AE8K5JjyN_4GaHRMHyExaDFm5yU,181
+omlish/sql/__init__.py,sha256=QHKkiM0rvSDWKUYrvTSynOni5fB46QQ2gOw_TcMBQ2o,398
 omlish/sql/_abc.py,sha256=HLhnnLZ7l0r_N99I-RCqJe6VHth-9iluU7cR-7-5jfs,1519
 omlish/sql/asyncs.py,sha256=Wye3dwh7oZEGYz2Y4DZQSHtW4xjI2AH5qjW-BSS2IfU,3688
 omlish/sql/dbs.py,sha256=lpdFmm2vTwLoBiVYGj9yPsVcTEYYNCxlYZZpjfChzkY,1870
 omlish/sql/duckdb.py,sha256=Z3wiZEn_21Lu1ElFRX0ATzoBMCw0KJxINjTRuTexYGM,3748
 omlish/sql/exprs.py,sha256=gO4Fj4xEY-PuDgV-N8hBMy55glZz7O-4H7v1LWabfZY,323
+omlish/sql/qualifiedname.py,sha256=rlW3gVmyucJbqwcxj_7BfK4X2HoXrMroZT2H45zPgJQ,2264
 omlish/sql/secrets.py,sha256=mDUunIACxHBsPD_ONbHQJVndeMMzJR4vMC2WWX7tGfY,177
 omlish/sql/sqlean.py,sha256=RbkuOuFIfM4fowwKk8-sQ6Dxk-tTUwxS94nY5Kxt52s,403
 omlish/testing/__init__.py,sha256=kfiF10ykrjWXniedIl3g8j3pNAFyuSbp1D3ZXug3-Eo,168
@@ -289,8 +295,8 @@ omlish/text/delimit.py,sha256=ubPXcXQmtbOVrUsNh5gH1mDq5H-n1y2R4cPL5_DQf68,4928
 omlish/text/glyphsplit.py,sha256=Ug-dPRO7x-OrNNr8g1y6DotSZ2KH0S-VcOmUobwa4B0,3296
 omlish/text/indent.py,sha256=6Jj6TFY9unaPa4xPzrnZemJ-fHsV53IamP93XGjSUHs,1274
 omlish/text/parts.py,sha256=KGgo0wHOIMVMZtDso-rhSWKAcAkYAH2IGpg9tULabu8,6505
-omlish-0.0.0.dev22.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev22.dist-info/METADATA,sha256=VLYWv2M6zOnFd6tjfwCF6zxknpq4PAREgFChwcGrM-4,3666
-omlish-0.0.0.dev22.dist-info/WHEEL,sha256=cVxcB9AmuTcXqmwrtPhNK88dr7IR_b6qagTj0UvIEbY,91
-omlish-0.0.0.dev22.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev22.dist-info/RECORD,,
+omlish-0.0.0.dev23.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev23.dist-info/METADATA,sha256=vhWl21vTSXsQivm5hv_6iQ-60K2Iiaa2UigiH6Hbkww,3666
+omlish-0.0.0.dev23.dist-info/WHEEL,sha256=cVxcB9AmuTcXqmwrtPhNK88dr7IR_b6qagTj0UvIEbY,91
+omlish-0.0.0.dev23.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev23.dist-info/RECORD,,