omlish 0.0.0.dev315__py3-none-any.whl → 0.0.0.dev317__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev315'
-__revision__ = '9f4bb119f0561532694288dd8bb808ce67ebb43d'
+__version__ = '0.0.0.dev317'
+__revision__ = 'fde65227a86537b0442352985307b74b7376b98e'
 
 
 #

omlish/collections/utils.py

@@ -58,13 +58,33 @@ def unique(
 ##
 
 
+@ta.overload
+def make_map(
+        kvs: ta.Iterable[tuple[K, V]],
+        *,
+        identity: ta.Literal[False] = False,
+        strict: bool = False,
+) -> dict[K, V]:
+    ...
+
+
+@ta.overload
 def make_map(
         kvs: ta.Iterable[tuple[K, V]],
         *,
         identity: bool = False,
         strict: bool = False,
 ) -> ta.MutableMapping[K, V]:
-    d: ta.MutableMapping[K, V] = IdentityKeyDict() if identity else {}
+    ...
+
+
+def make_map(
+        kvs,
+        *,
+        identity=False,
+        strict=False,
+):
+    d: ta.MutableMapping = IdentityKeyDict() if identity else {}
     for k, v in kvs:
         if k in d:
             if strict:
@@ -74,6 +94,21 @@ def make_map(
     return d
 
 
+#
+
+
+@ta.overload
+def make_map_by(
+        fn: ta.Callable[[V], K],
+        vs: ta.Iterable[V],
+        *,
+        identity: ta.Literal[False] = False,
+        strict: bool = False,
+) -> dict[K, V]:
+    ...
+
+
+@ta.overload
 def make_map_by(
         fn: ta.Callable[[V], K],
         vs: ta.Iterable[V],
@@ -81,6 +116,16 @@ def make_map_by(
         identity: bool = False,
         strict: bool = False,
 ) -> ta.MutableMapping[K, V]:
+    ...
+
+
+def make_map_by(
+        fn,
+        vs,
+        *,
+        identity=False,
+        strict=False,
+):
     return make_map(
         ((fn(v), v) for v in vs),
         identity=identity,
@@ -91,9 +136,30 @@ def make_map_by(
 ##
 
 
-def multi_map(kvs: ta.Iterable[tuple[K, V]], *, identity: bool = False) -> ta.MutableMapping[K, list[V]]:
-    d: ta.MutableMapping[K, list[V]] = IdentityKeyDict() if identity else {}
-    l: list[V]
+@ta.overload
+def multi_map(
+        kvs: ta.Iterable[tuple[K, V]],
+        *,
+        identity: ta.Literal[False] = False,
+) -> dict[K, list[V]]:
+    ...
+
+
+@ta.overload
+def multi_map(
+        kvs: ta.Iterable[tuple[K, V]],
+        *,
+        identity: bool = False,
+) -> ta.MutableMapping[K, list[V]]:
+    ...
+
+
+def multi_map(
+        kvs,
+        *,
+        identity=False,
+):
+    d: ta.MutableMapping = IdentityKeyDict() if identity else {}
     for k, v in kvs:
         try:
             l = d[k]
@@ -103,7 +169,35 @@ def multi_map(kvs: ta.Iterable[tuple[K, V]], *, identity: bool = False) -> ta.Mu
     return d
 
 
-def multi_map_by(fn: ta.Callable[[V], K], vs: ta.Iterable[V], *, identity: bool = False) -> ta.MutableMapping[K, list[V]]:  # noqa
+#
+
+
+@ta.overload
+def multi_map_by(
+        fn: ta.Callable[[V], K],
+        vs: ta.Iterable[V],
+        *,
+        identity: ta.Literal[False] = False,
+) -> dict[K, list[V]]:  # noqa
+    ...
+
+
+@ta.overload
+def multi_map_by(
+        fn: ta.Callable[[V], K],
+        vs: ta.Iterable[V],
+        *,
+        identity: bool = False,
+) -> ta.MutableMapping[K, list[V]]:  # noqa
+    ...
+
+
+def multi_map_by(
+        fn,
+        vs,
+        *,
+        identity=False,
+):
     return multi_map(((fn(v), v) for v in vs), identity=identity)
 
 

omlish/formats/json/encoding.py

@@ -1,6 +1,9 @@
 import json
 
 
+##
+
+
 detect_encoding = json.detect_encoding
 
 

omlish/formats/json/literals.py

@@ -15,6 +15,7 @@
 # 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/encoder.py
 # https://github.com/simplejson/simplejson/blob/6932004966ab70ef47250a2b3152acd8c904e6b5/simplejson/scanner.py
 import json
 import re
@@ -25,6 +26,91 @@ import typing as ta
 ##
 
 
+_ESCAPE_PAT = re.compile(r'[\x00-\x1f\\"]')
+_ESCAPE_ASCII_PAT = re.compile(r'([\\"]|[^\ -~])')
+
+ESCAPE_MAP: ta.Mapping[str, str] = {
+    **{
+        chr(i): f'\\u{i:04x}'
+        for i in range(0x20)
+    },
+    '\\': '\\\\',
+    '"': '\\"',
+    '\b': '\\b',
+    '\f': '\\f',
+    '\n': '\\n',
+    '\r': '\\r',
+    '\t': '\\t',
+}
+
+
+def _convert_to_string(s: str | bytes) -> str:
+    if isinstance(s, bytes):
+        return str(s, 'utf-8')
+
+    elif type(s) is not str:
+        # Convert a str subclass instance to exact str. Raise a TypeError otherwise.
+        return str.__str__(s)
+
+    else:
+        return s
+
+
+def encode_string(
+        s: str | bytes,
+        q: str = '"',
+        *,
+        escape_map: ta.Mapping[str, str] | None = None,
+) -> str:
+    """Return a JSON representation of a Python string."""
+
+    if escape_map is None:
+        escape_map = ESCAPE_MAP
+
+    s = _convert_to_string(s)
+
+    def replace(m):
+        return escape_map[m.group(0)]
+
+    return q + _ESCAPE_PAT.sub(replace, s) + q
+
+
+def encode_string_ascii(
+        s: str | bytes,
+        q: str = '"',
+        *,
+        escape_map: ta.Mapping[str, str] | None = None,
+) -> str:
+    """Return an ASCII-only JSON representation of a Python string."""
+
+    if escape_map is None:
+        escape_map = ESCAPE_MAP
+
+    s = _convert_to_string(s)
+
+    def replace(m):
+        s = m.group(0)
+
+        try:
+            return escape_map[s]
+
+        except KeyError:
+            n = ord(s)
+            if n < 0x10000:
+                return f'\\u{n:04x}'
+
+            # surrogate pair
+            n -= 0x10000
+            s1 = 0xD800 | ((n >> 10) & 0x3FF)
+            s2 = 0xDC00 | (n & 0x3FF)
+            return f'\\u{s1:04x}\\u{s2:04x}'
+
+    return q + str(_ESCAPE_ASCII_PAT.sub(replace, s)) + q
+
+
+##
+
+
 _FOUR_DIGIT_HEX_PAT = re.compile(r'^[0-9a-fA-F]{4}$')
 
 
@@ -32,7 +118,7 @@ def _scan_four_digit_hex(
         s: str,
         end: int,
 ):
-    """Scan a four digit hex number from s[end:end + 4]"""
+    """Scan a four digit hex number from s[end:end + 4]."""
 
     msg = 'Invalid \\uXXXX escape sequence'
     esc = s[end: end + 4]
@@ -47,7 +133,7 @@ def _scan_four_digit_hex(
 
 _STRING_CHUNK_PAT = re.compile(r'(.*?)(["\\\x00-\x1f])', re.VERBOSE | re.MULTILINE | re.DOTALL)
 
-_BACKSLASH_MAP = {
+BACKSLASH_MAP: ta.Mapping[str, str] = {
     '"': '"',
     '\\': '\\',
     '/': '/',
@@ -86,7 +172,7 @@ def parse_string(
         prev_end = end
         end = chunk.end()
         content, terminator = chunk.groups()
-        # Content is contains zero or more unescaped string characters
+        # Content contains zero or more unescaped string characters
         if content:
             chunks.append(content)
 
@@ -110,7 +196,7 @@ def parse_string(
         # If not a unicode escape sequence, must be in the lookup table
         if esc != 'u':
             try:
-                char = _BACKSLASH_MAP[esc]
+                char = BACKSLASH_MAP[esc]
             except KeyError:
                 msg = 'Invalid \\X escape sequence %r'
                 raise json.JSONDecodeError(msg, s, end) from None

omlish/formats/json/rendering.py

@@ -12,12 +12,13 @@ from .types import Scalar
 
 I = ta.TypeVar('I')
 
-MULTILINE_SEPARATORS = consts.Separators(',', ': ')
-
 
 ##
 
 
+MULTILINE_SEPARATORS = consts.Separators(',', ': ')
+
+
 class AbstractJsonRenderer(lang.Abstract, ta.Generic[I]):
     class State(enum.Enum):
         VALUE = enum.auto()
@@ -25,6 +26,7 @@ class AbstractJsonRenderer(lang.Abstract, ta.Generic[I]):
 
     def __init__(
             self,
+            *,
             indent: int | str | None = None,
             separators: tuple[str, str] | None = None,
             sort_keys: bool = False,

omlish/formats/json5/rendering.py

@@ -0,0 +1,44 @@
+import typing as ta
+
+from ..json import Scalar
+from ..json.literals import ESCAPE_MAP
+from ..json.literals import encode_string
+from ..json.literals import encode_string_ascii
+from ..json.rendering import JsonRenderer
+from ..json.rendering import JsonRendererOut
+
+
+##
+
+
+MULTILINE_STRINGS_ESCAPE_MAP = {
+    **ESCAPE_MAP,
+    '\n': '\\n\\\n',
+}
+
+
+class Json5Renderer(JsonRenderer):
+    def __init__(
+            self,
+            out: JsonRendererOut,
+            *,
+            multiline_strings: bool = False,
+            **kwargs: ta.Any,
+    ) -> None:
+        super().__init__(out, **kwargs)
+
+        self._multiline_strings = multiline_strings
+
+    def _format_scalar(self, o: Scalar) -> str:
+        if (
+                self._multiline_strings and
+                isinstance(o, str) and
+                '\n' in o
+        ):
+            if self._ensure_ascii:
+                return encode_string_ascii(o, escape_map=MULTILINE_STRINGS_ESCAPE_MAP)
+            else:
+                return encode_string(o, escape_map=MULTILINE_STRINGS_ESCAPE_MAP)
+
+        else:
+            return super()._format_scalar(o)

omlish/http/coro/server.py

@@ -56,8 +56,7 @@ import abc
 import dataclasses as dc
 import email.utils
 import html
-import http.client
-import http.server
+import http
 import io
 import textwrap
 import time

omlish/lang/__init__.py

@@ -225,13 +225,6 @@ from .iterables import (  # noqa
     take,
 )
 
-from .maybes import (  # noqa
-    Maybe,
-    empty,
-    just,
-    maybe,
-)
-
 from .objects import (  # noqa
     Identity,
     SimpleProxy,
@@ -341,6 +334,13 @@ from ..lite.imports import (  # noqa
     import_module_attr,
 )
 
+from ..lite.maybes import (  # noqa
+    Maybe,
+)
+
+empty = Maybe.empty
+just = Maybe.just
+
 from ..lite.reprs import (  # noqa
     AttrRepr,
     attr_repr,

omlish/lang/cached/function.py

@@ -22,6 +22,7 @@ TODO:
 import dataclasses as dc
 import functools
 import inspect
+import types
 import typing as ta
 
 from ..classes.abstract import Abstract
@@ -153,6 +154,10 @@ def _make_cache_key_maker(
 ##
 
 
+class _CachedException(ta.NamedTuple):
+    ex: BaseException
+
+
 class _CachedFunction(ta.Generic[T], Abstract):
     @dc.dataclass(frozen=True, kw_only=True)
     class Opts:
@@ -160,6 +165,19 @@ class _CachedFunction(ta.Generic[T], Abstract):
         lock: DefaultLockable = None
         transient: bool = False
         no_wrapper_update: bool = False
+        cache_exceptions: type[BaseException] | tuple[type[BaseException], ...] | None = None
+
+        def __post_init__(self) -> None:
+            if (ce := self.cache_exceptions) is not None:
+                if isinstance(ce, type):
+                    if not issubclass(ce, BaseException):
+                        raise TypeError(ce)
+                elif isinstance(ce, tuple):
+                    for e in ce:
+                        if not issubclass(e, BaseException):
+                            raise TypeError(e)
+                else:
+                    raise TypeError(ce)
 
     def __init__(
             self,
@@ -199,13 +217,33 @@ class _CachedFunction(ta.Generic[T], Abstract):
     def __call__(self, *args, **kwargs) -> T:
         k = self._key_maker(*args, **kwargs)
 
-        try:
-            return self._values[k]
-        except KeyError:
-            pass
+        if (ce := self._opts.cache_exceptions) is None:
+            try:
+                return self._values[k]
+            except KeyError:
+                pass
 
-        def call_value_fn():
-            return self._value_fn(*args, **kwargs)
+        else:
+            try:
+                hit = self._values[k]
+            except KeyError:
+                pass
+            else:
+                if isinstance(hit, _CachedException):
+                    raise hit.ex
+                else:
+                    return hit
+
+        if ce is None:
+            def call_value_fn():
+                return self._value_fn(*args, **kwargs)
+
+        else:
+            def call_value_fn():
+                try:
+                    return self._value_fn(*args, **kwargs)
+                except ce as ex:  # type: ignore[misc]
+                    return _CachedException(ex)
 
         if self._lock is not None:
             with self._lock:
@@ -220,7 +258,11 @@ class _CachedFunction(ta.Generic[T], Abstract):
             value = call_value_fn()
 
         self._values[k] = value
-        return value
+
+        if isinstance(value, _CachedException):
+            raise value.ex
+        else:
+            return value
 
 
 #
@@ -369,12 +411,27 @@ def cached_function(fn=None, **kwargs):  # noqa
 
     opts = _CachedFunction.Opts(**kwargs)
 
+    if isinstance(fn, types.MethodType):
+        return _FreeCachedFunction(
+            fn,
+            opts=opts,
+            key_maker=_make_cache_key_maker(fn, bound=True),
+        )
+
     if isinstance(fn, staticmethod):
-        return _FreeCachedFunction(fn, opts=opts, value_fn=unwrap_func(fn))
+        return _FreeCachedFunction(
+            fn,
+            opts=opts,
+            value_fn=unwrap_func(fn),
+        )
 
     scope = classmethod if isinstance(fn, classmethod) else None
 
-    return _DescriptorCachedFunction(fn, scope, opts=opts)
+    return _DescriptorCachedFunction(
+        fn,
+        scope,
+        opts=opts,
+    )
 
 
 def static_init(fn: CallableT) -> CallableT:

omlish/lang/generators.py

@@ -2,10 +2,8 @@ import abc
 import functools
 import typing as ta
 
+from ..lite.maybes import Maybe
 from .classes.restrict import Abstract
-from .maybes import Maybe
-from .maybes import empty
-from .maybes import just
 
 
 T = ta.TypeVar('T')
@@ -203,7 +201,7 @@ class GeneratorMappedIterator(ta.Generic[O, I, R]):
 
         self._g = g
         self._it = it
-        self._value: Maybe[R] = empty()
+        self._value: Maybe[R] = Maybe.empty()
 
     @property
     def g(self) -> ta.Generator[O, I, R]:
@@ -225,7 +223,7 @@ class GeneratorMappedIterator(ta.Generic[O, I, R]):
         try:
             o = self._g.send(i)
         except StopIteration as e:
-            self._value = just(e.value)
+            self._value = Maybe.just(e.value)
             raise StopIteration from e
         return o
 

omlish/lang/params.py

@@ -7,12 +7,10 @@ import enum
 import inspect
 import typing as ta
 
+from ..lite.maybes import Maybe
 from .classes.abstract import Abstract
 from .classes.restrict import Final
 from .classes.restrict import Sealed
-from .maybes import Maybe
-from .maybes import empty
-from .maybes import just
 
 
 T = ta.TypeVar('T')
@@ -25,7 +23,7 @@ T = ta.TypeVar('T')
 class Param(Sealed, Abstract):
     name: str
 
-    annotation: Maybe = empty()
+    annotation: Maybe = Maybe.empty()
 
     prefix: ta.ClassVar[str] = ''
 
@@ -57,7 +55,7 @@ class KwargsParam(VarParam, Final):
 
 @dc.dataclass(frozen=True, unsafe_hash=True)
 class ValParam(Param):
-    default: Maybe = empty()
+    default: Maybe = Maybe.empty()
 
 
 @dc.dataclass(frozen=True, unsafe_hash=True)
@@ -83,9 +81,9 @@ class ParamSeparator(enum.Enum):
 
 def _inspect_empty_to_maybe(o: T) -> Maybe[T]:
     if o is inspect.Parameter.empty:
-        return empty()
+        return Maybe.empty()
     else:
-        return just(o)
+        return Maybe.just(o)
 
 
 class ParamSpec(ta.Sequence[Param], Final):
@@ -119,8 +117,8 @@ class ParamSpec(ta.Sequence[Param], Final):
             if i < offset:
                 continue
 
-            ann = _inspect_empty_to_maybe(ip.annotation) if not strip_annotations else empty()
-            dfl = _inspect_empty_to_maybe(ip.default) if not strip_defaults else empty()
+            ann = _inspect_empty_to_maybe(ip.annotation) if not strip_annotations else Maybe.empty()
+            dfl = _inspect_empty_to_maybe(ip.default) if not strip_defaults else Maybe.empty()
 
             if ip.kind == inspect.Parameter.POSITIONAL_ONLY:
                 ps.append(PosOnlyParam(ip.name, ann, dfl))