jmux 0.0.5__tar.gz → 0.0.6__tar.gz

{jmux-0.0.5/src/jmux.egg-info → jmux-0.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jmux
-Version: 0.0.5
+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

{jmux-0.0.5 → jmux-0.0.6}/src/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-0.0.5 → jmux-0.0.6}/src/jmux/demux.py

@@ -47,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,
@@ -199,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,
@@ -481,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:
@@ -537,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:
@@ -579,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)
@@ -593,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:
@@ -622,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(
@@ -670,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)
@@ -681,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-0.0.5 → jmux-0.0.6}/src/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.5 → jmux-0.0.6/src/jmux.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jmux
-Version: 0.0.5
+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

{jmux-0.0.5 → jmux-0.0.6}/src/jmux.egg-info/SOURCES.txt

@@ -22,4 +22,5 @@ tests/test_decoder.py
 tests/test_demux__parse.py
 tests/test_demux__stream.py
 tests/test_demux__validate.py
-tests/test_helpers.py
+tests/test_helpers.py
+tests/test_pda.py