omlish 0.0.0.dev423__py3-none-any.whl → 0.0.0.dev484__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

@@ -1,29 +1,24 @@
 # ruff: noqa: I001
-import typing as _ta
-
 from .. import lang as _lang
 
 
-if _ta.TYPE_CHECKING:
+with _lang.auto_proxy_init(globals()):
+    ##
+
     from . import api  # noqa
-else:
-    globals()['api'] = _lang.proxy_import('.api', __package__)
 
-from .dbs import (  # noqa
-    DbLoc,
-    DbSpec,
-    DbType,
-    DbTypes,
-    HostDbLoc,
-    UrlDbLoc,
-)
+    from .dbs import (  # noqa
+        DbLoc,
+        DbSpec,
+        DbType,
+        DbTypes,
+        HostDbLoc,
+        UrlDbLoc,
+    )
 
-from .qualifiedname import (  # noqa
-    QualifiedName,
-    qn,
-)
+    from .qualifiedname import (  # noqa
+        QualifiedName,
+        qn,
+    )
 
-if _ta.TYPE_CHECKING:
     from . import queries  # noqa
-else:
-    globals()['queries'] = _lang.proxy_import('.queries', __package__)

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/queries/_marshal.py

@@ -40,7 +40,7 @@ class OpMarshalerUnmarshaler(msh.Marshaler, msh.Unmarshaler):
         return col.make_map(((o.name, o) for _, o in self.ns), strict=True)
 
     def marshal(self, ctx: msh.MarshalContext, o: ta.Any) -> msh.Value:
-        return check.isinstance(o, self.ty).name  # type: ignore  # noqa
+        return check.isinstance(o, self.ty).name
 
     def unmarshal(self, ctx: msh.UnmarshalContext, v: msh.Value) -> ta.Any:
         return self.by_name[check.isinstance(v, str)]
@@ -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/params.py

@@ -16,7 +16,7 @@ class Param(lang.Final):
         if self.n is not None:
             return f'{self.__class__.__name__}({self.n!r})'
         else:
-            return f'{self.__class__.__name__}(@{hex(id(self))[2:]})'
+            return f'{self.__class__.__name__}(@{id(self):x})'
 
     def __eq__(self, other):
         if not isinstance(other, Param):

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/all.py

@@ -0,0 +1,135 @@
+import sys as _sys
+import typing as _ta
+
+from .. import lang as _lang  # noqa
+
+
+with _lang.auto_proxy_init(globals()):
+    ##
+
+    from .asyncs import (  # noqa
+        AbstractAsyncSubprocesses,
+    )
+
+    from .base import (  # noqa
+        SubprocessChannelOption,
+
+        VerboseCalledProcessError,
+        BaseSubprocesses,
+    )
+
+    from .maysync import (  # noqa
+        MaysyncSubprocesses,
+    )
+
+    from .run import (  # noqa
+        SubprocessRunOutput,
+        SubprocessRun,
+        SubprocessRunnable,
+    )
+
+    from .sync import (  # noqa
+        AbstractSubprocesses,
+
+        Subprocesses,
+
+        subprocesses,
+    )
+
+    from .utils import (  # noqa
+        subprocess_close as close,
+    )
+
+    from .wrap import (  # noqa
+        subprocess_shell_wrap_exec as shell_wrap_exec,
+        subprocess_maybe_shell_wrap_exec as maybe_shell_wrap_exec,
+    )
+
+
+##
+
+
+if _ta.TYPE_CHECKING:
+    from . import sync as _sync  # noqa
+else:
+    _sync = _lang.proxy_import('.sync', __package__)
+
+
+def run(
+        *cmd: str,
+        input: _ta.Any = None,  # noqa
+        timeout: '_lang.TimeoutLike' = None,
+        check: bool = False,
+        capture_output: bool | None = None,
+        **kwargs: _ta.Any,
+) -> 'SubprocessRunOutput':
+    return _sync.subprocesses.run(
+        *cmd,
+        input=input,
+        timeout=timeout,
+        check=check,
+        capture_output=capture_output,
+        **kwargs,
+    )
+
+
+def check_call(
+        *cmd: str,
+        stdout: _ta.Any = _sys.stderr,
+        **kwargs: _ta.Any,
+) -> None:
+    return _sync.subprocesses.check_call(
+        *cmd,
+        stdout=stdout,
+        **kwargs,
+    )
+
+
+def check_output(
+        *cmd: str,
+        **kwargs: _ta.Any,
+) -> bytes:
+    return _sync.subprocesses.check_output(
+        *cmd,
+        **kwargs,
+    )
+
+
+def check_output_str(
+        *cmd: str,
+        **kwargs: _ta.Any,
+) -> str:
+    return _sync.subprocesses.check_output_str(
+        *cmd,
+        **kwargs,
+    )
+
+
+def try_call(
+        *cmd: str,
+        **kwargs: _ta.Any,
+) -> bool:
+    return _sync.subprocesses.try_call(
+        *cmd,
+        **kwargs,
+    )
+
+
+def try_output(
+        *cmd: str,
+        **kwargs: _ta.Any,
+) -> bytes | None:
+    return _sync.subprocesses.try_output(
+        *cmd,
+        **kwargs,
+    )
+
+
+def try_output_str(
+        *cmd: str,
+        **kwargs: _ta.Any,
+) -> str | None:
+    return _sync.subprocesses.try_output_str(
+        *cmd,
+        **kwargs,
+    )

omlish/subprocesses/base.py

@@ -9,6 +9,7 @@ import typing as ta
 
 from ..lite.abstract import Abstract
 from ..lite.timeouts import Timeout
+from ..logs.protocols import LoggerLike
 from .wrap import subprocess_maybe_shell_wrap_exec
 
 
@@ -55,12 +56,16 @@ class VerboseCalledProcessError(subprocess.CalledProcessError):
 
 
 class BaseSubprocesses(Abstract):
-    DEFAULT_LOGGER: ta.ClassVar[ta.Optional[logging.Logger]] = None
+    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,
             *,
-            log: ta.Optional[logging.Logger] = None,
+            log: ta.Optional[LoggerLike] = None,
             try_exceptions: ta.Optional[ta.Tuple[ta.Type[Exception], ...]] = None,
     ) -> None:
         super().__init__()
@@ -68,7 +73,7 @@ class BaseSubprocesses(Abstract):
         self._log = log if log is not None else self.DEFAULT_LOGGER
         self._try_exceptions = try_exceptions if try_exceptions is not None else self.DEFAULT_TRY_EXCEPTIONS
 
-    def set_logger(self, log: ta.Optional[logging.Logger]) -> None:
+    def set_logger(self, log: ta.Optional[LoggerLike]) -> None:
         self._log = log
 
     #

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:
@@ -136,3 +140,160 @@ class ConditionDeque(ta.Generic[T]):
             while not self.deque:
                 self.cond.wait(timeout)
             return self.deque.popleft()
+
+
+##
+
+
+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__()
+
+        self._count = count
+        self._cond = threading.Condition()
+
+    def count_down(self) -> None:
+        with self._cond:
+            self._count -= 1
+            if self._count <= 0:
+                self._cond.notify_all()
+
+    def wait(
+            self,
+            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()