omlish 0.0.0.dev264__py3-none-any.whl → 0.0.0.dev266__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev264'
-__revision__ = '4a101c8e5b339dfa81732f13f8df74dec23b204f'
+__version__ = '0.0.0.dev266'
+__revision__ = '965387f5aa0862e8b1e30cbd03e24adb0a3e87bc'
 
 
 #
@@ -99,15 +99,15 @@ class Project(ProjectBase):
             'aiosqlite ~= 0.21',
             'asyncpg ~= 0.30',
 
-            'apsw ~= 3.47',
+            'apsw ~= 3.49',
 
-            'sqlean.py ~= 3.45',
+            'sqlean.py ~= 3.47',
 
             'duckdb ~= 1.2',
         ],
 
         'testing': [
-            'pytest ~= 8.0',
+            'pytest ~= 8.3',
         ],
     }
 

omlish/collections/__init__.py

@@ -57,6 +57,11 @@ from .identity import (  # noqa
     IdentityWeakSet,
 )
 
+if _ta.TYPE_CHECKING:
+    from . import kv
+else:
+    kv = _lang.proxy_import('.kv', __package__)
+
 from .mappings import (  # noqa
     MissingDict,
     TypeMap,

omlish/collections/abc.py

@@ -1,5 +1,6 @@
 # ruff: noqa: ANN204
 
+
 class Hashable:
     def __hash__(self): ...
 
@@ -156,3 +157,26 @@ class MutableMapping(Mapping):
 
 
 # endregion
+
+
+# region Views
+
+
+class MappingView(Sized):
+    @property
+    def _mapping(self): ...  # noqa
+
+
+class KeysView(MappingView, Set):
+    pass
+
+
+class ValuesView(MappingView, Collection):
+    pass
+
+
+class ItemsView(MappingView, Set):
+    pass
+
+
+# endregion

omlish/collections/cache/descriptor.py

@@ -15,6 +15,9 @@ C = ta.TypeVar('C', bound=ta.Callable)
 CC: ta.TypeAlias = ta.Callable[[C], C]
 
 
+##
+
+
 class Scope(enum.Enum):
     INSTANCE = 'INSTANCE'
     CLASS = 'CLASS'

omlish/collections/cache/impl.py

@@ -30,6 +30,9 @@ V2 = ta.TypeVar('V2')
 log = logging.getLogger(__name__)
 
 
+##
+
+
 class SKIP(lang.Marker):
     pass
 

omlish/collections/cache/types.py

@@ -6,6 +6,9 @@ K = ta.TypeVar('K')
 V = ta.TypeVar('V')
 
 
+##
+
+
 class OverweightError(Exception):
     pass
 

omlish/collections/coerce.py

@@ -12,7 +12,8 @@ K2 = ta.TypeVar('K2')
 V = ta.TypeVar('V')
 V2 = ta.TypeVar('V2')
 
-_map = map
+
+##
 
 
 def _unpack_fn(fn):

omlish/collections/frozen.py

@@ -11,6 +11,9 @@ K = ta.TypeVar('K')
 V = ta.TypeVar('V')
 
 
+##
+
+
 class Frozen(ta.Hashable, abc.ABC):
     pass
 

omlish/collections/hasheq.py

@@ -16,6 +16,9 @@ K2 = ta.TypeVar('K2')
 V2 = ta.TypeVar('V2')
 
 
+##
+
+
 class HashEq(lang.Abstract, ta.Generic[K]):
     @abc.abstractmethod
     def hash(self, k: K) -> int:

omlish/collections/identity.py

@@ -11,6 +11,9 @@ K = ta.TypeVar('K')
 V = ta.TypeVar('V')
 
 
+##
+
+
 class IdentityWrapper(ta.Generic[T]):
     def __init__(self, value: T) -> None:
         super().__init__()

omlish/collections/kv/__init__.py

@@ -0,0 +1,51 @@
+from .base import (  # noqa
+    Kv,
+    MutableKv,
+)
+
+from .capabilities import (  # noqa
+    Closeable,
+    close,
+    closing,
+
+    Flushable,
+    flush,
+)
+
+from .filtered import (  # noqa
+    KeyFilteredKv,
+    KeyFilteredMutableKv,
+
+    ValueFilteredKeyError,
+    ValueFilteredKv,
+    ValueFilteredMutableKv,
+)
+
+from .mappings import (  # noqa
+    MappingKv,
+    MappingMutableKv,
+
+    KvMapping,
+    KvMutableMapping,
+)
+
+from .transformed import (  # noqa
+    KeyTransformedKv,
+    KeyTransformedMutableKey,
+
+    ValueTransformedKv,
+    ValueTransformedMutableKv,
+)
+
+from .wrappers import (  # noqa
+    WrapperKv,
+
+    underlying,
+    underlying_of,
+
+    SimpleWrapperKv,
+    SimpleWrapperMutableKv,
+
+    UnmodifiableError,
+    UnmodifiableKv,
+)

omlish/collections/kv/base.py

@@ -0,0 +1,55 @@
+"""
+TODO:
+ - further decomp?
+  - Sized + Iterable?
+  - COM-style QueryInterface? :|
+ - OpKv
+ - table ala guava - (row key, column key) keys, sparse storage
+ - router
+ - value thunker idiom - for key-iterable-only storage, transform Kv[K, V], to Kv[K, ta.Callable[[], V]]
+ - zict classes
+  - AsyncBuffer
+  - Buffer
+  - Cache
+  - File
+  - Func
+  - LMDB
+  - LRU
+  - Sieve
+  - Zip
+"""
+import abc
+import typing as ta
+
+from ... import lang
+
+
+K = ta.TypeVar('K')
+V = ta.TypeVar('V')
+
+
+##
+
+
+class Kv(lang.Abstract, ta.Generic[K, V]):
+    @abc.abstractmethod
+    def __getitem__(self, k: K, /) -> V:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def __len__(self) -> int:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def items(self) -> ta.Iterator[tuple[K, V]]:
+        raise NotImplementedError
+
+
+class MutableKv(Kv[K, V], lang.Abstract):  # noqa
+    @abc.abstractmethod
+    def __setitem__(self, k: K, v: V, /) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def __delitem__(self, k: K, /) -> None:
+        raise NotImplementedError

omlish/collections/kv/capabilities.py

@@ -0,0 +1,46 @@
+import abc
+import contextlib
+import typing as ta
+
+from ... import lang
+from .base import Kv
+from .wrappers import underlying_of
+
+
+KvT = ta.TypeVar('KvT', bound=Kv)
+
+
+##
+
+
+class Closeable(lang.Abstract):
+    @abc.abstractmethod
+    def close(self) -> None:
+        pass
+
+
+def close(root: Kv) -> None:
+    for c in underlying_of(root, Closeable):  # type: ignore[type-abstract]
+        c.close()
+
+
+@contextlib.contextmanager
+def closing(kv: KvT) -> ta.Iterator[KvT]:
+    try:
+        yield kv
+    finally:
+        close(kv)
+
+
+##
+
+
+class Flushable(lang.Abstract):
+    @abc.abstractmethod
+    def flush(self) -> None:
+        pass
+
+
+def flush(root: Kv) -> None:
+    for c in underlying_of(root, Flushable):  # type: ignore[type-abstract]
+        c.flush()

omlish/collections/kv/filtered.py

@@ -0,0 +1,101 @@
+import typing as ta
+
+from ... import lang
+from .base import Kv
+from .base import MutableKv
+from .wrappers import SimpleWrapperKv
+from .wrappers import SimpleWrapperMutableKv
+
+
+K = ta.TypeVar('K')
+V = ta.TypeVar('V')
+
+
+##
+
+
+class KeyFilteredKv(SimpleWrapperKv[K, V]):
+    def __init__(
+            self,
+            u: Kv[K, V],
+            fn: ta.Callable[[K], bool],
+    ) -> None:
+        super().__init__(u)
+
+        self._fn = fn
+
+    def __getitem__(self, k: K, /) -> V:
+        if not self._fn(k):
+            raise KeyError(k)
+        return self._u[k]
+
+    def __len__(self) -> int:
+        return lang.ilen(self.items())
+
+    def items(self) -> ta.Iterator[tuple[K, V]]:
+        fn = self._fn
+        return filter(lambda t: fn(t[0]), self._u.items())
+
+
+class KeyFilteredMutableKv(KeyFilteredKv[K, V], SimpleWrapperMutableKv[K, V]):
+    def __init__(
+            self,
+            u: MutableKv[K, V],
+            fn: ta.Callable[[K], bool],
+    ) -> None:
+        super().__init__(u, fn)
+
+    def __setitem__(self, k: K, v: V, /) -> None:
+        if not self._fn(k):
+            raise KeyError(k)
+        self._u[k] = v
+
+    def __delitem__(self, k: K, /) -> None:
+        if not self._fn(k):
+            raise KeyError(k)
+        del self._u[k]
+
+
+##
+
+
+class ValueFilteredKeyError(KeyError):
+    pass
+
+
+class ValueFilteredKv(SimpleWrapperKv[K, V]):
+    def __init__(
+            self,
+            u: Kv[K, V],
+            fn: ta.Callable[[V], bool],
+    ) -> None:
+        super().__init__(u)
+
+        self._fn = fn
+
+    def __getitem__(self, k: K, /) -> V:
+        v = self._u[k]
+        if not self._fn(v):
+            raise ValueFilteredKeyError(k)
+        return v
+
+    def __len__(self) -> int:
+        return lang.ilen(self.items())
+
+    def items(self) -> ta.Iterator[tuple[K, V]]:
+        fn = self._fn
+        return ((k, v) for k, v in self._u.items() if fn(v))
+
+
+class ValueFilteredMutableKv(ValueFilteredKv[K, V], SimpleWrapperMutableKv[K, V]):
+    def __init__(
+            self,
+            u: MutableKv[K, V],
+            fn: ta.Callable[[V], bool],
+    ) -> None:
+        super().__init__(u, fn)
+
+    def __setitem__(self, k: K, v: V, /) -> None:
+        if not self._fn(v):
+            raise ValueFilteredKeyError(k)
+        self._u[k] = v

omlish/collections/kv/mappings.py

@@ -0,0 +1,76 @@
+import typing as ta
+
+from .base import Kv
+from .base import MutableKv
+
+
+K = ta.TypeVar('K')
+V = ta.TypeVar('V')
+
+
+##
+
+
+class MappingKv(Kv[K, V]):
+    def __init__(self, m: ta.Mapping[K, V]) -> None:
+        super().__init__()
+
+        self._m = m
+
+    def __getitem__(self, k: K, /) -> V:
+        return self._m[k]
+
+    def __len__(self) -> int:
+        return len(self._m)
+
+    def items(self) -> ta.Iterator[tuple[K, V]]:
+        return iter(self._m.items())
+
+
+class MappingMutableKv(MappingKv[K, V], MutableKv[K, V]):
+    def __init__(self, m: ta.MutableMapping[K, V]) -> None:
+        super().__init__(m)
+
+    _m: ta.MutableMapping[K, V]
+
+    def __setitem__(self, k: K, v: V, /) -> None:
+        self._m[k] = v
+
+    def __delitem__(self, k: K, /) -> None:
+        del self._m[k]
+
+
+##
+
+
+class KvMapping(ta.Mapping[K, V]):
+    def __init__(self, kv: Kv[K, V]) -> None:
+        super().__init__()
+
+        self._kv = kv
+
+    def __getitem__(self, key: K, /) -> V:
+        return self._kv[key]
+
+    def __len__(self) -> int:
+        return len(self._kv)
+
+    # FIXME: ItemsView
+    def items(self) -> ta.Iterator[tuple[K, V]]:  # type: ignore[override]
+        return iter(self._kv.items())
+
+    def __iter__(self) -> ta.Iterator[K]:
+        return (k for k, v in self.items())
+
+
+class KvMutableMapping(KvMapping[K, V], ta.MutableMapping[K, V]):
+    def __init__(self, kv: MutableKv[K, V]) -> None:
+        super().__init__(kv)
+
+    _kv: MutableKv[K, V]
+
+    def __setitem__(self, key: K, value: V, /) -> None:
+        self._kv[key] = value
+
+    def __delitem__(self, key: K, /) -> None:
+        del self._kv[key]

omlish/collections/kv/transformed.py

@@ -0,0 +1,123 @@
+import typing as ta
+
+from ... import check
+from .base import Kv
+from .base import MutableKv
+from .wrappers import WrapperKv
+
+
+K = ta.TypeVar('K')
+V = ta.TypeVar('V')
+
+KF = ta.TypeVar('KF')
+KT = ta.TypeVar('KT')
+VF = ta.TypeVar('VF')
+VT = ta.TypeVar('VT')
+
+
+##
+
+
+class KeyTransformedKv(WrapperKv[KT, V], ta.Generic[KT, KF, V]):
+    def __init__(
+            self,
+            u: Kv[KF, V],
+            *,
+            t_to_f: ta.Callable[[KT], KF] | None = None,
+            f_to_t: ta.Callable[[KF], KT] | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._u = u
+        self._t_to_f = t_to_f
+        self._f_to_t = f_to_t
+
+    def underlying(self) -> ta.Sequence[Kv]:
+        return [self._u]
+
+    def __getitem__(self, k: KT, /) -> V:
+        fn = check.not_none(self._t_to_f)
+        return self._u[fn(k)]
+
+    def __len__(self) -> int:
+        return len(self._u)
+
+    def items(self) -> ta.Iterator[tuple[KT, V]]:
+        fn = check.not_none(self._f_to_t)
+        return ((fn(k), v) for k, v in self._u.items())
+
+
+class KeyTransformedMutableKey(KeyTransformedKv[KT, KF, V], MutableKv[KT, V], ta.Generic[KT, KF, V]):
+    def __init__(
+            self,
+            u: MutableKv[KF, V],
+            *,
+            t_to_f: ta.Callable[[KT], KF] | None = None,
+            f_to_t: ta.Callable[[KF], KT] | None = None,
+    ) -> None:
+        super().__init__(
+            u,
+            t_to_f=t_to_f,
+            f_to_t=f_to_t,
+        )
+
+    _u: MutableKv[KF, V]
+
+    def __setitem__(self, k: KT, v: V, /) -> None:
+        fn = check.not_none(self._t_to_f)
+        self._u[fn(k)] = v
+
+    def __delitem__(self, k: KT, /) -> None:
+        fn = check.not_none(self._t_to_f)
+        del self._u[fn(k)]
+
+
+##
+
+
+class ValueTransformedKv(WrapperKv[K, VT], ta.Generic[K, VT, VF]):
+    def __init__(
+            self,
+            u: Kv[K, VF],
+            f_to_t: ta.Callable[[VF], VT] | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._u = u
+        self._f_to_t = f_to_t
+
+    def underlying(self) -> ta.Sequence[Kv]:
+        return [self._u]
+
+    def __getitem__(self, k: K, /) -> VT:
+        fn = check.not_none(self._f_to_t)
+        return fn(self._u[k])
+
+    def __len__(self) -> int:
+        return len(self._u)
+
+    def items(self) -> ta.Iterator[tuple[K, VT]]:
+        fn = check.not_none(self._f_to_t)
+        return ((k, fn(v)) for k, v in self._u.items())
+
+
+class ValueTransformedMutableKv(ValueTransformedKv[K, VT, VF], MutableKv[K, VT], ta.Generic[K, VT, VF]):
+    def __init__(
+            self,
+            u: MutableKv[K, VF],
+            *,
+            f_to_t: ta.Callable[[VF], VT] | None = None,
+            t_to_f: ta.Callable[[VT], VF] | None = None,
+    ) -> None:
+        super().__init__(u, f_to_t)
+
+        self._t_to_f = t_to_f
+
+    _u: MutableKv[K, VF]
+
+    def __setitem__(self, k: K, v: VT, /) -> None:
+        fn = check.not_none(self._t_to_f)
+        self._u[k] = fn(v)
+
+    def __delitem__(self, k: K, /) -> None:
+        del self._u[k]

omlish/collections/kv/wrappers.py

@@ -0,0 +1,99 @@
+import abc
+import typing as ta
+
+from ... import lang
+from .base import Kv
+from .base import MutableKv
+
+
+K = ta.TypeVar('K')
+V = ta.TypeVar('V')
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+class WrapperKv(Kv[K, V], lang.Abstract):
+    @abc.abstractmethod
+    def underlying(self) -> ta.Iterable[Kv]:
+        raise NotImplementedError
+
+
+##
+
+
+def underlying(
+        root: Kv,
+        *,
+        leaves_only: bool = False,
+        filter: ta.Callable[[Kv], bool] | None = None,  # noqa
+) -> ta.Iterator[Kv]:
+    def rec(c):
+        if isinstance(c, WrapperKv):
+            if not leaves_only:
+                yield c
+            for n in c.underlying():
+                yield from rec(n)
+        else:
+            yield c
+
+    for u in rec(root):
+        if filter is not None and not filter(u):
+            continue
+        yield u
+
+
+def underlying_of(root: Kv, cls: type[T]) -> ta.Iterator[T]:
+    return underlying(root, filter=lambda c: isinstance(c, cls))  # type: ignore[return-value]
+
+
+##
+
+
+class SimpleWrapperKv(WrapperKv[K, V]):
+    def __init__(self, u: Kv[K, V]) -> None:
+        super().__init__()
+
+        self._u = u
+
+    def underlying(self) -> ta.Sequence[Kv]:
+        return [self._u]
+
+    def __getitem__(self, k: K, /) -> V:
+        return self._u[k]
+
+    def __len__(self) -> int:
+        return len(self._u)
+
+    def items(self) -> ta.Iterator[tuple[K, V]]:
+        return self._u.items()
+
+
+class SimpleWrapperMutableKv(SimpleWrapperKv[K, V], MutableKv[K, V]):
+    def __init__(self, u: MutableKv[K, V]) -> None:
+        super().__init__(u)
+
+    _u: MutableKv[K, V]
+
+    def __setitem__(self, k: K, v: V, /) -> None:
+        self._u[k] = v
+
+    def __delitem__(self, k: K, /) -> None:
+        del self._u[k]
+
+
+##
+
+
+class UnmodifiableError(Exception):
+    pass
+
+
+class UnmodifiableKv(SimpleWrapperKv[K, V], MutableKv[K, V]):
+    def __setitem__(self, k: K, v: V, /) -> None:
+        raise UnmodifiableError
+
+    def __delitem__(self, k: K, /) -> None:
+        raise UnmodifiableError