omlish 0.0.0.dev81__py3-none-any.whl → 0.0.0.dev83__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/formats/xml.py

@@ -0,0 +1,63 @@
+"""
+TODO:
+ - lxml abstraction
+ - stuff from ommlx/wiki
+"""
+import typing as ta
+
+from .. import dataclasses as dc
+from .. import lang
+
+
+if ta.TYPE_CHECKING:
+    import xml.etree.ElementTree as ET
+else:
+    ET = lang.proxy_import('xml.etree.ElementTree')
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class SimpleElement:
+    tag: str
+    attributes: ta.Mapping[str, str] | None = dc.xfield(default=None, repr_fn=dc.truthy_repr)
+    body: ta.Sequence[ta.Union['SimpleElement', str]] | None = dc.xfield(default=None, repr_fn=dc.truthy_repr)
+
+    def as_dict(self) -> dict[str, ta.Any]:
+        dct: dict[str, ta.Any] = {'tag': self.tag}
+        if self.attributes:
+            dct['attributes'] = self.attributes
+        if self.body:
+            dct['body'] = [
+                c.as_dict() if isinstance(c, SimpleElement) else c
+                for c in self.body
+            ]
+        return dct
+
+
+def build_simple_element(element: 'ET.Element') -> SimpleElement:
+    atts = {}
+    for name, value in element.attrib.items():
+        atts[name] = value  # noqa
+
+    body: list[SimpleElement | str] = []
+
+    if element.text and (s := element.text.strip()):
+        body.append(s)
+
+    for child in element:
+        body.append(build_simple_element(child))
+
+        if child.tail and (s := child.tail.strip()):
+            body.append(s)
+
+    return SimpleElement(
+        element.tag,
+        atts,
+        body,
+    )
+
+
+def parse_tree(s: str) -> 'ET.ElementTree':
+    return ET.ElementTree(ET.fromstring(s.strip()))  # noqa

omlish/genmachine.py

@@ -1,6 +1,7 @@
 """
 TODO:
  - feed_iter helper
+ - accept yielding outputs on transitions, *except* on initial state - add test
 
 See:
  - https://github.com/pytransitions/transitions
@@ -25,10 +26,19 @@ 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:
@@ -57,7 +67,8 @@ class GenMachine(ta.Generic[I, O]):
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        self.close()
+        if exc_type is None:
+            self.close()
 
     #
 
@@ -74,6 +85,7 @@ class GenMachine(ta.Generic[I, O]):
 
     def _advance(self, gen: MachineGen) -> None:
         self._gen = gen
+
         if (n := next(self._gen)) is not None:  # noqa
             raise GenMachine.ClosedError
 

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.dev81.dist-info → omlish-0.0.0.dev83.dist-info}/METADATA

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