omlish 0.0.0.dev80__py3-none-any.whl → 0.0.0.dev82__py3-none-any.whl

omlish/formats/json/stream/parse.py

@@ -0,0 +1,244 @@
+import typing as ta
+
+from .... import lang
+from ....genmachine import GenMachine
+from .lex import SCALAR_VALUE_TYPES
+from .lex import VALUE_TOKEN_KINDS
+from .lex import ScalarValue
+from .lex import Token
+
+
+##
+
+
+class BeginObject(lang.Marker):
+    pass
+
+
+class Key(ta.NamedTuple):
+    key: str
+
+
+class EndObject(lang.Marker):
+    pass
+
+
+class BeginArray(lang.Marker):
+    pass
+
+
+class EndArray(lang.Marker):
+    pass
+
+
+JsonStreamParserEvent: ta.TypeAlias = ta.Union[  # noqa
+    type[BeginObject],
+    Key,
+    type[EndObject],
+
+    type[BeginArray],
+    type[EndArray],
+
+    ScalarValue,
+]
+
+
+class JsonStreamParserEvents(lang.Namespace):
+    BeginObject = BeginObject
+    Key = Key
+    EndObject = EndObject
+
+    BeginArray = BeginArray
+    EndArray = EndArray
+
+
+##
+
+
+def yield_parser_events(obj: ta.Any) -> ta.Generator[JsonStreamParserEvent, None, None]:
+    if isinstance(obj, SCALAR_VALUE_TYPES):
+        yield obj  # type: ignore
+
+    elif isinstance(obj, ta.Mapping):
+        yield BeginObject
+        for k, v in obj.items():
+            yield Key(k)
+            yield from yield_parser_events(v)
+        yield EndObject
+
+    elif isinstance(obj, ta.Sequence):
+        yield BeginArray
+        for v in obj:
+            yield from yield_parser_events(v)
+        yield EndArray
+
+    else:
+        raise TypeError(obj)
+
+
+##
+
+
+class JsonStreamObject(list):
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({super().__repr__()})'
+
+
+class JsonStreamParser(GenMachine[Token, JsonStreamParserEvent]):
+    def __init__(self) -> None:
+        super().__init__(self._do_value())
+
+        self._stack: list[ta.Literal['OBJECT', 'KEY', 'ARRAY']] = []
+
+    #
+
+    def _emit_event(self, v):
+        if not self._stack:
+            return ((v,), self._do_value())
+
+        tt = self._stack[-1]
+        if tt == 'KEY':
+            self._stack.pop()
+            if not self._stack:
+                raise self.StateError
+
+            tt2 = self._stack[-1]
+            if tt2 == 'OBJECT':
+                return ((v,), self._do_after_pair())
+
+            else:
+                raise self.StateError
+
+        elif tt == 'ARRAY':
+            return ((v,), self._do_after_element())
+
+        else:
+            raise self.StateError
+
+    #
+
+    def _do_value(self):
+        try:
+            tok = yield None
+        except GeneratorExit:
+            if self._stack:
+                raise self.StateError from None
+            else:
+                raise
+
+        if tok.kind in VALUE_TOKEN_KINDS:
+            y, r = self._emit_event(tok.value)
+            yield y
+            return r
+
+        elif tok.kind == 'LBRACE':
+            y, r = self._emit_begin_object()
+            yield y
+            return r
+
+        elif tok.kind == 'LBRACKET':
+            y, r = self._emit_begin_array()
+            yield y
+            return r
+
+        elif tok.kind == 'RBRACKET':
+            y, r = self._emit_end_array()
+            yield y
+            return r
+
+        else:
+            raise self.StateError
+
+    #
+
+    def _emit_begin_object(self):
+        self._stack.append('OBJECT')
+        return ((BeginObject,), self._do_object_body())
+
+    def _emit_end_object(self):
+        if not self._stack:
+            raise self.StateError
+
+        tt = self._stack.pop()
+        if tt != 'OBJECT':
+            raise self.StateError
+
+        return self._emit_event(EndObject)
+
+    def _do_object_body(self):
+        try:
+            tok = yield None
+        except GeneratorExit:
+            raise self.StateError from None
+
+        if tok.kind == 'STRING':
+            k = tok.value
+
+            try:
+                tok = yield None
+            except GeneratorExit:
+                raise self.StateError from None
+            if tok.kind != 'COLON':
+                raise self.StateError
+
+            yield (Key(k),)
+            self._stack.append('KEY')
+            return self._do_value()
+
+        elif tok.kind == 'RBRACE':
+            y, r = self._emit_end_object()
+            yield y
+            return r
+
+        else:
+            raise self.StateError
+
+    def _do_after_pair(self):
+        try:
+            tok = yield None
+        except GeneratorExit:
+            raise self.StateError from None
+
+        if tok.kind == 'COMMA':
+            return self._do_object_body()
+
+        elif tok.kind == 'RBRACE':
+            y, r = self._emit_end_object()
+            yield y
+            return r
+
+        else:
+            raise self.StateError
+
+    #
+
+    def _emit_begin_array(self):
+        self._stack.append('ARRAY')
+        return ((BeginArray,), self._do_value())
+
+    def _emit_end_array(self):
+        if not self._stack:
+            raise self.StateError
+
+        tt = self._stack.pop()
+        if tt != 'ARRAY':
+            raise self.StateError
+
+        return self._emit_event(EndArray)
+
+    def _do_after_element(self):
+        try:
+            tok = yield None
+        except GeneratorExit:
+            raise self.StateError from None
+
+        if tok.kind == 'COMMA':
+            return self._do_value()
+
+        elif tok.kind == 'RBRACKET':
+            y, r = self._emit_end_array()
+            yield y
+            return r
+
+        else:
+            raise self.StateError

omlish/formats/json/stream/render.py

@@ -0,0 +1,119 @@
+import json
+import typing as ta
+
+from ..render import AbstractJsonRenderer
+from ..render import JsonRendererOut
+from .build import JsonObjectBuilder
+from .parse import BeginArray
+from .parse import BeginObject
+from .parse import EndArray
+from .parse import EndObject
+from .parse import JsonStreamParserEvent
+from .parse import Key
+
+
+##
+
+
+class StreamJsonRenderer(AbstractJsonRenderer[ta.Iterable[JsonStreamParserEvent]]):
+    def __init__(
+            self,
+            out: JsonRendererOut,
+            opts: AbstractJsonRenderer.Options = AbstractJsonRenderer.Options(),
+    ) -> None:
+        if opts.sort_keys:
+            raise TypeError('Not yet implemented')
+
+        super().__init__(out, opts)
+
+        self._stack: list[tuple[ta.Literal['OBJECT', 'ARRAY'], int]] = []
+        self._builder: JsonObjectBuilder | None = None
+
+    def _render_value(
+            self,
+            o: ta.Any,
+            state: AbstractJsonRenderer.State = AbstractJsonRenderer.State.VALUE,
+    ) -> None:
+        if self._opts.style is not None:
+            pre, post = self._opts.style(o, state)
+            self._write(pre)
+        else:
+            post = None
+
+        if o is None or isinstance(o, bool):
+            self._write(self._literals[o])
+
+        elif isinstance(o, (str, int, float)):
+            self._write(json.dumps(o))
+
+        else:
+            raise TypeError(o)
+
+        if post:
+            self._write(post)
+
+    def _render(self, e: JsonStreamParserEvent) -> None:
+        if e != EndArray and self._stack and (tt := self._stack[-1])[0] == 'ARRAY':
+            if tt[1]:
+                self._write(self._comma)
+            self._write_indent()
+
+            self._stack[-1] = ('ARRAY', tt[1] + 1)
+
+        #
+
+        if e is None or isinstance(e, (str, int, float, bool)):
+            self._render_value(e)
+
+        #
+
+        elif e is BeginObject:
+            self._stack.append(('OBJECT', 0))
+            self._write('{')
+            self._level += 1
+
+        elif isinstance(e, Key):
+            if not self._stack or (tt := self._stack.pop())[0] != 'OBJECT':
+                raise Exception
+
+            if tt[1]:
+                self._write(self._comma)
+            self._write_indent()
+            self._render_value(e.key, AbstractJsonRenderer.State.KEY)
+            self._write(self._colon)
+
+            self._stack.append(('OBJECT', tt[1] + 1))
+
+        elif e is EndObject:
+            if not self._stack or (tt := self._stack.pop())[0] != 'OBJECT':
+                raise Exception
+
+            self._level -= 1
+            if tt[1]:
+                self._write_indent()
+            self._write('}')
+
+        #
+
+        elif e is BeginArray:
+            self._stack.append(('ARRAY', 0))
+            self._write('[')
+            self._level += 1
+
+        elif e is EndArray:
+            if not self._stack or (tt := self._stack.pop())[0] != 'ARRAY':
+                raise Exception
+
+            self._level -= 1
+            if tt[1]:
+                self._write_indent()
+            self._write(']')
+
+        #
+
+        else:
+            raise TypeError(e)
+
+    def render(self, events: ta.Iterable[JsonStreamParserEvent]) -> None:
+        for e in events:
+            self._render(e)

omlish/genmachine.py

@@ -1,4 +1,8 @@
 """
+TODO:
+ - feed_iter helper
+ - accept yielding outputs on transitions, *except* on initial state - add test
+
 See:
  - https://github.com/pytransitions/transitions
 """
@@ -15,10 +19,6 @@ MachineGen: ta.TypeAlias = ta.Generator[ta.Any, ta.Any, ta.Any]
 ##
 
 
-class IllegalStateError(Exception):
-    pass
-
-
 class GenMachine(ta.Generic[I, O]):
     """
     Generator-powered state machine. Generators are sent an `I` object and yield any number of `O` objects in response,
@@ -26,34 +26,80 @@ class GenMachine(ta.Generic[I, O]):
     `None` to terminate.
     """
 
-    def __init__(self, initial: MachineGen) -> None:
+    def __init__(self, initial: MachineGen | None = None) -> None:
         super().__init__()
+
+        if initial is None:
+            initial = self._initial_state()
+            if initial is None:
+                raise TypeError('No initial state')
+
         self._advance(initial)
 
+    def _initial_state(self) -> MachineGen | None:
+        return None
+
+    _gen: MachineGen | None
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}@{hex(id(self))[2:]}<{self.state}>'
+
+    #
+
     @property
     def state(self) -> str | None:
         if self._gen is not None:
             return self._gen.gi_code.co_qualname
         return None
 
-    def __repr__(self) -> str:
-        return f'{self.__class__.__name__}@{hex(id(self))[2:]}<{self.state}>'
+    #
 
-    _gen: MachineGen | None
+    @property
+    def closed(self) -> bool:
+        return self._gen is None
+
+    def close(self) -> None:
+        if self._gen is not None:
+            self._gen.close()
+            self._gen = None
+
+    def __enter__(self) -> ta.Self:
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if exc_type is None:
+            self.close()
+
+    #
+
+    class Error(Exception):
+        pass
+
+    class ClosedError(Exception):
+        pass
+
+    class StateError(Exception):
+        pass
+
+    #
 
     def _advance(self, gen: MachineGen) -> None:
         self._gen = gen
+
         if (n := next(self._gen)) is not None:  # noqa
-            raise IllegalStateError
+            raise GenMachine.ClosedError
 
     def __call__(self, i: I) -> ta.Iterable[O]:
         if self._gen is None:
-            raise IllegalStateError
+            raise GenMachine.ClosedError
+
         try:
             while (o := self._gen.send(i)) is not None:
                 yield from o
+
         except StopIteration as s:
             if s.value is None:
                 self._gen = None
                 return None
+
             self._advance(s.value)

omlish/lang/resources.py

@@ -1,14 +1,19 @@
+import dataclasses as dc
 import functools
 import importlib.resources
 import os.path
 import typing as ta
 
 
-class RelativeResource(ta.NamedTuple):
+@dc.dataclass(frozen=True)
+class RelativeResource:
     name: str
     is_file: bool
     read_bytes: ta.Callable[[], bytes]
 
+    def read_text(self, encoding: str = 'utf-8') -> str:
+        return self.read_bytes().decode(encoding)
+
 
 def get_relative_resources(
         path: str = '',

omlish/marshal/base.py

@@ -6,6 +6,8 @@ TODO:
  - streaming? Start/EndObject, etc..
  - lang.Marker - class name, handle type[Foo]
   - can't disambiguate from str - can't coexist in bare union
+ - factories being free MatchFns does more harm than good - in practice these are such big guns you want to write a
+   class body if only ceremonially
 
 See:
  - https://github.com/python-attrs/cattrs

omlish/marshal/newtypes.py

@@ -0,0 +1,24 @@
+from .. import check
+from .. import reflect as rfl
+from .base import MarshalContext
+from .base import Marshaler
+from .base import MarshalerFactory
+from .base import UnmarshalContext
+from .base import Unmarshaler
+from .base import UnmarshalerFactory
+
+
+class NewtypeMarshalerFactory(MarshalerFactory):
+    def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
+        return isinstance(rty, rfl.NewType)
+
+    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
+        return ctx.make(check.isinstance(rty, rfl.NewType).ty)
+
+
+class NewtypeUnmarshalerFactory(UnmarshalerFactory):
+    def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
+        return isinstance(rty, rfl.NewType)
+
+    def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
+        return ctx.make(check.isinstance(rty, rfl.NewType).ty)

omlish/marshal/standard.py

@@ -21,6 +21,8 @@ from .mappings import MappingMarshalerFactory
 from .mappings import MappingUnmarshalerFactory
 from .maybes import MaybeMarshalerFactory
 from .maybes import MaybeUnmarshalerFactory
+from .newtypes import NewtypeMarshalerFactory
+from .newtypes import NewtypeUnmarshalerFactory
 from .numbers import NUMBERS_MARSHALER_FACTORY
 from .numbers import NUMBERS_UNMARSHALER_FACTORY
 from .optionals import OptionalMarshalerFactory
@@ -38,6 +40,7 @@ from .uuids import UUID_UNMARSHALER_FACTORY
 
 STANDARD_MARSHALER_FACTORIES: list[MarshalerFactory] = [
     PRIMITIVE_MARSHALER_FACTORY,
+    NewtypeMarshalerFactory(),
     OptionalMarshalerFactory(),
     PrimitiveUnionMarshalerFactory(),
     DataclassMarshalerFactory(),
@@ -68,6 +71,7 @@ def new_standard_marshaler_factory() -> MarshalerFactory:
 
 STANDARD_UNMARSHALER_FACTORIES: list[UnmarshalerFactory] = [
     PRIMITIVE_UNMARSHALER_FACTORY,
+    NewtypeUnmarshalerFactory(),
     OptionalUnmarshalerFactory(),
     PrimitiveUnionUnmarshalerFactory(),
     DataclassUnmarshalerFactory(),

omlish/reflect/__init__.py

@@ -33,6 +33,7 @@ from .types import (  # noqa
     TYPES,
     Type,
     Union,
+    get_newtype_supertype,
     get_orig_bases,
     get_orig_class,
     get_params,

omlish/reflect/types.py

@@ -107,6 +107,10 @@ def get_orig_class(obj: ta.Any) -> ta.Any:
     return obj.__orig_class__  # noqa
 
 
+def get_newtype_supertype(obj: ta.Any) -> ta.Any:
+    return obj.__supertype__
+
+
 ##
 
 
@@ -164,6 +168,7 @@ class Generic:
 @dc.dataclass(frozen=True)
 class NewType:
     obj: ta.Any
+    ty: Type
 
 
 @dc.dataclass(frozen=True)
@@ -243,7 +248,7 @@ class Reflector:
             return Union(frozenset(self.type(a) for a in ta.get_args(obj)))
 
         if isinstance(obj, ta.NewType):  # noqa
-            return NewType(obj)
+            return NewType(obj, get_newtype_supertype(obj))
 
         if (
                 is_simple_generic_alias_type(oty) or

{omlish-0.0.0.dev80.dist-info → omlish-0.0.0.dev82.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev80
+Version: 0.0.0.dev82
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause
@@ -19,6 +19,7 @@ Requires-Dist: greenlet ~=3.1 ; extra == 'all'
 Requires-Dist: trio ~=0.27 ; extra == 'all'
 Requires-Dist: trio-asyncio ~=0.15 ; extra == 'all'
 Requires-Dist: lz4 ~=4.3 ; extra == 'all'
+Requires-Dist: python-snappy ~=0.7 ; extra == 'all'
 Requires-Dist: zstd ~=1.5 ; extra == 'all'
 Requires-Dist: asttokens ~=2.4 ; extra == 'all'
 Requires-Dist: executing ~=2.1 ; extra == 'all'
@@ -37,11 +38,10 @@ Requires-Dist: pg8000 ~=1.31 ; extra == 'all'
 Requires-Dist: pymysql ~=1.1 ; extra == 'all'
 Requires-Dist: aiomysql ~=0.2 ; extra == 'all'
 Requires-Dist: aiosqlite ~=0.20 ; extra == 'all'
+Requires-Dist: asyncpg ~=0.30 ; extra == 'all'
 Requires-Dist: apsw ~=3.46 ; extra == 'all'
 Requires-Dist: duckdb ~=1.1 ; extra == 'all'
 Requires-Dist: pytest ~=8.0 ; extra == 'all'
-Requires-Dist: python-snappy ~=0.7 ; (python_version < "3.13") and extra == 'all'
-Requires-Dist: asyncpg ~=0.30 ; (python_version < "3.13") and extra == 'all'
 Requires-Dist: sqlean.py ~=3.45 ; (python_version < "3.13") and extra == 'all'
 Provides-Extra: async
 Requires-Dist: anyio ~=4.6 ; extra == 'async'
@@ -51,8 +51,8 @@ Requires-Dist: trio ~=0.27 ; extra == 'async'
 Requires-Dist: trio-asyncio ~=0.15 ; extra == 'async'
 Provides-Extra: compress
 Requires-Dist: lz4 ~=4.3 ; extra == 'compress'
+Requires-Dist: python-snappy ~=0.7 ; extra == 'compress'
 Requires-Dist: zstd ~=1.5 ; extra == 'compress'
-Requires-Dist: python-snappy ~=0.7 ; (python_version < "3.13") and extra == 'compress'
 Provides-Extra: diag
 Requires-Dist: asttokens ~=2.4 ; extra == 'diag'
 Requires-Dist: executing ~=2.1 ; extra == 'diag'
@@ -85,9 +85,9 @@ Requires-Dist: pg8000 ~=1.31 ; extra == 'sqldrivers'
 Requires-Dist: pymysql ~=1.1 ; extra == 'sqldrivers'
 Requires-Dist: aiomysql ~=0.2 ; extra == 'sqldrivers'
 Requires-Dist: aiosqlite ~=0.20 ; extra == 'sqldrivers'
+Requires-Dist: asyncpg ~=0.30 ; extra == 'sqldrivers'
 Requires-Dist: apsw ~=3.46 ; extra == 'sqldrivers'
 Requires-Dist: duckdb ~=1.1 ; extra == 'sqldrivers'
-Requires-Dist: asyncpg ~=0.30 ; (python_version < "3.13") and extra == 'sqldrivers'
 Requires-Dist: sqlean.py ~=3.45 ; (python_version < "3.13") and extra == 'sqldrivers'
 Provides-Extra: testing
 Requires-Dist: pytest ~=8.0 ; extra == 'testing'