omlish 0.0.0.dev316__tar.gz → 0.0.0.dev318__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev316
+Version: 0.0.0.dev318
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause
@@ -41,7 +41,7 @@ Requires-Dist: aiosqlite~=0.21; extra == "all"
 Requires-Dist: asyncpg~=0.30; extra == "all"
 Requires-Dist: apsw~=3.49; extra == "all"
 Requires-Dist: sqlean.py~=3.49; extra == "all"
-Requires-Dist: duckdb~=1.2; extra == "all"
+Requires-Dist: duckdb~=1.3; extra == "all"
 Requires-Dist: markupsafe~=3.0; extra == "all"
 Requires-Dist: jinja2~=3.1; extra == "all"
 Requires-Dist: pytest~=8.3; extra == "all"
@@ -89,7 +89,7 @@ Requires-Dist: aiosqlite~=0.21; extra == "sqldrivers"
 Requires-Dist: asyncpg~=0.30; extra == "sqldrivers"
 Requires-Dist: apsw~=3.49; extra == "sqldrivers"
 Requires-Dist: sqlean.py~=3.49; extra == "sqldrivers"
-Requires-Dist: duckdb~=1.2; extra == "sqldrivers"
+Requires-Dist: duckdb~=1.3; extra == "sqldrivers"
 Provides-Extra: templates
 Requires-Dist: markupsafe~=3.0; extra == "templates"
 Requires-Dist: jinja2~=3.1; extra == "templates"

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

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev316'
-__revision__ = 'c32f4122c29baf0486a328e8d6e54beb8c47b3fc'
+__version__ = '0.0.0.dev318'
+__revision__ = 'b80bceb394abe03974e4312775224ac1dbcb5b22'
 
 
 #
@@ -103,7 +103,7 @@ class Project(ProjectBase):
 
             'sqlean.py ~= 3.49',
 
-            'duckdb ~= 1.2',
+            'duckdb ~= 1.3',
         ],
 
         'templates': [

{omlish-0.0.0.dev316 → omlish-0.0.0.dev318}/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.dev318}/omlish/dataclasses/api/classes/conversion.py

@@ -12,6 +12,8 @@ from ...specs import FieldSpec
 def std_params_to_class_spec(
         p: StdParams,
         fields: ta.Sequence[FieldSpec],
+        *,
+        metadata: ta.Sequence[ta.Any] | None = None,
 ) -> ClassSpec:
     return ClassSpec(
         fields=fields,
@@ -27,4 +29,6 @@ def std_params_to_class_spec(
         kw_only=check.isinstance(p.kw_only, bool),
         slots=check.isinstance(p.slots, bool),
         weakref_slot=check.isinstance(p.weakref_slot, bool),
+
+        metadata=metadata,
     )

{omlish-0.0.0.dev316 → omlish-0.0.0.dev318}/omlish/dataclasses/reflection.py

@@ -3,6 +3,7 @@ import typing as ta
 
 from .. import lang
 from .api.classes.conversion import std_params_to_class_spec
+from .api.classes.metadata import extract_cls_metadata
 from .api.classes.params import get_class_spec
 from .api.fields.conversion import std_field_to_field_spec
 from .concerns.fields import InitFields
@@ -49,9 +50,12 @@ class ClassReflection:
             for f in dc.fields(self._cls)  # noqa
         ]
 
+        cmd = extract_cls_metadata(self._cls, deep=True)
+
         cs = std_params_to_class_spec(
             p,
             fsl,
+            metadata=cmd.user_metadata or None,
         )
 
         return cs

{omlish-0.0.0.dev316 → omlish-0.0.0.dev318}/omlish/diag/_pycharm/runhack.py

@@ -59,6 +59,9 @@ class _cached_nullary:  # noqa
 #
 
 
+_repr = repr
+
+
 def _attr_repr(obj, *atts):
     return f'{obj.__class__.__name__}({", ".join(f"{a}={getattr(obj, a)!r}" for a in atts)})'
 
@@ -127,6 +130,109 @@ class AsJson:
 ##
 
 
+class SysModule(AttrsClass, AsJson):
+    def __init__(
+            self,
+            name,  # type: str
+            *,
+            seq=None,  # type: int | None
+            repr=None,  # type: str | None  # noqa
+
+            origin=None,  # type: str | None
+            file=None,  # type: str | None
+    ) -> None:
+        super().__init__()
+
+        self._name = name
+
+        self._seq = seq
+        self._repr = repr
+
+        self._origin = origin
+        self._file = file
+
+    __attrs__ = (
+        'name',
+
+        'seq',
+        'repr',
+
+        'origin',
+        'file',
+    )
+
+    @property
+    def name(self):  # type: () -> str
+        return self._name
+
+    @property
+    def seq(self):  # type: () -> int | None
+        return self._seq
+
+    @property
+    def repr(self):  # type: () -> str | None
+        return self._repr
+
+    @property
+    def origin(self):  # type: () -> str | None
+        return self._origin
+
+    @property
+    def file(self):  # type: () -> str | None
+        return self._file
+
+    def as_json(self):  # type: () -> dict[str, object]
+        return self.attrs_dict()
+
+
+def build_sys_module(
+        name,  # type: str
+        mod,
+        *,
+        seq=None,  # type: int | None
+) -> SysModule:
+    kwargs = dict()  # type: dict
+    kwargs.update(
+        name=name,
+
+        seq=seq,
+        repr=_repr(mod),
+    )
+
+    try:
+        spec = mod.__spec__
+    except AttributeError:
+        pass
+    else:
+        if spec is not None:
+            kwargs.update(origin=spec.origin)
+
+    try:
+        file = mod.__file__
+    except AttributeError:
+        pass
+    else:
+        kwargs.update(file=file)
+
+    return SysModule(**kwargs)
+
+
+def build_sys_modules(dct=None):  # type: (dict[str, object] | None) -> list[SysModule]
+    if dct is None:
+        dct_ = sys.modules
+    else:
+        dct_ = dct  # type: ignore
+
+    lst = []  # type: list[SysModule]
+    for i, (n, m) in enumerate(dct_.items()):
+        lst.append(build_sys_module(n, m, seq=i))
+
+    return lst
+
+
+##
+
+
 class RunEnv(AttrsClass, AsJson):
     def __init__(
             self,
@@ -143,6 +249,7 @@ class RunEnv(AttrsClass, AsJson):
             pycharm_hosted=None,  # type: bool | None
 
             sys_path=None,  # type: list[str] | None
+            sys_modules=None,  # type: list[SysModule] | None
     ) -> None:
         super().__init__()
 
@@ -182,6 +289,10 @@ class RunEnv(AttrsClass, AsJson):
             sys_path = list(sys.path)
         self._sys_path = sys_path
 
+        if sys_modules is None:
+            sys_modules = build_sys_modules()
+        self._sys_modules = sys_modules
+
     __attrs__ = (
         'argv',
         'orig_argv',
@@ -195,6 +306,7 @@ class RunEnv(AttrsClass, AsJson):
         'pycharm_hosted',
 
         'sys_path',
+        'sys_modules',
     )
 
     @property
@@ -233,8 +345,15 @@ class RunEnv(AttrsClass, AsJson):
     def sys_path(self):  # type: () -> list[str]
         return self._sys_path
 
+    @property
+    def sys_modules(self):  # type: () -> list[SysModule]
+        return self._sys_modules
+
     def as_json(self):  # type: () -> dict[str, object]
-        return self.attrs_dict()
+        return {
+            **self.attrs_dict(),
+            'sys_modules': [m.as_json() for m in self.sys_modules],
+        }
 
 
 ##

{omlish-0.0.0.dev316 → omlish-0.0.0.dev318}/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.dev318}/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.dev318/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.dev318}/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.dev318}/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.dev318}/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(