omlish 0.0.0.dev162__py3-none-any.whl → 0.0.0.dev164__py3-none-any.whl

omlish/.manifests.json

@@ -23,6 +23,234 @@
       }
     }
   },
+  {
+    "module": ".formats.cbor",
+    "attr": "_CBOR_LAZY_CODEC",
+    "file": "omlish/formats/cbor.py",
+    "line": 30,
+    "value": {
+      "$.codecs.base.LazyLoadedCodec": {
+        "mod_name": "omlish.formats.cbor",
+        "attr_name": "CBOR_CODEC",
+        "name": "cbor",
+        "aliases": null
+      }
+    }
+  },
+  {
+    "module": ".formats.json.codecs",
+    "attr": "_JSON_LAZY_CODEC",
+    "file": "omlish/formats/json/codecs.py",
+    "line": 14,
+    "value": {
+      "$.codecs.base.LazyLoadedCodec": {
+        "mod_name": "omlish.formats.json.codecs",
+        "attr_name": "JSON_CODEC",
+        "name": "json",
+        "aliases": null
+      }
+    }
+  },
+  {
+    "module": ".formats.json.codecs",
+    "attr": "_JSON_COMPACT_LAZY_CODEC",
+    "file": "omlish/formats/json/codecs.py",
+    "line": 23,
+    "value": {
+      "$.codecs.base.LazyLoadedCodec": {
+        "mod_name": "omlish.formats.json.codecs",
+        "attr_name": "JSON_COMPACT_CODEC",
+        "name": "json-compact",
+        "aliases": null
+      }
+    }
+  },
+  {
+    "module": ".formats.json.codecs",
+    "attr": "_JSON_PRETTY_LAZY_CODEC",
+    "file": "omlish/formats/json/codecs.py",
+    "line": 32,
+    "value": {
+      "$.codecs.base.LazyLoadedCodec": {
+        "mod_name": "omlish.formats.json.codecs",
+        "attr_name": "JSON_PRETTY_CODEC",
+        "name": "json-pretty",
+        "aliases": null
+      }
+    }
+  },
+  {
+    "module": ".formats.json5",
+    "attr": "_JSON5_LAZY_CODEC",
+    "file": "omlish/formats/json5.py",
+    "line": 30,
+    "value": {
+      "$.codecs.base.LazyLoadedCodec": {
+        "mod_name": "omlish.formats.json5",
+        "attr_name": "JSON5_CODEC",
+        "name": "json5",
+        "aliases": null
+      }
+    }
+  },
+  {
+    "module": ".formats.pickle",
+    "attr": "_PICKLE_LAZY_CODEC",
+    "file": "omlish/formats/pickle.py",
+    "line": 30,
+    "value": {
+      "$.codecs.base.LazyLoadedCodec": {
+        "mod_name": "omlish.formats.pickle",
+        "attr_name": "PICKLE_CODEC",
+        "name": "pickle",
+        "aliases": null
+      }
+    }
+  },
+  {
+    "module": ".formats.toml",
+    "attr": "_TOML_LAZY_CODEC",
+    "file": "omlish/formats/toml.py",
+    "line": 16,
+    "value": {
+      "$.codecs.base.LazyLoadedCodec": {
+        "mod_name": "omlish.formats.toml",
+        "attr_name": "TOML_CODEC",
+        "name": "toml",
+        "aliases": null
+      }
+    }
+  },
+  {
+    "module": ".formats.yaml",
+    "attr": "_YAML_LAZY_CODEC",
+    "file": "omlish/formats/yaml.py",
+    "line": 258,
+    "value": {
+      "$.codecs.base.LazyLoadedCodec": {
+        "mod_name": "omlish.formats.yaml",
+        "attr_name": "YAML_CODEC",
+        "name": "yaml",
+        "aliases": [
+          "yml"
+        ]
+      }
+    }
+  },
+  {
+    "module": ".io.compress.brotli",
+    "attr": "_BROTLI_LAZY_CODEC",
+    "file": "omlish/io/compress/brotli.py",
+    "line": 46,
+    "value": {
+      "$.codecs.base.LazyLoadedCodec": {
+        "mod_name": "omlish.io.compress.brotli",
+        "attr_name": "BROTLI_CODEC",
+        "name": "brotli",
+        "aliases": null
+      }
+    }
+  },
+  {
+    "module": ".io.compress.bz2",
+    "attr": "_BZ2_LAZY_CODEC",
+    "file": "omlish/io/compress/bz2.py",
+    "line": 60,
+    "value": {
+      "$.codecs.base.LazyLoadedCodec": {
+        "mod_name": "omlish.io.compress.bz2",
+        "attr_name": "BZ2_CODEC",
+        "name": "bz2",
+        "aliases": null
+      }
+    }
+  },
+  {
+    "module": ".io.compress.gzip",
+    "attr": "_GZIP_LAZY_CODEC",
+    "file": "omlish/io/compress/gzip.py",
+    "line": 349,
+    "value": {
+      "$.codecs.base.LazyLoadedCodec": {
+        "mod_name": "omlish.io.compress.gzip",
+        "attr_name": "GZIP_CODEC",
+        "name": "gzip",
+        "aliases": [
+          "gz"
+        ]
+      }
+    }
+  },
+  {
+    "module": ".io.compress.lz4",
+    "attr": "_LZ4_LAZY_CODEC",
+    "file": "omlish/io/compress/lz4.py",
+    "line": 90,
+    "value": {
+      "$.codecs.base.LazyLoadedCodec": {
+        "mod_name": "omlish.io.compress.lz4",
+        "attr_name": "LZ4_CODEC",
+        "name": "lz4",
+        "aliases": null
+      }
+    }
+  },
+  {
+    "module": ".io.compress.lzma",
+    "attr": "_LZMA_LAZY_CODEC",
+    "file": "omlish/io/compress/lzma.py",
+    "line": 80,
+    "value": {
+      "$.codecs.base.LazyLoadedCodec": {
+        "mod_name": "omlish.io.compress.lzma",
+        "attr_name": "LZMA_CODEC",
+        "name": "lzma",
+        "aliases": null
+      }
+    }
+  },
+  {
+    "module": ".io.compress.snappy",
+    "attr": "_SNAPPY_LAZY_CODEC",
+    "file": "omlish/io/compress/snappy.py",
+    "line": 33,
+    "value": {
+      "$.codecs.base.LazyLoadedCodec": {
+        "mod_name": "omlish.io.compress.snappy",
+        "attr_name": "SNAPPY_CODEC",
+        "name": "snappy",
+        "aliases": null
+      }
+    }
+  },
+  {
+    "module": ".io.compress.zlib",
+    "attr": "_ZLIB_LAZY_CODEC",
+    "file": "omlish/io/compress/zlib.py",
+    "line": 73,
+    "value": {
+      "$.codecs.base.LazyLoadedCodec": {
+        "mod_name": "omlish.io.compress.zlib",
+        "attr_name": "ZLIB_CODEC",
+        "name": "zlib",
+        "aliases": null
+      }
+    }
+  },
+  {
+    "module": ".io.compress.zstd",
+    "attr": "_ZSTD_LAZY_CODEC",
+    "file": "omlish/io/compress/zstd.py",
+    "line": 43,
+    "value": {
+      "$.codecs.base.LazyLoadedCodec": {
+        "mod_name": "omlish.io.compress.zstd",
+        "attr_name": "ZSTD_CODEC",
+        "name": "zstd",
+        "aliases": null
+      }
+    }
+  },
   {
     "module": ".secrets.pwgen",
     "attr": "_CLI_MODULE",

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev162'
-__revision__ = 'd9129e1bcec87862768d3a2fc10011def8f3fd52'
+__version__ = '0.0.0.dev164'
+__revision__ = '72b4cfb1086b384ec55cc221069d5bb2be6b3c10'
 
 
 #

omlish/codecs/__init__.py

@@ -0,0 +1,69 @@
+from .base import (  # noqa
+    EagerCodec,
+    IncrementalCodec,
+    ComboCodec,
+
+    check_codec_name,
+
+    Codec,
+
+    LazyLoadedCodec,
+)
+
+from .bytes import (  # noqa
+    ASCII85,
+    BASE16,
+    BASE32,
+    BASE64,
+    BASE85,
+    BASE32_HEX,
+    BASE64_HEX,
+    BASE64_URLSAFE,
+    HEX,
+)
+
+from .chain import (  # noqa
+    ChainEagerCodec,
+
+    chain,
+)
+
+from .funcs import (  # noqa
+    FnPairEagerCodec,
+)
+
+from .registry import (  # noqa
+    CodecRegistry,
+
+    REGISTRY,
+    register,
+    lookup,
+
+    encode,
+    decode,
+)
+
+from .standard import (  # noqa
+    STANDARD_CODECS,
+)
+
+from .text import (  # noqa
+    TextEncodingErrors,
+    TextEncodingOptions,
+
+    TextEncodingComboCodec,
+
+    TextEncodingCodec,
+
+    ASCII,
+    LATIN1,
+    UTF32,
+    UTF32BE,
+    UTF32LE,
+    UTF16,
+    UTF16BE,
+    UTF16LE,
+    UTF7,
+    UTF8,
+    UTF8SIG,
+)

omlish/codecs/base.py

@@ -0,0 +1,102 @@
+"""
+TODO:
+ - bytes-like - bytearray, memoryview
+"""
+import abc
+import typing as ta
+
+from omlish import check
+from omlish import dataclasses as dc
+from omlish import lang
+from omlish import reflect as rfl
+
+
+I = ta.TypeVar('I')
+O = ta.TypeVar('O')
+
+
+##
+
+
+class EagerCodec(lang.Abstract, ta.Generic[I, O]):
+    @abc.abstractmethod
+    def encode(self, i: I) -> O:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def decode(self, o: O) -> I:
+        raise NotImplementedError
+
+
+class IncrementalCodec(lang.Abstract, ta.Generic[I, O]):
+    @abc.abstractmethod
+    def encode_incremental(self) -> ta.Generator[O | None, I, None]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def decode_incremental(self) -> ta.Generator[I | None, O, None]:
+        raise NotImplementedError
+
+
+class ComboCodec(  # noqa
+    EagerCodec[I, O],
+    IncrementalCodec[I, O],
+    lang.Abstract,
+    ta.Generic[I, O],
+):
+    pass
+
+
+##
+
+
+def check_codec_name(s: str) -> str:
+    check.non_empty_str(s)
+    check.not_in('_', s)
+    check.equal(s.strip(), s)
+    return s
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class Codec:
+    name: str = dc.xfield(coerce=check_codec_name)
+    aliases: ta.Collection[str] | None = dc.xfield(
+        default=None,
+        coerce=lang.opt_fn(lambda s: [check_codec_name(a) for a in s]),  # type: ignore
+    )
+
+    input: rfl.Type = dc.xfield(coerce=rfl.type_)
+    output: rfl.Type = dc.xfield(coerce=rfl.type_)
+
+    options: type | None = None
+
+    new: ta.Callable[..., EagerCodec]
+    new_incremental: ta.Callable[..., IncrementalCodec] | None = None
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class LazyLoadedCodec:
+    mod_name: str
+    attr_name: str
+    name: str
+    aliases: ta.Collection[str] | None = None
+
+    @classmethod
+    def new(
+            cls,
+            mod_name: str,
+            attr_name: str,
+            codec: Codec,
+    ) -> 'LazyLoadedCodec':
+        return cls(
+            mod_name=mod_name,
+            attr_name=attr_name,
+            name=codec.name,
+            aliases=codec.aliases,
+        )

omlish/codecs/bytes.py

@@ -0,0 +1,119 @@
+"""
+TODO:
+ - options / kwargs
+"""
+import base64
+import binascii
+import typing as ta
+
+from .. import check
+from .base import Codec
+from .funcs import FnPairEagerCodec
+from .standard import STANDARD_CODECS
+
+
+##
+
+
+class BytesCodec(Codec):
+    pass
+
+
+def make_bytes_encoding_codec(
+        name: str,
+        aliases: ta.Collection[str] | None,
+        encode: ta.Callable[[bytes], bytes],
+        decode: ta.Callable[[bytes], bytes],
+        *,
+        append_to: ta.MutableSequence[Codec] | None = None,
+) -> BytesCodec:
+    codec = BytesCodec(
+        name=name,
+        aliases=check.not_isinstance(aliases, str),
+
+        input=bytes,
+        output=bytes,
+
+        new=lambda: FnPairEagerCodec.of(encode, decode),
+    )
+
+    if append_to is not None:
+        append_to.append(codec)
+
+    return codec
+
+
+##
+
+
+ASCII85 = make_bytes_encoding_codec(
+    'ascii85',
+    ['a85'],
+    base64.a85encode,
+    base64.a85decode,
+    append_to=STANDARD_CODECS,
+)
+
+BASE16 = make_bytes_encoding_codec(
+    'base16',
+    ['b16'],
+    base64.b16encode,
+    base64.b16decode,
+    append_to=STANDARD_CODECS,
+)
+
+BASE32 = make_bytes_encoding_codec(
+    'base32',
+    ['b32'],
+    base64.b32encode,
+    base64.b32decode,
+    append_to=STANDARD_CODECS,
+)
+
+BASE64 = make_bytes_encoding_codec(
+    'base64',
+    ['b64'],
+    base64.b64encode,
+    base64.b64decode,
+    append_to=STANDARD_CODECS,
+)
+
+BASE85 = make_bytes_encoding_codec(
+    'base85',
+    ['b85'],
+    base64.b85encode,
+    base64.b85decode,
+    append_to=STANDARD_CODECS,
+)
+
+BASE32_HEX = make_bytes_encoding_codec(
+    'base32-hex',
+    ['b32-hex'],
+    base64.b32hexencode,
+    base64.b32hexdecode,
+    append_to=STANDARD_CODECS,
+)
+
+BASE64_HEX = make_bytes_encoding_codec(
+    'base64-hex',
+    ['b64-hex'],
+    base64.standard_b64encode,
+    base64.standard_b64decode,
+    append_to=STANDARD_CODECS,
+)
+
+BASE64_URLSAFE = make_bytes_encoding_codec(
+    'base64-urlsafe',
+    ['b64-urlsafe'],
+    base64.urlsafe_b64encode,
+    base64.urlsafe_b64decode,
+    append_to=STANDARD_CODECS,
+)
+
+HEX = make_bytes_encoding_codec(
+    'hex',
+    [],
+    binascii.b2a_hex,
+    binascii.a2b_hex,
+    append_to=STANDARD_CODECS,
+)

omlish/codecs/chain.py

@@ -0,0 +1,23 @@
+import dataclasses as dc
+import typing as ta
+
+from .base import EagerCodec
+
+
+@dc.dataclass(frozen=True)
+class ChainEagerCodec(EagerCodec[ta.Any, ta.Any]):
+    codecs: ta.Sequence[EagerCodec]
+
+    def encode(self, v: ta.Any) -> ta.Any:
+        for c in self.codecs:
+            v = c.encode(v)
+        return v
+
+    def decode(self, v: ta.Any) -> ta.Any:
+        for c in reversed(self.codecs):
+            v = c.decode(v)
+        return v
+
+
+def chain(*codecs: EagerCodec) -> ChainEagerCodec:
+    return ChainEagerCodec(codecs)

omlish/codecs/funcs.py

@@ -0,0 +1,28 @@
+import dataclasses as dc
+import typing as ta
+
+from ..funcs import pairs as fps
+from .base import EagerCodec
+
+
+I = ta.TypeVar('I')
+O = ta.TypeVar('O')
+
+
+@dc.dataclass(frozen=True)
+class FnPairEagerCodec(EagerCodec[I, O]):
+    fp: fps.FnPair[I, O]
+
+    def encode(self, i: I) -> O:
+        return self.fp.forward(i)
+
+    def decode(self, o: O) -> I:
+        return self.fp.backward(o)
+
+    @classmethod
+    def of(
+            cls,
+            encode: ta.Callable[[I], O],
+            decode: ta.Callable[[O], I],
+    ) -> 'FnPairEagerCodec[I, O]':
+        return cls(fps.of(encode, decode))