omlish 0.0.0.dev163__tar.gz → 0.0.0.dev165__tar.gz

{omlish-0.0.0.dev163/omlish.egg-info → omlish-0.0.0.dev165}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev163
+Version: 0.0.0.dev165
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev163 → omlish-0.0.0.dev165}/omlish/.manifests.json

@@ -37,6 +37,20 @@
       }
     }
   },
+  {
+    "module": ".formats.cloudpickle",
+    "attr": "_CLOUDPICKLE_LAZY_CODEC",
+    "file": "omlish/formats/cloudpickle.py",
+    "line": 30,
+    "value": {
+      "$.codecs.base.LazyLoadedCodec": {
+        "mod_name": "omlish.formats.cloudpickle",
+        "attr_name": "CLOUDPICKLE_CODEC",
+        "name": "cloudpickle",
+        "aliases": null
+      }
+    }
+  },
   {
     "module": ".formats.json.codecs",
     "attr": "_JSON_LAZY_CODEC",
@@ -55,7 +69,7 @@
     "module": ".formats.json.codecs",
     "attr": "_JSON_COMPACT_LAZY_CODEC",
     "file": "omlish/formats/json/codecs.py",
-    "line": 23,
+    "line": 21,
     "value": {
       "$.codecs.base.LazyLoadedCodec": {
         "mod_name": "omlish.formats.json.codecs",
@@ -69,7 +83,7 @@
     "module": ".formats.json.codecs",
     "attr": "_JSON_PRETTY_LAZY_CODEC",
     "file": "omlish/formats/json/codecs.py",
-    "line": 32,
+    "line": 28,
     "value": {
       "$.codecs.base.LazyLoadedCodec": {
         "mod_name": "omlish.formats.json.codecs",
@@ -137,6 +151,20 @@
       }
     }
   },
+  {
+    "module": ".formats.yaml",
+    "attr": "_YAML_UNSAFE_LAZY_CODEC",
+    "file": "omlish/formats/yaml.py",
+    "line": 265,
+    "value": {
+      "$.codecs.base.LazyLoadedCodec": {
+        "mod_name": "omlish.formats.yaml",
+        "attr_name": "YAML_UNSAFE_CODEC",
+        "name": "yaml-unsafe",
+        "aliases": null
+      }
+    }
+  },
   {
     "module": ".io.compress.brotli",
     "attr": "_BROTLI_LAZY_CODEC",

{omlish-0.0.0.dev163 → omlish-0.0.0.dev165}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev163'
-__revision__ = '59b1e8eb235adafbfe9cdd495c8c2ad8202c6829'
+__version__ = '0.0.0.dev165'
+__revision__ = '5e68eb26c319c7641fcdbec0513840b576224ff3'
 
 
 #

{omlish-0.0.0.dev163 → omlish-0.0.0.dev165}/omlish/codecs/__init__.py

@@ -30,6 +30,9 @@ from .chain import (  # noqa
 
 from .funcs import (  # noqa
     FnPairEagerCodec,
+
+    of_pair,
+    of,
 )
 
 from .registry import (  # noqa

{omlish-0.0.0.dev163 → omlish-0.0.0.dev165}/omlish/codecs/base.py

@@ -9,6 +9,7 @@ from omlish import check
 from omlish import dataclasses as dc
 from omlish import lang
 from omlish import reflect as rfl
+from omlish.funcs import pairs as fps
 
 
 I = ta.TypeVar('I')
@@ -27,6 +28,9 @@ class EagerCodec(lang.Abstract, ta.Generic[I, O]):
     def decode(self, o: O) -> I:
         raise NotImplementedError
 
+    def as_pair(self) -> fps.FnPair[I, O]:
+        return fps.of(self.encode, self.decode)
+
 
 class IncrementalCodec(lang.Abstract, ta.Generic[I, O]):
     @abc.abstractmethod

{omlish-0.0.0.dev163 → omlish-0.0.0.dev165}/omlish/codecs/funcs.py

@@ -26,3 +26,14 @@ class FnPairEagerCodec(EagerCodec[I, O]):
             decode: ta.Callable[[O], I],
     ) -> 'FnPairEagerCodec[I, O]':
         return cls(fps.of(encode, decode))
+
+
+def of_pair(fp: fps.FnPair[I, O]) -> FnPairEagerCodec[I, O]:
+    return FnPairEagerCodec(fp)
+
+
+def of(
+        encode: ta.Callable[[I], O],
+        decode: ta.Callable[[O], I],
+) -> FnPairEagerCodec[I, O]:
+    return FnPairEagerCodec(fps.of(encode, decode))

omlish-0.0.0.dev165/omlish/formats/cloudpickle.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 cloudpickle
+else:
+    cloudpickle = lang.proxy_import('cloudpickle')
+
+
+##
+
+
+def dump(obj: ta.Any) -> bytes:
+    return cloudpickle.dumps(obj)
+
+
+def load(s: bytes) -> ta.Any:
+    return cloudpickle.loads(s)
+
+
+##
+
+
+CLOUDPICKLE_CODEC = make_bytes_object_codec('cloudpickle', dump, load)
+
+# @omlish-manifest
+_CLOUDPICKLE_LAZY_CODEC = make_object_lazy_loaded_codec(__name__, 'CLOUDPICKLE_CODEC', CLOUDPICKLE_CODEC)

{omlish-0.0.0.dev163 → omlish-0.0.0.dev165}/omlish/formats/json/codecs.py

@@ -14,19 +14,15 @@ 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

omlish-0.0.0.dev165/omlish/formats/json/delimted.py

@@ -0,0 +1,4 @@
+"""
+TODO:
+ - jsonl codec
+"""

{omlish-0.0.0.dev163 → omlish-0.0.0.dev165}/omlish/formats/yaml.py

@@ -257,3 +257,10 @@ 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)
+
+#
+
+YAML_UNSAFE_CODEC = make_str_object_codec('yaml-unsafe', dump, full_load)
+
+# @omlish-manifest
+_YAML_UNSAFE_LAZY_CODEC = make_object_lazy_loaded_codec(__name__, 'YAML_UNSAFE_CODEC', YAML_UNSAFE_CODEC)

omlish-0.0.0.dev165/omlish/funcs/pairs.py

@@ -0,0 +1,215 @@
+import abc
+import dataclasses as dc
+import typing as ta
+
+from .. import lang
+
+
+if ta.TYPE_CHECKING:
+    import struct as _struct
+else:
+    _struct = lang.proxy_import('struct')
+
+
+##
+
+
+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 __call__(self, f: F) -> T:
+        return self.forward(f)
+
+    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))
+
+
+##
+
+
+@lang.unabstract_class(['forward', 'backward'])
+@dc.dataclass(frozen=True)
+class Simple(FnPair[F, T]):
+    forward: ta.Callable[[F], T]  # type: ignore
+    backward: ta.Callable[[T], F]  # type: ignore
+
+
+of = Simple
+
+NOP: FnPair[ta.Any, ta.Any] = of(lang.identity, lang.identity)
+
+
+##
+
+
+@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)
+
+
+I0 = ta.TypeVar('I0')
+I1 = ta.TypeVar('I1')
+I2 = ta.TypeVar('I2')
+I3 = ta.TypeVar('I3')
+I4 = ta.TypeVar('I4')
+
+
+@ta.overload
+def compose(
+        fp0: FnPair[F, I0],
+        f01: FnPair[I0, T],
+) -> FnPair[F, T]:
+    ...
+
+
+@ta.overload
+def compose(
+        fp0: FnPair[F, I0],
+        f01: FnPair[I0, I1],
+        fp2: FnPair[I1, T],
+) -> FnPair[F, T]:
+    ...
+
+
+@ta.overload
+def compose(
+        fp0: FnPair[F, I0],
+        f01: FnPair[I0, I1],
+        fp2: FnPair[I1, I2],
+        fp3: FnPair[I2, T],
+) -> FnPair[F, T]:
+    ...
+
+
+@ta.overload
+def compose(
+        fp0: FnPair[F, I0],
+        f01: FnPair[I0, I1],
+        fp2: FnPair[I1, I2],
+        fp3: FnPair[I2, I3],
+        fp4: FnPair[I3, T],
+) -> FnPair[F, T]:
+    ...
+
+
+@ta.overload
+def compose(
+        fp0: FnPair[F, I0],
+        f01: FnPair[I0, I1],
+        fp2: FnPair[I1, I2],
+        fp3: FnPair[I2, I3],
+        fp4: FnPair[I3, I4],
+        fp5: FnPair[I4, T],
+) -> FnPair[F, T]:
+    ...
+
+
+@ta.overload
+def compose(*ps: FnPair) -> FnPair:
+    ...
+
+
+def compose(*ps):
+    if not ps:
+        return NOP
+    if len(ps) == 1:
+        return ps[0]
+    return Composite(ps)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class Optional(FnPair[F | None, T | None]):
+    fp: FnPair[F, T]
+
+    def forward(self, f: F | None) -> T | None:
+        return None if f is None else self.fp.forward(f)
+
+    def backward(self, t: T | None) -> F | None:
+        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()
+
+
+##
+
+
+@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)
+
+
+##
+
+
+Object: ta.TypeAlias = FnPair[ta.Any, T]
+ObjectStr: ta.TypeAlias = Object[str]
+ObjectBytes: ta.TypeAlias = Object[bytes]
+
+
+class Object_(FnPair[ta.Any, T], lang.Abstract):  # noqa
+    pass
+
+
+class ObjectStr_(Object_[str], lang.Abstract):  # noqa
+    pass
+
+
+class ObjectBytes_(Object_[bytes], lang.Abstract):  # noqa
+    pass

{omlish-0.0.0.dev163 → omlish-0.0.0.dev165/omlish.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev163
+Version: 0.0.0.dev165
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev163 → omlish-0.0.0.dev165}/omlish.egg-info/SOURCES.txt

@@ -214,6 +214,7 @@ omlish/docker/manifests.py
 omlish/docker/timebomb.py
 omlish/formats/__init__.py
 omlish/formats/cbor.py
+omlish/formats/cloudpickle.py
 omlish/formats/codecs.py
 omlish/formats/dotenv.py
 omlish/formats/json5.py
@@ -225,6 +226,7 @@ omlish/formats/yaml.py
 omlish/formats/json/__init__.py
 omlish/formats/json/codecs.py
 omlish/formats/json/consts.py
+omlish/formats/json/delimted.py
 omlish/formats/json/encoding.py
 omlish/formats/json/json.py
 omlish/formats/json/literals.py

{omlish-0.0.0.dev163 → omlish-0.0.0.dev165}/pyproject.toml

@@ -12,7 +12,7 @@ authors = [
 urls = {source = 'https://github.com/wrmsr/omlish'}
 license = {text = 'BSD-3-Clause'}
 requires-python = '>=3.12'
-version = '0.0.0.dev163'
+version = '0.0.0.dev165'
 classifiers = [
     'License :: OSI Approved :: BSD License',
     'Development Status :: 2 - Pre-Alpha',