omlish 0.0.0.dev2__py3-none-any.whl → 0.0.0.dev3__py3-none-any.whl

omlish/fnpairs.py

@@ -0,0 +1,311 @@
+import abc
+import codecs
+import dataclasses as dc
+import typing as ta
+
+from . import lang
+
+if ta.TYPE_CHECKING:
+    import bzip2 as _bzip2
+    import gzip as _gzip
+    import json as _json
+    import lzma as _lzma
+    import pickle as _pickle
+    import struct as _struct
+    import tomllib as _tomllib
+
+else:
+    _bzip2 = lang.proxy_import('bzip2')
+    _gzip = lang.proxy_import('gzip')
+    _json = lang.proxy_import('json')
+    _lzma = lang.proxy_import('lzma')
+    _pickle = lang.proxy_import('pickle')
+    _struct = lang.proxy_import('struct')
+    _tomllib = lang.proxy_import('tomllib')
+
+_zstd = lang.proxy_import('zstd')
+_yaml = lang.proxy_import('yaml')
+
+
+##
+
+
+F = ta.TypeVar('F')
+T = ta.TypeVar('T')
+U = ta.TypeVar('U')
+
+
+class FnPair(ta.Generic[F, T], abc.ABC):
+    @abc.abstractmethod
+    def forward(self, f: F) -> T:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def backward(self, t: T) -> F:
+        raise NotImplementedError
+
+    def invert(self) -> 'FnPair[T, F]':
+        if isinstance(self, Inverted):
+            return self.fp
+        return Inverted(self)
+
+    def compose(self, nxt: 'FnPair[T, U]') -> 'FnPair[F, U]':
+        return Composite((self, nxt))
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class Simple(FnPair[F, T]):
+    forward: ta.Callable[[F], T]  # type: ignore
+    backward: ta.Callable[[T], F]  # type: ignore
+
+    def _forward(self, f: F) -> T:
+        return self.forward(f)
+
+    def _backward(self, t: T) -> F:
+        return self.backward(t)
+
+
+# HACK: ABC workaround. Our dataclasses handle this with `override=True` but we don't want to dep that in here.
+Simple.forward = Simple._forward  # type: ignore  # noqa
+Simple.backward = Simple._backward  # type: ignore  # noqa
+Simple.__abstractmethods__ = frozenset()  # noqa
+
+
+of = Simple
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class Inverted(FnPair[F, T]):
+    fp: FnPair[T, F]
+
+    def forward(self, f: F) -> T:
+        return self.fp.backward(f)
+
+    def backward(self, t: T) -> F:
+        return self.fp.forward(t)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class Composite(FnPair[F, T]):
+    children: ta.Sequence[FnPair]
+
+    def forward(self, f: F) -> T:
+        for c in self.children:
+            f = c.forward(f)
+        return ta.cast(T, f)
+
+    def backward(self, t: T) -> F:
+        for c in reversed(self.children):
+            t = c.backward(t)
+        return ta.cast(F, t)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class Text(FnPair[str, bytes]):
+    ci: codecs.CodecInfo
+    encode_errors: str = dc.field(default='strict', kw_only=True)
+    decode_errors: str = dc.field(default='strict', kw_only=True)
+
+    def forward(self, f: str) -> bytes:
+        # Python ignores the returned length:
+        #   https://github.com/python/cpython/blob/7431c3799efbd06ed03ee70b64420f45e83b3667/Python/codecs.c#L424
+        t, _ = self.ci.encode(f, self.encode_errors)
+        return t
+
+    def backward(self, t: bytes) -> str:
+        f, _ = self.ci.decode(t, self.decode_errors)
+        return f
+
+
+def text(name: str, *, encode_errors: str = 'strict', decode_errors: str = 'strict') -> Text:
+    ci = codecs.lookup(name)
+    if not ci._is_text_encoding:  # noqa
+        raise TypeError(f'must be text codec: {name}')
+    return Text(ci, encode_errors=encode_errors, decode_errors=decode_errors)
+
+
+UTF8 = text('utf-8')
+
+
+#
+
+
+@dc.dataclass(frozen=True)
+class Optional(FnPair[ta.Optional[F], ta.Optional[T]]):
+    fp: FnPair[F, T]
+
+    def forward(self, f: ta.Optional[F]) -> ta.Optional[T]:
+        return None if f is None else self.fp.forward(f)
+
+    def backward(self, t: ta.Optional[T]) -> ta.Optional[F]:
+        return None if t is None else self.fp.backward(t)
+
+
+class Lines(FnPair[ta.Sequence[str], str]):
+    def forward(self, f: ta.Sequence[str]) -> str:
+        return '\n'.join(f)
+
+    def backward(self, t: str) -> ta.Sequence[str]:
+        return t.splitlines()
+
+
+##
+
+
+_EXTENSION_REGISTRY: dict[str, type[FnPair]] = {}
+
+
+def _register_extension(*ss):
+    def inner(cls):
+        for s in ss:
+            if s in _EXTENSION_REGISTRY:
+                raise Exception(s)
+            _EXTENSION_REGISTRY[s] = cls
+        return cls
+    return inner
+
+
+##
+
+
+class Compression(FnPair[bytes, bytes], abc.ABC):
+    pass
+
+
+@_register_extension('gz')
+@dc.dataclass(frozen=True)
+class Gzip(Compression):
+    compresslevel: int = 9
+
+    def forward(self, f: bytes) -> bytes:
+        return _gzip.compress(f, compresslevel=self.compresslevel)
+
+    def backward(self, t: bytes) -> bytes:
+        return _gzip.decompress(t)
+
+
+@_register_extension('bz2')
+@dc.dataclass(frozen=True)
+class Bzip2(Compression):
+    compresslevel: int = 9
+
+    def forward(self, f: bytes) -> bytes:
+        return _bzip2.compress(f, compresslevel=self.compresslevel)
+
+    def backward(self, t: bytes) -> bytes:
+        return _bzip2.decompress(t)
+
+
+@_register_extension('lzma')
+class Lzma(Compression):
+    def forward(self, f: bytes) -> bytes:
+        return _lzma.compress(f)
+
+    def backward(self, t: bytes) -> bytes:
+        return _lzma.decompress(t)
+
+
+#
+
+
+@_register_extension('zstd')
+class Zstd(Compression):
+    def forward(self, f: bytes) -> bytes:
+        return _zstd.compress(f)
+
+    def backward(self, t: bytes) -> bytes:
+        return _zstd.decompress(t)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class Struct(FnPair[tuple, bytes]):
+    fmt: str
+
+    def forward(self, f: tuple) -> bytes:
+        return _struct.pack(self.fmt, *f)
+
+    def backward(self, t: bytes) -> tuple:
+        return _struct.unpack(self.fmt, t)
+
+
+@_register_extension('pkl')
+@dc.dataclass(frozen=True)
+class Pickle(FnPair[ta.Any, bytes]):
+    protocol: int | None = None
+
+    def forward(self, f: ta.Any) -> bytes:
+        return _pickle.dumps(f, protocol=self.protocol)
+
+    def backward(self, t: bytes) -> ta.Any:
+        return _pickle.loads(t)
+
+
+@_register_extension('json')
+@dc.dataclass(frozen=True)
+class Json(FnPair[ta.Any, str]):
+    indent: int | str | None = dc.field(default=None, kw_only=True)
+    separators: tuple[str, str] | None = dc.field(default=None, kw_only=True)
+
+    def forward(self, f: ta.Any) -> str:
+        return _json.dumps(f, indent=self.indent, separators=self.separators)
+
+    def backward(self, t: str) -> ta.Any:
+        return _json.loads(t)
+
+
+JSON = Json()
+PRETTY_JSON = Json(indent=2)
+COMPACT_JSON = Json(separators=(',', ':'))
+
+
+@_register_extension('jsonl')
+class JsonLines(FnPair[ta.Sequence[ta.Any], str]):
+    def forward(self, f: ta.Sequence[ta.Any]) -> str:
+        return '\n'.join(_json.dumps(e) for e in f)
+
+    def backward(self, t: str) -> ta.Sequence[ta.Any]:
+        return [_json.loads(l) for l in t.splitlines()]
+
+
+@_register_extension('toml')
+class Toml(FnPair[ta.Any, str]):
+    def forward(self, f: ta.Any) -> str:
+        raise NotImplementedError
+
+    def backward(self, t: str) -> ta.Any:
+        return _tomllib.loads(t)
+
+
+#
+
+
+@_register_extension('yml', 'yaml')
+class Yaml(FnPair[ta.Any, str]):
+    def forward(self, f: ta.Any) -> str:
+        return _yaml.dump(f)
+
+    def backward(self, t: str) -> ta.Any:
+        return _yaml.safe_load(t)
+
+
+class UnsafeYaml(FnPair[ta.Any, str]):
+    def forward(self, f: ta.Any) -> str:
+        return _yaml.dump(f)
+
+    def backward(self, t: str) -> ta.Any:
+        return _yaml.safe_load(t, loader=_yaml.FullLoader)

omlish/graphs/trees.py

@@ -18,7 +18,7 @@ NodeWalker = ta.Callable[[NodeT], ta.Iterable[NodeT]]
 NodeGenerator = ta.Generator[NodeT, None, None]
 
 
-class NodeException(ta.Generic[NodeT], Exception):
+class NodeError(ta.Generic[NodeT], Exception):
     def __init__(self, node: NodeT, msg: str, *args, **kwargs) -> None:
         super().__init__(msg, *args, **kwargs)  # noqa
         self._node = node
@@ -28,12 +28,12 @@ class NodeException(ta.Generic[NodeT], Exception):
         return self._node
 
 
-class DuplicateNodeException(NodeException[NodeT]):
+class DuplicateNodeError(NodeError[NodeT]):
     def __init__(self, node: NodeT, *args, **kwargs) -> None:
         super().__init__(node, f'Duplicate node: {node!r}', *args, **kwargs)
 
 
-class UnknownNodeException(NodeException[NodeT]):
+class UnknownNodeError(NodeError[NodeT]):
     def __init__(self, node: NodeT, *args, **kwargs) -> None:
         super().__init__(node, f'Unknown node: {node!r}', *args, **kwargs)
 
@@ -55,19 +55,19 @@ class BasicTreeAnalysis(ta.Generic[NodeT]):
 
         self._set_fac: ta.Callable[..., ta.MutableSet[NodeT]] = col.IdentitySet if identity else set
         self._dict_fac: ta.Callable[..., ta.MutableMapping[NodeT, ta.Any]] = col.IdentityKeyDict if identity else dict
-        self._idx_seq_fac: ta.Callable[..., col.IndexedSeq[NodeT]] = functools.partial(col.IndexedSeq, identity=identity)  # noqa
+        self._idx_seq_fac: ta.Callable[..., col.IndexedSeq[NodeT]] = functools.partial(col.IndexedSeq, identity=identity)  # type: ignore  # noqa
 
         def walk(cur: NodeT, parent: NodeT | None) -> None:
             check.not_none(cur)
             if cur in node_set:
-                raise DuplicateNodeException(cur)
+                raise DuplicateNodeError(cur)
 
             nodes.append(cur)
             node_set.add(cur)
             if parent is None:
                 check.state(cur is root)
             elif parent not in node_set:
-                raise UnknownNodeException(parent)
+                raise UnknownNodeError(parent)
 
             parents_by_node[cur] = parent
 
@@ -77,19 +77,19 @@ class BasicTreeAnalysis(ta.Generic[NodeT]):
                 walk(child, cur)
 
         nodes: list[NodeT] = []
-        node_set: ta.MutableSet[NodeT] = self._set_fac()  # type: ignore
-        children_by_node: ta.MutableMapping[NodeT | None, ta.Sequence[NodeT]] = self._dict_fac()  # type: ignore
-        child_sets_by_node: ta.MutableMapping[ta.Optional[NodeT], ta.AbstractSet[NodeT]] = self._dict_fac()  # type: ignore  # noqa
-        parents_by_node: ta.MutableMapping[NodeT, NodeT | None] = self._dict_fac()  # type: ignore
+        node_set: ta.MutableSet[NodeT] = self._set_fac()
+        children_by_node: ta.MutableMapping[NodeT | None, ta.Sequence[NodeT]] = self._dict_fac()
+        child_sets_by_node: ta.MutableMapping[ta.Optional[NodeT], ta.AbstractSet[NodeT]] = self._dict_fac()
+        parents_by_node: ta.MutableMapping[NodeT, NodeT | None] = self._dict_fac()
 
         children_by_node[None] = [root]
-        child_sets_by_node[None] = self._set_fac([root])  # type: ignore
+        child_sets_by_node[None] = self._set_fac([root])
 
         walk(root, None)
 
-        self._nodes = self._idx_seq_fac(nodes)  # type: ignore
+        self._nodes = self._idx_seq_fac(nodes)
         self._node_set: ta.AbstractSet[NodeT] = node_set
-        self._children_by_node: ta.Mapping[NodeT | None, col.IndexedSeq[NodeT]] = self._dict_fac(  # type: ignore
+        self._children_by_node: ta.Mapping[NodeT | None, col.IndexedSeq[NodeT]] = self._dict_fac(
             [(n, self._idx_seq_fac(cs)) for n, cs in children_by_node.items()])
         self._child_sets_by_node: ta.Mapping[NodeT | None, ta.AbstractSet[NodeT]] = child_sets_by_node
         self._parents_by_node: ta.Mapping[NodeT, NodeT | None] = parents_by_node

omlish/inject/__init__.py

@@ -18,13 +18,13 @@ from .elements import (  # noqa
 )
 
 from .exceptions import (  # noqa
-    CyclicDependencyException,
-    DuplicateKeyException,
-    KeyException,
-    ScopeAlreadyOpenException,
-    ScopeException,
-    ScopeNotOpenException,
-    UnboundKeyException,
+    BaseKeyError,
+    CyclicDependencyError,
+    DuplicateKeyError,
+    ScopeAlreadyOpenError,
+    ScopeError,
+    ScopeNotOpenError,
+    UnboundKeyError,
 )
 
 from .injector import (  # noqa

omlish/inject/elements.py

@@ -27,7 +27,7 @@ class Elements(lang.Final):
 
 def as_elements(*args: Element | Elements) -> Elements:
     es: set[Element] = set()
-    cs: set['Elements'] = set()
+    cs: set[Elements] = set()
     for a in args:
         if isinstance(a, Element):
             es.add(a)

omlish/inject/exceptions.py

@@ -9,7 +9,7 @@ from .types import Scope
 
 
 @dc.dataclass()
-class KeyException(Exception):
+class BaseKeyError(Exception):
     key: Key
 
     source: ta.Any = None
@@ -17,17 +17,17 @@ class KeyException(Exception):
 
 
 @dc.dataclass()
-class UnboundKeyException(KeyException):
+class UnboundKeyError(KeyError):
     pass
 
 
 @dc.dataclass()
-class DuplicateKeyException(KeyException):
+class DuplicateKeyError(KeyError):
     pass
 
 
 @dc.dataclass()
-class CyclicDependencyException(KeyException):
+class CyclicDependencyError(KeyError):
     pass
 
 
@@ -35,15 +35,15 @@ class CyclicDependencyException(KeyException):
 
 
 @dc.dataclass()
-class ScopeException(Exception):
+class ScopeError(Exception):
     scope: Scope
 
 
 @dc.dataclass()
-class ScopeAlreadyOpenException(ScopeException):
+class ScopeAlreadyOpenError(ScopeError):
     pass
 
 
 @dc.dataclass()
-class ScopeNotOpenException(ScopeException):
+class ScopeNotOpenError(ScopeError):
     pass

omlish/inject/impl/elements.py

@@ -25,7 +25,7 @@ from ..bindings import Binding
 from ..eagers import Eager
 from ..elements import Element
 from ..elements import Elements
-from ..exceptions import DuplicateKeyException
+from ..exceptions import DuplicateKeyError
 from ..keys import Key
 from ..overrides import Overrides
 from ..private import Expose
@@ -51,7 +51,7 @@ class ElementCollection(lang.Final):
 
         self._es = check.isinstance(es, Elements)
 
-        self._private_infos: ta.MutableMapping[Private, 'private_.PrivateInfo'] | None = None
+        self._private_infos: ta.MutableMapping[Private, private_.PrivateInfo] | None = None
 
     ##
 
@@ -98,7 +98,7 @@ class ElementCollection(lang.Final):
                     try:
                         bs = ovr[k]
                     except KeyError:
-                        bs = src[k]
+                        bs = b
                     add(k, *bs)
 
             else:
@@ -139,7 +139,7 @@ class ElementCollection(lang.Final):
                 mm.setdefault(k, []).extend(bis)
             else:
                 if len(bis) > 1:
-                    raise DuplicateKeyException(k)
+                    raise DuplicateKeyError(k)
                 [pm[k]] = bis
 
         if mm:

omlish/inject/impl/injector.py

@@ -16,8 +16,8 @@ from ... import check
 from ... import lang
 from ..eagers import Eager
 from ..elements import Elements
-from ..exceptions import CyclicDependencyException
-from ..exceptions import UnboundKeyException
+from ..exceptions import CyclicDependencyError
+from ..exceptions import UnboundKeyError
 from ..injector import Injector
 from ..inspect import KwargsTarget
 from ..keys import Key
@@ -54,7 +54,7 @@ class InjectorImpl(Injector, lang.Final):
         self._bim = ec.binding_impl_map()
 
         self._cs: weakref.WeakSet[InjectorImpl] | None = None
-        self._root: InjectorImpl = p._root if p is not None else self
+        self._root: InjectorImpl = p._root if p is not None else self  # noqa
 
         self.__cur_req: InjectorImpl._Request | None = None
 
@@ -97,7 +97,7 @@ class InjectorImpl(Injector, lang.Final):
             except KeyError:
                 pass
             if key in self._seen_keys:
-                raise CyclicDependencyException(key)
+                raise CyclicDependencyError(key)
             self._seen_keys.add(key)
             return lang.empty()
 
@@ -154,7 +154,7 @@ class InjectorImpl(Injector, lang.Final):
         v = self.try_provide(key)
         if v.present:
             return v.must()
-        raise UnboundKeyException(key)
+        raise UnboundKeyError(key)
 
     def provide_kwargs(self, kt: KwargsTarget) -> ta.Mapping[str, ta.Any]:
         ret: dict[str, ta.Any] = {}

omlish/inject/impl/inspect.py

@@ -11,7 +11,7 @@ import typing as ta
 import weakref
 
 from ... import reflect as rfl
-from ..exceptions import DuplicateKeyException
+from ..exceptions import DuplicateKeyError
 from ..inspect import Kwarg
 from ..inspect import KwargsTarget
 from ..keys import Key
@@ -83,7 +83,7 @@ def build_kwargs_target(
             k = tag(k, pt)
 
         if k in seen:
-            raise DuplicateKeyException(k)
+            raise DuplicateKeyError(k)
         seen.add(k)
 
         kws.append(Kwarg(

omlish/inject/impl/scopes.py

@@ -9,8 +9,8 @@ from ... import lang
 from ..bindings import Binding
 from ..elements import Elements
 from ..elements import as_elements
-from ..exceptions import ScopeAlreadyOpenException
-from ..exceptions import ScopeNotOpenException
+from ..exceptions import ScopeAlreadyOpenError
+from ..exceptions import ScopeNotOpenError
 from ..injector import Injector
 from ..keys import Key
 from ..providers import Provider
@@ -134,7 +134,7 @@ class SeededScopeImpl(ScopeImpl):
 
     def must_state(self) -> 'SeededScopeImpl.State':
         if (st := self._st) is None:
-            raise ScopeNotOpenException(self._ss)
+            raise ScopeNotOpenError(self._ss)
         return st
 
     class Manager(SeededScope.Manager, lang.Final):
@@ -147,14 +147,14 @@ class SeededScopeImpl(ScopeImpl):
         @contextlib.contextmanager
         def __call__(self, seeds: ta.Mapping[Key, ta.Any]) -> ta.Generator[None, None, None]:
             try:
-                if self._ssi._st is not None:
-                    raise ScopeAlreadyOpenException(self._ss)
-                self._ssi._st = SeededScopeImpl.State(dict(seeds))
+                if self._ssi._st is not None:  # noqa
+                    raise ScopeAlreadyOpenError(self._ss)
+                self._ssi._st = SeededScopeImpl.State(dict(seeds))  # noqa
                 yield
             finally:
-                if self._ssi._st is None:
-                    raise ScopeNotOpenException(self._ss)
-                self._ssi._st = None
+                if self._ssi._st is None:  # noqa
+                    raise ScopeNotOpenError(self._ss)
+                self._ssi._st = None  # noqa
 
     def auto_elements(self) -> Elements:
         return as_elements(

omlish/inject/proxy.py

@@ -22,7 +22,7 @@ def _cyclic_dependency_proxy() -> tuple[type, ta.Callable[[ta.Any, ta.Any], None
         def __init__(self, cls):
             super().__init__(_CyclicDependencyPlaceholder(cls))
             if isinstance(cls, type):
-                self._self__class__ = cls
+                self._self__class__ = cls  # noqa
 
         def __repr__(self) -> str:
             return f'_CyclicDependencyProxy({self.__wrapped__!r})'
@@ -35,14 +35,14 @@ def _cyclic_dependency_proxy() -> tuple[type, ta.Callable[[ta.Any, ta.Any], None
                     pass
             return object.__getattribute__(self, att)  # noqa
 
-    def set(prox, obj):
+    def set_obj(prox, obj):
         check.state(type(prox) is _CyclicDependencyProxy)
         check.not_isinstance(obj, _CyclicDependencyPlaceholder)
         check.isinstance(prox.__wrapped__, _CyclicDependencyPlaceholder)
         if hasattr(prox, '_self__class__'):
-            check.issubclass(type(obj), prox._self__class__)
+            check.issubclass(type(obj), prox._self__class__)  # noqa
         prox.__wrapped__ = obj
         if hasattr(prox, '_self__class__'):
-            del prox._self__class__
+            del prox._self__class__  # noqa
 
-    return (_CyclicDependencyProxy, set)  # noqa
+    return (_CyclicDependencyProxy, set_obj)  # noqa