omlish 0.0.0.dev450__tar.gz → 0.0.0.dev452__tar.gz

{omlish-0.0.0.dev450/omlish.egg-info → omlish-0.0.0.dev452}/PKG-INFO

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

{omlish-0.0.0.dev450 → omlish-0.0.0.dev452}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev450'
-__revision__ = '06a2dac5a7edcb1d06e2cc83c467c9b78d637e60'
+__version__ = '0.0.0.dev452'
+__revision__ = '85534912bc13f26aa289d4d012b6bf27695609c5'
 
 
 #

{omlish-0.0.0.dev450 → omlish-0.0.0.dev452}/omlish/bootstrap/_marshal.py

@@ -8,7 +8,7 @@ from .harness import BOOTSTRAP_TYPES_BY_NAME
 
 
 @lang.static_init
-def _install_standard_marshalling() -> None:
+def _install_standard_marshaling() -> None:
     cfgs_poly = msh.Polymorphism(
         Bootstrap.Config,
         [msh.Impl(b.Config, n) for n, b in BOOTSTRAP_TYPES_BY_NAME.items()],

{omlish-0.0.0.dev450 → omlish-0.0.0.dev452}/omlish/diag/pycharm.py

@@ -191,9 +191,23 @@ def pycharm_remote_debugger_attach(prd: PycharmRemoteDebugger) -> None:
     else:
         pydevd_pycharm = _import_pydevd_pycharm(version=version)
 
+    import inspect
+    st_sig = inspect.signature(pydevd_pycharm.settrace)
+
+    kw: dict = {}
+    if 'stdoutToServer' in st_sig.parameters:
+        kw.update(
+            stdoutToServer=True,
+            stderrToServer=True,
+        )
+    else:
+        kw.update(
+            stdout_to_server=True,
+            stderr_to_server=True,
+        )
+
     pydevd_pycharm.settrace(
         host,
         port=prd.port,
-        stdoutToServer=True,
-        stderrToServer=True,
+        **kw,
     )

{omlish-0.0.0.dev450 → omlish-0.0.0.dev452}/omlish/diag/pydevd.py

@@ -119,7 +119,19 @@ def _pydevd() -> types.ModuleType | None:
 
 
 def is_present() -> bool:
-    return lang.can_import('pydevd')
+    # FIXME: try to use `lang.can_import('pydevd'), but raises with:
+    # INTERNALERROR>   File "/Users/spinlock/src/wrmsr/omlish/omlish/lang/imports/resolving.py", line 16, in can_import
+    # INTERNALERROR>     spec = importlib.util.find_spec(name, package)
+    # INTERNALERROR>   File "<frozen importlib.util>", line 111, in find_spec
+    # INTERNALERROR> ValueError: pydevd.__spec__ is None
+    # Really want to avoid actually importing pydevd due to side-effects, slowness, and even a pkg_resources deprecation
+    # warning...
+    try:
+        __import__('pydevd')
+    except ImportError:
+        return False
+    else:
+        return True
 
 
 def get_setup() -> dict | None:

{omlish-0.0.0.dev450 → omlish-0.0.0.dev452}/omlish/formats/dotenv.py

@@ -584,7 +584,7 @@ def dotenv_values(
     For example, `foo=bar` results in `{"foo": "bar"}` whereas `foo` alone results in
     `{"foo": None}`
 
-    Parameters:
+    Args:
         path: Absolute or relative path to the .env file.
         stream: `StringIO` object with .env content, used if `path` is `None`.
         verbose: Whether to output a warning if the .env file is missing.

{omlish-0.0.0.dev450 → omlish-0.0.0.dev452}/omlish/funcs/match.py

@@ -5,6 +5,8 @@ TODO:
  - unify MatchFnClass with dispatch.method?
   - __call__ = mfs.method(); @__call__.register(lambda: ...) def _call_... ?
   - not really the same thing, dispatch is unordered this is necessarily ordered
+  - !! well.. unify interface at least?
+   - guard(*a, **k) -> bool + fn(*a, **k) -> T becomes dispatch(*a, **k) -> (Callable -> T) | None
 """
 import abc
 import dataclasses as dc

{omlish-0.0.0.dev450 → omlish-0.0.0.dev452}/omlish/lite/pycharm.py

@@ -6,7 +6,7 @@ import typing as ta
 ##
 
 
-DEFAULT_PYCHARM_VERSION = '242.23726.102'
+DEFAULT_PYCHARM_VERSION = '252.26199.168'
 
 
 @dc.dataclass(frozen=True)

{omlish-0.0.0.dev450 → omlish-0.0.0.dev452}/omlish/marshal/__init__.py

@@ -113,6 +113,17 @@ with _lang.auto_proxy_init(globals()):
         OptionalUnmarshaler,
     )
 
+    from .composite.unions import (  # noqa
+        MatchUnionMarshaler,
+        MatchUnionUnmarshaler,
+
+        PRIMITIVE_UNION_TYPES,
+        PrimitiveUnionMarshaler,
+        PrimitiveUnionMarshalerFactory,
+        PrimitiveUnionUnmarshaler,
+        PrimitiveUnionUnmarshalerFactory,
+    )
+
     from .composite.wrapped import (  # noqa
         WrappedMarshaler,
         WrappedUnmarshaler,
@@ -197,6 +208,7 @@ with _lang.auto_proxy_init(globals()):
     )
 
     from .polymorphism.metadata import (  # noqa
+        AutoStripSuffix,
         FieldTypeTagging,
         Impl,
         Impls,
@@ -212,13 +224,8 @@ with _lang.auto_proxy_init(globals()):
     )
 
     from .polymorphism.unions import (  # noqa
-        PRIMITIVE_UNION_TYPES,
         PolymorphismUnionMarshalerFactory,
         PolymorphismUnionUnmarshalerFactory,
-        PrimitiveUnionMarshaler,
-        PrimitiveUnionMarshalerFactory,
-        PrimitiveUnionUnmarshaler,
-        PrimitiveUnionUnmarshalerFactory,
     )
 
     from .polymorphism.unmarshal import (  # noqa

{omlish-0.0.0.dev450 → omlish-0.0.0.dev452}/omlish/marshal/base/contexts.py

@@ -47,8 +47,9 @@ class MarshalContext(BaseContext, lang.Final):
 
     def make(self, o: ta.Any) -> 'Marshaler':
         rty = self._reflect(o)
+        fac = check.not_none(self.factory)
         try:
-            return check.not_none(self.factory).make_marshaler(self, rty)
+            return fac.make_marshaler(self, rty)
         except mfs.MatchGuardError:
             raise UnhandledTypeError(rty)  # noqa
 
@@ -62,8 +63,9 @@ class UnmarshalContext(BaseContext, lang.Final):
 
     def make(self, o: ta.Any) -> 'Unmarshaler':
         rty = self._reflect(o)
+        fac = check.not_none(self.factory)
         try:
-            return check.not_none(self.factory).make_unmarshaler(self, rty)
+            return fac.make_unmarshaler(self, rty)
         except mfs.MatchGuardError:
             raise UnhandledTypeError(rty)  # noqa
 

omlish-0.0.0.dev452/omlish/marshal/base/registries.py

@@ -0,0 +1,216 @@
+"""
+TODO:
+ - col.TypeMap?
+  - at least get_any
+"""
+import dataclasses as dc
+import threading
+import typing as ta
+
+from ... import lang
+
+
+##
+
+
+class RegistryItem(lang.Abstract):
+    pass
+
+
+RegistryItemT = ta.TypeVar('RegistryItemT', bound=RegistryItem)
+RegistryItemU = ta.TypeVar('RegistryItemU', bound=RegistryItem)
+
+
+class RegistrySealedError(Exception):
+    pass
+
+
+class Registry(ta.Generic[RegistryItemT]):
+    def __init__(
+            self,
+            *,
+            lock: ta.Optional[threading.RLock] = None,  # noqa
+    ) -> None:
+        super().__init__()
+
+        if lock is None:
+            lock = threading.RLock()
+        self._lock = lock
+
+        self._state: Registry._State[RegistryItemT] = Registry._State(
+            dct={},
+            id_dct={},
+            version=0,
+        )
+
+        self._sealed = False
+
+    #
+
+    @dc.dataclass(frozen=True)
+    class _KeyItems(ta.Generic[RegistryItemU]):
+        key: ta.Any
+        items: ta.Sequence[RegistryItemU] = ()
+        item_lists_by_ty: ta.Mapping[type[RegistryItemU], ta.Sequence[RegistryItemU]] = dc.field(default_factory=dict)
+
+        def add(self, *items: RegistryItemU) -> 'Registry._KeyItems[RegistryItemU]':
+            item_lists_by_ty: dict[type[RegistryItemU], list[RegistryItemU]] = {}
+
+            for i in items:
+                try:
+                    l = item_lists_by_ty[type(i)]
+                except KeyError:
+                    l = item_lists_by_ty[type(i)] = list(self.item_lists_by_ty.get(type(i), ()))
+                l.append(i)
+
+            return Registry._KeyItems(
+                self.key,
+                (*self.items, *items),
+                {**self.item_lists_by_ty, **item_lists_by_ty},
+            )
+
+    @dc.dataclass(frozen=True, kw_only=True)
+    class _State(ta.Generic[RegistryItemU]):
+        dct: ta.Mapping[ta.Any, 'Registry._KeyItems[RegistryItemU]']
+        id_dct: ta.Mapping[ta.Any, 'Registry._KeyItems[RegistryItemU]']
+        version: int
+
+        #
+
+        def register(
+                self,
+                key: ta.Any,
+                *items: RegistryItemT,
+                identity: bool = False,
+        ) -> 'Registry._State[RegistryItemU]':
+            if not items:
+                return self
+
+            sr_dct: ta.Any = self.dct if not identity else self.id_dct
+            if (sr := sr_dct.get(key)) is None:
+                sr = Registry._KeyItems(key)
+            sr = sr.add(*items)
+            new = {key: sr}
+
+            return Registry._State(
+                dct={**self.dct, **new} if not identity else self.dct,
+                id_dct={**self.id_dct, **new} if identity else self.id_dct,
+                version=self.version + 1,
+            )
+
+        #
+
+        _get_cache: dict[ta.Any, ta.Sequence[RegistryItem]] = dc.field(default_factory=dict)
+
+        def get(
+                self,
+                key: ta.Any,
+                *,
+                identity: bool | None = None,
+        ) -> ta.Sequence[RegistryItem]:
+            if identity is None:
+                try:
+                    return self._get_cache[key]
+                except KeyError:
+                    pass
+
+                ret = self._get_cache[key] = (
+                    *self.get(key, identity=True),
+                    *self.get(key, identity=False),
+                )
+                return ret
+
+            dct: ta.Any = self.dct if not identity else self.id_dct
+            try:
+                return dct[key].items
+            except KeyError:
+                return ()
+
+        _get_of_cache: dict[ta.Any, dict[type, ta.Sequence[RegistryItem]]] = dc.field(default_factory=dict)
+
+        def get_of(
+                self,
+                key: ta.Any,
+                item_ty: type[RegistryItem],
+                *,
+                identity: bool | None = None,
+        ) -> ta.Sequence[RegistryItem]:
+            if identity is None:
+                try:
+                    return self._get_of_cache[key][item_ty]
+                except KeyError:
+                    pass
+
+                ret = self._get_of_cache.setdefault(key, {})[item_ty] = (
+                    *self.get_of(key, item_ty, identity=True),
+                    *self.get_of(key, item_ty, identity=False),
+                )
+                return ret
+
+            dct: ta.Any = self.dct if not identity else self.id_dct
+            try:
+                sr = dct[key]
+            except KeyError:
+                return ()
+            return sr.item_lists_by_ty.get(item_ty, ())
+
+    def is_sealed(self) -> bool:
+        if self._sealed:
+            return True
+        with self._lock:
+            return self._sealed
+
+    def seal(self) -> ta.Self:
+        if self._sealed:
+            raise RegistrySealedError(self)
+        with self._lock:
+            self._seal()
+        return self
+
+    def _seal(self) -> None:
+        if self._sealed:
+            raise RegistrySealedError(self)
+
+        self._sealed = True
+
+    #
+
+    def register(
+            self,
+            key: ta.Any,
+            *items: RegistryItemT,
+            identity: bool = False,
+    ) -> ta.Self:
+        if not items:
+            return self
+
+        with self._lock:
+            if self._sealed:
+                raise RegistrySealedError(self)
+
+            self._state = self._state.register(
+                key,
+                *items,
+                identity=identity,
+            )
+
+        return self
+
+    #
+
+    def get(
+            self,
+            key: ta.Any,
+            *,
+            identity: bool | None = None,
+    ) -> ta.Sequence[RegistryItem]:
+        return self._state.get(key, identity=identity)
+
+    def get_of(
+            self,
+            key: ta.Any,
+            item_ty: type[RegistryItemU],
+            *,
+            identity: bool | None = None,
+    ) -> ta.Sequence[RegistryItemU]:
+        return self._state.get_of(key, item_ty, identity=identity)  # type: ignore[return-value]

{omlish-0.0.0.dev450 → omlish-0.0.0.dev452}/omlish/marshal/composite/literals.py

@@ -1,3 +1,7 @@
+"""
+TODO:
+ - squash literal unions - typing machinery doesn't
+"""
 import dataclasses as dc
 import typing as ta
 
@@ -26,7 +30,7 @@ class LiteralMarshaler(Marshaler):
 
 class LiteralMarshalerFactory(SimpleMarshalerFactory):
     def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
-        return isinstance(rty, rfl.Literal)
+        return isinstance(rty, rfl.Literal) and len(set(map(type, rty.args))) == 1
 
     def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
         lty = check.isinstance(rty, rfl.Literal)
@@ -45,7 +49,7 @@ class LiteralUnmarshaler(Unmarshaler):
 
 class LiteralUnmarshalerFactory(SimpleUnmarshalerFactory):
     def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
-        return isinstance(rty, rfl.Literal)
+        return isinstance(rty, rfl.Literal) and len(set(map(type, rty.args))) == 1
 
     def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
         lty = check.isinstance(rty, rfl.Literal)

omlish-0.0.0.dev452/omlish/marshal/composite/unions.py

@@ -0,0 +1,213 @@
+import typing as ta
+
+from ... import check
+from ... import collections as col
+from ... import dataclasses as dc
+from ... import lang
+from ... import reflect as rfl
+from ...funcs import match as mfs
+from ..base.contexts import MarshalContext
+from ..base.contexts import UnmarshalContext
+from ..base.types import Marshaler
+from ..base.types import Unmarshaler
+from ..base.values import Value
+from ..factories.simple import SimpleMarshalerFactory
+from ..factories.simple import SimpleUnmarshalerFactory
+
+
+##
+
+
+class MatchUnionMarshaler(Marshaler):
+    mmf: mfs.MultiMatchFn[[UnmarshalContext, Value], ta.Any]
+
+    def marshal(self, ctx: MarshalContext, o: ta.Any) -> Value:
+        try:
+            m = self.mmf.match(ctx, o)
+        except mfs.AmbiguousMatchesError:
+            raise ValueError(o)  # noqa
+        return m.fn(ctx, o)
+
+
+class MatchUnionUnmarshaler(Unmarshaler):
+    mmf: mfs.MultiMatchFn[[UnmarshalContext, Value], ta.Any]
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
+        try:
+            m = self.mmf.match(ctx, v)
+        except mfs.AmbiguousMatchesError:
+            raise ValueError(v)  # noqa
+        return m.fn(ctx, v)
+
+
+##
+
+
+PRIMITIVE_UNION_TYPES: tuple[type, ...] = (
+    float,
+    int,
+    str,
+    bool,
+)
+
+
+class DestructuredPrimitiveUnionType(ta.NamedTuple):
+    prim: ta.Sequence[type]
+    non_prim: ta.Sequence[rfl.Type]
+
+
+def _destructure_primitive_union_type(
+        rty: rfl.Type,
+        prim_tys: ta.Container[type] = PRIMITIVE_UNION_TYPES,
+) -> DestructuredPrimitiveUnionType | None:
+    if not isinstance(rty, rfl.Union):
+        return None
+
+    pr = col.partition(rty.args, lambda a: isinstance(a, type) and a in prim_tys)
+    if not pr.t or len(pr.f) > 1:
+        return None
+
+    return DestructuredPrimitiveUnionType(*pr)  # type: ignore[arg-type]
+
+
+#
+
+
+@dc.dataclass(frozen=True)
+class PrimitiveUnionMarshaler(Marshaler):
+    tys: ta.Sequence[type]
+    x: Marshaler | None = None
+
+    def marshal(self, ctx: MarshalContext, o: ta.Any) -> Value:
+        if type(o) not in self.tys:
+            if self.x is not None:
+                return self.x.marshal(ctx, o)
+            raise TypeError(o)
+        return o
+
+
+@dc.dataclass(frozen=True)
+class PrimitiveUnionMarshalerFactory(SimpleMarshalerFactory):
+    tys: ta.Sequence[type] = PRIMITIVE_UNION_TYPES
+
+    def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
+        return _destructure_primitive_union_type(rty, self.tys) is not None
+
+    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
+        prim, non_prim = check.not_none(_destructure_primitive_union_type(rty, self.tys))
+        return PrimitiveUnionMarshaler(
+            prim,
+            ctx.make(check.single(non_prim)) if non_prim else None,
+        )
+
+
+#
+
+
+@dc.dataclass(frozen=True)
+class PrimitiveUnionUnmarshaler(Unmarshaler):
+    tys: ta.Sequence[type]
+    x: Unmarshaler | None = None
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
+        if type(v) not in self.tys:
+            if self.x is not None:
+                return self.x.unmarshal(ctx, v)
+            raise TypeError(v)
+        return v
+
+
+@dc.dataclass(frozen=True)
+class PrimitiveUnionUnmarshalerFactory(SimpleUnmarshalerFactory):
+    tys: ta.Sequence[type] = PRIMITIVE_UNION_TYPES
+
+    def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
+        return _destructure_primitive_union_type(rty, self.tys) is not None
+
+    def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
+        prim, non_prim = check.not_none(_destructure_primitive_union_type(rty, self.tys))
+        return PrimitiveUnionUnmarshaler(
+            prim,
+            ctx.make(check.single(non_prim)) if non_prim else None,
+        )
+
+
+##
+
+
+LITERAL_UNION_TYPES: tuple[type, ...] = (
+    int,
+    str,
+)
+
+
+class DestructuredLiteralUnionType(ta.NamedTuple):
+    v_ty: type
+    lit: rfl.Literal
+    non_lit: rfl.Type
+
+
+def _destructure_literal_union_type(rty: rfl.Type) -> DestructuredLiteralUnionType | None:
+    if not isinstance(rty, rfl.Union):
+        return None
+    lits, non_lits = col.partition(rty.args, lang.isinstance_of(rfl.Literal))  # noqa
+    if len(lits) != 1 or len(non_lits) != 1:
+        return None
+    lit = check.isinstance(check.single(lits), rfl.Literal)
+    v_tys = set(map(type, lit.args))
+    if len(v_tys) != 1:
+        return None
+    [v_ty] = v_tys
+    if v_ty in rty.args or v_ty not in LITERAL_UNION_TYPES:
+        return None
+    return DestructuredLiteralUnionType(v_ty, lit, check.single(non_lits))
+
+
+#
+
+
+@dc.dataclass(frozen=True)
+class LiteralUnionMarshaler(Marshaler):
+    v_ty: type
+    l: Marshaler
+    x: Marshaler
+
+    def marshal(self, ctx: MarshalContext, o: ta.Any | None) -> Value:
+        if isinstance(o, self.v_ty):
+            return self.l.marshal(ctx, o)
+        else:
+            return self.x.marshal(ctx, o)
+
+
+class LiteralUnionMarshalerFactory(SimpleMarshalerFactory):
+    def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
+        return _destructure_literal_union_type(rty) is not None
+
+    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
+        ds = check.not_none(_destructure_literal_union_type(rty))
+        return LiteralUnionMarshaler(ds.v_ty, ctx.make(ds.lit), ctx.make(ds.non_lit))
+
+
+#
+
+
+@dc.dataclass(frozen=True)
+class LiteralUnionUnmarshaler(Unmarshaler):
+    v_ty: type
+    l: Unmarshaler
+    x: Unmarshaler
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any | None:
+        if isinstance(v, self.v_ty):
+            return self.l.unmarshal(ctx, v)  # type: ignore[arg-type]
+        else:
+            return self.x.unmarshal(ctx, v)
+
+
+class LiteralUnionUnmarshalerFactory(SimpleUnmarshalerFactory):
+    def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
+        return _destructure_literal_union_type(rty) is not None
+
+    def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
+        ds = check.not_none(_destructure_literal_union_type(rty))
+        return LiteralUnionUnmarshaler(ds.v_ty, ctx.make(ds.lit), ctx.make(ds.non_lit))

{omlish-0.0.0.dev450 → omlish-0.0.0.dev452}/omlish/marshal/factories/moduleimport/factories.py

@@ -43,11 +43,11 @@ class _ModuleImportingFactory(mfs.MatchFn[[ContextT, rfl.Type], R]):
         self._callback = callback
 
         self._lock = threading.RLock()
-        self._has_imported = False
+        self._last_mis: ta.Any = None
 
-    def _do_import(self, ctx: ContextT) -> None:
+    def _do_import(self, ctx: ContextT, mis: ta.Sequence[ModuleImport]) -> None:
         c = 0
-        for mi in ctx.config_registry.get_of(None, ModuleImport):
+        for mi in mis:
             if mi.import_if_necessary():
                 c += 1
 
@@ -56,13 +56,11 @@ class _ModuleImportingFactory(mfs.MatchFn[[ContextT, rfl.Type], R]):
                 self._callback()
 
     def _import_if_necessary(self, ctx: ContextT) -> None:
-        # FIXME:
-        # if not self._has_imported:
-        #     with self._lock:
-        #         if not self._has_imported:
-        #             self._do_import(ctx)
-        #             self._has_imported = True
-        self._do_import(ctx)
+        if (mis := ctx.config_registry.get_of(None, ModuleImport)) and mis is not self._last_mis:
+            with self._lock:
+                if (mis := ctx.config_registry.get_of(None, ModuleImport)) and mis is not self._last_mis:
+                    self._do_import(ctx, mis)
+                    self._last_mis = mis
 
     def guard(self, ctx: ContextT, rty: rfl.Type) -> bool:
         self._import_if_necessary(ctx)