omlish 0.0.0.dev254__py3-none-any.whl → 0.0.0.dev256__py3-none-any.whl

omlish/specs/jsonrpc/__init__.py

@@ -1,22 +1,34 @@
 from .errors import (  # noqa
-    CUSTOM_ERROR_BASE,
     KnownError,
     KnownErrors,
+
+    CUSTOM_ERROR_BASE,
 )
 
 from .types import (  # noqa
-    Error,
-    Id,
-    NotSpecified,
+    NUMBER_TYPES,
     Number,
     Object,
-    Request,
-    Response,
+    ID_TYPES,
+    Id,
+
     VERSION,
-    error,
-    notification,
+
+    NotSpecified,
+    is_not_specified,
+
+    Request,
     request,
+    notification,
+
+    Response,
     result,
+
+    Error,
+    error,
+
+    Message,
+    detect_message_type,
 )
 
 

omlish/specs/jsonrpc/types.py

@@ -9,15 +9,21 @@ See:
  - https://github.com/python-lsp/python-lsp-jsonrpc
 """
 import operator
+import types
 import typing as ta
 
+from ... import check
 from ... import dataclasses as dc
 from ... import lang
 from ... import marshal as msh
 
 
+NUMBER_TYPES: tuple[type, ...] = (int, float)
 Number: ta.TypeAlias = int | float
+
 Object: ta.TypeAlias = ta.Mapping[str, ta.Any]
+
+ID_TYPES: tuple[type, ...] = (str, *NUMBER_TYPES, types.NoneType)
 Id: ta.TypeAlias = str | Number | None
 
 
@@ -27,6 +33,9 @@ Id: ta.TypeAlias = str | Number | None
 VERSION = '2.0'
 
 
+##
+
+
 class NotSpecified(lang.Marker):
     pass
 
@@ -43,6 +52,14 @@ def is_not_specified(v: ta.Any) -> bool:
 @msh.update_fields_metadata(['params'], omit_if=operator.not_)
 class Request(lang.Final):
     id: Id | type[NotSpecified]
+
+    @property
+    def is_notification(self) -> bool:
+        return self.id is NotSpecified
+
+    def id_value(self) -> Id:
+        return check.isinstance(self.id, ID_TYPES)
+
     method: str
     params: Object | None = None
 
@@ -50,6 +67,7 @@ class Request(lang.Final):
     dc.validate(lambda self: self.jsonrpc == VERSION)
 
 
+
 def request(id: Id, method: str, params: Object | None = None) -> Request:  # noqa
     return Request(id, method, params)
 
@@ -94,3 +112,18 @@ class Error(lang.Final):
 
 def error(id: Id, error: Error) -> Response:  # noqa
     return Response(id, error=error)
+
+
+##
+
+
+Message: ta.TypeAlias = Request | Response | Error
+
+
+def detect_message_type(dct: ta.Mapping[str, ta.Any]) -> type[Message]:
+    if 'method' in dct:
+        return Request
+    elif 'code' in dct:
+        return Error
+    else:
+        return Response

omlish/sql/parsing/Minisql.g4

@@ -100,11 +100,14 @@ sortItem
     ;
 
 relation
-    : relation AS? ident                                                     #aliasedRelation
-    | left=relation ty=joinType? JOIN right=relation (ON cond=booleanExpr)?  #joinRelation
-    | '(' select ')'                                                         #selectRelation
-    | '(' relation ')'                                                       #parenRelation
-    | qualifiedName                                                          #tableRelation
+    : relation AS? ident      #aliasedRelation
+    | left=relation
+      ty=joinType?
+      JOIN right=relation
+      (ON cond=booleanExpr)?  #joinRelation
+    | '(' select ')'          #selectRelation
+    | '(' relation ')'        #parenRelation
+    | qualifiedName           #tableRelation
     ;
 
 groupBy

omlish/sync.py

@@ -2,6 +2,7 @@
 TODO:
  - sync (lol) w/ asyncs.anyio
  - atomics
+ - Once poison=False, PoisonedError
 """
 import collections
 import threading
@@ -13,6 +14,9 @@ from . import lang
 T = ta.TypeVar('T')
 
 
+##
+
+
 class Once:
     def __init__(self) -> None:
         super().__init__()
@@ -32,6 +36,9 @@ class Once:
             return True
 
 
+##
+
+
 class Lazy(ta.Generic[T]):
     def __init__(self) -> None:
         super().__init__()
@@ -71,6 +78,9 @@ class LazyFn(ta.Generic[T]):
         return self._v.must()
 
 
+##
+
+
 class ConditionDeque(ta.Generic[T]):
     def __init__(
             self,

omlish/testing/pytest/plugins/asyncs/fixtures.py

@@ -27,7 +27,6 @@ from _pytest.outcomes import XFailed  # noqa
 
 from ..... import check
 from ..... import lang
-from ..... import outcome
 from .backends.base import AsyncsBackend
 from .utils import is_coroutine_function
 
@@ -225,14 +224,14 @@ class AsyncsFixture:
             # process), save any exception that *isn't* Cancelled (because if its Cancelled then we can't route it to
             # the right place, and anyway the teardown code will get it again if it matters), and then use a shield to
             # keep waiting for the teardown to finish without having to worry about cancellation.
-            yield_outcome: outcome.Outcome = outcome.Value(None)
+            yield_outcome: lang.Outcome = lang.Value(None)
             try:
                 for event in self.user_done_events:
                     await event.wait()
 
             except BaseException as exc:  # noqa
                 check.isinstance(exc, anyio.get_cancelled_exc_class())
-                yield_outcome = outcome.Error(exc)
+                yield_outcome = lang.Error(exc)
                 test_ctx.crash(self, None)
                 with anyio.CancelScope(shield=True):
                     for event in self.user_done_events:

omlish/text/go/quoting.py

@@ -0,0 +1,260 @@
+# ruff: noqa: Q000
+"""
+https:#github.com/golang/go/blob/3d33437c450aa74014ea1d41cd986b6ee6266984/src/strconv/quote.go
+"""
+# Copyright 2009 The Go Authors.
+#
+# Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+# following conditions are met:
+#
+#    * Redistributions of source code must retain the above copyright notice, this list of conditions and the following
+#      disclaimer.
+#    * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
+#      following disclaimer in the documentation and/or other materials provided with the distribution.
+#    * Neither the name of Google LLC nor the names of its contributors may be used to endorse or promote products
+#      derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+def unhex(b: str) -> int | None:
+    c = ord(b)
+    if ord('0') <= c <= ord('9'):
+        return c - ord('0')
+    elif ord('a') <= c <= ord('f'):
+        return c - ord('a') + 10
+    elif ord('A') <= c <= ord('F'):
+        return c - ord('A') + 10
+    else:
+        return None
+
+
+SURROGATE_MIN = 0xD800
+SURROGATE_MAX = 0xDFFF
+MAX_RUNE = ord('\U0010FFFF')  # Maximum valid Unicode code point.
+
+
+def is_valid_utf8(r: int) -> bool:
+    if 0 <= r < SURROGATE_MIN:
+        return True
+    elif SURROGATE_MAX < r <= MAX_RUNE:
+        return True
+    return False
+
+
+##
+
+
+class UnquoteError(Exception):
+    pass
+
+
+def unquote_char(s: str, quote: str) -> tuple[str, bool, str]:  # (value, multibyte, tail)
+    # UnquoteChar decodes the first character or byte in the escaped string or character literal represented by the
+    # string s. It returns four values:
+    #
+    #  1. value, the decoded Unicode code point or byte value;
+    #  2. multibyte, a boolean indicating whether the decoded character requires a multibyte UTF-8 representation;
+    #  3. tail, the remainder of the string after the character; and
+    #  4. an error that will be nil if the character is syntactically valid.
+    #
+    # The second argument, quote, specifies the type of literal being parsed and therefore which escaped quote character
+    # is permitted.
+    # If set to a single quote, it permits the sequence \' and disallows unescaped '.
+    # If set to a double quote, it permits \" and disallows unescaped ".
+    # If set to zero, it does not permit either escape and allows both quote characters to appear unescaped.
+
+    # easy cases
+    if not s:
+        raise UnquoteError
+
+    c = s[0]
+    if c == quote and quote in '\'"':
+        raise UnquoteError
+    # elif c >= utf8.graphic_only:
+    #     r, size = utf8.DecodeRuneInString(s)
+    #     return r, True, s[size:]
+    elif c != '\\':
+        return s[0], False, s[1:]
+
+    # hard case: c is backslash
+    if len(s) <= 1:
+        raise UnquoteError
+
+    c = s[1]
+    s = s[2:]
+    value: str
+    multibyte = False
+
+    if c == 'a':
+        value = '\a'
+    elif c == 'b':
+        value = '\b'
+    elif c == 'f':
+        value = '\f'
+    elif c == 'n':
+        value = '\n'
+    elif c == 'r':
+        value = '\r'
+    elif c == 't':
+        value = '\t'
+    elif c == 'v':
+        value = '\v'
+    elif c in 'xuU':
+        n = 0
+        if c == 'x':
+            n = 2
+        elif c == 'u':
+            n = 4
+        elif c == 'U':
+            n = 8
+        if len(s) < n:
+            raise UnquoteError
+        v = 0
+        for j in range(n):
+            x = unhex(s[j])
+            if x is None:
+                raise UnquoteError
+            v = v << 4 | x
+        s = s[n:]
+        if c == 'x':
+            try:
+                value = chr(v)  # noqa
+            except ValueError:
+                raise UnquoteError from None
+        else:
+            # single-byte string, possibly not UTF-8
+            if not is_valid_utf8(v):
+                raise UnquoteError
+            try:
+                value = chr(v)  # noqa
+            except ValueError:
+                raise UnquoteError from None
+            multibyte = True
+    elif c in '01234567':
+        v = ord(c) - ord('0')
+        if len(s) < 2:
+            raise UnquoteError
+        for j in range(2):  # one digit already; two more
+            x = ord(s[j]) - ord('0')
+            if x < 0 or x > 7:
+                raise UnquoteError
+            v = (v << 3) | x
+        s = s[2:]
+        if v > 255:
+            raise UnquoteError
+        value = chr(v)
+    elif c == '\\':
+        value = '\\'
+    elif c in ('\'', '"'):
+        if c != quote:
+            raise UnquoteError
+        value = c
+    else:
+        raise UnquoteError
+
+    tail = s
+    return value, multibyte, tail
+
+
+def unquote_(ins: str, unescape: bool) -> tuple[str, str]:  # (out, rem)
+    # unquote parses a quoted string at the start of the input, returning the parsed prefix, the remaining suffix, and
+    # any parse errors. If unescape is true, the parsed prefix is unescaped, otherwise the input prefix is provided
+    # verbatim.
+
+    # Determine the quote form and optimistically find the terminating quote.
+    if len(ins) < 2:
+        raise UnquoteError
+    quote = ins[0]
+    end = ins[1:].find(quote)
+    if end < 0:
+        raise UnquoteError
+    end += 2  # position after terminating quote; may be wrong if escape sequences are present
+
+    if quote == '`':
+        if not unescape:
+            out = ins[:end]  # include quotes
+        elif '\r' not in ins[:end]:
+            out = ins[len("`"): end - len("`")]  # exclude quotes
+        else:
+            # Carriage return characters ('\r') inside raw string literals are discarded from the raw string value.
+            buf = []
+            for i in range(len("`"), end - len("`")):
+                if ins[i] != '\r':
+                    buf.append(ins[i])
+            out = ''.join(buf)
+
+        # NOTE: Prior implementations did not verify that raw strings consist of valid UTF-8 characters and we continue
+        # to not verify it as such. The Go specification does not explicitly require valid UTF-8, but only mention that
+        # it is implicitly valid for Go source code (which must be valid UTF-8).
+        return out, ins[end:]
+
+    elif quote in ('"', '\''):
+        # Handle quoted strings without any escape sequences.
+        if '\\' not in ins[:end] and '\n' not in ins[:end]:
+            valid = False
+            if quote == '"':
+                # valid = utf8.ValidString(ins[len('"'): end - len('"')])
+                valid = True
+            elif quote == '\'':
+                # r, n = utf8.DecodeRuneInString(ins[len("'"): end - len("'")])
+                # valid = len("'") + n + len("'") == end and (r != utf8.RuneError or n != 1)
+                valid = end == 3
+            if valid:
+                out = ins[:end]
+                if unescape:
+                    out = out[1: end - 1]  # exclude quotes
+                return out, ins[end:]
+
+        # Handle quoted strings with escape sequences.
+        buf = []
+        in0 = ins
+        ins = ins[1:]  # skip starting quote
+
+        while ins and ins[0] != quote:
+            # Process the next character, rejecting any unescaped newline characters which are invalid.
+            r, multibyte, rem = unquote_char(ins, quote)
+            if ins[0] == '\n':
+                raise UnquoteError
+            ins = rem
+
+            # Append the character if unescaping the input.
+            if unescape:
+                # if r < utf8.RuneSelf or not multibyte:
+                #     buf.append(byte(r))
+                # else:
+                buf.append(r)
+
+            # Single quoted strings must be a single character.
+            if quote == '\'':
+                break
+
+        # Verify that the string ends with a terminating quote.
+        if not (ins and ins[0] == quote):
+            raise UnquoteError
+
+        ins = ins[1:]  # skip terminating quote
+
+        if unescape:
+            return ''.join(buf), ins
+
+        return in0[:len(in0) - len(ins)], ins
+
+    else:
+        raise UnquoteError
+
+
+def unquote(s: str) -> str:
+    # Unquote interprets s as a single-quoted, double-quoted, or backquoted Go string literal, returning the string
+    # value that s quotes.  (If s is single-quoted, it would be a Go character literal; Unquote returns the
+    # corresponding one-character string.)
+    out, rem = unquote_(s, True)
+    if rem:
+        raise UnquoteError
+    return out

omlish/text/parts.py

@@ -72,40 +72,47 @@ class Meta(DataPart):
 
 
 class PartTransform:
+    def __call__(self, part: Part | None) -> Part:
+        return self._transform(part)
+
     @dispatch.method
-    def __call__(self, part: Part) -> Part:
+    def _transform(self, part: Part | None) -> Part:
         raise TypeError(part)
 
-    @__call__.register
-    def __call__str(self, part: str) -> Part:
+    @_transform.register
+    def _transform_none(self, part: None) -> Part:
+        return []
+
+    @_transform.register
+    def _transform_str(self, part: str) -> Part:
         return part
 
-    @__call__.register
-    def __call__sequence(self, part: collections.abc.Sequence) -> Part:
+    @_transform.register
+    def _transform_sequence(self, part: collections.abc.Sequence) -> Part:
         return [self(c) for c in part]
 
-    @__call__.register
-    def __call__wrap(self, part: Wrap) -> Part:
+    @_transform.register
+    def _transform_wrap(self, part: Wrap) -> Part:
         return Wrap(self(part.part), part.wrapper)
 
-    @__call__.register
-    def __call__list(self, part: List) -> Part:
+    @_transform.register
+    def _transform_list(self, part: List) -> Part:
         return List([self(c) for c in part.parts], part.delimiter, part.trailer)
 
-    @__call__.register
-    def __call__concat(self, part: Concat) -> Part:
+    @_transform.register
+    def _transform_concat(self, part: Concat) -> Part:
         return Concat([self(c) for c in part.parts])
 
-    @__call__.register
-    def __call__block(self, part: Block) -> Part:
+    @_transform.register
+    def _transform_block(self, part: Block) -> Part:
         return Block([self(c) for c in part.parts])
 
-    @__call__.register
-    def __call__section(self, part: Section) -> Part:
+    @_transform.register
+    def _transform_section(self, part: Section) -> Part:
         return Section([self(c) for c in part.parts])
 
-    @__call__.register
-    def __call__meta(self, part: Meta) -> Meta:
+    @_transform.register
+    def _transform_meta(self, part: Meta) -> Meta:
         return part
 
 
@@ -113,8 +120,8 @@ class PartTransform:
 
 
 class RemoveMetas(PartTransform):
-    @PartTransform.__call__.register
-    def __call__meta(self, part: Meta) -> Part:
+    @PartTransform._transform.register  # noqa
+    def _transform_meta(self, part: Meta) -> Part:
         return []
 
 
@@ -137,27 +144,27 @@ def _drop_empties(it: ta.Iterable[T]) -> list[T]:
 
 
 class CompactPart(PartTransform):
-    @PartTransform.__call__.register
-    def __call__sequence(self, part: collections.abc.Sequence) -> Part:
+    @PartTransform._transform.register  # noqa
+    def _transform_sequence(self, part: collections.abc.Sequence) -> Part:
         return _drop_empties(self(c) for c in part)
 
-    @PartTransform.__call__.register
-    def __call__list(self, part: List) -> Part:
+    @PartTransform._transform.register  # noqa
+    def _transform_list(self, part: List) -> Part:
         parts = _drop_empties(self(c) for c in part.parts)
         return List(parts, part.delimiter, part.trailer) if parts else []
 
-    @PartTransform.__call__.register
-    def __call__concat(self, part: Concat) -> Part:
+    @PartTransform._transform.register  # noqa
+    def _transform_concat(self, part: Concat) -> Part:
         parts = _drop_empties(self(c) for c in part.parts)
         return Concat(parts) if parts else []
 
-    @PartTransform.__call__.register
-    def __call__block(self, part: Block) -> Part:
+    @PartTransform._transform.register  # noqa
+    def _transform_block(self, part: Block) -> Part:
         parts = _drop_empties(self(c) for c in part.parts)
         return Block(parts) if parts else []
 
-    @PartTransform.__call__.register
-    def __call__section(self, part: Section) -> Part:
+    @PartTransform._transform.register  # noqa
+    def _transform_section(self, part: Section) -> Part:
         parts = _drop_empties(self(c) for c in part.parts)
         return Section(parts) if parts else []
 
@@ -204,29 +211,36 @@ class PartRenderer:
             self._blank_lines += n
             self._has_indented = False
 
+    def __call__(self, part: Part | None) -> None:
+        return self._render(part)
+
     @dispatch.method
-    def __call__(self, part: Part) -> None:
+    def _render(self, part: Part | None) -> None:
         raise TypeError(part)
 
-    @__call__.register
-    def __call__str(self, part: str) -> None:
+    @_render.register
+    def _render_none(self, part: None) -> None:
+        pass
+
+    @_render.register
+    def _render_str(self, part: str) -> None:
         self._write(part)
 
-    @__call__.register
-    def __call__sequence(self, part: collections.abc.Sequence) -> None:
+    @_render.register
+    def _render_sequence(self, part: collections.abc.Sequence) -> None:
         for i, c in enumerate(part):
             if i:
                 self._write(' ')
             self(c)
 
-    @__call__.register
-    def __call__wrap(self, part: Wrap) -> None:
+    @_render.register
+    def _render_wrap(self, part: Wrap) -> None:
         self._write(part.wrapper[0])
         self(part.part)
         self._write(part.wrapper[1])
 
-    @__call__.register
-    def __call__list(self, part: List) -> None:
+    @_render.register
+    def _render_list(self, part: List) -> None:
         for i, c in enumerate(part.parts):
             if i:
                 self._write(part.delimiter + ' ')
@@ -234,19 +248,19 @@ class PartRenderer:
         if part.trailer:
             self._write(part.delimiter)
 
-    @__call__.register
-    def __call__concat(self, part: Concat) -> None:
+    @_render.register
+    def _render_concat(self, part: Concat) -> None:
         for c in part.parts:
             self(c)
 
-    @__call__.register
-    def __call__block(self, part: Block) -> None:
+    @_render.register
+    def _render_block(self, part: Block) -> None:
         for c in part.parts:
             self(c)
             self._write_newline()
 
-    @__call__.register
-    def __call__section(self, part: Section) -> None:
+    @_render.register
+    def _render_section(self, part: Section) -> None:
         self._indents += 1
         try:
             for c in part.parts:

{omlish-0.0.0.dev254.dist-info → omlish-0.0.0.dev256.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: omlish
-Version: 0.0.0.dev254
+Version: 0.0.0.dev256
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause