omlish 0.0.0.dev147__tar.gz → 0.0.0.dev149__tar.gz

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

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

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

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

omlish-0.0.0.dev149/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.dev147/omlish/argparse.py → omlish-0.0.0.dev149/omlish/argparse/cli.py

@@ -1,3 +1,5 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
 """
 TODO:
  - default command
@@ -9,8 +11,11 @@ import functools
 import sys
 import typing as ta
 
-from . import c3
-from . import check
+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
 
 
 T = ta.TypeVar('T')
@@ -19,43 +24,11 @@ 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
-
-
-##
-
-
 @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,42 +36,42 @@ 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]
+ArgparseCommandFn = ta.Callable[[], ta.Optional[int]]  # ta.TypeAlias
 
 
 @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:
         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.callable(self.fn)
-        check.arg(all(isinstance(a, Arg) for a in self.args))
-        check.isinstance(self.parent, (Command, 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)
 
@@ -107,25 +80,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.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 Command(
+        return ArgparseCommand(
             (name if name is not None else fn.__name__).replace('_', '-'),
             fn,
             args,
@@ -140,7 +113,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 +126,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)):
-                    check.not_in(v, bseen)
+                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 [])]:
@@ -203,7 +179,7 @@ class _CliMeta(type):
                         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(
@@ -215,9 +191,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 +205,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 +216,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 +234,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.dev147 → omlish-0.0.0.dev149}/omlish/check.py

@@ -1,6 +1,8 @@
 """
 TODO:
  - def maybe(v: lang.Maybe[T])
+ - patch / override lite.check ?
+  - checker interface?
 """
 import collections
 import threading

omlish-0.0.0.dev147/omlish/lite/io.py → omlish-0.0.0.dev149/omlish/io/buffers.py

@@ -1,11 +1,12 @@
 # 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_isinstance
+from ..lite.check import check_not_empty
+from ..lite.check import check_not_none
+from ..lite.strings import attr_repr
 
 
 class DelimitingBuffer:
@@ -192,7 +193,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 +208,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.dev147/omlish/lite → omlish-0.0.0.dev149/omlish/io}/fdio/corohttp.py

@@ -2,15 +2,15 @@
 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 ...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 ...lite.socket import SocketAddress
+from ..buffers import IncrementalWriteBuffer
+from ..buffers import ReadableListBuffer
 from .handlers import SocketFdioHandler
 
 

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

@@ -3,8 +3,8 @@ import abc
 import socket
 import typing as ta
 
-from ..check import check_not_none
-from ..socket import SocketAddress
+from ...lite.check import check_not_none
+from ...lite.socket import SocketAddress
 
 
 class FdioHandler(abc.ABC):

omlish-0.0.0.dev149/omlish/lite/asyncio/asyncio.py

@@ -0,0 +1,63 @@
+# ruff: noqa: UP006 UP007
+import asyncio.base_subprocess
+import asyncio.subprocess
+import typing as ta
+
+
+AwaitableT = ta.TypeVar('AwaitableT', bound=ta.Awaitable)
+
+
+##
+
+
+ASYNCIO_DEFAULT_BUFFER_LIMIT = 2 ** 16
+
+
+async def asyncio_open_stream_reader(
+        f: ta.IO,
+        loop: ta.Any = None,
+        *,
+        limit: int = ASYNCIO_DEFAULT_BUFFER_LIMIT,
+) -> asyncio.StreamReader:
+    if loop is None:
+        loop = asyncio.get_running_loop()
+
+    reader = asyncio.StreamReader(limit=limit, loop=loop)
+    await loop.connect_read_pipe(
+        lambda: asyncio.StreamReaderProtocol(reader, loop=loop),
+        f,
+    )
+
+    return reader
+
+
+async def asyncio_open_stream_writer(
+        f: ta.IO,
+        loop: ta.Any = None,
+) -> asyncio.StreamWriter:
+    if loop is None:
+        loop = asyncio.get_running_loop()
+
+    writer_transport, writer_protocol = await loop.connect_write_pipe(
+        lambda: asyncio.streams.FlowControlMixin(loop=loop),
+        f,
+    )
+
+    return asyncio.streams.StreamWriter(
+        writer_transport,
+        writer_protocol,
+        None,
+        loop,
+    )
+
+
+##
+
+
+def asyncio_maybe_timeout(
+        fut: AwaitableT,
+        timeout: ta.Optional[float] = None,
+) -> AwaitableT:
+    if timeout is not None:
+        fut = asyncio.wait_for(fut, timeout)  # type: ignore
+    return fut