omlish 0.0.0.dev149__tar.gz → 0.0.0.dev150__tar.gz

{omlish-0.0.0.dev149/omlish.egg-info → omlish-0.0.0.dev150}/PKG-INFO

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

{omlish-0.0.0.dev149 → omlish-0.0.0.dev150}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev149'
-__revision__ = '78e7c7e35dc2bc806db7fd199c1ce42b0f41cbe8'
+__version__ = '0.0.0.dev150'
+__revision__ = 'ab779edf0b58378203e055980af0fedacedb20aa'
 
 
 #

{omlish-0.0.0.dev149 → omlish-0.0.0.dev150}/omlish/argparse/cli.py

@@ -11,16 +11,15 @@ import functools
 import sys
 import typing as ta
 
-from ..lite.check import check_arg
-from ..lite.check import check_isinstance
-from ..lite.check import check_not_empty
-from ..lite.check import check_not_in
-from ..lite.check import check_not_isinstance
+from ..lite.check import check
 
 
 T = ta.TypeVar('T')
 
 
+ArgparseCommandFn = ta.Callable[[], ta.Optional[int]]  # ta.TypeAlias
+
+
 ##
 
 
@@ -43,9 +42,6 @@ def argparse_arg(*args, **kwargs) -> ArgparseArg:
 #
 
 
-ArgparseCommandFn = ta.Callable[[], ta.Optional[int]]  # ta.TypeAlias
-
-
 @dc.dataclass(eq=False)
 class ArgparseCommand:
     name: str
@@ -60,18 +56,18 @@ class ArgparseCommand:
 
     def __post_init__(self) -> None:
         def check_name(s: str) -> None:
-            check_isinstance(s, str)
-            check_not_in('_', s)
-            check_not_empty(s)
+            check.isinstance(s, str)
+            check.not_in('_', s)
+            check.not_empty(s)
         check_name(self.name)
-        check_not_isinstance(self.aliases, str)
+        check.not_isinstance(self.aliases, str)
         for a in self.aliases or []:
             check_name(a)
 
-        check_arg(callable(self.fn))
-        check_arg(all(isinstance(a, ArgparseArg) for a in self.args))
-        check_isinstance(self.parent, (ArgparseCommand, type(None)))
-        check_isinstance(self.accepts_unknown, bool)
+        check.arg(callable(self.fn))
+        check.arg(all(isinstance(a, ArgparseArg) for a in self.args))
+        check.isinstance(self.parent, (ArgparseCommand, type(None)))
+        check.isinstance(self.accepts_unknown, bool)
 
         functools.update_wrapper(self, self.fn)
 
@@ -92,10 +88,10 @@ def argparse_command(
         accepts_unknown: bool = False,
 ) -> ta.Any:  # ta.Callable[[ArgparseCommandFn], ArgparseCommand]:  # FIXME
     for arg in args:
-        check_isinstance(arg, ArgparseArg)
-    check_isinstance(name, (str, type(None)))
-    check_isinstance(parent, (ArgparseCommand, type(None)))
-    check_not_isinstance(aliases, str)
+        check.isinstance(arg, ArgparseArg)
+    check.isinstance(name, (str, type(None)))
+    check.isinstance(parent, (ArgparseCommand, type(None)))
+    check.not_isinstance(aliases, str)
 
     def inner(fn):
         return ArgparseCommand(
@@ -151,7 +147,7 @@ class ArgparseCli:
             bseen = set()  # type: ignore
             for k, v in bns.items():
                 if isinstance(v, (ArgparseCommand, ArgparseArg)):
-                    check_not_in(v, bseen)
+                    check.not_in(v, bseen)
                     bseen.add(v)
                     objs[k] = v
                 elif k in objs:
@@ -163,7 +159,7 @@ class ArgparseCli:
         }), globalns=ns.get('__globals__', {}))
 
         if '_parser' in ns:
-            parser = check_isinstance(ns['_parser'], argparse.ArgumentParser)
+            parser = check.isinstance(ns['_parser'], argparse.ArgumentParser)
         else:
             parser = argparse.ArgumentParser()
             setattr(cls, '_parser', parser)
@@ -179,7 +175,7 @@ class ArgparseCli:
                         if (
                                 len(arg.args) == 1 and
                                 isinstance(arg.args[0], str) and
-                                not (n := check_isinstance(arg.args[0], str)).startswith('-') and
+                                not (n := check.isinstance(arg.args[0], str)).startswith('-') and
                                 'metavar' not in arg.kwargs
                         ):
                             cparser.add_argument(

omlish-0.0.0.dev150/omlish/check.py

@@ -0,0 +1,98 @@
+import typing as ta
+
+from .lite.check import CheckArgsRenderer as ArgsRenderer  # noqa
+from .lite.check import CheckExceptionFactory as ExceptionFactory  # noqa
+from .lite.check import CheckLateConfigureFn as LateConfigureFn  # noqa
+from .lite.check import CheckMessage as Message  # noqa
+from .lite.check import CheckOnRaiseFn as OnRaiseFn  # noqa
+from .lite.check import Checks
+from .lite.check import check
+
+
+_isinstance = isinstance
+_issubclass = issubclass
+_callable = callable
+
+
+##
+
+
+register_on_raise = check.register_on_raise
+unregister_on_raise = check.unregister_on_raise
+
+
+##
+
+
+def _try_get_args_rendering() -> ArgsRenderer | None:
+    try:
+        from .diag.asts import ArgsRenderer
+
+        ArgsRenderer.smoketest()
+
+    except Exception:  # noqa
+        return None
+
+    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)
+
+    return _real_render_args
+
+
+def _try_enable_args_rendering(c: Checks) -> None:
+    if (rf := _try_get_args_rendering()) is not None:
+        c.set_args_renderer(rf)
+
+
+check.register_late_configure(_try_enable_args_rendering)
+
+
+##
+
+
+isinstance = check.isinstance  # noqa
+of_isinstance = check.of_isinstance
+cast = check.cast
+of_cast = check.of_cast
+not_isinstance = check.not_isinstance
+of_not_isinstance = check.of_not_isinstance
+
+#
+
+issubclass = check.issubclass  # noqa
+not_issubclass = check.not_issubclass
+
+#
+
+in_ = check.in_
+not_in = check.not_in
+empty = check.empty
+iterempty = check.iterempty
+not_empty = check.not_empty
+unique = check.unique
+single = check.single
+opt_single = check.opt_single
+
+#
+
+none = check.none
+not_none = check.not_none
+
+#
+
+equal = check.equal
+is_ = check.is_
+is_not = check.is_not
+callable = check.callable  # noqa
+non_empty_str = check.non_empty_str
+replacing = check.replacing
+replacing_none = check.replacing_none
+
+#
+
+arg = check.arg
+state = check.state

{omlish-0.0.0.dev149/omlish/lite → omlish-0.0.0.dev150/omlish}/http/coroserver.py

@@ -1,4 +1,5 @@
 # ruff: noqa: UP006 UP007
+# @omlish-lite
 # PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
 # --------------------------------------------
 #
@@ -62,11 +63,9 @@ import textwrap
 import time
 import typing as ta
 
-from ..check import check_isinstance
-from ..check import check_none
-from ..check import check_not_none
-from ..socket import SocketAddress
-from ..socket import SocketHandler
+from ..lite.check import check
+from ..lite.socket import SocketAddress
+from ..lite.socket import SocketHandler
 from .handlers import HttpHandler
 from .handlers import HttpHandlerRequest
 from .handlers import UnsupportedMethodHttpHandlerError
@@ -406,13 +405,13 @@ class CoroHttpServer:
                     yield o
 
                 elif isinstance(o, self.AnyReadIo):
-                    i = check_isinstance((yield o), bytes)
+                    i = check.isinstance((yield o), bytes)
 
                 elif isinstance(o, self._Response):
                     i = None
                     r = self._preprocess_response(o)
                     b = self._build_response_bytes(r)
-                    check_none((yield self.WriteIo(b)))
+                    check.none((yield self.WriteIo(b)))
 
                 else:
                     raise TypeError(o)
@@ -435,7 +434,7 @@ class CoroHttpServer:
         sz = next(gen)
         while True:
             try:
-                line = check_isinstance((yield self.ReadLineIo(sz)), bytes)
+                line = check.isinstance((yield self.ReadLineIo(sz)), bytes)
                 sz = gen.send(line)
             except StopIteration as e:
                 parsed = e.value
@@ -454,11 +453,11 @@ class CoroHttpServer:
             yield self._build_error_response(err)
             return
 
-        parsed = check_isinstance(parsed, ParsedHttpRequest)
+        parsed = check.isinstance(parsed, ParsedHttpRequest)
 
         # Log
 
-        check_none((yield self.ParsedRequestLogIo(parsed)))
+        check.none((yield self.ParsedRequestLogIo(parsed)))
 
         # Handle CONTINUE
 
@@ -474,7 +473,7 @@ class CoroHttpServer:
 
         request_data: ta.Optional[bytes]
         if (cl := parsed.headers.get('Content-Length')) is not None:
-            request_data = check_isinstance((yield self.ReadIo(int(cl))), bytes)
+            request_data = check.isinstance((yield self.ReadIo(int(cl))), bytes)
         else:
             request_data = None
 
@@ -482,7 +481,7 @@ class CoroHttpServer:
 
         handler_request = HttpHandlerRequest(
             client_address=self._client_address,
-            method=check_not_none(parsed.method),
+            method=check.not_none(parsed.method),
             path=parsed.path,
             headers=parsed.headers,
             data=request_data,

{omlish-0.0.0.dev149/omlish/lite → omlish-0.0.0.dev150/omlish}/http/handlers.py

@@ -1,9 +1,10 @@
 # ruff: noqa: UP006 UP007
+# @omlish-lite
 import dataclasses as dc
 import http.server
 import typing as ta
 
-from ..socket import SocketAddress
+from ..lite.socket import SocketAddress
 from .parsing import HttpHeaders
 
 

{omlish-0.0.0.dev149/omlish/lite → omlish-0.0.0.dev150/omlish}/http/parsing.py

@@ -1,4 +1,5 @@
 # ruff: noqa: UP006 UP007
+# @omlish-lite
 # PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
 # --------------------------------------------
 #

{omlish-0.0.0.dev149/omlish/lite → omlish-0.0.0.dev150/omlish}/http/versions.py

@@ -1,4 +1,5 @@
 # ruff: noqa: UP006 UP007
+# @omlish-lite
 import typing as ta
 
 

{omlish-0.0.0.dev149 → omlish-0.0.0.dev150}/omlish/io/buffers.py

@@ -3,9 +3,7 @@
 import io
 import typing as ta
 
-from ..lite.check import check_isinstance
-from ..lite.check import check_not_empty
-from ..lite.check import check_not_none
+from ..lite.check import check
 from ..lite.strings import attr_repr
 
 
@@ -40,7 +38,7 @@ class DelimitingBuffer:
     ) -> None:
         super().__init__()
 
-        self._delimiters = frozenset(check_isinstance(d, int) for d in delimiters)
+        self._delimiters = frozenset(check.isinstance(d, int) for d in delimiters)
         self._keep_ends = keep_ends
         self._max_size = max_size
 
@@ -71,7 +69,7 @@ class DelimitingBuffer:
         return r
 
     def _append_and_reset(self, chunk: bytes) -> bytes:
-        buf = check_not_none(self._buf)
+        buf = check.not_none(self._buf)
         if not buf.tell():
             return chunk
 
@@ -193,7 +191,7 @@ class IncrementalWriteBuffer:
     ) -> None:
         super().__init__()
 
-        check_not_empty(data)
+        check.not_empty(data)
         self._len = len(data)
         self._write_size = write_size
 
@@ -208,11 +206,11 @@ class IncrementalWriteBuffer:
         return self._len - self._pos
 
     def write(self, fn: ta.Callable[[bytes], int]) -> int:
-        lst = check_not_empty(self._lst)
+        lst = check.not_empty(self._lst)
 
         t = 0
         for i, d in enumerate(lst):  # noqa
-            n = fn(check_not_empty(d))
+            n = fn(check.not_empty(d))
             if not n:
                 break
             t += n

{omlish-0.0.0.dev149 → omlish-0.0.0.dev150}/omlish/io/fdio/corohttp.py

@@ -2,12 +2,9 @@
 import socket
 import typing as ta
 
-from ...lite.check import check_isinstance
-from ...lite.check import check_none
-from ...lite.check import check_not_none
-from ...lite.check import check_state
-from ...lite.http.coroserver import CoroHttpServer
-from ...lite.http.handlers import HttpHandler
+from ...http.coroserver import CoroHttpServer
+from ...http.handlers import HttpHandler
+from ...lite.check import check
 from ...lite.socket import SocketAddress
 from ..buffers import IncrementalWriteBuffer
 from ..buffers import ReadableListBuffer
@@ -25,7 +22,7 @@ class CoroHttpServerConnectionFdioHandler(SocketFdioHandler):
             write_size: int = 0x10000,
             log_handler: ta.Optional[ta.Callable[[CoroHttpServer, CoroHttpServer.AnyLogIo], None]] = None,
     ) -> None:
-        check_state(not sock.getblocking())
+        check.state(not sock.getblocking())
 
         super().__init__(addr, sock)
 
@@ -49,7 +46,7 @@ class CoroHttpServerConnectionFdioHandler(SocketFdioHandler):
     #
 
     def _next_io(self) -> None:  # noqa
-        coro = check_not_none(self._srv_coro)
+        coro = check.not_none(self._srv_coro)
 
         d: bytes | None = None
         o = self._cur_io
@@ -82,7 +79,7 @@ class CoroHttpServerConnectionFdioHandler(SocketFdioHandler):
                 o = None
 
             elif isinstance(o, CoroHttpServer.WriteIo):
-                check_none(self._write_buf)
+                check.none(self._write_buf)
                 self._write_buf = IncrementalWriteBuffer(o.data, write_size=self._write_size)
                 break
 
@@ -103,7 +100,7 @@ class CoroHttpServerConnectionFdioHandler(SocketFdioHandler):
 
     def on_readable(self) -> None:
         try:
-            buf = check_not_none(self._sock).recv(self._read_size)
+            buf = check.not_none(self._sock).recv(self._read_size)
         except BlockingIOError:
             return
         except ConnectionResetError:
@@ -119,12 +116,12 @@ class CoroHttpServerConnectionFdioHandler(SocketFdioHandler):
             self._next_io()
 
     def on_writable(self) -> None:
-        check_isinstance(self._cur_io, CoroHttpServer.WriteIo)
-        wb = check_not_none(self._write_buf)
+        check.isinstance(self._cur_io, CoroHttpServer.WriteIo)
+        wb = check.not_none(self._write_buf)
         while wb.rem > 0:
             def send(d: bytes) -> int:
                 try:
-                    return check_not_none(self._sock).send(d)
+                    return check.not_none(self._sock).send(d)
                 except ConnectionResetError:
                     self.close()
                     return 0

{omlish-0.0.0.dev149 → omlish-0.0.0.dev150}/omlish/io/fdio/handlers.py

@@ -3,7 +3,7 @@ import abc
 import socket
 import typing as ta
 
-from ...lite.check import check_not_none
+from ...lite.check import check
 from ...lite.socket import SocketAddress
 
 
@@ -55,7 +55,7 @@ class SocketFdioHandler(FdioHandler, abc.ABC):
         self._sock: ta.Optional[socket.socket] = sock
 
     def fd(self) -> int:
-        return check_not_none(self._sock).fileno()
+        return check.not_none(self._sock).fileno()
 
     @property
     def closed(self) -> bool:

{omlish-0.0.0.dev149 → omlish-0.0.0.dev150}/omlish/lite/asyncio/subprocesses.py

@@ -8,10 +8,7 @@ import subprocess
 import sys
 import typing as ta
 
-from ..check import check_equal
-from ..check import check_isinstance
-from ..check import check_not_none
-from ..check import check_single
+from ..check import check
 from ..logs import log
 from ..subprocesses import DEFAULT_SUBPROCESS_TRY_EXCEPTIONS
 from ..subprocesses import prepare_subprocess_invocation
@@ -36,7 +33,7 @@ async def asyncio_subprocess_popen(
     if shell:
         fac = functools.partial(
             asyncio.create_subprocess_shell,
-            check_single(cmd),
+            check.single(cmd),
         )
     else:
         fac = functools.partial(
@@ -76,7 +73,7 @@ class AsyncioProcessCommunicator:
         self._proc = proc
         self._loop = loop
 
-        self._transport: asyncio.base_subprocess.BaseSubprocessTransport = check_isinstance(
+        self._transport: asyncio.base_subprocess.BaseSubprocessTransport = check.isinstance(
             proc._transport,  # type: ignore  # noqa
             asyncio.base_subprocess.BaseSubprocessTransport,
         )
@@ -86,7 +83,7 @@ class AsyncioProcessCommunicator:
         return self._loop.get_debug()
 
     async def _feed_stdin(self, input: bytes) -> None:  # noqa
-        stdin = check_not_none(self._proc.stdin)
+        stdin = check.not_none(self._proc.stdin)
         try:
             if input is not None:
                 stdin.write(input)
@@ -110,13 +107,13 @@ class AsyncioProcessCommunicator:
         return None
 
     async def _read_stream(self, fd: int) -> bytes:
-        transport: ta.Any = check_not_none(self._transport.get_pipe_transport(fd))
+        transport: ta.Any = check.not_none(self._transport.get_pipe_transport(fd))
 
         if fd == 2:
-            stream = check_not_none(self._proc.stderr)
+            stream = check.not_none(self._proc.stderr)
         else:
-            check_equal(fd, 1)
-            stream = check_not_none(self._proc.stdout)
+            check.equal(fd, 1)
+            stream = check.not_none(self._proc.stdout)
 
         if self._debug:
             name = 'stdout' if fd == 1 else 'stderr'
@@ -236,7 +233,7 @@ async def asyncio_subprocess_check_output(
         **kwargs,
     )
 
-    return check_not_none(stdout)
+    return check.not_none(stdout)
 
 
 async def asyncio_subprocess_check_output_str(*args: str, **kwargs: ta.Any) -> str: