omlish 0.0.0.dev447__py3-none-any.whl → 0.0.0.dev493__py3-none-any.whl

omlish/specs/openapi/_marshal.py

@@ -5,7 +5,6 @@ from ... import dataclasses as dc
 from ... import lang
 from ... import marshal as msh
 from ... import reflect as rfl
-from ...funcs import match as mfs
 from .. import jsonschema as jsch
 from .openapi import Reference
 from .openapi import Schema
@@ -36,10 +35,14 @@ class _ReferenceUnionMarshaler(msh.Marshaler):
             return self.m.marshal(ctx, o)
 
 
-class _ReferenceUnionMarshalerFactory(msh.MarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: _reference_union_arg(rty) is not None)
-    def _build(self, ctx: msh.MarshalContext, rty: rfl.Type) -> msh.Marshaler:
-        return _ReferenceUnionMarshaler(ctx.make(check.not_none(_reference_union_arg(rty))), ctx.make(Reference))
+class _ReferenceUnionMarshalerFactory(msh.MarshalerFactory):
+    def make_marshaler(self, ctx: msh.MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Marshaler] | None:
+        if (rua := _reference_union_arg(rty)) is None:
+            return None
+        return lambda: _ReferenceUnionMarshaler(
+            ctx.make_marshaler(check.not_none(rua)),
+            ctx.make_marshaler(Reference),
+        )
 
 
 #
@@ -59,10 +62,14 @@ class _ReferenceUnionUnmarshaler(msh.Unmarshaler):
             return self.u.unmarshal(ctx, v)  # noqa
 
 
-class _ReferenceUnionUnmarshalerFactory(msh.UnmarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: _reference_union_arg(rty) is not None)
-    def _build(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> msh.Unmarshaler:
-        return _ReferenceUnionUnmarshaler(ctx.make(check.not_none(_reference_union_arg(rty))), ctx.make(Reference))
+class _ReferenceUnionUnmarshalerFactory(msh.UnmarshalerFactory):
+    def make_unmarshaler(self, ctx: msh.UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Unmarshaler] | None:  # noqa
+        if (rua := _reference_union_arg(rty)) is None:
+            return None
+        return lambda: _ReferenceUnionUnmarshaler(
+            ctx.make_unmarshaler(check.not_none(rua)),
+            ctx.make_unmarshaler(Reference),
+        )
 
 
 ##
@@ -86,16 +93,17 @@ class _SchemaMarshaler(msh.Marshaler):
         return dct
 
 
-class _SchemaMarshalerFactory(msh.MarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: rty is Schema)
-    def _build(self, ctx: msh.MarshalContext, rty: rfl.Type) -> msh.Marshaler:
-        return _SchemaMarshaler(
+class _SchemaMarshalerFactory(msh.MarshalerFactory):
+    def make_marshaler(self, ctx: msh.MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Marshaler] | None:
+        if rty is not Schema:
+            return None
+        return lambda: _SchemaMarshaler(
             {
-                f: (msh.translate_name(f, msh.Naming.LOW_CAMEL), ctx.make(rfl.type_(a)))
+                f: (msh.translate_name(f, msh.Naming.LOW_CAMEL), ctx.make_marshaler(rfl.type_(a)))
                 for f, a in dc.reflect(Schema).field_annotations.items()
                 if f != 'keywords'
             },
-            ctx.make(jsch.Keywords),
+            ctx.make_marshaler(jsch.Keywords),
         )
 
 
@@ -121,16 +129,17 @@ class _SchemaUnmarshaler(msh.Unmarshaler):
         return Schema(**kw)
 
 
-class _SchemaUnmarshalerFactory(msh.UnmarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: rty is Schema)
-    def _build(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> msh.Unmarshaler:
-        return _SchemaUnmarshaler(
+class _SchemaUnmarshalerFactory(msh.UnmarshalerFactory):
+    def make_unmarshaler(self, ctx: msh.UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Unmarshaler] | None:  # noqa
+        if rty is not Schema:
+            return None
+        return lambda: _SchemaUnmarshaler(
             {
-                msh.translate_name(f, msh.Naming.LOW_CAMEL): (f, ctx.make(rfl.type_(a)))
+                msh.translate_name(f, msh.Naming.LOW_CAMEL): (f, ctx.make_unmarshaler(rfl.type_(a)))
                 for f, a in dc.reflect(Schema).field_annotations.items()
                 if f != 'keywords'
             },
-            ctx.make(jsch.Keywords),
+            ctx.make_unmarshaler(jsch.Keywords),
         )
 
 
@@ -138,7 +147,7 @@ class _SchemaUnmarshalerFactory(msh.UnmarshalerFactoryMatchClass):
 
 
 @lang.static_init
-def _install_standard_marshalling() -> None:
+def _install_standard_marshaling() -> None:
     msh.install_standard_factories(
         _ReferenceUnionMarshalerFactory(),
         _ReferenceUnionUnmarshalerFactory(),

omlish/sql/__init__.py

@@ -7,18 +7,37 @@ with _lang.auto_proxy_init(globals()):
 
     from . import api  # noqa
 
+    from . import dbapi  # noqa
+
+    from . import queries  # noqa
+
+    #
+
     from .dbs import (  # noqa
-        DbLoc,
-        DbSpec,
         DbType,
         DbTypes,
-        HostDbLoc,
+
+        DbLoc,
         UrlDbLoc,
+        HostDbLoc,
+
+        DbSpec,
+    )
+
+    from .params import (  # noqa
+        ParamKey,
+        ParamsPreparer,
+        LinearParamsPreparer,
+        NumericParamsPreparer,
+        NamedParamsPreparer,
+
+        ParamStyle,
+        make_params_preparer,
+
+        substitute_params,
     )
 
     from .qualifiedname import (  # noqa
         QualifiedName,
         qn,
     )
-
-    from . import queries  # noqa

omlish/sql/{tabledefs/alchemy.py → alchemy/tabledefs.py}

@@ -7,13 +7,13 @@ import typing as ta
 import sqlalchemy as sa
 import sqlalchemy.sql.schema
 
-from .tabledefs import TableDef
+from ..tabledefs import TableDef
 
 
 ##
 
 
-def build_sa_table(
+def build_td_table(
         td: TableDef,
         *,
         metadata: sa.MetaData | None = None,

omlish/sql/api/dbapi.py

@@ -1,7 +1,7 @@
 import typing as ta
 
 from ... import check
-from .. import abc as dbapi_abc
+from ..dbapi import abc as dbapi_abc
 from .base import Adapter
 from .base import Conn
 from .base import Db

omlish/sql/dbapi/__init__.py

@@ -0,0 +1,15 @@
+from .abc import (  # noqa
+    DbapiTypeCode,
+    DbapiColumnDescription,
+    DbapiColumnDescription_,
+    DbapiConnection,
+    DbapiCursor,
+    DbapiThreadSafety,
+    DbapiModule,
+)
+
+from .drivers import (  # noqa
+    DbapiDialect,
+    DbapiDriver,
+    DbapiDrivers,
+)

omlish/sql/{dbapi.py → dbapi/drivers.py}

@@ -41,8 +41,8 @@ ROWID type
 import dataclasses as dc
 import enum
 
-from .. import lang
-from .params import ParamStyle
+from ... import lang
+from ..params import ParamStyle
 
 
 ##

omlish/sql/queries/__init__.py

@@ -65,9 +65,12 @@ from .relations import (  # noqa
 )
 
 from .rendering import (  # noqa
+    RenderedQuery,
+    RenderedQueryParts,
     Renderer,
     StdRenderer,
     render,
+    render_parts,
 )
 
 from .selects import (  # noqa

omlish/sql/queries/_marshal.py

@@ -63,7 +63,7 @@ class LowerEnumMarshaler(msh.Marshaler, msh.Unmarshaler):
 
 
 @lang.static_init
-def _install_standard_marshalling() -> None:
+def _install_standard_marshaling() -> None:
     for ty, ns in [
         (BinaryOp, BinaryOps),
         (UnaryOp, UnaryOps),
@@ -92,7 +92,7 @@ def _install_standard_marshalling() -> None:
         p = msh.polymorphism_from_subclasses(
             cls,
             naming=msh.Naming.SNAKE,
-            strip_suffix='auto',
+            strip_suffix=msh.AutoStripSuffix,
         )
         msh.install_standard_factories(
             msh.PolymorphismMarshalerFactory(p),

omlish/sql/queries/rendering.py

@@ -81,7 +81,7 @@ class Renderer(lang.Abstract):
     def args(self) -> lang.Args:
         return self._params_preparer.prepare()
 
-    @dispatch.method
+    @dispatch.method(instance_cache=True)
     def render(self, o: ta.Any) -> tp.Part:
         raise TypeError(o)
 

omlish/sql/tabledefs/_marshal.py

@@ -16,6 +16,6 @@ def _install_poly(cls: type) -> None:
 
 
 @lang.static_init
-def _install_standard_marshalling() -> None:
+def _install_standard_marshaling() -> None:
     _install_poly(Dtype)
     _install_poly(Element)

omlish/subprocesses/base.py

@@ -58,6 +58,10 @@ class VerboseCalledProcessError(subprocess.CalledProcessError):
 class BaseSubprocesses(Abstract):
     DEFAULT_LOGGER: ta.ClassVar[ta.Optional[LoggerLike]] = None
 
+    PIPE: ta.ClassVar[int] = subprocess.PIPE
+    STDOUT: ta.ClassVar[int] = subprocess.STDOUT
+    DEVNULL: ta.ClassVar[int] = subprocess.DEVNULL
+
     def __init__(
             self,
             *,

omlish/subprocesses/editor.py

@@ -32,7 +32,7 @@ def get_user_text_editor(default: ta.Optional[str] = None) -> str:
 ##
 
 
-class EditTextWithUserEditor(SubprocessRunnable, ExitStacked):
+class EditTextWithUserEditor(SubprocessRunnable[ta.Optional[str]], ExitStacked):
     def __init__(self, initial_text: str = '') -> None:
         super().__init__()
 

omlish/sync.py

@@ -1,3 +1,5 @@
+# ruff: noqa: UP006 UP043 UP045
+# @omlish-lite
 """
 TODO:
  - sync (lol) w/ asyncs.anyio
@@ -5,19 +7,21 @@ TODO:
  - Once poison=False, PoisonedError
 """
 import collections
+import contextlib
 import threading
 import typing as ta
 
-from . import lang
+from .lite.maybes import Maybe
 
 
 T = ta.TypeVar('T')
+U = ta.TypeVar('U')
 
 
 ##
 
 
-class Once:
+class SyncOnce:
     def __init__(self) -> None:
         super().__init__()
 
@@ -40,43 +44,43 @@ class Once:
 ##
 
 
-class Lazy(ta.Generic[T]):
+class SyncLazy(ta.Generic[T]):
     def __init__(self) -> None:
         super().__init__()
 
-        self._once = Once()
-        self._v: lang.Maybe[T] = lang.empty()
+        self._once = SyncOnce()
+        self._v: Maybe[T] = Maybe.empty()
 
-    def peek(self) -> lang.Maybe[T]:
+    def peek(self) -> Maybe[T]:
         return self._v
 
     def set(self, v: T) -> None:
-        self._v = lang.just(v)
+        self._v = Maybe.just(v)
 
     def get(self, fn: ta.Callable[[], T]) -> T:
         def do():
-            self._v = lang.just(fn())
+            self._v = Maybe.just(fn())
         self._once.do(do)
         return self._v.must()
 
 
-class LazyFn(ta.Generic[T]):
+class SyncLazyFn(ta.Generic[T]):
     def __init__(self, fn: ta.Callable[[], T]) -> None:
         super().__init__()
 
         self._fn = fn
-        self._once = Once()
-        self._v: lang.Maybe[T] = lang.empty()
+        self._once = SyncOnce()
+        self._v: Maybe[T] = Maybe.empty()
 
-    def peek(self) -> lang.Maybe[T]:
+    def peek(self) -> Maybe[T]:
         return self._v
 
     def set(self, v: T) -> None:
-        self._v = lang.just(v)
+        self._v = Maybe.just(v)
 
     def get(self) -> T:
         def do():
-            self._v = lang.just(self._fn())
+            self._v = Maybe.just(self._fn())
         self._once.do(do)
         return self._v.must()
 
@@ -89,11 +93,11 @@ class ConditionDeque(ta.Generic[T]):
             self,
             *,
             cond: ta.Optional['threading.Condition'] = None,
-            deque: collections.deque[T] | None = None,
+            deque: ta.Optional[ta.Deque[T]] = None,
 
             lock: ta.Optional['threading.RLock'] = None,
-            maxlen: int | None = None,
-            init: ta.Iterable[T] | None = None,
+            maxlen: ta.Optional[int] = None,
+            init: ta.Optional[ta.Iterable[T]] = None,
     ) -> None:
         super().__init__()
 
@@ -112,7 +116,7 @@ class ConditionDeque(ta.Generic[T]):
         return self._cond
 
     @property
-    def deque(self) -> collections.deque[T]:
+    def deque(self) -> ta.Deque[T]:
         return self._deque
 
     def push(
@@ -126,9 +130,9 @@ class ConditionDeque(ta.Generic[T]):
 
     def pop(
             self,
-            timeout: float | None = None,
+            timeout: ta.Optional[float] = None,
             *,
-            if_empty: ta.Callable[[], None] | None = None,
+            if_empty: ta.Optional[ta.Callable[[], None]] = None,
     ) -> T:
         with self.cond:
             if not self.deque and if_empty is not None:
@@ -141,6 +145,45 @@ class ConditionDeque(ta.Generic[T]):
 ##
 
 
+class SyncBufferRelay(ta.Generic[T]):
+    def __init__(
+            self,
+            *,
+            wake_fn: ta.Callable[[], None],
+    ) -> None:
+        super().__init__()
+
+        self._wake_fn = wake_fn
+
+        self._lock = threading.Lock()
+        self._buffer: SyncBufferRelay._Buffer = SyncBufferRelay._Buffer()
+
+    class _Buffer:
+        def __init__(self) -> None:
+            self.lst: list = []
+            self.age = 0
+
+        def __repr__(self) -> str:
+            return f'{self.__class__.__qualname__}({self.lst!r}, age={self.age!r})'
+
+    def push(self, *vs: T) -> None:
+        with self._lock:
+            buf = self._buffer
+            needs_wake = not buf.age
+            buf.lst.extend(vs)
+            buf.age += 1
+        if needs_wake:
+            self._wake_fn()
+
+    def swap(self) -> ta.Sequence[T]:
+        with self._lock:
+            buf, self._buffer = self._buffer, SyncBufferRelay._Buffer()
+        return buf.lst
+
+
+##
+
+
 class CountDownLatch:
     def __init__(self, count: int) -> None:
         super().__init__()
@@ -156,10 +199,101 @@ class CountDownLatch:
 
     def wait(
             self,
-            timeout: float | None = None,
+            timeout: ta.Optional[float] = None,
     ) -> bool:
         with self._cond:
             return self._cond.wait_for(
                 lambda: self._count < 1,
                 timeout,
             )
+
+
+##
+
+
+class ObjectPool(ta.Generic[T]):
+    def __init__(self, new: ta.Optional[ta.Callable[[], T]] = None) -> None:
+        super().__init__()
+
+        self._new = new
+
+        self._lock = threading.Lock()
+        self._pool: ta.List[T] = []
+        self._closed: bool = False
+
+    #
+
+    class ClosedError(Exception):
+        pass
+
+    def _check_not_closed(self) -> None:
+        if self._closed:
+            raise ObjectPool.ClosedError
+
+    def close(self) -> None:
+        with self._lock:
+            self._closed = True
+
+    #
+
+    class EmptyError(Exception):
+        pass
+
+    def get(self, new: ta.Optional[ta.Callable[[], T]] = None) -> T:
+        with self._lock:
+            self._check_not_closed()
+            if self._pool:
+                return self._pool.pop()
+
+        if new is None:
+            new = self._new
+        if new is not None:
+            return new()
+
+        raise ObjectPool.EmptyError
+
+    def put(self, obj: T) -> None:
+        with self._lock:
+            self._check_not_closed()
+            self._pool.append(obj)
+
+    def acquire(self, new: ta.Optional[ta.Callable[[], T]] = None) -> ta.ContextManager[T]:
+        @contextlib.contextmanager
+        def inner():
+            o = self.get(new)
+            try:
+                yield o
+            finally:
+                self.put(o)
+
+        return inner()
+
+    def drain(self) -> ta.List[T]:
+        with self._lock:
+            out = self._pool
+            self._pool = []
+
+        return out
+
+    #
+
+    def manage(
+            self,
+            drain: ta.Optional[ta.Callable[[T], None]] = None,
+    ) -> ta.ContextManager['ObjectPool[T]']:
+        @contextlib.contextmanager
+        def inner():
+            with self._lock:
+                self._check_not_closed()
+
+            try:
+                yield self
+
+            finally:
+                self.close()
+
+                if drain is not None:
+                    for o in self.drain():
+                        drain(o)
+
+        return inner()

omlish/term/alt.py

@@ -0,0 +1,60 @@
+import io
+
+
+##
+
+
+_ESC = '\x1b'
+
+
+def _csi(seq: str) -> str:
+    return f'{_ESC}[{seq}'
+
+
+_ENTER_ALT = _csi('?1049h')
+_LEAVE_ALT = _csi('?1049l')
+_HIDE_CURSOR = _csi('?25l')
+_SHOW_CURSOR = _csi('?25h')
+_CLEAR_LINE = _csi('2K')
+
+_SYNC_OUTPUT_ON = _csi('?2026h')
+_SYNC_OUTPUT_OFF = _csi('?2026l')
+
+
+def _move(row: int, col: int) -> str:
+    return _csi(f'{row};{col}H')  # CUP
+
+
+_MOVE_BOTTOM_LEFT = _move(999, 1)  # clamped
+
+
+##
+
+
+def render_write_from_alt(
+        s: str,
+        *,
+        no_sync_output: bool = False,
+        move_and_clear: bool = False,
+) -> str:
+    out = io.StringIO()
+
+    if not no_sync_output:
+        out.write(_SYNC_OUTPUT_ON)
+
+    out.write(_HIDE_CURSOR)
+    out.write(_LEAVE_ALT)
+
+    if move_and_clear:
+        out.write(_MOVE_BOTTOM_LEFT)
+        out.write(_CLEAR_LINE)
+
+    out.write(s)
+
+    out.write(_ENTER_ALT)
+    out.write(_SHOW_CURSOR)
+
+    if not no_sync_output:
+        out.write(_SYNC_OUTPUT_OFF)
+
+    return out.getvalue()

omlish/term/confirm.py

@@ -15,7 +15,7 @@ def confirm_action(
         stdin = sys.stdin
     if not stdin.isatty():
         raise OSError(f'stdin {stdin!r} is not a tty')
-    # FIXME: we want to make sure we only run on a tty, but we als want input()'s readline goodies..
+    # FIXME: we want to make sure we only run on a tty, but we also want input()'s readline goodies..
     if stdin is not sys.stdin:
         raise RuntimeError('Unsupported stdin')
 
@@ -24,15 +24,15 @@ def confirm_action(
     if not stdout.isatty():
         raise OSError(f'stdout {stdout!r} is not a tty')
 
-    while True:
-        if message and not message[-1].isspace():
-            if '\n' in message:
-                prefix = message + '\n\n'
-            else:
-                prefix = message + ' '
+    if message:
+        if '\n' in message:
+            prefix = message + '\n\n'
         else:
-            prefix = ''
+            prefix = message + ' '
+    else:
+        prefix = ''
 
+    while True:
         c = input(f'{prefix}(y/n): ').lower().strip()
 
         if c == 'y':