jmux 0.0.4__py3-none-any.whl → 0.0.6__py3-none-any.whl

jmux/awaitable.py

@@ -1,11 +1,15 @@
+from __future__ import annotations
+
 from asyncio import Event, Queue
 from enum import Enum
 from types import NoneType
 from typing import (
     AsyncGenerator,
+    Generic,
     Protocol,
     Set,
     Type,
+    TypeVar,
     cast,
     runtime_checkable,
 )
@@ -13,13 +17,15 @@ from typing import (
 from jmux.error import NothingEmittedError, SinkClosedError
 from jmux.helpers import extract_types_from_generic_alias
 
+T = TypeVar("T")
+
 
 class SinkType(Enum):
     STREAMABLE_VALUES = "StreamableValues"
     AWAITABLE_VALUE = "AwaitableValue"
 
 
-class UnderlyingGenericMixin[T]:
+class UnderlyingGenericMixin(Generic[T]):
     """
     A mixin class that provides methods for inspecting the generic types of a 
     class at runtime.
@@ -61,7 +67,7 @@ class UnderlyingGenericMixin[T]:
 
 
 @runtime_checkable
-class IAsyncSink[T](Protocol):
+class IAsyncSink(Protocol[T]):
     """
     An asynchronous sink protocol that defines a common interface for putting, closing,
     and retrieving values from a sink.
@@ -96,7 +102,7 @@ class IAsyncSink[T](Protocol):
         ...
 
 
-class StreamableValues[T](UnderlyingGenericMixin[T]):
+class StreamableValues(UnderlyingGenericMixin[T], Generic[T]):
     """
     A class that represents a stream of values that can be asynchronously iterated over.
     It uses an asyncio.Queue to store the items and allows for putting items into the
@@ -198,7 +204,7 @@ class StreamableValues[T](UnderlyingGenericMixin[T]):
             yield item
 
 
-class AwaitableValue[T](UnderlyingGenericMixin[T]):
+class AwaitableValue(UnderlyingGenericMixin[T], Generic[T]):
     """
     A class that represents a value that will be available in the future.
     It can be awaited to get the value, and it can only be set once.

jmux/decoder.py

@@ -32,26 +32,40 @@ class StringEscapeDecoder:
     def __init__(self):
         self._buffer = ""
         self._string_escape = False
+        self._is_parsing_unicode = False
+        self._unicode_buffer = ""
 
     def push(self, ch: str) -> str | None:
+        if self._is_parsing_unicode:
+            self._unicode_buffer += ch
+            if len(self._unicode_buffer) == 4:
+                code_point = int(self._unicode_buffer, 16)
+                decoded_char = chr(code_point)
+                self._buffer += decoded_char
+                self._is_parsing_unicode = False
+                self._unicode_buffer = ""
+                return decoded_char
+            return None
+
         if self._string_escape:
             self._string_escape = False
             if ch == "u":
-                self.is_parsing_unicode = True
-                self.unicode_buffer = ""
-                return
+                self._is_parsing_unicode = True
+                self._unicode_buffer = ""
+                return None
             escaped_char = self.escape_map.get(ch, ch)
             self._buffer += escaped_char
             return escaped_char
 
         if ch == "\\":
             self._string_escape = True
+            return None
         else:
             self._buffer += ch
             return ch
 
     def is_terminating_quote(self, ch: str) -> bool:
-        if self._string_escape:
+        if self._string_escape or self._is_parsing_unicode:
             return False
         if ch == '"':
             return True
@@ -60,6 +74,8 @@ class StringEscapeDecoder:
     def reset(self) -> None:
         self._buffer = ""
         self._string_escape = False
+        self._is_parsing_unicode = False
+        self._unicode_buffer = ""
 
     @property
     def buffer(self) -> str:

jmux/demux.py

@@ -1,10 +1,15 @@
+from __future__ import annotations
+
 from abc import ABC
 from enum import Enum
 from types import NoneType
 from typing import (
+    Generic,
     Optional,
     Set,
     Type,
+    TypeVar,
+    Union,
     get_args,
     get_origin,
     get_type_hints,
@@ -42,6 +47,8 @@ from jmux.types import (
     BOOLEAN_OPEN,
     COLON,
     COMMA,
+    EXPECT_KEY_IN_ROOT,
+    EXPECT_VALUE_IN_ARRAY,
     FLOAT_ALLOWED,
     INTERGER_ALLOWED,
     JSON_FALSE,
@@ -59,11 +66,13 @@ from jmux.types import (
 from jmux.types import Mode as M
 from jmux.types import State as S
 
-type Primitive = int | float | str | bool | None
-type Emittable = Primitive | "JMux" | Enum
+Primitive = Union[int, float, str, bool, None]
+Emittable = Union[int, float, str, bool, None, "JMux", Enum]
+
+T = TypeVar("T")
 
 
-class Sink[T: Emittable]:
+class Sink(Generic[T]):
     def __init__(self, delegate: "JMux"):
         self._current_key: Optional[str] = None
         self._current_sink: Optional[IAsyncSink[T]] = None
@@ -192,60 +201,74 @@ class JMux(ABC):
             ForbiddenTypeHintsError: If a type hint is not allowed.
             ObjectMissmatchedError: If the JMux class does not match the Pydantic model.
         """
-        for attr_name, type_alias in get_type_hints(cls).items():
-            jmux_main_type_set, jmux_subtype_set = extract_types_from_generic_alias(
-                type_alias
-            )
-
-            MaybePydanticType = get_type_hints(pydantic_model).get(attr_name, None)
-            if MaybePydanticType is None:
-                if NoneType in jmux_subtype_set:
-                    continue
-                else:
-                    raise MissingAttributeError(
-                        object_name=pydantic_model.__name__,
-                        attribute=attr_name,
-                    )
+        try:
+            for attr_name, type_alias in get_type_hints(cls).items():
+                jmux_main_type_set, jmux_subtype_set = extract_types_from_generic_alias(
+                    type_alias
+                )
 
-            pydantic_main_type_set, pydantic_subtype_set = (
-                extract_types_from_generic_alias(MaybePydanticType)
-            )
-            cls._assert_only_allowed_types(
-                jmux_main_type_set,
-                jmux_subtype_set,
-                pydantic_main_type_set,
-                pydantic_subtype_set,
-            )
-            cls._assert_correct_set_combinations(
-                jmux_main_type_set,
-                pydantic_main_type_set,
-                pydantic_subtype_set,
-            )
+                MaybePydanticType = get_type_hints(pydantic_model).get(attr_name, None)
+                if MaybePydanticType is None:
+                    if NoneType in jmux_subtype_set:
+                        continue
+                    else:
+                        raise MissingAttributeError(
+                            object_name=pydantic_model.__name__,
+                            attribute=attr_name,
+                        )
 
-            if StreamableValues in jmux_main_type_set:
-                cls._assert_is_allowed_streamable_values(
-                    jmux_subtype_set,
-                    pydantic_subtype_set,
-                    pydantic_main_type_set,
-                    pydantic_model,
-                    attr_name,
+                pydantic_main_type_set, pydantic_subtype_set = (
+                    extract_types_from_generic_alias(MaybePydanticType)
                 )
-            elif AwaitableValue in jmux_main_type_set:
-                cls._assert_is_allowed_awaitable_value(
+                cls._assert_only_allowed_types(
+                    jmux_main_type_set,
                     jmux_subtype_set,
-                    pydantic_subtype_set,
                     pydantic_main_type_set,
-                    pydantic_model,
-                    attr_name,
+                    pydantic_subtype_set,
                 )
-            else:
-                raise ObjectMissmatchedError(
-                    jmux_model=cls.__name__,
-                    pydantic_model=pydantic_model.__name__,
-                    attribute=attr_name,
-                    message="Unexpected main type on JMux",
+                cls._assert_correct_set_combinations(
+                    jmux_main_type_set,
+                    pydantic_main_type_set,
+                    pydantic_subtype_set,
                 )
 
+                if StreamableValues in jmux_main_type_set:
+                    cls._assert_is_allowed_streamable_values(
+                        jmux_subtype_set,
+                        pydantic_subtype_set,
+                        pydantic_main_type_set,
+                        pydantic_model,
+                        attr_name,
+                    )
+                elif AwaitableValue in jmux_main_type_set:
+                    cls._assert_is_allowed_awaitable_value(
+                        jmux_subtype_set,
+                        pydantic_subtype_set,
+                        pydantic_main_type_set,
+                        pydantic_model,
+                        attr_name,
+                    )
+                else:
+                    raise ObjectMissmatchedError(
+                        jmux_model=cls.__name__,
+                        pydantic_model=pydantic_model.__name__,
+                        attribute=attr_name,
+                        message="Unexpected main type on JMux",
+                    )
+        except TypeError as e:
+            raise ForbiddenTypeHintsError(message=f"Unexpected type hint: {e}") from e
+        except MissingAttributeError as e:
+            raise e
+        except ObjectMissmatchedError as e:
+            raise e
+        except Exception as e:
+            raise ObjectMissmatchedError(
+                jmux_model=cls.__name__,
+                pydantic_model=pydantic_model.__name__,
+                attribute=attr_name,
+                message=f"Unexpected main type on JMux: {e}",
+            )
+
     @classmethod
     def _assert_correct_set_combinations(
         cls,
@@ -474,18 +497,27 @@ class JMux(ABC):
             # CONTEXT: Root
             case M.ROOT:
                 match self._pda.state:
-                    case S.EXPECT_KEY:
+                    case _ if self._pda.state in EXPECT_KEY_IN_ROOT:
                         if ch in JSON_WHITESPACE:
                             pass
                         elif ch == '"':
                             self._pda.set_state(S.PARSING_KEY)
                             self._decoder.reset()
+                        elif ch in OBJECT_CLOSE:
+                            if self._pda.state is S.EXPECT_KEY_AFTER_COMMA:
+                                raise UnexpectedCharacterError(
+                                    ch,
+                                    self._pda.stack,
+                                    self._pda.state,
+                                    "Trailing comma in object is not allowed.",
+                                )
+                            await self._finalize()
                         else:
                             raise UnexpectedCharacterError(
                                 ch,
                                 self._pda.stack,
                                 self._pda.state,
-                                "Char needs to be '\"' or JSON whitespaces",
+                                "Char needs to be '\"', '}' or JSON whitespaces",
                             )
 
                     case S.PARSING_KEY:
@@ -530,6 +562,14 @@ class JMux(ABC):
                                     "Expected '[' or '\"' for 'StreamableValues'",
                                 )
                         elif ch in ARRAY_OPEN:
+                            if self._sink.current_sink_type == SinkType.AWAITABLE_VALUE:
+                                raise UnexpectedCharacterError(
+                                    ch,
+                                    self._pda.stack,
+                                    self._pda.state,
+                                    "Trying to parse 'array' but sink type is "
+                                    "'AwaitableValue'.",
+                                )
                             self._pda.set_state(S.EXPECT_VALUE)
                             self._pda.push(M.ARRAY)
                         else:
@@ -572,12 +612,12 @@ class JMux(ABC):
                             await self._parse_primitive()
                             await self._sink.close()
                             self._decoder.reset()
-                            if ch in JSON_WHITESPACE:
-                                self._pda.set_state(S.EXPECT_COMMA_OR_EOC)
-                            else:
-                                self._pda.set_state(S.EXPECT_KEY)
-                            if ch in OBJECT_CLOSE:
+                            if ch in COMMA:
+                                self._pda.set_state(S.EXPECT_KEY_AFTER_COMMA)
+                            elif ch in OBJECT_CLOSE:
                                 await self._finalize()
+                            else:
+                                self._pda.set_state(S.EXPECT_COMMA_OR_EOC)
                         else:
                             self._assert_primitive_character_allowed_in_state(ch)
                             self._decoder.push(ch)
@@ -586,7 +626,7 @@ class JMux(ABC):
                         if ch in JSON_WHITESPACE:
                             pass
                         elif ch in COMMA:
-                            self._pda.set_state(S.EXPECT_KEY)
+                            self._pda.set_state(S.EXPECT_KEY_AFTER_COMMA)
                         elif ch in OBJECT_CLOSE:
                             await self._finalize()
                         else:
@@ -615,12 +655,19 @@ class JMux(ABC):
                     )
 
                 match self._pda.state:
-                    case S.EXPECT_VALUE:
+                    case _ if self._pda.state in EXPECT_VALUE_IN_ARRAY:
                         if ch in JSON_WHITESPACE:
                             pass
                         elif await self._handle_common__expect_value(ch):
                             pass
                         elif ch in ARRAY_CLOSE:
+                            if self._pda.state is S.EXPECT_VALUE_AFTER_COMMA:
+                                raise UnexpectedCharacterError(
+                                    ch,
+                                    self._pda.stack,
+                                    self._pda.state,
+                                    "Trailing comma in array is not allowed.",
+                                )
                             await self._close_context(S.EXPECT_COMMA_OR_EOC)
                         else:
                             raise UnexpectedCharacterError(
@@ -663,9 +710,11 @@ class JMux(ABC):
                             await self._parse_primitive()
                             self._decoder.reset()
                             if ch in COMMA:
-                                self._pda.set_state(S.EXPECT_VALUE)
+                                self._pda.set_state(S.EXPECT_VALUE_AFTER_COMMA)
                             elif ch in ARRAY_CLOSE:
                                 await self._close_context(S.EXPECT_COMMA_OR_EOC)
+                            else:
+                                self._pda.set_state(S.EXPECT_COMMA_OR_EOC)
                         else:
                             self._assert_primitive_character_allowed_in_state(ch)
                             self._decoder.push(ch)
@@ -674,7 +723,7 @@ class JMux(ABC):
                         if ch in JSON_WHITESPACE:
                             pass
                         elif ch in COMMA:
-                            self._pda.set_state(S.EXPECT_VALUE)
+                            self._pda.set_state(S.EXPECT_VALUE_AFTER_COMMA)
                         elif ch in ARRAY_CLOSE:
                             await self._close_context(S.EXPECT_COMMA_OR_EOC)
                         else:

jmux/pda.py

@@ -1,7 +1,12 @@
-from typing import List
+from __future__ import annotations
 
+from typing import Generic, List, Optional, TypeVar
 
-class PushDownAutomata[Context, State]:
+Context = TypeVar("Context")
+State = TypeVar("State")
+
+
+class PushDownAutomata(Generic[Context, State]):
     def __init__(self, start_state: State) -> None:
         self._stack: List[Context] = []
         self._state: State = start_state
@@ -15,7 +20,7 @@ class PushDownAutomata[Context, State]:
         return self._stack
 
     @property
-    def top(self) -> Context | None:
+    def top(self) -> Optional[Context]:
         if not self._stack:
             return None
         return self._stack[-1]

jmux/types.py

@@ -9,8 +9,10 @@ class State(Enum):
     ERROR = "error"
     # expect
     EXPECT_KEY = "expect_key"
+    EXPECT_KEY_AFTER_COMMA = "expect_key_after_comma"
     EXPECT_COLON = "expect_colon"
     EXPECT_VALUE = "expect_value"
+    EXPECT_VALUE_AFTER_COMMA = "expect_value_after_comma"
     EXPECT_COMMA_OR_EOC = "expect_comma_or_eoc"
     # parsing
     PARSING_KEY = "parsing_key"
@@ -29,6 +31,9 @@ PARSING_PRIMITIVE_STATES: Set[State] = {
     State.PARSING_NULL,
 }
 
+EXPECT_KEY_IN_ROOT = {State.EXPECT_KEY, State.EXPECT_KEY_AFTER_COMMA}
+EXPECT_VALUE_IN_ARRAY = {State.EXPECT_VALUE, State.EXPECT_VALUE_AFTER_COMMA}
+
 
 class Mode(Enum):
     ROOT = "$"

{jmux-0.0.4.dist-info → jmux-0.0.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jmux
-Version: 0.0.4
+Version: 0.0.6
 Summary: JMux: A Python package for demultiplexing a JSON string into multiple awaitable variables.
 Author-email: "Johannes A.I. Unruh" <johannes@unruh.ai>
 License: MIT License
@@ -32,7 +32,7 @@ Project-URL: Repository, https://github.com/jaunruh/jmux
 Keywords: demultiplexer,python,package,json
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.12
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: anyio>=4.0.0

jmux-0.0.6.dist-info/RECORD

@@ -0,0 +1,13 @@
+jmux/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jmux/awaitable.py,sha256=otX4vbWzVmIwxvMDWOtaIvS9do8YJtbls9xFjwH9Yw0,8534
+jmux/decoder.py,sha256=YoCkBKposMx1PA78BIVawgFw96QsqTZaOW4gNCSkI7I,2197
+jmux/demux.py,sha256=R2vazLOtfh4zvQKoj3_92RgdqG-zaG3CkQMBz72fAIE,38800
+jmux/error.py,sha256=VZJYivt8RPfjcF2bs-T7_UkH3dVA3xH-xGbZggQV14k,4665
+jmux/helpers.py,sha256=zOlw1Yk7-sdKAeasswRRcuUOTEBAUbymoAGwBTMaOjg,2902
+jmux/pda.py,sha256=19joQd0DD5OAmwRpp2jVVbtiFXnjv5P_1mZm87-QOeY,922
+jmux/types.py,sha256=a5Xyx_8A3gsZkscII1_7E6oyu4VQ-oI4_osTnPLi_xs,1649
+jmux-0.0.6.dist-info/licenses/LICENSE,sha256=y0qnwaAe4bEqzNPyq4M_VZA2I2mQly8MawajyZhqw0k,1169
+jmux-0.0.6.dist-info/METADATA,sha256=cJJfsEjvnpvffxjEgdwbsTQFxB8uqIArJApCYRjTETo,13330
+jmux-0.0.6.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+jmux-0.0.6.dist-info/top_level.txt,sha256=TF2N6kHqLghfOkCiNlCueMDX4l5rPn_5MSPNtYrS1-o,5
+jmux-0.0.6.dist-info/RECORD,,

{jmux-0.0.4.dist-info → jmux-0.0.6.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

jmux-0.0.4.dist-info/RECORD

@@ -1,13 +0,0 @@
-jmux/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jmux/awaitable.py,sha256=gceBygIf3fAIWLsN1lWxsz9ExWNasDuk1WaGz8d9FAc,8427
-jmux/decoder.py,sha256=Y6KVryRDLvGV5nBsneXpTvC0WUGhR5Z89Dvqz4HMAgg,1562
-jmux/demux.py,sha256=g9DkMc9sLs31nuVwb7jbGZAjs0KulsKDGfOIM87NuWQ,36317
-jmux/error.py,sha256=VZJYivt8RPfjcF2bs-T7_UkH3dVA3xH-xGbZggQV14k,4665
-jmux/helpers.py,sha256=zOlw1Yk7-sdKAeasswRRcuUOTEBAUbymoAGwBTMaOjg,2902
-jmux/pda.py,sha256=81gnh0eWGsgd_SrHkqjRQy_KkOSlBf5nor7pqKGgYjw,791
-jmux/types.py,sha256=CJhFS9RVgR0cDBNJR8ROAFnxzG4YTYpNZ90hyD2SxsY,1389
-jmux-0.0.4.dist-info/licenses/LICENSE,sha256=y0qnwaAe4bEqzNPyq4M_VZA2I2mQly8MawajyZhqw0k,1169
-jmux-0.0.4.dist-info/METADATA,sha256=vVREVDZvfTC0KadGCOrw7RrSGxXdmZZNHJ8K-Zr3ZLM,13330
-jmux-0.0.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-jmux-0.0.4.dist-info/top_level.txt,sha256=TF2N6kHqLghfOkCiNlCueMDX4l5rPn_5MSPNtYrS1-o,5
-jmux-0.0.4.dist-info/RECORD,,