omlish 0.0.0.dev133__py3-none-any.whl → 0.0.0.dev177__py3-none-any.whl

omlish/formats/json/stream/parse.py

@@ -1,9 +1,12 @@
+import dataclasses as dc
 import typing as ta
 
 from .... import lang
-from ....genmachine import GenMachine
+from ....funcs.genmachine import GenMachine
+from .errors import JsonStreamError
 from .lex import SCALAR_VALUE_TYPES
 from .lex import VALUE_TOKEN_KINDS
+from .lex import Position
 from .lex import ScalarValue
 from .lex import Token
 
@@ -79,6 +82,13 @@ def yield_parser_events(obj: ta.Any) -> ta.Generator[JsonStreamParserEvent, None
 ##
 
 
+@dc.dataclass()
+class JsonStreamParseError(JsonStreamError):
+    message: str
+
+    pos: Position | None = None
+
+
 class JsonStreamObject(list):
     def __repr__(self) -> str:
         return f'{self.__class__.__name__}({super().__repr__()})'
@@ -100,29 +110,29 @@ class JsonStreamParser(GenMachine[Token, JsonStreamParserEvent]):
         if tt == 'KEY':
             self._stack.pop()
             if not self._stack:
-                raise self.StateError
+                raise JsonStreamParseError('Unexpected key')
 
             tt2 = self._stack[-1]
             if tt2 == 'OBJECT':
                 return ((v,), self._do_after_pair())
 
             else:
-                raise self.StateError
+                raise JsonStreamParseError('Unexpected key')
 
         elif tt == 'ARRAY':
             return ((v,), self._do_after_element())
 
         else:
-            raise self.StateError
+            raise JsonStreamParseError(f'Unexpected value: {v!r}')
 
     #
 
-    def _do_value(self):
+    def _do_value(self, *, must_be_present: bool = False):
         try:
             tok = yield None
         except GeneratorExit:
             if self._stack:
-                raise self.StateError from None
+                raise JsonStreamParseError('Expected value') from None
             else:
                 raise
 
@@ -141,13 +151,16 @@ class JsonStreamParser(GenMachine[Token, JsonStreamParserEvent]):
             yield y
             return r
 
+        elif must_be_present:
+            raise JsonStreamParseError('Expected value', tok.pos)
+
         elif tok.kind == 'RBRACKET':
             y, r = self._emit_end_array()
             yield y
             return r
 
         else:
-            raise self.StateError
+            raise JsonStreamParseError('Expected value', tok.pos)
 
     #
 
@@ -157,19 +170,19 @@ class JsonStreamParser(GenMachine[Token, JsonStreamParserEvent]):
 
     def _emit_end_object(self):
         if not self._stack:
-            raise self.StateError
+            raise JsonStreamParseError('Unexpected end object')
 
         tt = self._stack.pop()
         if tt != 'OBJECT':
-            raise self.StateError
+            raise JsonStreamParseError('Unexpected end object')
 
         return self._emit_event(EndObject)
 
-    def _do_object_body(self):
+    def _do_object_body(self, *, must_be_present: bool = False):
         try:
             tok = yield None
         except GeneratorExit:
-            raise self.StateError from None
+            raise JsonStreamParseError('Expected object body') from None
 
         if tok.kind == 'STRING':
             k = tok.value
@@ -177,30 +190,33 @@ class JsonStreamParser(GenMachine[Token, JsonStreamParserEvent]):
             try:
                 tok = yield None
             except GeneratorExit:
-                raise self.StateError from None
+                raise JsonStreamParseError('Expected key') from None
             if tok.kind != 'COLON':
-                raise self.StateError
+                raise JsonStreamParseError('Expected colon', tok.pos)
 
             yield (Key(k),)
             self._stack.append('KEY')
             return self._do_value()
 
+        elif must_be_present:
+            raise JsonStreamParseError('Expected value', tok.pos)
+
         elif tok.kind == 'RBRACE':
             y, r = self._emit_end_object()
             yield y
             return r
 
         else:
-            raise self.StateError
+            raise JsonStreamParseError('Expected value', tok.pos)
 
     def _do_after_pair(self):
         try:
             tok = yield None
         except GeneratorExit:
-            raise self.StateError from None
+            raise JsonStreamParseError('Expected continuation') from None
 
         if tok.kind == 'COMMA':
-            return self._do_object_body()
+            return self._do_object_body(must_be_present=True)
 
         elif tok.kind == 'RBRACE':
             y, r = self._emit_end_object()
@@ -208,7 +224,7 @@ class JsonStreamParser(GenMachine[Token, JsonStreamParserEvent]):
             return r
 
         else:
-            raise self.StateError
+            raise JsonStreamParseError('Expected continuation', tok.pos)
 
     #
 
@@ -218,11 +234,11 @@ class JsonStreamParser(GenMachine[Token, JsonStreamParserEvent]):
 
     def _emit_end_array(self):
         if not self._stack:
-            raise self.StateError
+            raise JsonStreamParseError('Expected end array')
 
         tt = self._stack.pop()
         if tt != 'ARRAY':
-            raise self.StateError
+            raise JsonStreamParseError('Unexpected end array')
 
         return self._emit_event(EndArray)
 
@@ -230,10 +246,10 @@ class JsonStreamParser(GenMachine[Token, JsonStreamParserEvent]):
         try:
             tok = yield None
         except GeneratorExit:
-            raise self.StateError from None
+            raise JsonStreamParseError('Expected continuation') from None
 
         if tok.kind == 'COMMA':
-            return self._do_value()
+            return self._do_value(must_be_present=True)
 
         elif tok.kind == 'RBRACKET':
             y, r = self._emit_end_array()
@@ -241,4 +257,4 @@ class JsonStreamParser(GenMachine[Token, JsonStreamParserEvent]):
             return r
 
         else:
-            raise self.StateError
+            raise JsonStreamParseError('Expected continuation', tok.pos)

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/repr.py

@@ -0,0 +1,25 @@
+import ast
+import typing as ta
+
+from .codecs import make_object_lazy_loaded_codec
+from .codecs import make_str_object_codec
+
+
+##
+
+
+def dumps(obj: ta.Any) -> str:
+    return repr(obj)
+
+
+def loads(s: str) -> ta.Any:
+    return ast.literal_eval(s)
+
+
+##
+
+
+REPR_CODEC = make_str_object_codec('repr', dumps, loads)
+
+# @omlish-manifest
+_REPR_LAZY_CODEC = make_object_lazy_loaded_codec(__name__, 'REPR_CODEC', REPR_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,26 @@ 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)
+
+#
+
+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/{genmachine.py → funcs/genmachine.py}

@@ -12,7 +12,7 @@ import typing as ta
 I = ta.TypeVar('I')
 O = ta.TypeVar('O')
 
-# MachineGen: ta.TypeAlias = ta.Generator[ta.Iterable[O] | None, I, ta.Optional[MachineGen[I, O]]]
+# MachineGen: ta.TypeAlias = ta.Generator[ta.Iterable[O] | None, I | None, ta.Optional[MachineGen[I, O]]]
 MachineGen: ta.TypeAlias = ta.Generator[ta.Any, ta.Any, ta.Any]
 
 
@@ -67,8 +67,7 @@ class GenMachine(ta.Generic[I, O]):
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        if exc_type is None:
-            self.close()
+        self.close()
 
     #
 
@@ -93,8 +92,10 @@ class GenMachine(ta.Generic[I, O]):
         if self._gen is None:
             raise GenMachine.ClosedError
 
+        gi: I | None = i
         try:
-            while (o := self._gen.send(i)) is not None:
+            while (o := self._gen.send(gi)) is not None:
+                gi = None
                 yield from o
 
         except StopIteration as s:

omlish/{matchfns.py → funcs/match.py}

@@ -8,7 +8,7 @@ import abc
 import dataclasses as dc
 import typing as ta
 
-from . import lang
+from .. import lang
 
 
 T = ta.TypeVar('T')

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/http/__init__.py

@@ -1,48 +0,0 @@
-from . import consts  # noqa
-
-from .clients import (  # noqa
-    HttpClient,
-    HttpClientError,
-    HttpRequest,
-    HttpResponse,
-    HttpxHttpClient,
-    UrllibHttpClient,
-    client,
-    request,
-)
-
-from .cookies import (  # noqa
-    CookieTooBigError,
-    dump_cookie,
-    parse_cookie,
-)
-
-from .dates import (  # noqa
-    http_date,
-    parse_date,
-)
-
-from .encodings import (  # noqa
-    latin1_decode,
-    latin1_encode,
-)
-
-from .headers import (  # noqa
-    CanHttpHeaders,
-    HttpHeaders,
-    headers,
-)
-
-from .json import (  # noqa
-    JSON_TAGGER,
-    JsonTag,
-    JsonTagger,
-    json_dumps,
-    json_loads,
-)
-
-from .multipart import (  # noqa
-    MultipartData,
-    MultipartEncoder,
-    MultipartField,
-)

omlish/http/all.py

@@ -0,0 +1,48 @@
+from . import consts  # noqa
+
+from .clients import (  # noqa
+    HttpClient,
+    HttpClientError,
+    HttpRequest,
+    HttpResponse,
+    HttpxHttpClient,
+    UrllibHttpClient,
+    client,
+    request,
+)
+
+from .cookies import (  # noqa
+    CookieTooBigError,
+    dump_cookie,
+    parse_cookie,
+)
+
+from .dates import (  # noqa
+    http_date,
+    parse_date,
+)
+
+from .encodings import (  # noqa
+    latin1_decode,
+    latin1_encode,
+)
+
+from .headers import (  # noqa
+    CanHttpHeaders,
+    HttpHeaders,
+    headers,
+)
+
+from .json import (  # noqa
+    JSON_TAGGER,
+    JsonTag,
+    JsonTagger,
+    json_dumps,
+    json_loads,
+)
+
+from .multipart import (  # noqa
+    MultipartData,
+    MultipartEncoder,
+    MultipartField,
+)