omlish 0.0.0.dev148__tar.gz → 0.0.0.dev150__tar.gz

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

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

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

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev148'
-__revision__ = '01263e3c2d1b82ca19c3d1d6916041ca4276737b'
+__version__ = '0.0.0.dev150'
+__revision__ = 'ab779edf0b58378203e055980af0fedacedb20aa'
 
 
 #

omlish-0.0.0.dev150/omlish/argparse/all.py

@@ -0,0 +1,45 @@
+# ruff: noqa: I001
+import argparse
+
+from .cli import (  # noqa
+    ArgparseArg as Arg,
+    argparse_arg as arg,
+
+    ArgparseCommandFn as CommandFn,
+    ArgparseCommand as Command,
+    argparse_command as command,
+
+    ArgparseCli as Cli,
+)
+
+
+##
+
+
+SUPPRESS = argparse.SUPPRESS
+
+OPTIONAL = argparse.OPTIONAL
+ZERO_OR_MORE = argparse.ZERO_OR_MORE
+ONE_OR_MORE = argparse.ONE_OR_MORE
+PARSER = argparse.PARSER
+REMAINDER = argparse.REMAINDER
+
+HelpFormatter = argparse.HelpFormatter
+RawDescriptionHelpFormatter = argparse.RawDescriptionHelpFormatter
+RawTextHelpFormatter = argparse.RawTextHelpFormatter
+ArgumentDefaultsHelpFormatter = argparse.ArgumentDefaultsHelpFormatter
+
+MetavarTypeHelpFormatter = argparse.MetavarTypeHelpFormatter
+
+ArgumentError = argparse.ArgumentError
+ArgumentTypeError = argparse.ArgumentTypeError
+
+Action = argparse.Action
+BooleanOptionalAction = argparse.BooleanOptionalAction
+SubParsersAction = argparse._SubParsersAction  # noqa
+
+FileType = argparse.FileType
+
+Namespace = argparse.Namespace
+
+ArgumentParser = argparse.ArgumentParser

omlish-0.0.0.dev148/omlish/argparse.py → omlish-0.0.0.dev150/omlish/argparse/cli.py

@@ -1,3 +1,5 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
 """
 TODO:
  - default command
@@ -9,53 +11,23 @@ import functools
 import sys
 import typing as ta
 
-from . import c3
-from . import check
+from ..lite.check import check
 
 
 T = ta.TypeVar('T')
 
 
-##
-
-
-SUPPRESS = argparse.SUPPRESS
-
-OPTIONAL = argparse.OPTIONAL
-ZERO_OR_MORE = argparse.ZERO_OR_MORE
-ONE_OR_MORE = argparse.ONE_OR_MORE
-PARSER = argparse.PARSER
-REMAINDER = argparse.REMAINDER
-
-HelpFormatter = argparse.HelpFormatter
-RawDescriptionHelpFormatter = argparse.RawDescriptionHelpFormatter
-RawTextHelpFormatter = argparse.RawTextHelpFormatter
-ArgumentDefaultsHelpFormatter = argparse.ArgumentDefaultsHelpFormatter
-
-MetavarTypeHelpFormatter = argparse.MetavarTypeHelpFormatter
-
-ArgumentError = argparse.ArgumentError
-ArgumentTypeError = argparse.ArgumentTypeError
-
-Action = argparse.Action
-BooleanOptionalAction = argparse.BooleanOptionalAction
-SubParsersAction = argparse._SubParsersAction  # noqa
-
-FileType = argparse.FileType
-
-Namespace = argparse.Namespace
-
-ArgumentParser = argparse.ArgumentParser
+ArgparseCommandFn = ta.Callable[[], ta.Optional[int]]  # ta.TypeAlias
 
 
 ##
 
 
 @dc.dataclass(eq=False)
-class Arg:
+class ArgparseArg:
     args: ta.Sequence[ta.Any]
     kwargs: ta.Mapping[str, ta.Any]
-    dest: str | None = None
+    dest: ta.Optional[str] = None
 
     def __get__(self, instance, owner=None):
         if instance is None:
@@ -63,26 +35,23 @@ class Arg:
         return getattr(instance.args, self.dest)  # type: ignore
 
 
-def arg(*args, **kwargs) -> Arg:
-    return Arg(args, kwargs)
+def argparse_arg(*args, **kwargs) -> ArgparseArg:
+    return ArgparseArg(args, kwargs)
 
 
 #
 
 
-CommandFn = ta.Callable[[], int | None]
-
-
 @dc.dataclass(eq=False)
-class Command:
+class ArgparseCommand:
     name: str
-    fn: CommandFn
-    args: ta.Sequence[Arg] = ()  # noqa
+    fn: ArgparseCommandFn
+    args: ta.Sequence[ArgparseArg] = ()  # noqa
 
-    _: dc.KW_ONLY
+    # _: dc.KW_ONLY
 
-    aliases: ta.Sequence[str] | None = None
-    parent: ta.Optional['Command'] = None
+    aliases: ta.Optional[ta.Sequence[str]] = None
+    parent: ta.Optional['ArgparseCommand'] = None
     accepts_unknown: bool = False
 
     def __post_init__(self) -> None:
@@ -95,9 +64,9 @@ class Command:
         for a in self.aliases or []:
             check_name(a)
 
-        check.callable(self.fn)
-        check.arg(all(isinstance(a, Arg) for a in self.args))
-        check.isinstance(self.parent, (Command, None))
+        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)
@@ -107,25 +76,25 @@ class Command:
             return self
         return dc.replace(self, fn=self.fn.__get__(instance, owner))  # noqa
 
-    def __call__(self, *args, **kwargs) -> int | None:
+    def __call__(self, *args, **kwargs) -> ta.Optional[int]:
         return self.fn(*args, **kwargs)
 
 
-def command(
-        *args: Arg,
-        name: str | None = None,
-        aliases: ta.Iterable[str] | None = None,
-        parent: Command | None = None,
+def argparse_command(
+        *args: ArgparseArg,
+        name: ta.Optional[str] = None,
+        aliases: ta.Optional[ta.Iterable[str]] = None,
+        parent: ta.Optional[ArgparseCommand] = None,
         accepts_unknown: bool = False,
-) -> ta.Any:  # ta.Callable[[CommandFn], Command]:  # FIXME
+) -> ta.Any:  # ta.Callable[[ArgparseCommandFn], ArgparseCommand]:  # FIXME
     for arg in args:
-        check.isinstance(arg, Arg)
-    check.isinstance(name, (str, None))
-    check.isinstance(parent, (Command, None))
+        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 Command(
+        return ArgparseCommand(
             (name if name is not None else fn.__name__).replace('_', '-'),
             fn,
             args,
@@ -140,7 +109,7 @@ def command(
 ##
 
 
-def get_arg_ann_kwargs(ann: ta.Any) -> ta.Mapping[str, ta.Any]:
+def _get_argparse_arg_ann_kwargs(ann: ta.Any) -> ta.Mapping[str, ta.Any]:
     if ann is str:
         return {}
     elif ann is int:
@@ -153,48 +122,51 @@ def get_arg_ann_kwargs(ann: ta.Any) -> ta.Mapping[str, ta.Any]:
         raise TypeError(ann)
 
 
-class _AnnotationBox:
-
+class _ArgparseCliAnnotationBox:
     def __init__(self, annotations: ta.Mapping[str, ta.Any]) -> None:
         super().__init__()
         self.__annotations__ = annotations  # type: ignore
 
 
-class _CliMeta(type):
+class ArgparseCli:
+    def __init__(self, argv: ta.Optional[ta.Sequence[str]] = None) -> None:
+        super().__init__()
+
+        self._argv = argv if argv is not None else sys.argv[1:]
 
-    def __new__(mcls, name: str, bases: ta.Sequence[type], namespace: ta.Mapping[str, ta.Any]) -> type:
-        if not bases:
-            return super().__new__(mcls, name, tuple(bases), dict(namespace))
+        self._args, self._unknown_args = self.get_parser().parse_known_args(self._argv)
 
-        bases = list(bases)
-        namespace = dict(namespace)
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+
+        ns = cls.__dict__
 
         objs = {}
-        mro = c3.merge([list(b.__mro__) for b in bases])
-        for bns in [bcls.__dict__ for bcls in reversed(mro)] + [namespace]:
+        mro = cls.__mro__[::-1]
+        for bns in [bcls.__dict__ for bcls in reversed(mro)] + [ns]:
             bseen = set()  # type: ignore
             for k, v in bns.items():
-                if isinstance(v, (Command, Arg)):
+                if isinstance(v, (ArgparseCommand, ArgparseArg)):
                     check.not_in(v, bseen)
                     bseen.add(v)
                     objs[k] = v
                 elif k in objs:
                     del [k]
 
-        anns = ta.get_type_hints(_AnnotationBox({
+        anns = ta.get_type_hints(_ArgparseCliAnnotationBox({
             **{k: v for bcls in reversed(mro) for k, v in getattr(bcls, '__annotations__', {}).items()},
-            **namespace.get('__annotations__', {}),
-        }), globalns=namespace.get('__globals__', {}))
+            **ns.get('__annotations__', {}),
+        }), globalns=ns.get('__globals__', {}))
 
-        if 'parser' in namespace:
-            parser = check.isinstance(namespace.pop('parser'), ArgumentParser)
+        if '_parser' in ns:
+            parser = check.isinstance(ns['_parser'], argparse.ArgumentParser)
         else:
-            parser = ArgumentParser()
-        namespace['_parser'] = parser
+            parser = argparse.ArgumentParser()
+            setattr(cls, '_parser', parser)
 
         subparsers = parser.add_subparsers()
         for att, obj in objs.items():
-            if isinstance(obj, Command):
+            if isinstance(obj, ArgparseCommand):
                 if obj.parent is not None:
                     raise NotImplementedError
                 for cn in [obj.name, *(obj.aliases or [])]:
@@ -215,9 +187,9 @@ class _CliMeta(type):
                             cparser.add_argument(*arg.args, **arg.kwargs)
                     cparser.set_defaults(_cmd=obj)
 
-            elif isinstance(obj, Arg):
+            elif isinstance(obj, ArgparseArg):
                 if att in anns:
-                    akwargs = get_arg_ann_kwargs(anns[att])
+                    akwargs = _get_argparse_arg_ann_kwargs(anns[att])
                     obj.kwargs = {**akwargs, **obj.kwargs}
                 if not obj.dest:
                     if 'dest' in obj.kwargs:
@@ -229,22 +201,10 @@ class _CliMeta(type):
             else:
                 raise TypeError(obj)
 
-        return super().__new__(mcls, name, tuple(bases), namespace)
-
-
-class Cli(metaclass=_CliMeta):
-
-    def __init__(self, argv: ta.Sequence[str] | None = None) -> None:
-        super().__init__()
-
-        self._argv = argv if argv is not None else sys.argv[1:]
-
-        self._args, self._unknown_args = self.get_parser().parse_known_args(self._argv)
-
-    _parser: ta.ClassVar[ArgumentParser]
+    _parser: ta.ClassVar[argparse.ArgumentParser]
 
     @classmethod
-    def get_parser(cls) -> ArgumentParser:
+    def get_parser(cls) -> argparse.ArgumentParser:
         return cls._parser
 
     @property
@@ -252,17 +212,17 @@ class Cli(metaclass=_CliMeta):
         return self._argv
 
     @property
-    def args(self) -> Namespace:
+    def args(self) -> argparse.Namespace:
         return self._args
 
     @property
     def unknown_args(self) -> ta.Sequence[str]:
         return self._unknown_args
 
-    def _run_cmd(self, cmd: Command) -> int | None:
+    def _run_cmd(self, cmd: ArgparseCommand) -> ta.Optional[int]:
         return cmd.__get__(self, type(self))()
 
-    def __call__(self) -> int | None:
+    def __call__(self) -> ta.Optional[int]:
         cmd = getattr(self.args, '_cmd', None)
 
         if self._unknown_args and not (cmd is not None and cmd.accepts_unknown):
@@ -270,7 +230,7 @@ class Cli(metaclass=_CliMeta):
             if (parser := self.get_parser()).exit_on_error:  # type: ignore
                 parser.error(msg)
             else:
-                raise ArgumentError(None, msg)
+                raise argparse.ArgumentError(None, msg)
 
         if cmd is None:
             self.get_parser().print_help()

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.dev148/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.dev148/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.dev148/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.dev148/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.dev148/omlish/lite/io.py → omlish-0.0.0.dev150/omlish/io/buffers.py

@@ -1,11 +1,10 @@
 # ruff: noqa: UP007
+# @omlish-lite
 import io
 import typing as ta
 
-from .check import check_isinstance
-from .check import check_non_empty
-from .check import check_not_none
-from .strings import attr_repr
+from ..lite.check import check
+from ..lite.strings import attr_repr
 
 
 class DelimitingBuffer:
@@ -39,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
 
@@ -70,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
 
@@ -192,7 +191,7 @@ class IncrementalWriteBuffer:
     ) -> None:
         super().__init__()
 
-        check_non_empty(data)
+        check.not_empty(data)
         self._len = len(data)
         self._write_size = write_size
 
@@ -207,11 +206,11 @@ class IncrementalWriteBuffer:
         return self._len - self._pos
 
     def write(self, fn: ta.Callable[[bytes], int]) -> int:
-        lst = check_non_empty(self._lst)
+        lst = check.not_empty(self._lst)
 
         t = 0
         for i, d in enumerate(lst):  # noqa
-            n = fn(check_non_empty(d))
+            n = fn(check.not_empty(d))
             if not n:
                 break
             t += n

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

@@ -2,15 +2,12 @@
 import socket
 import typing as ta
 
-from ..check import check_isinstance
-from ..check import check_none
-from ..check import check_not_none
-from ..check import check_state
-from ..http.coroserver import CoroHttpServer
-from ..http.handlers import HttpHandler
-from ..io import IncrementalWriteBuffer
-from ..io import ReadableListBuffer
-from ..socket import SocketAddress
+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
 from .handlers import SocketFdioHandler
 
 
@@ -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