omlish 0.0.0.dev316__tar.gz → 0.0.0.dev317__tar.gz

{omlish-0.0.0.dev316/omlish.egg-info → omlish-0.0.0.dev317}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev316
+Version: 0.0.0.dev317
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev316 → omlish-0.0.0.dev317}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev316'
-__revision__ = 'c32f4122c29baf0486a328e8d6e54beb8c47b3fc'
+__version__ = '0.0.0.dev317'
+__revision__ = 'fde65227a86537b0442352985307b74b7376b98e'
 
 
 #

{omlish-0.0.0.dev316 → omlish-0.0.0.dev317}/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-0.0.0.dev316 → omlish-0.0.0.dev317}/omlish/formats/json/literals.py

@@ -29,7 +29,7 @@ import typing as ta
 _ESCAPE_PAT = re.compile(r'[\x00-\x1f\\"]')
 _ESCAPE_ASCII_PAT = re.compile(r'([\\"]|[^\ -~])')
 
-_ESCAPE_DCT = {
+ESCAPE_MAP: ta.Mapping[str, str] = {
     **{
         chr(i): f'\\u{i:04x}'
         for i in range(0x20)
@@ -56,19 +56,35 @@ def _convert_to_string(s: str | bytes) -> str:
         return s
 
 
-def encode_string(s: str | bytes, q: str = '"') -> str:
-    """Return a JSON representation of a Python string"""
+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_DCT[m.group(0)]
+        return escape_map[m.group(0)]
 
     return q + _ESCAPE_PAT.sub(replace, s) + q
 
 
-def encode_string_ascii(s: str | bytes, q: str = '"') -> str:
-    """Return an ASCII-only JSON representation of a Python string"""
+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)
 
@@ -76,7 +92,7 @@ def encode_string_ascii(s: str | bytes, q: str = '"') -> str:
         s = m.group(0)
 
         try:
-            return _ESCAPE_DCT[s]
+            return escape_map[s]
 
         except KeyError:
             n = ord(s)
@@ -102,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]
@@ -117,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] = {
     '"': '"',
     '\\': '\\',
     '/': '/',
@@ -180,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-0.0.0.dev316 → omlish-0.0.0.dev317}/omlish/formats/json/rendering.py

@@ -26,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-0.0.0.dev317/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-0.0.0.dev316 → omlish-0.0.0.dev317}/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-0.0.0.dev316 → omlish-0.0.0.dev317}/omlish/lite/maybes.py

@@ -166,9 +166,11 @@ class _JustMaybe(_Maybe[T]):
     def __repr__(self) -> str:
         return f'just({self._v!r})'
 
+    _hash: int
+
     def __hash__(self) -> int:
         try:
-            return self._hash  # type: ignore[has-type]
+            return self._hash
         except AttributeError:
             pass
         h = self._hash = hash((_JustMaybe, self._v))

{omlish-0.0.0.dev316 → omlish-0.0.0.dev317}/omlish/sockets/ports.py

@@ -16,21 +16,38 @@ DEFAULT_AVAILABLE_PORT_HOST: str = '127.0.0.1'
 
 
 @contextlib.contextmanager
-def get_available_port_context(host: ta.Optional[str] = None) -> ta.Iterator[int]:
+def get_available_port_context(
+        host: ta.Optional[str] = None,
+        family: int = socket.AF_INET,
+        type: int = socket.SOCK_STREAM,  # noqa
+        *,
+        listen: ta.Union[bool, int, None] = False,
+) -> ta.Iterator[int]:
     if host is None:
         host = DEFAULT_AVAILABLE_PORT_HOST
 
-    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+    if listen is not None:
+        if listen is True:
+            listen = 1
+        elif listen is False:
+            listen = None
+        else:
+            listen = check.isinstance(listen, int)
+
+    with socket.socket(family, type) as sock:
         sock.bind((host, 0))
-        sock.listen(1)
+
+        if listen is not None:
+            sock.listen(listen)
+
         port = sock.getsockname()[1]
+
         yield port
 
 
-def get_available_port(host: ta.Optional[str] = None) -> int:
-    with get_available_port_context(host) as port:
-        pass
-    return port
+def get_available_port(*args: ta.Any, **kwargs: ta.Any) -> int:
+    with get_available_port_context(*args, **kwargs) as port:
+        return port
 
 
 def get_available_ports(

omlish-0.0.0.dev317/omlish/testing/pytest/plugins/switches.py

@@ -0,0 +1,183 @@
+"""
+TODO:
+ - inheritance
+ - dynamic registration
+ - dynamic switching (skip docker if not running, skip online if not online, ...)
+"""
+import dataclasses as dc
+import typing as ta
+
+import pytest
+
+from .... import check
+from .... import collections as col
+from ....docker import all as docker
+from ._registry import register
+
+
+Configable: ta.TypeAlias = pytest.FixtureRequest | pytest.Config
+
+
+##
+
+
+@dc.dataclass(frozen=True, eq=False)
+class Switch:
+    name: str
+    _default_enabled: bool | ta.Callable[[], bool]
+
+    _: dc.KW_ONLY
+
+    add_marks: ta.Sequence[ta.Any] | None = None
+
+    def default_enabled(self) -> bool:
+        if isinstance(e := self._default_enabled, bool):
+            return e
+        elif callable(e):
+            return check.isinstance(e(), bool)
+        else:
+            raise TypeError(e)
+
+    @property
+    def attr(self) -> str:
+        return self.name.replace('-', '_')
+
+
+SWITCHES: ta.Sequence[Switch] = [
+    Switch(
+        'name',
+        docker.has_cli,
+    ),
+
+    Switch(
+        'docker-guest',
+        docker.is_likely_in_docker,
+    ),
+
+    Switch(
+        'online',
+        True,
+    ),
+
+    Switch(
+        'integration',
+        True,
+    ),
+
+    Switch(
+        'high-mem',
+        True,
+        add_marks=[
+            # https://pytest-xdist.readthedocs.io/en/latest/distribution.html
+            pytest.mark.xdist_group('high-mem'),
+        ],
+    ),
+
+    Switch(
+        'slow',
+        False,
+    ),
+]
+
+
+SWITCHES_BY_NAME: ta.Mapping[str, Switch] = col.make_map_by(lambda sw: sw.name, SWITCHES, strict=True)
+SWITCHES_BY_ATTR: ta.Mapping[str, Switch] = col.make_map_by(lambda sw: sw.attr, SWITCHES, strict=True)
+
+
+##
+
+
+SwitchState: ta.TypeAlias = bool | ta.Literal['only']
+
+SWITCH_STATE_OPT_PREFIXES: ta.Mapping[SwitchState, str] = {
+    True: '--',
+    False: '--no-',
+    'only': '--only-',
+}
+
+
+def _get_obj_config(obj: Configable) -> pytest.Config:
+    if isinstance(obj, pytest.Config):
+        return obj
+    elif isinstance(obj, pytest.FixtureRequest):
+        return obj.config
+    else:
+        raise TypeError(obj)
+
+
+def is_disabled(obj: Configable | None, name: str) -> bool:
+    check.isinstance(name, str)
+    check.in_(name, SWITCHES_BY_NAME)
+    return obj is not None and _get_obj_config(obj).getoption(f'--no-{name}')
+
+
+def skip_if_disabled(obj: Configable | None, name: str) -> None:
+    if is_disabled(obj, name):
+        pytest.skip(f'{name} disabled')
+
+
+def get_specified_switches(obj: Configable) -> dict[Switch, SwitchState]:
+    ret: dict[Switch, SwitchState] = {}
+    for sw in SWITCHES:
+        sts = {
+            st
+            for st, pfx in SWITCH_STATE_OPT_PREFIXES.items()
+            if _get_obj_config(obj).getoption(pfx + sw.name)
+        }
+        if sts:
+            if len(sts) > 1:
+                raise Exception(f'Multiple switches specified for {sw.name}')
+            ret[sw] = check.single(sts)
+    return ret
+
+
+@register
+class SwitchesPlugin:
+    def pytest_configure(self, config):
+        for sw in SWITCHES:
+            config.addinivalue_line('markers', f'{sw.attr}: mark test as {sw.attr}')
+            config.addinivalue_line('markers', f'not_{sw.attr}: mark test as not {sw.attr}')
+
+    def pytest_addoption(self, parser):
+        for sw in SWITCHES:
+            parser.addoption(f'--no-{sw.name}', action='store_true', default=False, help=f'disable {sw.name} tests')
+            parser.addoption(f'--{sw.name}', action='store_true', default=False, help=f'enables {sw.name} tests')
+            parser.addoption(f'--only-{sw.name}', action='store_true', default=False, help=f'enables only {sw.name} tests')  # noqa
+
+    def pytest_collection_modifyitems(self, config, items):
+        switch_states: dict[Switch, SwitchState] = {
+            **{
+                sw: sw.default_enabled()
+                for sw in SWITCHES
+            },
+            **get_specified_switches(config),
+        }
+
+        inv_switch_states: dict[SwitchState, list[Switch]] = col.multi_map((st, sw) for sw, st in switch_states.items())
+        true_switches = frozenset(inv_switch_states.get(True, ()))
+        false_switches = frozenset(inv_switch_states.get(False, ()))
+        only_switches = frozenset(inv_switch_states.get('only', ()))
+
+        def process(item):
+            item_switches = {sw for sw in SWITCHES if sw.attr in item.keywords}
+            item_not_switches = {sw for sw in SWITCHES if ('not_' + sw.attr) in item.keywords}
+
+            for sw in item_switches:
+                for mk in sw.add_marks or []:
+                    item.add_marker(mk)
+
+            if only_switches:
+                if not any(sw in only_switches for sw in item_switches):
+                    item.add_marker(pytest.mark.skip(reason=f'skipping switches {item_switches}'))
+                    return
+
+            for sw in item_switches:
+                if sw in false_switches:
+                    item.add_marker(pytest.mark.skip(reason=f'skipping switches {sw}'))
+
+            for sw in item_not_switches:
+                if sw in true_switches:
+                    item.add_marker(pytest.mark.skip(reason=f'skipping switches {sw}'))
+
+        for item in items:
+            process(item)

{omlish-0.0.0.dev316 → omlish-0.0.0.dev317/omlish.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev316
+Version: 0.0.0.dev317
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev316 → omlish-0.0.0.dev317}/omlish.egg-info/SOURCES.txt

@@ -297,6 +297,7 @@ omlish/formats/json5/codec.py
 omlish/formats/json5/errors.py
 omlish/formats/json5/literals.py
 omlish/formats/json5/parsing.py
+omlish/formats/json5/rendering.py
 omlish/formats/json5/_antlr/Json5Lexer.py
 omlish/formats/json5/_antlr/Json5Listener.py
 omlish/formats/json5/_antlr/Json5Parser.py

{omlish-0.0.0.dev316 → omlish-0.0.0.dev317}/pyproject.toml

@@ -12,7 +12,7 @@ authors = [
 urls = {source = 'https://github.com/wrmsr/omlish'}
 license = {text = 'BSD-3-Clause'}
 requires-python = '>=3.12'
-version = '0.0.0.dev316'
+version = '0.0.0.dev317'
 classifiers = [
     'License :: OSI Approved :: BSD License',
     'Development Status :: 2 - Pre-Alpha',