omlish 0.0.0.dev117__py3-none-any.whl → 0.0.0.dev118__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev117'
-__revision__ = '53d3fb51abb6f481bd836efe8a32c8da91113468'
+__version__ = '0.0.0.dev118'
+__revision__ = '3d4642bb79ba8bc7d7c6a1009237095185ac3c86'
 
 
 #

omlish/collections/hasheq.py

@@ -27,21 +27,11 @@ class HashEq(lang.Abstract, ta.Generic[K]):
         raise NotImplementedError
 
 
-@lang.unabstract_class([
-    ('hash', '_hash'),
-    ('eq', '_eq'),
-])
 @dc.dataclass(frozen=True)
 class HashEq_(ta.Generic[K]):  # noqa
     hash: ta.Callable[[K], int]
     eq: ta.Callable[[K, K], bool]
 
-    def _hash(self, k: K) -> int:
-        return self.hash(k)
-
-    def _eq(self, l: K, r: K) -> bool:
-        return self.eq(l, r)
-
 
 class hash_eq(HashEq[K], lang.NotInstantiable, lang.Final):  # noqa
     """Workaround for PEP 695 support."""

omlish/fnpairs.py

@@ -94,21 +94,12 @@ class FnPair(ta.Generic[F, T], abc.ABC):
 ##
 
 
-@lang.unabstract_class([
-    ('forward', '_forward'),
-    ('backward', 'backward'),
-])
+@lang.unabstract_class(['forward', 'backward'])
 @dc.dataclass(frozen=True)
 class Simple(FnPair[F, T]):
     forward: ta.Callable[[F], T]  # type: ignore
     backward: ta.Callable[[T], F]  # type: ignore
 
-    def _forward(self, f: F) -> T:
-        return self.forward(f)
-
-    def _backward(self, t: T) -> F:
-        return self.backward(t)
-
 
 of = Simple
 

omlish/formats/json/__init__.py

@@ -37,3 +37,8 @@ else:
     _lang.proxy_init(globals(), '.render', [
         'JsonRenderer',
     ])
+
+from .types import (  # noqa
+    SCALAR_TYPES,
+    Scalar,
+)

omlish/formats/json/literals.py

@@ -0,0 +1,179 @@
+# MIT License
+# ===========
+#
+# Copyright (c) 2006 Bob Ippolito
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+# Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+# OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+# https://github.com/simplejson/simplejson/blob/6932004966ab70ef47250a2b3152acd8c904e6b5/simplejson/scanner.py
+import json
+import re
+import sys
+import typing as ta
+
+
+##
+
+
+_FOUR_DIGIT_HEX_PAT = re.compile(r'^[0-9a-fA-F]{4}$')
+
+
+def _scan_four_digit_hex(
+        s: str,
+        end: int,
+):
+    """Scan a four digit hex number from s[end:end + 4]"""
+
+    msg = 'Invalid \\uXXXX escape sequence'
+    esc = s[end: end + 4]
+    if not _FOUR_DIGIT_HEX_PAT.match(esc):
+        raise json.JSONDecodeError(msg, s, end - 2)
+
+    try:
+        return int(esc, 16), end + 4
+    except ValueError:
+        raise json.JSONDecodeError(msg, s, end - 2) from None
+
+
+_STRING_CHUNK_PAT = re.compile(r'(.*?)(["\\\x00-\x1f])', re.VERBOSE | re.MULTILINE | re.DOTALL)
+
+_BACKSLASH_MAP = {
+    '"': '"',
+    '\\': '\\',
+    '/': '/',
+    'b': '\b',
+    'f': '\f',
+    'n': '\n',
+    'r': '\r',
+    't': '\t',
+}
+
+
+def parse_string(
+        s: str,
+        idx: int = 0,
+        *,
+        strict: bool = True,
+) -> tuple[str, int]:
+    """
+    Scan the string s for a JSON string. Idx is the index of the quote that starts the JSON string. Unescapes all valid
+    JSON string escape sequences and raises ValueError on attempt to decode an invalid string. If strict is False then
+    literal control characters are allowed in the string.
+
+    Returns a tuple of the decoded string and the index of the character in s after the end quote.
+    """
+
+    if s[idx] != '"':
+        raise json.JSONDecodeError('No opening string quotes at', s, idx)
+
+    chunks: list[str] = []
+    end = idx + 1
+    while True:
+        chunk = _STRING_CHUNK_PAT.match(s, end)
+        if chunk is None:
+            raise json.JSONDecodeError('Unterminated string starting at', s, idx)
+
+        prev_end = end
+        end = chunk.end()
+        content, terminator = chunk.groups()
+        # Content is contains zero or more unescaped string characters
+        if content:
+            chunks.append(content)
+
+        # Terminator is the end of string, a literal control character, or a backslash denoting that an escape sequence
+        # follows
+        if terminator == '"':
+            break
+        elif terminator != '\\':
+            if strict:
+                msg = 'Invalid control character %r at'
+                raise json.JSONDecodeError(msg, s, prev_end)
+            else:
+                chunks.append(terminator)
+                continue
+
+        try:
+            esc = s[end]
+        except IndexError:
+            raise json.JSONDecodeError('Unterminated string starting at', s, idx) from None
+
+        # If not a unicode escape sequence, must be in the lookup table
+        if esc != 'u':
+            try:
+                char = _BACKSLASH_MAP[esc]
+            except KeyError:
+                msg = 'Invalid \\X escape sequence %r'
+                raise json.JSONDecodeError(msg, s, end) from None
+            end += 1
+
+        else:
+            # Unicode escape sequence
+            uni, end = _scan_four_digit_hex(s, end + 1)
+
+            # Check for surrogate pair on UCS-4 systems Note that this will join high/low surrogate pairs but will also
+            # pass unpaired surrogates through
+            if (
+                    sys.maxunicode > 65535 and
+                    uni & 0xFC00 == 0xD800 and
+                    s[end: end + 2] == '\\u'
+            ):
+                uni2, end2 = _scan_four_digit_hex(s, end + 2)
+                if uni2 & 0xFC00 == 0xDC00:
+                    uni = 0x10000 + (((uni - 0xD800) << 10) | (uni2 - 0xDC00))
+                    end = end2
+
+            char = chr(uni)
+
+        # Append the unescaped character
+        chunks.append(char)
+
+    return ''.join(chunks), end
+
+
+def try_parse_string(
+        s: str,
+        idx: int = 0,
+        *,
+        strict: bool = True,
+) -> tuple[str, int] | None:
+    if not s or s[idx] != '"':
+        return None
+
+    return parse_string(s, idx, strict=strict)
+
+
+##
+
+
+_NUMBER_PAT = re.compile(
+    r'(-?(?:0|[1-9]\d*))(\.\d+)?([eE][-+]?\d+)?',
+    (re.VERBOSE | re.MULTILINE | re.DOTALL),
+)
+
+
+def try_parse_number(
+        s: str,
+        idx: int = 0,
+        *,
+        parse_float: ta.Callable[[str], float] = float,
+        parse_int: ta.Callable[[str], int] = int,
+) -> tuple[int | float, int] | None:
+    if (m := _NUMBER_PAT.match(s, idx)) is None:
+        return None
+
+    integer, frac, exp = m.groups()
+    if frac or exp:
+        res = parse_float(integer + (frac or '') + (exp or ''))
+    else:
+        res = parse_int(integer)
+    return res, m.end()

omlish/formats/json/render.py

@@ -6,12 +6,11 @@ import typing as ta
 
 from ... import lang
 from . import consts
+from .types import SCALAR_TYPES
+from .types import Scalar
 
 
 I = ta.TypeVar('I')
-Scalar: ta.TypeAlias = bool | int | float | str | None
-
-SCALAR_TYPES: tuple[type, ...] = (bool, int, float, str, type(None))
 
 MULTILINE_SEPARATORS = consts.Separators(',', ': ')
 

omlish/formats/json/stream/render.py

@@ -1,8 +1,8 @@
 import io
 import typing as ta
 
-from ..render import SCALAR_TYPES
 from ..render import AbstractJsonRenderer
+from ..types import SCALAR_TYPES
 from .parse import BeginArray
 from .parse import BeginObject
 from .parse import EndArray

omlish/formats/json/types.py

@@ -0,0 +1,6 @@
+import typing as ta
+
+
+Scalar: ta.TypeAlias = bool | int | float | str | None
+
+SCALAR_TYPES: tuple[type, ...] = (bool, int, float, str, type(None))

omlish/lang/classes/abstract.py

@@ -7,6 +7,10 @@ T = ta.TypeVar('T')
 
 _DISABLE_CHECKS = False
 
+_ABSTRACT_METHODS_ATTR = '__abstractmethods__'
+_IS_ABSTRACT_METHOD_ATTR = '__isabstractmethod__'
+_FORCE_ABSTRACT_ATTR = '__forceabstract__'
+
 
 def make_abstract(obj: T) -> T:
     if callable(obj):
@@ -29,13 +33,13 @@ class Abstract(abc.ABC):  # noqa
     def __forceabstract__(self):
         raise TypeError
 
-    setattr(__forceabstract__, '__isabstractmethod__', True)
+    setattr(__forceabstract__, _IS_ABSTRACT_METHOD_ATTR, True)
 
     def __init_subclass__(cls, **kwargs: ta.Any) -> None:
         if Abstract in cls.__bases__:
-            cls.__forceabstract__ = Abstract.__forceabstract__  # type: ignore
+            setattr(cls, _FORCE_ABSTRACT_ATTR, getattr(Abstract, _FORCE_ABSTRACT_ATTR))
         else:
-            cls.__forceabstract__ = False  # type: ignore
+            setattr(cls, _FORCE_ABSTRACT_ATTR, False)
 
         super().__init_subclass__(**kwargs)
 
@@ -43,7 +47,7 @@ class Abstract(abc.ABC):  # noqa
             ams = {a for a, o in cls.__dict__.items() if is_abstract_method(o)}
             seen = set(cls.__dict__)
             for b in cls.__bases__:
-                ams.update(set(getattr(b, '__abstractmethods__', [])) - seen)
+                ams.update(set(getattr(b, _ABSTRACT_METHODS_ATTR, [])) - seen)
                 seen.update(dir(b))
             if ams:
                 raise TypeError(
@@ -53,18 +57,18 @@ class Abstract(abc.ABC):  # noqa
 
 
 def is_abstract_method(obj: ta.Any) -> bool:
-    return bool(getattr(obj, '__isabstractmethod__', False))
+    return bool(getattr(obj, _IS_ABSTRACT_METHOD_ATTR, False))
 
 
 def is_abstract_class(obj: ta.Any) -> bool:
-    if bool(getattr(obj, '__abstractmethods__', [])):
+    if bool(getattr(obj, _ABSTRACT_METHODS_ATTR, [])):
         return True
     if isinstance(obj, type):
         if Abstract in obj.__bases__:
             return True
         if (
                 Abstract in obj.__mro__
-                and getattr(obj.__dict__.get('__forceabstract__', None), '__isabstractmethod__', False)
+                and getattr(obj.__dict__.get(_FORCE_ABSTRACT_ATTR, None), _IS_ABSTRACT_METHOD_ATTR, False)
         ):
             return True
     return False
@@ -75,13 +79,32 @@ def is_abstract(obj: ta.Any) -> bool:
 
 
 def unabstract_class(
-        impls: ta.Iterable[tuple[str, ta.Any]],
-) -> ta.Callable[[type[T]], type[T]]:
+        members: ta.Iterable[str | tuple[str, ta.Any]],
+):  # -> ta.Callable[[type[T]], type[T]]:
     def inner(cls):
-        for name, impl in impls:
-            if isinstance(impl, str):
-                impl = getattr(cls, impl)
-            setattr(cls, name, impl)
-        setattr(cls, '__abstractmethods__', frozenset())
+        if isinstance(members, str):
+            raise TypeError(members)
+
+        ams = getattr(cls, _ABSTRACT_METHODS_ATTR)
+
+        names: set[str] = set()
+        for m in members:
+            if isinstance(m, str):
+                if m not in ams:
+                    raise NameError(m)
+                getattr(cls, m)
+                names.add(m)
+
+            elif isinstance(m, tuple):
+                name, impl = m
+                if name not in ams:
+                    raise NameError(name)
+                if isinstance(impl, str):
+                    impl = getattr(cls, impl)
+                setattr(cls, name, impl)
+                names.add(name)
+
+        setattr(cls, _ABSTRACT_METHODS_ATTR, ams - names)
         return cls
+
     return inner

omlish/lang/imports.py

@@ -312,7 +312,7 @@ class _ProxyInit:
         try:
             mod = self._mods_by_pkgs[pkg]
         except KeyError:
-            mod = importlib.import_module(pkg, package=self.name_package.package)
+            mod = importlib.import_module(pkg, package=self._name_package.package)
 
         val = getattr(mod, attr)
 

omlish/lang/maybes.py

@@ -50,15 +50,15 @@ class Maybe(abc.ABC, ta.Generic[T]):
         raise NotImplementedError
 
     @abc.abstractmethod
-    def or_else(self, other: T) -> 'Maybe[T]':
+    def or_else(self, other: T) -> T:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def or_else_get(self, supplier: ta.Callable[[], T]) -> 'Maybe[T]':
+    def or_else_get(self, supplier: ta.Callable[[], T]) -> T:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def or_else_raise(self, exception_supplier: ta.Callable[[], Exception]) -> 'Maybe[T]':
+    def or_else_raise(self, exception_supplier: ta.Callable[[], Exception]) -> T:
         raise NotImplementedError
 
 
@@ -98,9 +98,7 @@ class _Maybe(Maybe[T], tuple):
 
     def map(self, mapper: ta.Callable[[T], U]) -> Maybe[U]:
         if self:
-            value = mapper(self[0])
-            if value is not None:
-                return just(value)
+            return just(mapper(self[0]))
         return _empty  # noqa
 
     def flat_map(self, mapper: ta.Callable[[T], Maybe[U]]) -> Maybe[U]:
@@ -111,15 +109,15 @@ class _Maybe(Maybe[T], tuple):
             return value
         return _empty  # noqa
 
-    def or_else(self, other: T) -> Maybe[T]:
-        return self if self else just(other)
+    def or_else(self, other: T) -> T:
+        return self.must() if self else other
 
-    def or_else_get(self, supplier: ta.Callable[[], T]) -> Maybe[T]:
-        return self if self else just(supplier())
+    def or_else_get(self, supplier: ta.Callable[[], T]) -> T:
+        return self.must() if self else supplier()
 
-    def or_else_raise(self, exception_supplier: ta.Callable[[], Exception]) -> Maybe[T]:
+    def or_else_raise(self, exception_supplier: ta.Callable[[], Exception]) -> T:
         if self:
-            return self
+            return self.must()
         raise exception_supplier()