omlish 0.0.0.dev447__py3-none-any.whl → 0.0.0.dev484__py3-none-any.whl

omlish/lang/lazyglobals.py

@@ -1,3 +1,4 @@
+import threading
 import typing as ta
 
 
@@ -15,6 +16,10 @@ class AmbiguousLazyGlobalsFallbackError(Exception):
         return f'{self.__class__.__name__}({self.attr!r}, {self.fallbacks!r})'
 
 
+_LAZY_GLOBALS_LOCK = threading.RLock()
+
+
+@ta.final
 class LazyGlobals:
     def __init__(
             self,
@@ -22,8 +27,6 @@ class LazyGlobals:
             globals: ta.MutableMapping[str, ta.Any] | None = None,  # noqa
             update_globals: bool = False,
     ) -> None:
-        super().__init__()
-
         self._globals = globals
         self._update_globals = update_globals
 
@@ -37,18 +40,28 @@ class LazyGlobals:
         except KeyError:
             pass
         else:
-            if not isinstance(xga, cls):
+            if xga.__class__ is not cls:
                 raise RuntimeError(f'Module already has __getattr__ hook: {xga}')  # noqa
             return xga
 
-        lm = cls(
-            globals=globals,
-            update_globals=True,
-        )
+        with _LAZY_GLOBALS_LOCK:
+            try:
+                xga = globals['__getattr__']
+            except KeyError:
+                pass
+            else:
+                if xga.__class__ is not cls:
+                    raise RuntimeError(f'Module already has __getattr__ hook: {xga}')  # noqa
+                return xga
+
+            lm = cls(
+                globals=globals,
+                update_globals=True,
+            )
 
-        globals['__getattr__'] = lm
+            globals['__getattr__'] = lm
 
-        return lm
+            return lm
 
     def set_fn(self, attr: str, fn: ta.Callable[[], ta.Any]) -> 'LazyGlobals':
         self._attr_fns[attr] = fn

omlish/lang/params.py

@@ -1,6 +1,7 @@
 """
 TODO:
  - check validity
+ - signature vs getfullargspec - diff unwrapping + 'self' handling
 """
 import dataclasses as dc
 import enum
@@ -16,6 +17,13 @@ from .classes.restrict import Sealed
 T = ta.TypeVar('T')
 
 
+CanParamSpec: ta.TypeAlias = ta.Union[
+    'ParamSpec',
+    inspect.Signature,
+    ta.Callable,
+]
+
+
 ##
 
 
@@ -101,6 +109,15 @@ class ParamSpec(ta.Sequence[Param], Final):
 
     #
 
+    @classmethod
+    def of(cls, obj: CanParamSpec) -> 'ParamSpec':
+        if isinstance(obj, ParamSpec):
+            return obj
+        elif isinstance(obj, inspect.Signature):
+            return cls.of_signature(obj)
+        else:
+            return cls.inspect(obj)
+
     @classmethod
     def of_signature(
             cls,

omlish/lang/recursion.py

@@ -13,7 +13,6 @@ P = ta.ParamSpec('P')
 
 
 _LOCK = threading.RLock()
-
 _LOCAL: threading.local
 
 

omlish/lang/sequences.py

@@ -0,0 +1,124 @@
+"""
+TODO:
+ - StrView, BytesView - in lieu of hkt lol
+ - cext? even necessary?
+ - __eq__, cmp, __hash__
+ - __buffer__
+ - optimize `slice(None)`, keep as SeqView but fast path ops
+ - shorter repr if __len__ > some threshold
+  - use materialize()?
+"""
+import typing as ta
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+def iterslice(
+        seq: ta.Sequence[T],
+        slc: slice,
+) -> ta.Iterator[T]:
+    return map(seq.__getitem__, range(*slc.indices(len(seq))))
+
+
+def iterrange(
+        seq: ta.Sequence[T],
+        start: int | None = None,
+        stop: int | None = None,
+        step: int | None = None,
+) -> ta.Iterator[T]:
+    return iterslice(seq, slice(start, stop, step))
+
+
+##
+
+
+@ta.final
+class SeqView(ta.Sequence[T]):
+    def __init__(self, data: ta.Sequence[T], slice_: slice = slice(None)) -> None:
+        if data.__class__ is SeqView:
+            self._data = data._data  # type: ignore[attr-defined]  # noqa
+            self._range = data._range[slice_]  # type: ignore[attr-defined]  # noqa
+        else:
+            self._data = data
+            self._range = range(*slice_.indices(len(data)))
+
+    def __init_subclass__(cls, **kwargs):
+        raise TypeError
+
+    _data: ta.Sequence[T]
+    _range: range
+
+    @classmethod
+    def _from_range(cls, base: ta.Sequence[T], rng: range) -> 'SeqView[T]':
+        self = object.__new__(cls)
+        self._data = base
+        self._range = rng
+        return self
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self._data!r}, {self.slice!r})'
+
+    #
+
+    def __len__(self) -> int:
+        return len(self._range)
+
+    def __getitem__(self, key: int | slice) -> ta.Union[T, 'SeqView[T]']:  # type: ignore[override]
+        if isinstance(key, slice):
+            nr = self._range[key]
+            return SeqView._from_range(self._data, nr)
+        return self._data[self._range[key]]
+
+    def __iter__(self) -> ta.Iterator[T]:
+        return map(self._data.__getitem__, self._range)
+
+    def __reversed__(self) -> ta.Iterator[T]:
+        return map(self._data.__getitem__, reversed(self._range))
+
+    def count(self, value: ta.Any) -> int:
+        c = 0
+        for i in self._range:
+            if self._data[i] == value:
+                c += 1
+        return c
+
+    def index(self, value: ta.Any, start: int = 0, stop: int | None = None) -> int:
+        sub = self._range[slice(start, stop, 1)]
+        for off, i in enumerate(sub):
+            if self._data[i] == value:
+                return off
+        raise ValueError(f'{value!r} is not in view')
+
+    #
+
+    @property
+    def data(self) -> ta.Sequence[T]:
+        return self._data
+
+    _slice: slice
+
+    @property
+    def slice(self) -> slice:
+        try:
+            return self._slice
+        except AttributeError:
+            pass
+
+        step = self._range.step
+        start = self._range.start
+        if len(self._range) == 0:
+            stop = start
+        else:
+            last = start + (len(self._range) - 1) * step
+            stop = last + (1 if step > 0 else -1)
+        slc = slice(start, stop, step)
+
+        self._slice = slc
+        return slc
+
+    def materialize(self) -> ta.Sequence[T]:
+        return self._data[self.slice]

omlish/lite/abstract.py

@@ -3,6 +3,9 @@ import abc
 import typing as ta
 
 
+T = ta.TypeVar('T')
+
+
 ##
 
 
@@ -14,25 +17,49 @@ def is_abstract_method(obj: ta.Any) -> bool:
     return bool(getattr(obj, _IS_ABSTRACT_METHOD_ATTR, False))
 
 
-def update_abstracts(cls, *, force=False):
+def compute_abstract_methods(cls: type) -> ta.FrozenSet[str]:
+    # ~> https://github.com/python/cpython/blob/f3476c6507381ca860eec0989f53647b13517423/Modules/_abc.c#L358
+
+    # Stage 1: direct abstract methods
+
+    abstracts = {
+        a
+        # Get items as a list to avoid mutation issues during iteration
+        for a, v in list(cls.__dict__.items())
+        if is_abstract_method(v)
+    }
+
+    # Stage 2: inherited abstract methods
+
+    for base in cls.__bases__:
+        # Get __abstractmethods__ from base if it exists
+        if (base_abstracts := getattr(base, _ABSTRACT_METHODS_ATTR, None)) is None:
+            continue
+
+        # Iterate over abstract methods in base
+        for key in base_abstracts:
+            # Check if this class has an attribute with this name
+            try:
+                value = getattr(cls, key)
+            except AttributeError:
+                # Attribute not found in this class, skip
+                continue
+
+            # Check if it's still abstract
+            if is_abstract_method(value):
+                abstracts.add(key)
+
+    return frozenset(abstracts)
+
+
+def update_abstracts(cls: ta.Type[T], *, force: bool = False) -> ta.Type[T]:
     if not force and not hasattr(cls, _ABSTRACT_METHODS_ATTR):
         # Per stdlib: We check for __abstractmethods__ here because cls might by a C implementation or a python
         # implementation (especially during testing), and we want to handle both cases.
         return cls
 
-    abstracts: ta.Set[str] = set()
-
-    for scls in cls.__bases__:
-        for name in getattr(scls, _ABSTRACT_METHODS_ATTR, ()):
-            value = getattr(cls, name, None)
-            if getattr(value, _IS_ABSTRACT_METHOD_ATTR, False):
-                abstracts.add(name)
-
-    for name, value in cls.__dict__.items():
-        if getattr(value, _IS_ABSTRACT_METHOD_ATTR, False):
-            abstracts.add(name)
-
-    setattr(cls, _ABSTRACT_METHODS_ATTR, frozenset(abstracts))
+    abstracts = compute_abstract_methods(cls)
+    setattr(cls, _ABSTRACT_METHODS_ATTR, abstracts)
     return cls
 
 
@@ -86,23 +113,26 @@ class Abstract:
         super().__init_subclass__(**kwargs)
 
         if not (Abstract in cls.__bases__ or abc.ABC in cls.__bases__):
-            ams = {a: cls for a, o in cls.__dict__.items() if is_abstract_method(o)}
-
-            seen = set(cls.__dict__)
-            for b in cls.__bases__:
-                ams.update({a: b for a in set(getattr(b, _ABSTRACT_METHODS_ATTR, [])) - seen})  # noqa
-                seen.update(dir(b))
+            if ams := compute_abstract_methods(cls):
+                amd = {
+                    a: mcls
+                    for mcls in cls.__mro__[::-1]
+                    for a in ams
+                    if a in mcls.__dict__
+                }
 
-            if ams:
                 raise AbstractTypeError(
                     f'Cannot subclass abstract class {cls.__name__} with abstract methods: ' +
                     ', '.join(sorted([
                         '.'.join([
-                            *([m] if (m := getattr(c, '__module__')) else []),
-                            getattr(c, '__qualname__', getattr(c, '__name__')),
+                            *([
+                                *([m] if (m := getattr(c, '__module__')) else []),
+                                getattr(c, '__qualname__', getattr(c, '__name__')),
+                            ] if c is not None else '?'),
                             a,
                         ])
-                        for a, c in ams.items()
+                        for a in ams
+                        for c in [amd.get(a)]
                     ])),
                 )
 

omlish/lite/asyncs.py

@@ -50,12 +50,12 @@ def sync_await(aw: ta.Awaitable[T]) -> T:
 
     ret = missing = object()
 
-    async def gate():
+    async def thunk():
         nonlocal ret
 
         ret = await aw
 
-    cr = gate()
+    cr = thunk()
     try:
         try:
             cr.send(None)

omlish/lite/attrops.py

@@ -6,6 +6,8 @@ TODO:
  - per-attr repr transform / filter
  - __ne__ ? cases where it still matters
  - ordering ?
+ - repr_filter: ta.Union[ta.Callable[[ta.Any], ta.Optional[str]], ta.Literal['not_none', 'truthy']]] ?
+  - unify repr/repr_fn/repr_filter
 """
 import types  # noqa
 import typing as ta

omlish/lite/contextmanagers.py

@@ -54,7 +54,7 @@ class ExitStacked:
             es.__enter__()
             try:
                 self._enter_contexts()
-            except Exception:  # noqa
+            except BaseException:  # noqa
                 es.__exit__(*sys.exc_info())
                 raise
             return self
@@ -65,7 +65,7 @@ class ExitStacked:
             return None
         try:
             self._exit_contexts()
-        except Exception:  # noqa
+        except BaseException:  # noqa
             es.__exit__(*sys.exc_info())
             raise
         return es.__exit__(exc_type, exc_val, exc_tb)
@@ -113,7 +113,7 @@ class AsyncExitStacked:
             await es.__aenter__()
             try:
                 await self._async_enter_contexts()
-            except Exception:  # noqa
+            except BaseException:  # noqa
                 await es.__aexit__(*sys.exc_info())
                 raise
             return self
@@ -124,7 +124,7 @@ class AsyncExitStacked:
             return None
         try:
             await self._async_exit_contexts()
-        except Exception:  # noqa
+        except BaseException:  # noqa
             await es.__aexit__(*sys.exc_info())
             raise
         return await es.__aexit__(exc_type, exc_val, exc_tb)

omlish/lite/dataclasses.py

@@ -100,6 +100,36 @@ def dataclass_repr_omit_falsey(obj: ta.Any) -> str:
 ##
 
 
+def dataclass_descriptor_method(*bind_attrs: str, bind_owner: bool = False) -> ta.Callable:
+    if not bind_attrs:
+        def __get__(self, instance, owner=None):  # noqa
+            return self
+
+    elif bind_owner:
+        def __get__(self, instance, owner=None):  # noqa
+            # Guaranteed to return a new instance even with no attrs
+            return dc.replace(self, **{
+                a: v.__get__(instance, owner) if (v := getattr(self, a)) is not None else None
+                for a in bind_attrs
+            })
+
+    else:
+        def __get__(self, instance, owner=None):  # noqa
+            if instance is None:
+                return self
+
+            # Guaranteed to return a new instance even with no attrs
+            return dc.replace(self, **{
+                a: v.__get__(instance, owner) if (v := getattr(self, a)) is not None else None
+                for a in bind_attrs
+            })
+
+    return __get__
+
+
+##
+
+
 def dataclass_kw_only_init():
     def inner(cls):
         if not isinstance(cls, type) and dc.is_dataclass(cls):
@@ -161,3 +191,17 @@ def dataclass_kw_only_init():
         return cls
 
     return inner
+
+
+##
+
+
+@dc.dataclass()
+class DataclassFieldRequiredError(Exception):
+    name: str
+
+
+def dataclass_field_required(name: str) -> ta.Callable[[], ta.Any]:
+    def inner() -> ta.NoReturn:
+        raise DataclassFieldRequiredError(name)
+    return inner

omlish/lite/maybes.py

@@ -1,6 +1,7 @@
 # ruff: noqa: UP007 UP045
 import abc
 import functools
+import operator
 import typing as ta
 
 from .abstract import Abstract
@@ -208,3 +209,10 @@ class _EmptyMaybe(_Maybe[T]):
 
 
 Maybe._empty = _EmptyMaybe()  # noqa
+
+
+##
+
+
+setattr(Maybe, 'just', _JustMaybe)  # noqa
+setattr(Maybe, 'empty', functools.partial(operator.attrgetter('_empty'), Maybe))

omlish/lite/maysync.py

@@ -25,6 +25,7 @@ Internally, it's not really correct to say that there is 'no event loop' in the
 ===
 
 TODO:
+ - ! impl iterators not just generators !
  - __del__
  - (test) maysync context managers
  - CancelledError
@@ -33,11 +34,6 @@ TODO:
   - works down to 3.8
  - make_maysync_from_sync can run with asyncio.run_in_thread
  - make_maysync_from_async can run with asyncio.run_soon
-
-TODO OVERHAUL:
- - no more sync/async context, just one Context, and it means sync
- - make FpMaywaitable *not reusable*
-  - `cannot reuse already awaited coroutine`
 """
 import abc
 import inspect

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/lite/typing.py

@@ -12,6 +12,12 @@ A2 = ta.TypeVar('A2')
 
 ##
 # A workaround for typing deficiencies (like `Argument 2 to NewType(...) must be subclassable`).
+#
+# Note that this problem doesn't happen at runtime - it happens in mypy:
+#
+#   mypy <(echo "import typing as ta; MyCallback = ta.NewType('MyCallback', ta.Callable[[], None])")
+#   /dev/fd/11:1:22: error: Argument 2 to NewType(...) must be subclassable (got "Callable[[], None]")  [valid-newtype]
+#
 
 
 @dc.dataclass(frozen=True)

omlish/logs/all.py

@@ -88,7 +88,7 @@ with _lang.auto_proxy_init(globals()):
         LogTimingContext,
         log_timing_context,
 
-        error_logging,
+        exception_logging,
     )
 
     from .warnings import (  # noqa

omlish/logs/utils.py

@@ -11,7 +11,7 @@ from .protocols import LoggerLike
 ##
 
 
-def error_logging(log):  # noqa
+def exception_logging(log):  # noqa
     def outer(fn):
         @functools.wraps(fn)
         def inner(*args, **kwargs):

omlish/manifests/loading.py

@@ -13,7 +13,7 @@ TODO:
    scan_root_dirs
   - currently the cli cant subprocess itself and keep manifests working
   - EnvVar cls is already lite
-
+ - can discover_packages deadlock with concurrent / multithreaded imports?
 """
 import dataclasses as dc
 import importlib.machinery
@@ -417,6 +417,7 @@ class ManifestLoader:
     def _read_package_file_text(cls, package_name: str, file_name: str) -> ta.Optional[str]:
         # importlib.resources.files actually imports the package - to avoid this, if possible, the file is read straight
         # off the filesystem.
+        # FIXME: find_spec *still* imports the parent package to get __path__ to feed to _find_spec...
         spec = importlib.util.find_spec(package_name)
         if (
                 spec is not None and

omlish/marshal/__init__.py

@@ -49,11 +49,17 @@ with _lang.auto_proxy_init(globals()):
 
     from .base.configs import (  # noqa
         Config,
+        Configs,
+
         ConfigRegistry,
     )
 
     from .base.contexts import (  # noqa
         BaseContext,
+
+        MarshalFactoryContext,
+        UnmarshalFactoryContext,
+
         MarshalContext,
         UnmarshalContext,
     )
@@ -108,19 +114,35 @@ with _lang.auto_proxy_init(globals()):
         IterableUnmarshaler,
     )
 
+    from .composite.optionals import (  # noqa
+        OptionalMarshaler,
+        OptionalUnmarshaler,
+    )
+
+    from .composite.unions.literals import (  # noqa
+        LITERAL_UNION_TYPES,
+        LiteralUnionMarshaler,
+        LiteralUnionMarshalerFactory,
+        LiteralUnionUnmarshaler,
+        LiteralUnionUnmarshalerFactory,
+    )
+
+    from .composite.unions.primitives import (  # noqa
+        PRIMITIVE_UNION_TYPES,
+        PrimitiveUnionMarshaler,
+        PrimitiveUnionMarshalerFactory,
+        PrimitiveUnionUnmarshaler,
+        PrimitiveUnionUnmarshalerFactory,
+    )
+
     from .composite.wrapped import (  # noqa
         WrappedMarshaler,
         WrappedUnmarshaler,
     )
 
-    from .factories.simple import (  # noqa
-        SimpleMarshalerFactory,
-        SimpleUnmarshalerFactory,
-    )
-
-    from .factories.match import (  # noqa
-        MarshalerFactoryMatchClass,
-        UnmarshalerFactoryMatchClass,
+    from .factories.method import (  # noqa
+        MarshalerFactoryMethodClass,
+        UnmarshalerFactoryMethodClass,
     )
 
     from .factories.moduleimport.configs import (  # noqa
@@ -192,6 +214,7 @@ with _lang.auto_proxy_init(globals()):
     )
 
     from .polymorphism.metadata import (  # noqa
+        AutoStripSuffix,
         FieldTypeTagging,
         Impl,
         Impls,
@@ -207,13 +230,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
@@ -225,6 +243,7 @@ with _lang.auto_proxy_init(globals()):
     from .singular.base64 import (  # noqa
         BASE64_MARSHALER_FACTORY,
         BASE64_UNMARSHALER_FACTORY,
+        Base64MarshalerUnmarshaler,
     )
 
     from .singular.primitives import (  # noqa
@@ -233,6 +252,7 @@ with _lang.auto_proxy_init(globals()):
 
     from .trivial.forbidden import (  # noqa
         ForbiddenTypeMarshalerFactory,
+        ForbiddenTypeMarshalerFactoryUnmarshalerFactory,
         ForbiddenTypeUnmarshalerFactory,
     )