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

omlish/.manifests.json

@@ -24,14 +24,272 @@
     }
   },
   {
-    "module": ".formats.json.cli.__main__",
-    "attr": "_CLI_MODULE",
-    "file": "omlish/formats/json/cli/__main__.py",
-    "line": 1,
+    "module": ".formats.cbor",
+    "attr": "_CBOR_LAZY_CODEC",
+    "file": "omlish/formats/cbor.py",
+    "line": 30,
     "value": {
-      "$omdev.cli.types.CliModule": {
-        "cmd_name": "json",
-        "mod_name": "omlish.formats.json.cli.__main__"
+      "$.codecs.base.LazyLoadedCodec": {
+        "mod_name": "omlish.formats.cbor",
+        "attr_name": "CBOR_CODEC",
+        "name": "cbor",
+        "aliases": null
+      }
+    }
+  },
+  {
+    "module": ".formats.cloudpickle",
+    "attr": "_CLOUDPICKLE_LAZY_CODEC",
+    "file": "omlish/formats/cloudpickle.py",
+    "line": 30,
+    "value": {
+      "$.codecs.base.LazyLoadedCodec": {
+        "mod_name": "omlish.formats.cloudpickle",
+        "attr_name": "CLOUDPICKLE_CODEC",
+        "name": "cloudpickle",
+        "aliases": null
+      }
+    }
+  },
+  {
+    "module": ".formats.json.codecs",
+    "attr": "_JSON_LAZY_CODEC",
+    "file": "omlish/formats/json/codecs.py",
+    "line": 14,
+    "value": {
+      "$.codecs.base.LazyLoadedCodec": {
+        "mod_name": "omlish.formats.json.codecs",
+        "attr_name": "JSON_CODEC",
+        "name": "json",
+        "aliases": null
+      }
+    }
+  },
+  {
+    "module": ".formats.json.codecs",
+    "attr": "_JSON_COMPACT_LAZY_CODEC",
+    "file": "omlish/formats/json/codecs.py",
+    "line": 21,
+    "value": {
+      "$.codecs.base.LazyLoadedCodec": {
+        "mod_name": "omlish.formats.json.codecs",
+        "attr_name": "JSON_COMPACT_CODEC",
+        "name": "json-compact",
+        "aliases": null
+      }
+    }
+  },
+  {
+    "module": ".formats.json.codecs",
+    "attr": "_JSON_PRETTY_LAZY_CODEC",
+    "file": "omlish/formats/json/codecs.py",
+    "line": 28,
+    "value": {
+      "$.codecs.base.LazyLoadedCodec": {
+        "mod_name": "omlish.formats.json.codecs",
+        "attr_name": "JSON_PRETTY_CODEC",
+        "name": "json-pretty",
+        "aliases": null
+      }
+    }
+  },
+  {
+    "module": ".formats.json5",
+    "attr": "_JSON5_LAZY_CODEC",
+    "file": "omlish/formats/json5.py",
+    "line": 30,
+    "value": {
+      "$.codecs.base.LazyLoadedCodec": {
+        "mod_name": "omlish.formats.json5",
+        "attr_name": "JSON5_CODEC",
+        "name": "json5",
+        "aliases": null
+      }
+    }
+  },
+  {
+    "module": ".formats.pickle",
+    "attr": "_PICKLE_LAZY_CODEC",
+    "file": "omlish/formats/pickle.py",
+    "line": 30,
+    "value": {
+      "$.codecs.base.LazyLoadedCodec": {
+        "mod_name": "omlish.formats.pickle",
+        "attr_name": "PICKLE_CODEC",
+        "name": "pickle",
+        "aliases": null
+      }
+    }
+  },
+  {
+    "module": ".formats.repr",
+    "attr": "_REPR_LAZY_CODEC",
+    "file": "omlish/formats/repr.py",
+    "line": 24,
+    "value": {
+      "$.codecs.base.LazyLoadedCodec": {
+        "mod_name": "omlish.formats.repr",
+        "attr_name": "REPR_CODEC",
+        "name": "repr",
+        "aliases": null
+      }
+    }
+  },
+  {
+    "module": ".formats.toml",
+    "attr": "_TOML_LAZY_CODEC",
+    "file": "omlish/formats/toml.py",
+    "line": 16,
+    "value": {
+      "$.codecs.base.LazyLoadedCodec": {
+        "mod_name": "omlish.formats.toml",
+        "attr_name": "TOML_CODEC",
+        "name": "toml",
+        "aliases": null
+      }
+    }
+  },
+  {
+    "module": ".formats.yaml",
+    "attr": "_YAML_LAZY_CODEC",
+    "file": "omlish/formats/yaml.py",
+    "line": 258,
+    "value": {
+      "$.codecs.base.LazyLoadedCodec": {
+        "mod_name": "omlish.formats.yaml",
+        "attr_name": "YAML_CODEC",
+        "name": "yaml",
+        "aliases": [
+          "yml"
+        ]
+      }
+    }
+  },
+  {
+    "module": ".formats.yaml",
+    "attr": "_YAML_UNSAFE_LAZY_CODEC",
+    "file": "omlish/formats/yaml.py",
+    "line": 265,
+    "value": {
+      "$.codecs.base.LazyLoadedCodec": {
+        "mod_name": "omlish.formats.yaml",
+        "attr_name": "YAML_UNSAFE_CODEC",
+        "name": "yaml-unsafe",
+        "aliases": null
+      }
+    }
+  },
+  {
+    "module": ".io.compress.brotli",
+    "attr": "_BROTLI_LAZY_CODEC",
+    "file": "omlish/io/compress/brotli.py",
+    "line": 46,
+    "value": {
+      "$.codecs.base.LazyLoadedCodec": {
+        "mod_name": "omlish.io.compress.brotli",
+        "attr_name": "BROTLI_CODEC",
+        "name": "brotli",
+        "aliases": null
+      }
+    }
+  },
+  {
+    "module": ".io.compress.bz2",
+    "attr": "_BZ2_LAZY_CODEC",
+    "file": "omlish/io/compress/bz2.py",
+    "line": 60,
+    "value": {
+      "$.codecs.base.LazyLoadedCodec": {
+        "mod_name": "omlish.io.compress.bz2",
+        "attr_name": "BZ2_CODEC",
+        "name": "bz2",
+        "aliases": null
+      }
+    }
+  },
+  {
+    "module": ".io.compress.gzip",
+    "attr": "_GZIP_LAZY_CODEC",
+    "file": "omlish/io/compress/gzip.py",
+    "line": 349,
+    "value": {
+      "$.codecs.base.LazyLoadedCodec": {
+        "mod_name": "omlish.io.compress.gzip",
+        "attr_name": "GZIP_CODEC",
+        "name": "gzip",
+        "aliases": [
+          "gz"
+        ]
+      }
+    }
+  },
+  {
+    "module": ".io.compress.lz4",
+    "attr": "_LZ4_LAZY_CODEC",
+    "file": "omlish/io/compress/lz4.py",
+    "line": 90,
+    "value": {
+      "$.codecs.base.LazyLoadedCodec": {
+        "mod_name": "omlish.io.compress.lz4",
+        "attr_name": "LZ4_CODEC",
+        "name": "lz4",
+        "aliases": null
+      }
+    }
+  },
+  {
+    "module": ".io.compress.lzma",
+    "attr": "_LZMA_LAZY_CODEC",
+    "file": "omlish/io/compress/lzma.py",
+    "line": 80,
+    "value": {
+      "$.codecs.base.LazyLoadedCodec": {
+        "mod_name": "omlish.io.compress.lzma",
+        "attr_name": "LZMA_CODEC",
+        "name": "lzma",
+        "aliases": null
+      }
+    }
+  },
+  {
+    "module": ".io.compress.snappy",
+    "attr": "_SNAPPY_LAZY_CODEC",
+    "file": "omlish/io/compress/snappy.py",
+    "line": 33,
+    "value": {
+      "$.codecs.base.LazyLoadedCodec": {
+        "mod_name": "omlish.io.compress.snappy",
+        "attr_name": "SNAPPY_CODEC",
+        "name": "snappy",
+        "aliases": null
+      }
+    }
+  },
+  {
+    "module": ".io.compress.zlib",
+    "attr": "_ZLIB_LAZY_CODEC",
+    "file": "omlish/io/compress/zlib.py",
+    "line": 73,
+    "value": {
+      "$.codecs.base.LazyLoadedCodec": {
+        "mod_name": "omlish.io.compress.zlib",
+        "attr_name": "ZLIB_CODEC",
+        "name": "zlib",
+        "aliases": null
+      }
+    }
+  },
+  {
+    "module": ".io.compress.zstd",
+    "attr": "_ZSTD_LAZY_CODEC",
+    "file": "omlish/io/compress/zstd.py",
+    "line": 43,
+    "value": {
+      "$.codecs.base.LazyLoadedCodec": {
+        "mod_name": "omlish.io.compress.zstd",
+        "attr_name": "ZSTD_CODEC",
+        "name": "zstd",
+        "aliases": null
       }
     }
   },

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev133'
-__revision__ = 'a351cfd2f4211dfabf34e559ec14459081ef5895'
+__version__ = '0.0.0.dev177'
+__revision__ = '3c81e0413acb397557436f3f66780dd6e8555500'
 
 
 #
@@ -32,7 +32,7 @@ class Project(ProjectBase):
 
     optional_dependencies = {
         'async': [
-            'anyio ~= 4.6',
+            'anyio ~= 4.7',
             'sniffio ~= 1.3',
 
             'greenlet ~= 3.1',
@@ -48,6 +48,8 @@ class Project(ProjectBase):
             'python-snappy ~= 0.7',
 
             'zstandard ~= 0.23',
+
+            'brotli ~= 1.1',
         ],
 
         'diag': [

omlish/antlr/_runtime/__init__.py

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

omlish/antlr/_runtime/_all.py

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

omlish/antlr/_runtime/atn/ParserATNSimulator.py

@@ -235,7 +235,7 @@
 # the input.</p>
 #
 import sys
-from .. import DFA
+from ..dfa.DFA import DFA
 from ..BufferedTokenStream import TokenStream
 from ..Parser import Parser
 from ..ParserRuleContext import ParserRuleContext

omlish/antlr/_runtime/dfa/DFASerializer.py

@@ -9,7 +9,7 @@
 
 # A DFA walker that knows how to dump them to serialized strings.#/
 from io import StringIO
-from .. import DFA
+from ..dfa.DFA import DFA
 from ..Utils import str_list
 from .DFAState import DFAState
 

omlish/antlr/_runtime/error/DiagnosticErrorListener.py

@@ -28,7 +28,8 @@
 # </ul>
 
 from io import StringIO
-from .. import Parser, DFA
+from ..Parser import Parser
+from ..dfa.DFA import DFA
 from ..atn.ATNConfigSet import ATNConfigSet
 from .ErrorListener import ErrorListener
 

omlish/antlr/_runtime/xpath/XPath.py

@@ -50,7 +50,13 @@
 # <p>
 # Whitespace is not allowed.</p>
 #
-from .. import CommonTokenStream, DFA, PredictionContextCache, Lexer, LexerATNSimulator, ParserRuleContext, TerminalNode
+from ..CommonTokenStream import CommonTokenStream
+from ..dfa.DFA import DFA
+from ..PredictionContext import PredictionContextCache
+from ..Lexer import Lexer
+from ..atn.LexerATNSimulator import LexerATNSimulator
+from ..ParserRuleContext import ParserRuleContext
+from ..tree.Tree import TerminalNode
 from ..InputStream import InputStream
 from ..Parser import Parser
 from ..RuleContext import RuleContext

omlish/antlr/_runtime/xpath/XPathLexer.py

@@ -2,7 +2,7 @@
 # ruff: noqa
 # flake8: noqa
 # Generated from XPathLexer.g4 by ANTLR 4.11.2-SNAPSHOT
-from .. import *
+from .._all import *
 from io import StringIO
 import sys
 if sys.version_info[1] > 5:

omlish/antlr/delimit.py

@@ -0,0 +1,106 @@
+# ruff: noqa: N802 N815
+import io
+import typing as ta
+
+from .. import check
+from . import runtime as antlr4
+
+
+class DelimitingLexer(antlr4.Lexer):
+    def __init__(
+            self,
+            *args: ta.Any,
+            delimiter_token: ta.Any,
+            delimiters: ta.Iterable[str],
+            no_skip: bool = False,
+            **kwargs,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+
+        self._delimiter_token = delimiter_token
+        self._delimiters = set(check.not_isinstance(delimiters, str))
+        self._no_skip = no_skip
+
+    _hitEOF: bool
+
+    def nextToken(self) -> antlr4.Token:
+        if self._input is None:
+            raise antlr4.IllegalStateException('nextToken requires a non-null input stream.')
+
+        token_start_marker = self._input.mark()
+        try:
+            while True:
+                if self._hitEOF:
+                    self.emitEOF()
+                    return self._token
+
+                self._token: antlr4.Token | None = None
+                self._channel = antlr4.Token.DEFAULT_CHANNEL
+                self._tokenStartCharIndex = self._input.index
+                self._tokenStartColumn = self._interp.column
+                self._tokenStartLine = self._interp.line
+                self._text = None
+
+                continue_outer = False
+                while True:
+                    self._type = antlr4.Token.INVALID_TYPE
+                    ttype = self.SKIP
+
+                    for delimiter in self._delimiters:
+                        if self._match_delimiter(delimiter):
+                            ttype = self._delimiter_token
+                            break
+                    else:
+                        try:
+                            ttype = self._interp.match(self._input, self._mode)
+                        except antlr4.LexerNoViableAltException as e:
+                            self.notifyListeners(e)  # report error
+                            self.recover(e)
+
+                    if self._input.LA(1) == antlr4.Token.EOF:
+                        self._hitEOF = True
+
+                    if self._type == antlr4.Token.INVALID_TYPE:
+                        self._type = ttype
+
+                    if not self._no_skip and self._type == self.SKIP:
+                        continue_outer = True
+                        break
+
+                    if self._type != self.MORE:
+                        break
+
+                if continue_outer:
+                    continue
+
+                if self._token is None:
+                    self.emit()
+
+                return self._token
+
+        finally:
+            self._input.release(token_start_marker)
+
+    def _match_delimiter(self, delimiter: str) -> bool:
+        for i, c in enumerate(delimiter):
+            if chr(self._input.LA(i + 1)) != c:
+                return False
+        self._input.seek(self._input.index + len(delimiter))
+        return True
+
+    def split(self) -> tuple[list[tuple[str, str]], str]:
+        lst = []
+        sb = io.StringIO()
+        while True:
+            token = self.nextToken()
+            if token.type == antlr4.Token.EOF:
+                break
+            if token.type == self._delimiter_token:
+                statement = sb.getvalue().strip()
+                if statement:
+                    lst.append((statement, token.text))
+                sb = io.StringIO()
+            else:
+                sb.write(token.text)
+        partial = sb.getvalue()
+        return lst, partial

omlish/antlr/dot.py

@@ -0,0 +1,31 @@
+from ..graphs import dot
+from . import runtime as antlr4
+from .utils import yield_contexts
+
+
+def dot_ctx(root: antlr4.ParserRuleContext) -> dot.Graph:
+    stmts: list[dot.Stmt] = [
+        dot.RawStmt('rankdir=LR;'),
+    ]
+
+    for c in yield_contexts(root):
+        if isinstance(c, antlr4.TerminalNode):
+            continue
+
+        lbl = [
+            [type(c).__name__],
+            [str(id(c))],
+            [f'{c.start} {c.stop}'],
+        ]
+
+        stmts.append(dot.Node(f'_{id(c)}', {'label': lbl, 'shape': 'box'}))
+
+        for n in (c.children or []):
+            if not isinstance(n, antlr4.TerminalNode):
+                stmts.append(dot.Edge(f'_{id(c)}', f'_{id(n)}'))
+
+    return dot.Graph(stmts)
+
+
+def open_dot_ctx(root: antlr4.ParserRuleContext) -> None:
+    dot.open_dot(dot.render(dot_ctx(root)))

omlish/antlr/errors.py

@@ -0,0 +1,11 @@
+# ruff: noqa: N802 N803
+from . import runtime as antlr4
+
+
+class ParseError(Exception):
+    pass
+
+
+class SilentRaisingErrorListener(antlr4.ErrorListener):
+    def syntaxError(self, recognizer, offendingSymbol, line, column, msg, e):
+        raise ParseError(recognizer, offendingSymbol, line, column, msg, e)

omlish/antlr/input.py

@@ -0,0 +1,96 @@
+# ruff: noqa: N802
+import typing as ta
+
+
+##
+
+
+# class InputStream(ta.Protocol):
+#
+#   @property
+#   def index(self) -> int: ...
+#
+#   @property
+#   def size(self) -> int: ...
+#
+#   # Reset the stream so that it's in the same state it was when the object was created *except* the data array is not
+#   # touched.
+#   def reset(self) -> None: ...
+#
+#   def consume(self) -> None: ...
+#
+#   def LA(self, offset: int) -> int: ...
+#
+#   def LT(self, offset: int) -> int: ...
+#
+#   def mark(self) -> int: ...
+#
+#   def release(self, marker: int) -> None: ...
+#
+#   # consume() ahead until p==_index; can't just set p=_index as we must update line and column. If we seek backwards,
+#   # just set p
+#   def seek(self, _index: int) -> None: ...
+#
+#   def getText(self, start: int, stop: int) -> str: ...
+#
+#   def __str__(self) -> str: ...
+
+
+InputStream: ta.TypeAlias = ta.Any
+
+
+##
+
+
+# @lang.protocol_check(InputStream)
+class ProxyInputStream:
+    def __init__(self, target: InputStream) -> None:
+        super().__init__()
+
+        self._target = target
+
+    @property
+    def index(self) -> int:
+        return self._target.index
+
+    @property
+    def size(self) -> int:
+        return self._target.size
+
+    def reset(self) -> None:
+        self._target.reset()
+
+    def consume(self) -> None:
+        self._target.consume()
+
+    def LA(self, offset: int) -> int:
+        return self._target.LA(offset)
+
+    def LT(self, offset: int) -> int:
+        return self._target.LT(offset)
+
+    def mark(self) -> int:
+        return self._target.mark()
+
+    def release(self, marker: int) -> None:
+        return self._target.release(marker)
+
+    def seek(self, _index: int) -> None:
+        return self._target.seek(_index)
+
+    def getText(self, start: int, stop: int) -> str:
+        return self._target.getText(start, stop)
+
+    def __str__(self) -> str:
+        return str(self._target)
+
+
+##
+
+
+class CaseInsensitiveInputStream(ProxyInputStream):
+    def LA(self, offset: int) -> int:
+        ret = super().LA(offset)
+        if ret != -1:
+            ret = ord(chr(ret).upper())
+        return ret

omlish/antlr/parsing.py

@@ -0,0 +1,19 @@
+# ruff: noqa: N802 N803
+import typing as ta
+
+from . import runtime as antlr4
+
+
+LexerT = ta.TypeVar('LexerT', bound=antlr4.Lexer)
+ParserT = ta.TypeVar('ParserT', bound=antlr4.Parser)
+
+
+def parse(
+        buf: str,
+        lexer_cls: type[LexerT],
+        parser_cls: type[ParserT],
+) -> ParserT:
+    lexer = lexer_cls(antlr4.InputStream(buf))
+    stream = antlr4.CommonTokenStream(lexer)
+    stream.fill()
+    return parser_cls(stream)