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

omlish/antlr/runtime.py

@@ -0,0 +1,102 @@
+# ruff: noqa: I001
+# flake8: noqa: F401
+
+from ._runtime.BufferedTokenStream import (  # type: ignore
+    TokenStream,
+)
+
+from ._runtime.CommonTokenStream import (  # type: ignore
+    CommonTokenStream,
+)
+
+from ._runtime.FileStream import (  # type: ignore
+    FileStream,
+)
+
+from ._runtime.InputStream import (  # type: ignore
+    InputStream,
+)
+
+from ._runtime.Lexer import (  # type: ignore
+    Lexer,
+)
+
+from ._runtime.Parser import (  # type: ignore
+    Parser,
+)
+
+from ._runtime.ParserRuleContext import (  # type: ignore
+    ParserRuleContext,
+    RuleContext,
+)
+
+from ._runtime.PredictionContext import (  # type: ignore
+    PredictionContextCache,
+)
+
+from ._runtime.StdinStream import (  # type: ignore
+    StdinStream,
+)
+
+from ._runtime.Token import (  # type: ignore
+    Token,
+)
+
+from ._runtime.Utils import (  # type: ignore
+    str_list,
+)
+
+from ._runtime.atn.ATN import (  # type: ignore
+    ATN,
+)
+
+from ._runtime.atn.ATNDeserializer import (  # type: ignore
+    ATNDeserializer,
+)
+
+from ._runtime.atn.LexerATNSimulator import (  # type: ignore
+    LexerATNSimulator,
+)
+
+from ._runtime.atn.ParserATNSimulator import (  # type: ignore
+    ParserATNSimulator,
+)
+
+from ._runtime.atn.PredictionMode import (  # type: ignore
+    PredictionMode,
+)
+
+from ._runtime.dfa.DFA import (  # type: ignore
+    DFA,
+)
+
+from ._runtime.error.DiagnosticErrorListener import (  # type: ignore
+    DiagnosticErrorListener,
+)
+
+from ._runtime.error.ErrorListener import (  # type: ignore
+    ErrorListener,
+)
+
+from ._runtime.error.ErrorStrategy import (  # type: ignore
+    BailErrorStrategy,
+)
+
+from ._runtime.error.Errors import (  # type: ignore
+    LexerNoViableAltException,
+)
+
+from ._runtime.error.Errors import (  # type: ignore
+    IllegalStateException,
+    NoViableAltException,
+    RecognitionException,
+)
+
+from ._runtime.tree.Tree import (  # type: ignore
+    ErrorNode,
+    ParseTreeListener,
+    ParseTreeVisitor,
+    ParseTreeWalker,
+    RuleNode,
+    TerminalNode,
+)

omlish/antlr/utils.py

@@ -0,0 +1,38 @@
+# ruff: noqa: N802 N803
+import io
+import typing as ta
+
+from . import runtime as antlr4
+
+
+##
+
+
+def pformat(
+        node: ta.Any,
+        *,
+        buf: ta.IO | None = None,
+        indent: str = '',
+        child_indent: str = '  ',
+) -> ta.IO:
+    if buf is None:
+        buf = io.StringIO()
+    buf.write(indent)
+    buf.write(node.__class__.__name__)
+    if hasattr(node, 'start') and hasattr(node, 'stop'):
+        buf.write(f' ({node.start} -> {node.stop})')
+    buf.write('\n')
+    for child in getattr(node, 'children', []) or []:
+        pformat(child, buf=buf, indent=indent + child_indent, child_indent=child_indent)
+    return buf
+
+
+def yield_contexts(
+        root: antlr4.ParserRuleContext,
+) -> ta.Iterator[antlr4.ParserRuleContext]:
+    q = [root]
+    while q:
+        c = q.pop()
+        yield c
+        if not isinstance(c, antlr4.TerminalNode) and c.children:
+            q.extend(c.children)

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/{argparse.py → argparse/cli.py}

@@ -1,7 +1,11 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
 """
 TODO:
  - default command
  - auto match all underscores to hyphens
+ - pre-run, post-run hooks
+ - exitstack?
 """
 import argparse
 import dataclasses as dc
@@ -9,53 +13,25 @@ import functools
 import sys
 import typing as ta
 
-from . import c3
-from . import check
+from ..lite.check import check
+from ..lite.reflect import get_optional_alias_arg
+from ..lite.reflect import is_optional_alias
 
 
 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 +39,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 +68,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 +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.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:
@@ -149,56 +122,71 @@ def get_arg_ann_kwargs(ann: ta.Any) -> ta.Mapping[str, ta.Any]:
         return {'action': 'store_true'}
     elif ann is list:
         return {'action': 'append'}
+    elif is_optional_alias(ann):
+        return _get_argparse_arg_ann_kwargs(get_optional_alias_arg(ann))
     else:
         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 [])]:
-                    cparser = subparsers.add_parser(cn)
+                    subparser = subparsers.add_parser(cn)
+
                     for arg in (obj.args or []):
                         if (
                                 len(arg.args) == 1 and
@@ -206,45 +194,38 @@ class _CliMeta(type):
                                 not (n := check.isinstance(arg.args[0], str)).startswith('-') and
                                 'metavar' not in arg.kwargs
                         ):
-                            cparser.add_argument(
+                            subparser.add_argument(
                                 n.replace('-', '_'),
                                 **arg.kwargs,
                                 metavar=n,
                             )
                         else:
-                            cparser.add_argument(*arg.args, **arg.kwargs)
-                    cparser.set_defaults(_cmd=obj)
+                            subparser.add_argument(*arg.args, **arg.kwargs)
+
+                    subparser.set_defaults(_cmd=obj)
 
-            elif isinstance(obj, Arg):
+            elif isinstance(obj, ArgparseArg):
                 if att in anns:
-                    akwargs = get_arg_ann_kwargs(anns[att])
-                    obj.kwargs = {**akwargs, **obj.kwargs}
+                    ann_kwargs = _get_argparse_arg_ann_kwargs(anns[att])
+                    obj.kwargs = {**ann_kwargs, **obj.kwargs}
+
                 if not obj.dest:
                     if 'dest' in obj.kwargs:
                         obj.dest = obj.kwargs['dest']
                     else:
                         obj.dest = obj.kwargs['dest'] = att  # type: ignore
+
                 parser.add_argument(*obj.args, **obj.kwargs)
 
             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 +233,19 @@ 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:
-        return cmd.__get__(self, type(self))()
+    #
+
+    def _bind_cli_cmd(self, cmd: ArgparseCommand) -> ta.Callable:
+        return cmd.__get__(self, type(self))
 
-    def __call__(self) -> int | None:
+    def prepare_cli_run(self) -> ta.Optional[ta.Callable]:
         cmd = getattr(self.args, '_cmd', None)
 
         if self._unknown_args and not (cmd is not None and cmd.accepts_unknown):
@@ -270,13 +253,35 @@ 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()
+            return None
+
+        return self._bind_cli_cmd(cmd)
+
+    #
+
+    def cli_run(self) -> ta.Optional[int]:
+        if (fn := self.prepare_cli_run()) is None:
             return 0
 
-        return self._run_cmd(cmd)
+        return fn()
+
+    def cli_run_and_exit(self) -> ta.NoReturn:
+        sys.exit(rc if isinstance(rc := self.cli_run(), int) else 0)
+
+    def __call__(self, *, exit: bool = False) -> ta.Optional[int]:  # noqa
+        if exit:
+            return self.cli_run_and_exit()
+        else:
+            return self.cli_run()
+
+    #
+
+    async def async_cli_run(self) -> ta.Optional[int]:
+        if (fn := self.prepare_cli_run()) is None:
+            return 0
 
-    def call_and_exit(self) -> ta.NoReturn:
-        sys.exit(rc if isinstance(rc := self(), int) else 0)
+        return await fn()

omlish/asyncs/__init__.py

@@ -1,35 +0,0 @@
-from .asyncs import (  # noqa
-    SyncableIterable,
-    async_list,
-    sync_await,
-    sync_list,
-    syncable_iterable,
-)
-
-from .bridge import (  # noqa
-    a_to_s,
-    is_in_bridge,
-    s_to_a,
-    s_to_a_await,
-    trivial_a_to_s,
-    trivial_s_to_a,
-)
-
-from .flavors import (  # noqa
-    ContextManagerAdapter,
-    Flavor,
-    adapt,
-    adapt_context,
-    from_anyio,
-    from_anyio_context,
-    from_asyncio,
-    from_asyncio_context,
-    from_trio,
-    from_trio_context,
-    get_flavor,
-    mark_anyio,
-    mark_asyncio,
-    mark_flavor,
-    mark_trio,
-    with_adapter_loop,
-)

omlish/asyncs/all.py

@@ -0,0 +1,35 @@
+from .asyncs import (  # noqa
+    SyncableIterable,
+    async_list,
+    sync_await,
+    sync_list,
+    syncable_iterable,
+)
+
+from .bridge import (  # noqa
+    a_to_s,
+    is_in_bridge,
+    s_to_a,
+    s_to_a_await,
+    trivial_a_to_s,
+    trivial_s_to_a,
+)
+
+from .flavors import (  # noqa
+    ContextManagerAdapter,
+    Flavor,
+    adapt,
+    adapt_context,
+    from_anyio,
+    from_anyio_context,
+    from_asyncio,
+    from_asyncio_context,
+    from_trio,
+    from_trio_context,
+    get_flavor,
+    mark_anyio,
+    mark_asyncio,
+    mark_flavor,
+    mark_trio,
+    with_adapter_loop,
+)

omlish/asyncs/asyncio/all.py

@@ -0,0 +1,7 @@
+# ruff: noqa: I001
+from .asyncio import (  # noqa
+    asyncio_once,
+    get_real_current_loop,
+    drain_tasks,
+    draining_asyncio_tasks,
+)

omlish/asyncs/asyncio/channels.py

@@ -0,0 +1,40 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+import asyncio
+import typing as ta
+
+
+class AsyncioBytesChannelTransport(asyncio.Transport):
+    def __init__(self, reader: asyncio.StreamReader) -> None:
+        super().__init__()
+
+        self.reader = reader
+        self.closed: asyncio.Future = asyncio.Future()
+
+    # @ta.override
+    def write(self, data: bytes) -> None:
+        self.reader.feed_data(data)
+
+    # @ta.override
+    def close(self) -> None:
+        self.reader.feed_eof()
+        if not self.closed.done():
+            self.closed.set_result(True)
+
+    # @ta.override
+    def is_closing(self) -> bool:
+        return self.closed.done()
+
+
+def asyncio_create_bytes_channel(
+        loop: ta.Any = None,
+) -> ta.Tuple[asyncio.StreamReader, asyncio.StreamWriter]:
+    if loop is None:
+        loop = asyncio.get_running_loop()
+
+    reader = asyncio.StreamReader()
+    protocol = asyncio.StreamReaderProtocol(reader)
+    transport = AsyncioBytesChannelTransport(reader)
+    writer = asyncio.StreamWriter(transport, protocol, reader, loop)
+
+    return reader, writer