omlish 0.0.0.dev161__py3-none-any.whl → 0.0.0.dev163__py3-none-any.whl

omlish/formats/codecs.py

@@ -0,0 +1,93 @@
+import typing as ta
+
+from .. import codecs
+from .. import reflect as rfl
+
+
+ObjectCodecT = ta.TypeVar('ObjectCodecT', bound='ObjectCodec')
+
+
+##
+
+
+class ObjectCodec(codecs.Codec):
+    pass
+
+
+def make_object_codec(
+        cls: type[ObjectCodecT],
+        name: str,
+        dumps: ta.Callable,
+        loads: ta.Callable,
+        *,
+        input: rfl.Type = rfl.type_(ta.Any),  # noqa
+        aliases: ta.Collection[str] | None = None,
+) -> ObjectCodecT:
+    return cls(
+        name=name,
+        aliases=aliases,
+
+        input=input,
+        output=bytes,
+
+        new=lambda: codecs.FnPairEagerCodec.of(dumps, loads),
+    )
+
+
+##
+
+
+class BytesObjectCodec(ObjectCodec):
+    pass
+
+
+def make_bytes_object_codec(
+        name: str,
+        dumps: ta.Callable[[ta.Any], bytes],
+        loads: ta.Callable[[bytes], ta.Any],
+        **kwargs: ta.Any,
+) -> BytesObjectCodec:
+    return make_object_codec(
+        BytesObjectCodec,
+        name,
+        dumps,
+        loads,
+        **kwargs,
+    )
+
+
+##
+
+
+class StrObjectCodec(ObjectCodec):
+    pass
+
+
+def make_str_object_codec(
+        name: str,
+        dumps: ta.Callable[[ta.Any], str],
+        loads: ta.Callable[[str], ta.Any],
+        **kwargs: ta.Any,
+) -> StrObjectCodec:
+    return make_object_codec(
+        StrObjectCodec,
+        name,
+        dumps,
+        loads,
+        **kwargs,
+    )
+
+
+##
+
+
+def make_object_lazy_loaded_codec(
+        mod_name: str,
+        attr_name: str,
+        codec: ObjectCodec,
+) -> codecs.LazyLoadedCodec:
+    return codecs.LazyLoadedCodec.new(
+        mod_name,
+        attr_name,
+        codec,
+    )

omlish/formats/json/codecs.py

@@ -0,0 +1,33 @@
+from ..codecs import make_object_lazy_loaded_codec
+from ..codecs import make_str_object_codec
+from .json import dumps
+from .json import dumps_compact
+from .json import dumps_pretty
+from .json import loads
+
+
+##
+
+
+JSON_CODEC = make_str_object_codec('json', dumps, loads)
+
+# @omlish-manifest
+_JSON_LAZY_CODEC = make_object_lazy_loaded_codec(__name__, 'JSON_CODEC', JSON_CODEC)
+
+
+#
+
+
+JSON_COMPACT_CODEC = make_str_object_codec('json-compact', dumps_compact, loads)
+
+# @omlish-manifest
+_JSON_COMPACT_LAZY_CODEC = make_object_lazy_loaded_codec(__name__, 'JSON_COMPACT_CODEC', JSON_COMPACT_CODEC)
+
+
+#
+
+
+JSON_PRETTY_CODEC = make_str_object_codec('json-pretty', dumps_pretty, loads)
+
+# @omlish-manifest
+_JSON_PRETTY_LAZY_CODEC = make_object_lazy_loaded_codec(__name__, 'JSON_PRETTY_CODEC', JSON_PRETTY_CODEC)

omlish/formats/json5.py

@@ -0,0 +1,31 @@
+import typing as ta
+
+from .. import lang
+from .codecs import make_object_lazy_loaded_codec
+from .codecs import make_str_object_codec
+
+
+if ta.TYPE_CHECKING:
+    import json5
+else:
+    json5 = lang.proxy_import('json5')
+
+
+##
+
+
+def dumps(obj: ta.Any) -> str:
+    return json5.dumps(obj)
+
+
+def loads(s: str) -> ta.Any:
+    return json5.loads(s)
+
+
+##
+
+
+JSON5_CODEC = make_str_object_codec('json5', dumps, loads)
+
+# @omlish-manifest
+_JSON5_LAZY_CODEC = make_object_lazy_loaded_codec(__name__, 'JSON5_CODEC', JSON5_CODEC)

omlish/formats/pickle.py

@@ -0,0 +1,31 @@
+import typing as ta
+
+from .. import lang
+from .codecs import make_bytes_object_codec
+from .codecs import make_object_lazy_loaded_codec
+
+
+if ta.TYPE_CHECKING:
+    import pickle
+else:
+    pickle = lang.proxy_import('pickle')
+
+
+##
+
+
+def dump(obj: ta.Any) -> bytes:
+    return pickle.dumps(obj)
+
+
+def load(s: bytes) -> ta.Any:
+    return pickle.loads(s)
+
+
+##
+
+
+PICKLE_CODEC = make_bytes_object_codec('pickle', dump, load)
+
+# @omlish-manifest
+_PICKLE_LAZY_CODEC = make_object_lazy_loaded_codec(__name__, 'PICKLE_CODEC', PICKLE_CODEC)

omlish/formats/toml.py

@@ -0,0 +1,17 @@
+import tomllib
+
+from .codecs import make_object_lazy_loaded_codec
+from .codecs import make_str_object_codec
+
+
+##
+
+
+def _dumps(obj):
+    raise TypeError('Unsupported')
+
+
+TOML_CODEC = make_str_object_codec('toml', _dumps, tomllib.loads)
+
+# @omlish-manifest
+_TOML_LAZY_CODEC = make_object_lazy_loaded_codec(__name__, 'TOML_CODEC', TOML_CODEC)

omlish/formats/yaml.py

@@ -14,6 +14,8 @@ import typing as ta
 from .. import check
 from .. import dataclasses as dc
 from .. import lang
+from .codecs import make_object_lazy_loaded_codec
+from .codecs import make_str_object_codec
 
 
 if ta.TYPE_CHECKING:
@@ -239,3 +241,19 @@ def full_load(stream):  # noqa
 
 def full_load_all(stream):  # noqa  # noqa
     return load_all(stream, yaml.FullLoader)
+
+
+##
+
+
+def dump(obj, **kwargs):
+    return yaml.dump(obj, **kwargs)
+
+
+##
+
+
+YAML_CODEC = make_str_object_codec('yaml', dump, safe_load, aliases=['yml'])
+
+# @omlish-manifest
+_YAML_LAZY_CODEC = make_object_lazy_loaded_codec(__name__, 'YAML_CODEC', YAML_CODEC)

omlish/io/compress/brotli.py

@@ -3,6 +3,8 @@ import typing as ta
 
 from ... import lang
 from .base import Compression
+from .codecs import make_compression_codec
+from .codecs import make_compression_lazy_loaded_codec
 
 
 if ta.TYPE_CHECKING:
@@ -11,8 +13,11 @@ else:
     brotli = lang.proxy_import('brotli')
 
 
+##
+
+
 @dc.dataclass(frozen=True, kw_only=True)
-class SnappyCompression(Compression):
+class BrotliCompression(Compression):
     mode: int | None = None
     quality: int | None = None
     lgwin: int | None = None
@@ -31,3 +36,12 @@ class SnappyCompression(Compression):
         return brotli.decompress(
             d,
         )
+
+
+##
+
+
+BROTLI_CODEC = make_compression_codec('brotli', BrotliCompression)
+
+# @omlish-manifest
+_BROTLI_LAZY_CODEC = make_compression_lazy_loaded_codec(__name__, 'BROTLI_CODEC', BROTLI_CODEC)

omlish/io/compress/bz2.py

@@ -9,6 +9,8 @@ from .adapters import CompressorObjectIncrementalAdapter
 from .adapters import DecompressorObjectIncrementalAdapter
 from .base import Compression
 from .base import IncrementalCompression
+from .codecs import make_compression_codec
+from .codecs import make_compression_lazy_loaded_codec
 
 
 if ta.TYPE_CHECKING:
@@ -17,6 +19,9 @@ else:
     bz2 = lang.proxy_import('bz2')
 
 
+##
+
+
 @dc.dataclass(frozen=True, kw_only=True)
 class Bz2Compression(Compression, IncrementalCompression):
     level: int = 9
@@ -45,3 +50,12 @@ class Bz2Compression(Compression, IncrementalCompression):
             bz2.BZ2Decompressor,  # type: ignore
             trailing_error=OSError,
         )()
+
+
+##
+
+
+BZ2_CODEC = make_compression_codec('bz2', Bz2Compression)
+
+# @omlish-manifest
+_BZ2_LAZY_CODEC = make_compression_lazy_loaded_codec(__name__, 'BZ2_CODEC', BZ2_CODEC)

omlish/io/compress/codecs.py

@@ -0,0 +1,58 @@
+import dataclasses as dc
+import typing as ta
+
+from ... import codecs
+from .base import Compression
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class CompressionEagerCodec(codecs.EagerCodec[bytes, bytes]):
+    compression: Compression
+
+    def encode(self, i: bytes) -> bytes:
+        return self.compression.compress(i)
+
+    def decode(self, o: bytes) -> bytes:
+        return self.compression.decompress(o)
+
+
+##
+
+
+class CompressionCodec(codecs.Codec):
+    pass
+
+
+def make_compression_codec(
+        name: str,
+        cls: type[Compression],
+        *,
+        aliases: ta.Collection[str] | None = None,
+) -> CompressionCodec:
+    return CompressionCodec(
+        name=name,
+        aliases=aliases,
+
+        input=bytes,
+        output=bytes,
+
+        new=lambda *args, **kwargs: CompressionEagerCodec(cls(*args, **kwargs)),
+    )
+
+
+##
+
+
+def make_compression_lazy_loaded_codec(
+        mod_name: str,
+        attr_name: str,
+        codec: CompressionCodec,
+) -> codecs.LazyLoadedCodec:
+    return codecs.LazyLoadedCodec.new(
+        mod_name,
+        attr_name,
+        codec,
+    )

omlish/io/compress/gzip.py

@@ -48,6 +48,8 @@ from ..generators import BytesSteppedReaderGenerator
 from ..generators.readers import PrependableBytesGeneratorReader
 from .base import Compression
 from .base import IncrementalCompression
+from .codecs import make_compression_codec
+from .codecs import make_compression_lazy_loaded_codec
 
 
 if ta.TYPE_CHECKING:
@@ -337,3 +339,12 @@ class IncrementalGzipDecompressor:
             stream_size += len(uncompress)
             pos += len(uncompress)
             check.none((yield uncompress))
+
+
+##
+
+
+GZIP_CODEC = make_compression_codec('gzip', GzipCompression, aliases=['gz'])
+
+# @omlish-manifest
+_GZIP_LAZY_CODEC = make_compression_lazy_loaded_codec(__name__, 'GZIP_CODEC', GZIP_CODEC)

omlish/io/compress/lz4.py

@@ -6,6 +6,8 @@ from ... import lang
 from ..generators import BytesSteppedGenerator
 from .base import Compression
 from .base import IncrementalCompression
+from .codecs import make_compression_codec
+from .codecs import make_compression_lazy_loaded_codec
 
 
 if ta.TYPE_CHECKING:
@@ -14,6 +16,9 @@ else:
     lz4_frame = lang.proxy_import('lz4.frame')
 
 
+##
+
+
 @dc.dataclass(frozen=True, kw_only=True)
 class Lz4Compression(Compression, IncrementalCompression):
     level: int = 0
@@ -75,3 +80,12 @@ class Lz4Compression(Compression, IncrementalCompression):
                     return
                 if (o := decompressor.decompress(i)):
                     yield o
+
+
+##
+
+
+LZ4_CODEC = make_compression_codec('lz4', Lz4Compression)
+
+# @omlish-manifest
+_LZ4_LAZY_CODEC = make_compression_lazy_loaded_codec(__name__, 'LZ4_CODEC', LZ4_CODEC)

omlish/io/compress/lzma.py

@@ -9,6 +9,8 @@ from .adapters import CompressorObjectIncrementalAdapter
 from .adapters import DecompressorObjectIncrementalAdapter
 from .base import Compression
 from .base import IncrementalCompression
+from .codecs import make_compression_codec
+from .codecs import make_compression_lazy_loaded_codec
 
 
 if ta.TYPE_CHECKING:
@@ -17,6 +19,9 @@ else:
     lzma = lang.proxy_import('lzma')
 
 
+##
+
+
 @dc.dataclass(frozen=True, kw_only=True)
 class LzmaCompression(Compression, IncrementalCompression):
     format: int | None = None
@@ -65,3 +70,12 @@ class LzmaCompression(Compression, IncrementalCompression):
             ),
             trailing_error=lzma.LZMAError,
         )()
+
+
+##
+
+
+LZMA_CODEC = make_compression_codec('lzma', LzmaCompression)
+
+# @omlish-manifest
+_LZMA_LAZY_CODEC = make_compression_lazy_loaded_codec(__name__, 'LZMA_CODEC', LZMA_CODEC)

omlish/io/compress/snappy.py

@@ -3,6 +3,8 @@ import typing as ta
 
 from ... import lang
 from .base import Compression
+from .codecs import make_compression_codec
+from .codecs import make_compression_lazy_loaded_codec
 
 
 if ta.TYPE_CHECKING:
@@ -11,6 +13,9 @@ else:
     snappy = lang.proxy_import('snappy')
 
 
+##
+
+
 @dc.dataclass(frozen=True)
 class SnappyCompression(Compression):
     def compress(self, d: bytes) -> bytes:
@@ -18,3 +23,12 @@ class SnappyCompression(Compression):
 
     def decompress(self, d: bytes) -> bytes:
         return snappy.decompress(d)
+
+
+##
+
+
+SNAPPY_CODEC = make_compression_codec('snappy', SnappyCompression)
+
+# @omlish-manifest
+_SNAPPY_LAZY_CODEC = make_compression_lazy_loaded_codec(__name__, 'SNAPPY_CODEC', SNAPPY_CODEC)

omlish/io/compress/zlib.py

@@ -9,6 +9,8 @@ from .adapters import CompressorObjectIncrementalAdapter
 from .adapters import DecompressorObjectIncrementalAdapter
 from .base import Compression
 from .base import IncrementalCompression
+from .codecs import make_compression_codec
+from .codecs import make_compression_lazy_loaded_codec
 
 
 if ta.TYPE_CHECKING:
@@ -17,6 +19,9 @@ else:
     zlib = lang.proxy_import('zlib')
 
 
+##
+
+
 @dc.dataclass(frozen=True, kw_only=True)
 class ZlibCompression(Compression, IncrementalCompression):
     level: int = 9
@@ -58,3 +63,12 @@ class ZlibCompression(Compression, IncrementalCompression):
             ),
             trailing_error=OSError,
         )()
+
+
+##
+
+
+ZLIB_CODEC = make_compression_codec('zlib', ZlibCompression)
+
+# @omlish-manifest
+_ZLIB_LAZY_CODEC = make_compression_lazy_loaded_codec(__name__, 'ZLIB_CODEC', ZLIB_CODEC)

omlish/io/compress/zstd.py

@@ -3,6 +3,8 @@ import typing as ta
 
 from ... import lang
 from .base import Compression
+from .codecs import make_compression_codec
+from .codecs import make_compression_lazy_loaded_codec
 
 
 if ta.TYPE_CHECKING:
@@ -11,6 +13,9 @@ else:
     zstandard = lang.proxy_import('zstandard')
 
 
+##
+
+
 @dc.dataclass(frozen=True, kw_only=True)
 class ZstdCompression(Compression):
     level: int | None = None
@@ -28,3 +33,12 @@ class ZstdCompression(Compression):
             d,
             max_output_size=self.max_output_size,
         )
+
+
+##
+
+
+ZSTD_CODEC = make_compression_codec('zstd', ZstdCompression)
+
+# @omlish-manifest
+_ZSTD_LAZY_CODEC = make_compression_lazy_loaded_codec(__name__, 'ZSTD_CODEC', ZSTD_CODEC)

omlish/lang/__init__.py

@@ -112,6 +112,7 @@ from .functions import (  # noqa
     issubclass_of,
     maybe_call,
     opt_coalesce,
+    opt_fn,
     periodically,
     raise_,
     raising,

omlish/lang/functions.py

@@ -4,6 +4,7 @@ import time
 import typing as ta
 
 
+F = ta.TypeVar('F')
 T = ta.TypeVar('T')
 P = ta.ParamSpec('P')
 CallableT = ta.TypeVar('CallableT', bound=ta.Callable)
@@ -81,6 +82,16 @@ def identity(obj: T) -> T:
     return obj
 
 
+def opt_fn(fn: ta.Callable[[F], T]) -> ta.Callable[[F | None], T | None]:
+    @functools.wraps(fn)
+    def inner(v: F | None) -> T | None:
+        if v is not None:
+            return fn(v)
+        else:
+            return None
+    return inner
+
+
 class constant(ta.Generic[T]):  # noqa
     def __init__(self, obj: T) -> None:
         super().__init__()

omlish/lite/inject.py

@@ -610,7 +610,7 @@ class InjectorBinder:
     def __new__(cls, *args, **kwargs):  # noqa
         raise TypeError
 
-    _FN_TYPES: ta.Tuple[type, ...] = (
+    _FN_TYPES: ta.ClassVar[ta.Tuple[type, ...]] = (
         types.FunctionType,
         types.MethodType,
 
@@ -632,7 +632,7 @@ class InjectorBinder:
             cls._FN_TYPES = (*cls._FN_TYPES, icls)
         return icls
 
-    _BANNED_BIND_TYPES: ta.Tuple[type, ...] = (
+    _BANNED_BIND_TYPES: ta.ClassVar[ta.Tuple[type, ...]] = (
         InjectorProvider,
     )
 
@@ -811,45 +811,35 @@ def bind_injector_eager_key(key: ta.Any) -> InjectorBinding:
 ##
 
 
-class Injection:
-    def __new__(cls, *args, **kwargs):  # noqa
-        raise TypeError
-
+class InjectionApi:
     # keys
 
-    @classmethod
-    def as_key(cls, o: ta.Any) -> InjectorKey:
+    def as_key(self, o: ta.Any) -> InjectorKey:
         return as_injector_key(o)
 
-    @classmethod
-    def array(cls, o: ta.Any) -> InjectorKey:
+    def array(self, o: ta.Any) -> InjectorKey:
         return dc.replace(as_injector_key(o), array=True)
 
-    @classmethod
-    def tag(cls, o: ta.Any, t: ta.Any) -> InjectorKey:
+    def tag(self, o: ta.Any, t: ta.Any) -> InjectorKey:
         return dc.replace(as_injector_key(o), tag=t)
 
     # bindings
 
-    @classmethod
-    def as_bindings(cls, *args: InjectorBindingOrBindings) -> InjectorBindings:
+    def as_bindings(self, *args: InjectorBindingOrBindings) -> InjectorBindings:
         return as_injector_bindings(*args)
 
-    @classmethod
-    def override(cls, p: InjectorBindings, *args: InjectorBindingOrBindings) -> InjectorBindings:
+    def override(self, p: InjectorBindings, *args: InjectorBindingOrBindings) -> InjectorBindings:
         return injector_override(p, *args)
 
     # injector
 
-    @classmethod
-    def create_injector(cls, *args: InjectorBindingOrBindings, parent: ta.Optional[Injector] = None) -> Injector:
+    def create_injector(self, *args: InjectorBindingOrBindings, parent: ta.Optional[Injector] = None) -> Injector:
         return _Injector(as_injector_bindings(*args), parent)
 
     # binder
 
-    @classmethod
     def bind(
-            cls,
+            self,
             obj: ta.Any,
             *,
             key: ta.Any = None,
@@ -884,32 +874,29 @@ class Injection:
 
     # helpers
 
-    @classmethod
     def bind_factory(
-            cls,
+            self,
             fn: ta.Callable[..., T],
             cls_: U,
             ann: ta.Any = None,
     ) -> InjectorBindingOrBindings:
-        return cls.bind(make_injector_factory(fn, cls_, ann))
+        return self.bind(make_injector_factory(fn, cls_, ann))
 
-    @classmethod
     def bind_array(
-            cls,
+            self,
             obj: ta.Any = None,
             *,
             tag: ta.Any = None,
     ) -> InjectorBindingOrBindings:
         return bind_injector_array(obj, tag=tag)
 
-    @classmethod
     def bind_array_type(
-            cls,
+            self,
             ele: ta.Union[InjectorKey, InjectorKeyCls],
             cls_: U,
             ann: ta.Any = None,
     ) -> InjectorBindingOrBindings:
-        return cls.bind(make_injector_array_type(ele, cls_, ann))
+        return self.bind(make_injector_array_type(ele, cls_, ann))
 
 
-inj = Injection
+inj = InjectionApi()