omlish 0.0.0.dev133__py3-none-any.whl → 0.0.0.dev177__py3-none-any.whl

omlish/sql/queries/params.py

@@ -0,0 +1,64 @@
+import typing as ta
+
+from ... import lang
+from .base import Builder
+from .exprs import Expr
+
+
+##
+
+
+class Param(Expr, lang.Final):
+    n: str | None = None
+
+    def __repr__(self) -> str:
+        if self.n is not None:
+            return f'{self.__class__.__name__}({self.n!r})'
+        else:
+            return f'{self.__class__.__name__}(@{hex(id(self))[2:]})'
+
+    def __eq__(self, other):
+        if not isinstance(other, Param):
+            return False
+        if self.n is None and other.n is None:
+            return self is other
+        else:
+            return self.n == other.n
+
+
+##
+
+
+CanParam: ta.TypeAlias = Param | str | None
+
+
+def as_param(o: CanParam = None) -> Param:
+    if isinstance(o, Param):
+        return o
+    else:
+        return Param(o)
+
+
+##
+
+
+class ParamAccessor(lang.Final):
+    def __getattr__(self, s: str) -> Param:
+        return Param(s)
+
+    def __call__(self, o: CanParam = None) -> Param:
+        return as_param(o)
+
+
+##
+
+
+class ParamBuilder(Builder):
+    @ta.final
+    def param(self, o: CanParam = None) -> Param:
+        return as_param(o)
+
+    @ta.final
+    @property
+    def p(self) -> ParamAccessor:
+        return ParamAccessor()

omlish/sql/queries/rendering.py

@@ -29,13 +29,13 @@ from .binary import BinaryOp
 from .binary import BinaryOps
 from .exprs import Literal
 from .exprs import NameExpr
-from .exprs import Param
 from .idents import Ident
 from .inserts import Insert
 from .inserts import Values
 from .multi import Multi
 from .multi import MultiKind
 from .names import Name
+from .params import Param
 from .relations import Table
 from .selects import Select
 from .selects import SelectItem

omlish/subprocesses.py

@@ -0,0 +1,340 @@
+# ruff: noqa: UP006 UP007
+import abc
+import contextlib
+import logging
+import os
+import shlex
+import subprocess
+import sys
+import time
+import typing as ta
+
+from .lite.runtime import is_debugger_attached
+
+
+T = ta.TypeVar('T')
+SubprocessChannelOption = ta.Literal['pipe', 'stdout', 'devnull']  # ta.TypeAlias
+
+
+##
+
+
+SUBPROCESS_CHANNEL_OPTION_VALUES: ta.Mapping[SubprocessChannelOption, int] = {
+    'pipe': subprocess.PIPE,
+    'stdout': subprocess.STDOUT,
+    'devnull': subprocess.DEVNULL,
+}
+
+
+##
+
+
+_SUBPROCESS_SHELL_WRAP_EXECS = False
+
+
+def subprocess_shell_wrap_exec(*cmd: str) -> ta.Tuple[str, ...]:
+    return ('sh', '-c', ' '.join(map(shlex.quote, cmd)))
+
+
+def subprocess_maybe_shell_wrap_exec(*cmd: str) -> ta.Tuple[str, ...]:
+    if _SUBPROCESS_SHELL_WRAP_EXECS or is_debugger_attached():
+        return subprocess_shell_wrap_exec(*cmd)
+    else:
+        return cmd
+
+
+##
+
+
+def subprocess_close(
+        proc: subprocess.Popen,
+        timeout: ta.Optional[float] = None,
+) -> None:
+    # TODO: terminate, sleep, kill
+    if proc.stdout:
+        proc.stdout.close()
+    if proc.stderr:
+        proc.stderr.close()
+    if proc.stdin:
+        proc.stdin.close()
+
+    proc.wait(timeout)
+
+
+##
+
+
+class BaseSubprocesses(abc.ABC):  # noqa
+    DEFAULT_LOGGER: ta.ClassVar[ta.Optional[logging.Logger]] = None
+
+    def __init__(
+            self,
+            *,
+            log: ta.Optional[logging.Logger] = None,
+            try_exceptions: ta.Optional[ta.Tuple[ta.Type[Exception], ...]] = None,
+    ) -> None:
+        super().__init__()
+
+        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:
+        self._log = log
+
+    #
+
+    def prepare_args(
+            self,
+            *cmd: str,
+            env: ta.Optional[ta.Mapping[str, ta.Any]] = None,
+            extra_env: ta.Optional[ta.Mapping[str, ta.Any]] = None,
+            quiet: bool = False,
+            shell: bool = False,
+            **kwargs: ta.Any,
+    ) -> ta.Tuple[ta.Tuple[ta.Any, ...], ta.Dict[str, ta.Any]]:
+        if self._log:
+            self._log.debug('Subprocesses.prepare_args: cmd=%r', cmd)
+            if extra_env:
+                self._log.debug('Subprocesses.prepare_args: extra_env=%r', extra_env)
+
+        if extra_env:
+            env = {**(env if env is not None else os.environ), **extra_env}
+
+        if quiet and 'stderr' not in kwargs:
+            if self._log and not self._log.isEnabledFor(logging.DEBUG):
+                kwargs['stderr'] = subprocess.DEVNULL
+
+        if not shell:
+            cmd = subprocess_maybe_shell_wrap_exec(*cmd)
+
+        return cmd, dict(
+            env=env,
+            shell=shell,
+            **kwargs,
+        )
+
+    @contextlib.contextmanager
+    def wrap_call(self, *cmd: ta.Any, **kwargs: ta.Any) -> ta.Iterator[None]:
+        start_time = time.time()
+        try:
+            if self._log:
+                self._log.debug('Subprocesses.wrap_call.try: cmd=%r', cmd)
+            yield
+
+        except Exception as exc:  # noqa
+            if self._log:
+                self._log.debug('Subprocesses.wrap_call.except: exc=%r', exc)
+            raise
+
+        finally:
+            end_time = time.time()
+            elapsed_s = end_time - start_time
+            if self._log:
+                self._log.debug('sSubprocesses.wrap_call.finally: elapsed_s=%f cmd=%r', elapsed_s, cmd)
+
+    @contextlib.contextmanager
+    def prepare_and_wrap(
+            self,
+            *cmd: ta.Any,
+            **kwargs: ta.Any,
+    ) -> ta.Iterator[ta.Tuple[
+        ta.Tuple[ta.Any, ...],
+        ta.Dict[str, ta.Any],
+    ]]:
+        cmd, kwargs = self.prepare_args(*cmd, **kwargs)
+        with self.wrap_call(*cmd, **kwargs):
+            yield cmd, kwargs
+
+    #
+
+    DEFAULT_TRY_EXCEPTIONS: ta.Tuple[ta.Type[Exception], ...] = (
+        FileNotFoundError,
+        subprocess.CalledProcessError,
+    )
+
+    def try_fn(
+            self,
+            fn: ta.Callable[..., T],
+            *cmd: str,
+            try_exceptions: ta.Optional[ta.Tuple[ta.Type[Exception], ...]] = None,
+            **kwargs: ta.Any,
+    ) -> ta.Union[T, Exception]:
+        if try_exceptions is None:
+            try_exceptions = self._try_exceptions
+
+        try:
+            return fn(*cmd, **kwargs)
+
+        except try_exceptions as e:  # noqa
+            if self._log and self._log.isEnabledFor(logging.DEBUG):
+                self._log.exception('command failed')
+            return e
+
+    async def async_try_fn(
+            self,
+            fn: ta.Callable[..., ta.Awaitable[T]],
+            *cmd: ta.Any,
+            try_exceptions: ta.Optional[ta.Tuple[ta.Type[Exception], ...]] = None,
+            **kwargs: ta.Any,
+    ) -> ta.Union[T, Exception]:
+        if try_exceptions is None:
+            try_exceptions = self._try_exceptions
+
+        try:
+            return await fn(*cmd, **kwargs)
+
+        except try_exceptions as e:  # noqa
+            if self._log and self._log.isEnabledFor(logging.DEBUG):
+                self._log.exception('command failed')
+            return e
+
+
+##
+
+
+class AbstractSubprocesses(BaseSubprocesses, abc.ABC):
+    @abc.abstractmethod
+    def check_call(
+            self,
+            *cmd: str,
+            stdout: ta.Any = sys.stderr,
+            **kwargs: ta.Any,
+    ) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def check_output(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> bytes:
+        raise NotImplementedError
+
+    #
+
+    def check_output_str(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> str:
+        return self.check_output(*cmd, **kwargs).decode().strip()
+
+    #
+
+    def try_call(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> bool:
+        if isinstance(self.try_fn(self.check_call, *cmd, **kwargs), Exception):
+            return False
+        else:
+            return True
+
+    def try_output(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> ta.Optional[bytes]:
+        if isinstance(ret := self.try_fn(self.check_output, *cmd, **kwargs), Exception):
+            return None
+        else:
+            return ret
+
+    def try_output_str(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> ta.Optional[str]:
+        if (ret := self.try_output(*cmd, **kwargs)) is None:
+            return None
+        else:
+            return ret.decode().strip()
+
+
+##
+
+
+class Subprocesses(AbstractSubprocesses):
+    def check_call(
+            self,
+            *cmd: str,
+            stdout: ta.Any = sys.stderr,
+            **kwargs: ta.Any,
+    ) -> None:
+        with self.prepare_and_wrap(*cmd, stdout=stdout, **kwargs) as (cmd, kwargs):  # noqa
+            subprocess.check_call(cmd, **kwargs)
+
+    def check_output(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> bytes:
+        with self.prepare_and_wrap(*cmd, **kwargs) as (cmd, kwargs):  # noqa
+            return subprocess.check_output(cmd, **kwargs)
+
+
+subprocesses = Subprocesses()
+
+
+##
+
+
+class AbstractAsyncSubprocesses(BaseSubprocesses):
+    @abc.abstractmethod
+    async def check_call(
+            self,
+            *cmd: str,
+            stdout: ta.Any = sys.stderr,
+            **kwargs: ta.Any,
+    ) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    async def check_output(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> bytes:
+        raise NotImplementedError
+
+    #
+
+    async def check_output_str(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> str:
+        return (await self.check_output(*cmd, **kwargs)).decode().strip()
+
+    #
+
+    async def try_call(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> bool:
+        if isinstance(await self.async_try_fn(self.check_call, *cmd, **kwargs), Exception):
+            return False
+        else:
+            return True
+
+    async def try_output(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> ta.Optional[bytes]:
+        if isinstance(ret := await self.async_try_fn(self.check_output, *cmd, **kwargs), Exception):
+            return None
+        else:
+            return ret
+
+    async def try_output_str(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> ta.Optional[str]:
+        if (ret := await self.try_output(*cmd, **kwargs)) is None:
+            return None
+        else:
+            return ret.decode().strip()

omlish/term.py

@@ -172,48 +172,63 @@ def _clamp_ofs(v: int, hi: int, ofs: int) -> str:
 
 FG8 = ControlSequence(
     lambda n: CSI + '38;5;' + str(n) + 'm',
-    '8-Bit Foreground Color')
+    '8-Bit Foreground Color',
+)
 FG8_STANDARD = ControlSequence(
     lambda n: CSI + '38;5;' + _clamp_ofs(n, 8, 0) + 'm',
-    '8-Bit Foreground Color (Standard)')
+    '8-Bit Foreground Color (Standard)',
+)
 FG8_HIGH_INTENSITY = ControlSequence(
     lambda n: CSI + '38;5;' + _clamp_ofs(n, 8, 8) + 'm',
-    '8-Bit Foreground Color (High Intensity)')
+    '8-Bit Foreground Color (High Intensity)',
+)
 FG8_216 = ControlSequence(
     lambda n: CSI + '38;5;' + _clamp_ofs(n, 216, 16) + 'm',
-    '8-Bit Foreground Color (High Intensity)')
+    '8-Bit Foreground Color (High Intensity)',
+)
 FG8_GRAYSCALE = ControlSequence(
     lambda n: CSI + '38;5;' + _clamp_ofs(n, 24, 232) + 'm',
-    '8-Bit Foreground Color (Grayscale)')
+    '8-Bit Foreground Color (Grayscale)',
+)
 FG8_RGB = ControlSequence(
     lambda r, g, b: CSI + '38;5;' + str(36 * r + 6 * g + b) + 'm',
-    '8-Bit Foreground Color (RGB)')
+    '8-Bit Foreground Color (RGB)',
+)
 
 BG8 = ControlSequence(
     lambda n: CSI + '48;5;' + str(n) + 'm',
-    '8-Bit Background Color')
+    '8-Bit Background Color',
+)
 BG8_STANDARD = ControlSequence(
     lambda n: CSI + '48;5;' + _clamp_ofs(n, 8, 0) + 'm',
-    '8-Bit Background Color (Standard)')
+    '8-Bit Background Color (Standard)',
+)
 BG8_HIGH_INTENSITY = ControlSequence(
     lambda n: CSI + '48;5;' + _clamp_ofs(n, 8, 8) + 'm',
-    '8-Bit Background Color (High Intensity)')
+    '8-Bit Background Color (High Intensity)',
+)
 BG8_216 = ControlSequence(
     lambda n: CSI + '48;5;' + _clamp_ofs(n, 216, 16) + 'm',
-    '8-Bit Background Color (High Intensity)')
+    '8-Bit Background Color (High Intensity)',
+)
 BG8_GRAYSCALE = ControlSequence(
     lambda n: CSI + '48;5;' + _clamp_ofs(n, 24, 232) + 'm',
-    '8-Bit Background Color (Grayscale)')
+    '8-Bit Background Color (Grayscale)',
+)
 BG8_RGB = ControlSequence(
     lambda r, g, b: CSI + '48;5;' + str(36 * r + 6 * g + b) + 'm',
-    '8-Bit Background Color (RGB)')
+    '8-Bit Background Color (RGB)',
+)
 
 FG24_RGB = ControlSequence(
     lambda r, g, b: CSI + '38;2;' + str(r) + ';' + str(g) + ';' + str(b) + 'm',
-    '24-Bit Foreground Color (RGB)')
+    '24-Bit Foreground Color (RGB)',
+)
 BG24_RGB = ControlSequence(
     lambda r, g, b: CSI + '48;2;' + str(r) + ';' + str(g) + ';' + str(b) + 'm',
-    '24-Bit Background Color (RGB)')
+    '24-Bit Background Color (RGB)',
+)
+
 
 ##
 

omlish/testing/pytest/marks.py

@@ -7,9 +7,9 @@ from .plugins.managermarks import ManagerMark  # noqa
 
 
 if ta.TYPE_CHECKING:
-    from ...asyncs import asyncio as aiu
+    from ...asyncs.asyncio import all as aiu
 else:
-    aiu = lang.proxy_import('...asyncs.asyncio', __package__)
+    aiu = lang.proxy_import('...asyncs.asyncio.all', __package__)
 
 
 class drain_asyncio(ManagerMark):  # noqa

omlish/testing/pytest/plugins/asyncs.py

@@ -142,7 +142,12 @@ class AsyncsPlugin:
         if len(bes) > 1 and set(bes) != {'trio', 'trio_asyncio'}:
             raise Exception(f'{item.nodeid}: multiple async backends specified: {bes}')
         elif is_async_function(item.obj) and not bes:
-            raise Exception(f'{item.nodeid}: async def function and no async plugin specified')
+            from _pytest.unittest import UnitTestCase  # noqa
+            if isinstance(item.parent, UnitTestCase):
+                # unittest handles these itself.
+                pass
+            else:
+                raise Exception(f'{item.nodeid}: async def function and no async plugin specified')
 
         if 'trio_asyncio' in bes:
             obj = item.obj

omlish/testing/pytest/plugins/logging.py

@@ -1,4 +1,4 @@
-from .... import logs
+from ....logs import all as logs
 from ._registry import register
 
 

omlish/testing/pytest/plugins/switches.py

@@ -10,8 +10,8 @@ import pytest
 
 from .... import check
 from .... import collections as col
-from .... import docker
 from .... import lang
+from ....docker import all as docker
 from ._registry import register
 
 

{omlish-0.0.0.dev133.dist-info → omlish-0.0.0.dev177.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev133
+Version: 0.0.0.dev177
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause
@@ -13,7 +13,7 @@ Classifier: Operating System :: POSIX
 Requires-Python: >=3.12
 License-File: LICENSE
 Provides-Extra: all
-Requires-Dist: anyio~=4.6; extra == "all"
+Requires-Dist: anyio~=4.7; extra == "all"
 Requires-Dist: sniffio~=1.3; extra == "all"
 Requires-Dist: greenlet~=3.1; extra == "all"
 Requires-Dist: trio~=0.27; extra == "all"
@@ -21,6 +21,7 @@ Requires-Dist: trio-asyncio~=0.15; extra == "all"
 Requires-Dist: lz4~=4.3; extra == "all"
 Requires-Dist: python-snappy~=0.7; extra == "all"
 Requires-Dist: zstandard~=0.23; extra == "all"
+Requires-Dist: brotli~=1.1; extra == "all"
 Requires-Dist: asttokens~=3.0; extra == "all"
 Requires-Dist: executing~=2.1; extra == "all"
 Requires-Dist: psutil~=6.0; extra == "all"
@@ -43,7 +44,7 @@ Requires-Dist: apsw~=3.47; extra == "all"
 Requires-Dist: sqlean.py~=3.45; extra == "all"
 Requires-Dist: duckdb~=1.1; extra == "all"
 Requires-Dist: pytest~=8.0; extra == "all"
-Requires-Dist: anyio~=4.6; extra == "all"
+Requires-Dist: anyio~=4.7; extra == "all"
 Requires-Dist: sniffio~=1.3; extra == "all"
 Requires-Dist: asttokens~=3.0; extra == "all"
 Requires-Dist: executing~=2.1; extra == "all"
@@ -51,7 +52,7 @@ Requires-Dist: orjson~=3.10; extra == "all"
 Requires-Dist: pyyaml~=6.0; extra == "all"
 Requires-Dist: wrapt~=1.14; extra == "all"
 Provides-Extra: async
-Requires-Dist: anyio~=4.6; extra == "async"
+Requires-Dist: anyio~=4.7; extra == "async"
 Requires-Dist: sniffio~=1.3; extra == "async"
 Requires-Dist: greenlet~=3.1; extra == "async"
 Requires-Dist: trio~=0.27; extra == "async"
@@ -60,6 +61,7 @@ Provides-Extra: compress
 Requires-Dist: lz4~=4.3; extra == "compress"
 Requires-Dist: python-snappy~=0.7; extra == "compress"
 Requires-Dist: zstandard~=0.23; extra == "compress"
+Requires-Dist: brotli~=1.1; extra == "compress"
 Provides-Extra: diag
 Requires-Dist: asttokens~=3.0; extra == "diag"
 Requires-Dist: executing~=2.1; extra == "diag"
@@ -91,7 +93,7 @@ Requires-Dist: duckdb~=1.1; extra == "sqldrivers"
 Provides-Extra: testing
 Requires-Dist: pytest~=8.0; extra == "testing"
 Provides-Extra: plus
-Requires-Dist: anyio~=4.6; extra == "plus"
+Requires-Dist: anyio~=4.7; extra == "plus"
 Requires-Dist: sniffio~=1.3; extra == "plus"
 Requires-Dist: asttokens~=3.0; extra == "plus"
 Requires-Dist: executing~=2.1; extra == "plus"