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

jmux/demux.py

@@ -32,7 +32,7 @@ from jmux.error import (
 from jmux.helpers import (
     extract_types_from_generic_alias,
     get_main_type,
-    is_json_whitespace,
+    str_to_bool,
 )
 from jmux.pda import PushDownAutomata
 from jmux.types import (
@@ -47,12 +47,13 @@ from jmux.types import (
     JSON_FALSE,
     JSON_NULL,
     JSON_TRUE,
+    JSON_WHITESPACE,
     NULL_ALLOWED,
     NULL_OPEN,
     NUMBER_OPEN,
     OBJECT_CLOSE,
     OBJECT_OPEN,
-    PRIMITIVE_STATES,
+    PARSING_PRIMITIVE_STATES,
     QUOTE,
 )
 from jmux.types import Mode as M
@@ -215,17 +216,11 @@ class JMux(ABC):
                 pydantic_main_type_set,
                 pydantic_subtype_set,
             )
-            if (
-                pydantic_wrong := len(pydantic_main_type_set) != 1
-                and len(pydantic_subtype_set) > 0
-            ) or len(jmux_main_type_set) != 1:
-                wrong_obj = "pydantic" if pydantic_wrong else "JMux"
-                wrong_set = (
-                    jmux_main_type_set if pydantic_wrong else pydantic_main_type_set
-                )
-                raise ForbiddenTypeHintsError(
-                    message=(f"Forbidden typing received on {wrong_obj}: {wrong_set}"),
-                )
+            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(
@@ -251,6 +246,80 @@ class JMux(ABC):
                     message="Unexpected main type on JMux",
                 )
 
+    @classmethod
+    def _assert_correct_set_combinations(
+        cls,
+        jmux_main_type_set: Set[Type],
+        pydantic_main_type_set: Set[Type],
+        pydantic_subtype_set: Set[Type],
+    ):
+        if (
+            pydantic_wrong := (
+                len(pydantic_main_type_set) != 1 and list not in pydantic_main_type_set
+            )
+            and len(pydantic_subtype_set) > 0
+        ) or len(jmux_main_type_set) != 1:
+            wrong_obj = "pydantic" if pydantic_wrong else "JMux"
+            wrong_set = pydantic_main_type_set if pydantic_wrong else jmux_main_type_set
+            raise ForbiddenTypeHintsError(
+                message=(f"Forbidden typing received on {wrong_obj}: {wrong_set}"),
+            )
+
+    @classmethod
+    def _assert_only_allowed_types(
+        cls,
+        jmux_main_type_set: Set[Type],
+        jmux_subtype_set: Set[Type],
+        pydantic_main_type_set: Set[Type],
+        pydantic_subtype_set: Set[Type],
+    ) -> None:
+        if not all(t in (AwaitableValue, StreamableValues) for t in jmux_main_type_set):
+            raise ForbiddenTypeHintsError(
+                message=(
+                    "JMux must have either AwaitableValue or StreamableValues as "
+                    f"main type, got {jmux_main_type_set}."
+                )
+            )
+
+        if not cls._all_elements_in_set_a_are_subclass_of_an_element_in_set_b(
+            set_a=jmux_subtype_set,
+            set_b={int, float, str, bool, NoneType, JMux, Enum},
+        ):
+            raise ForbiddenTypeHintsError(
+                message=(
+                    "JMux sub type must be one of the emittable types, got: "
+                    f"{jmux_subtype_set}."
+                )
+            )
+
+        if not cls._all_elements_in_set_a_are_subclass_of_an_element_in_set_b(
+            set_a=pydantic_subtype_set,
+            set_b={int, float, str, bool, NoneType, BaseModel, Enum},
+        ):
+            raise ForbiddenTypeHintsError(
+                message=(
+                    "Pydantic sub type must be one of the primitive, enum or "
+                    f"BaseModel, got: {pydantic_subtype_set}."
+                )
+            )
+
+        if not cls._all_elements_in_set_a_are_subclass_of_an_element_in_set_b(
+            set_a=pydantic_main_type_set,
+            set_b={int, float, str, bool, list, NoneType, BaseModel, Enum},
+        ):
+            raise ForbiddenTypeHintsError(
+                message=(
+                    "Pydantic main type must be one of the primitive, enum, list "
+                    f"or BaseModel, got {pydantic_main_type_set}."
+                )
+            )
+
+    @classmethod
+    def _all_elements_in_set_a_are_subclass_of_an_element_in_set_b(
+        cls, set_a: Set[Type], set_b: Set[Type]
+    ) -> bool:
+        return all(any(issubclass(elem, t) for t in set_b) for elem in set_a)
+
     @classmethod
     def _assert_is_allowed_streamable_values(
         cls,
@@ -328,58 +397,6 @@ class JMux(ABC):
                 ),
             )
 
-    @classmethod
-    def _assert_only_allowed_types(
-        cls,
-        jmux_main_type_set: Set[Type],
-        jmux_subtype_set: Set[Type],
-        pydantic_main_type_set: Set[Type],
-        pydantic_subtype_set: Set[Type],
-    ) -> None:
-        if not all(t in (AwaitableValue, StreamableValues) for t in jmux_main_type_set):
-            raise ForbiddenTypeHintsError(
-                message=(
-                    "JMux must have either AwaitableValue or StreamableValues as "
-                    f"main type, got {jmux_main_type_set}."
-                )
-            )
-
-        if not any(
-            issubclass(elem, t)
-            for t in (int, float, str, bool, NoneType, JMux, Enum)
-            for elem in jmux_subtype_set
-        ):
-            raise ForbiddenTypeHintsError(
-                message=(
-                    "JMux sub type must be one of the emittable types: "
-                    f"{jmux_subtype_set}."
-                )
-            )
-
-        if len(pydantic_subtype_set) > 0 and not any(
-            issubclass(elem, t)
-            for t in (int, float, str, bool, NoneType, BaseModel, Enum)
-            for elem in pydantic_subtype_set
-        ):
-            raise ForbiddenTypeHintsError(
-                message=(
-                    "Pydantic sub type must be one of the primitive, enum or "
-                    f"BaseModel, got: {pydantic_subtype_set}."
-                )
-            )
-
-        if not any(
-            issubclass(elem, t)
-            for t in (int, float, str, bool, list, NoneType, BaseModel, Enum)
-            for elem in pydantic_main_type_set
-        ):
-            raise ForbiddenTypeHintsError(
-                message=(
-                    "Pydantic main type must be one of the primitive, enum, list "
-                    f"or BaseModel, got {pydantic_main_type_set}."
-                )
-            )
-
     async def feed_chunks(self, chunks: str) -> None:
         """
         Feeds a string of characters to the JMux parser.
@@ -421,7 +438,7 @@ class JMux(ABC):
             case None:
                 match self._pda.state:
                     case S.START:
-                        if is_json_whitespace(ch):
+                        if ch in JSON_WHITESPACE:
                             pass
                         elif ch in OBJECT_OPEN:
                             self._pda.push(M.ROOT)
@@ -434,7 +451,7 @@ class JMux(ABC):
                                 "JSON must start with '{' character.",
                             )
                     case S.END:
-                        if is_json_whitespace(ch):
+                        if ch in JSON_WHITESPACE:
                             pass
                         else:
                             raise ObjectAlreadyClosedError(
@@ -458,7 +475,7 @@ class JMux(ABC):
             case M.ROOT:
                 match self._pda.state:
                     case S.EXPECT_KEY:
-                        if is_json_whitespace(ch):
+                        if ch in JSON_WHITESPACE:
                             pass
                         elif ch == '"':
                             self._pda.set_state(S.PARSING_KEY)
@@ -485,7 +502,7 @@ class JMux(ABC):
                             self._decoder.push(ch)
 
                     case S.EXPECT_COLON:
-                        if is_json_whitespace(ch):
+                        if ch in JSON_WHITESPACE:
                             pass
                         elif ch in COLON:
                             self._pda.set_state(S.EXPECT_VALUE)
@@ -498,7 +515,7 @@ class JMux(ABC):
                             )
 
                     case S.EXPECT_VALUE:
-                        if is_json_whitespace(ch):
+                        if ch in JSON_WHITESPACE:
                             pass
                         elif res := await self._handle_common__expect_value(ch):
                             if (
@@ -550,20 +567,23 @@ class JMux(ABC):
                             ):
                                 await self._sink.emit(maybe_char)
 
-                    case _ if self._pda.state in PRIMITIVE_STATES:
-                        if ch not in COMMA | OBJECT_CLOSE:
-                            self._assert_primitive_character_allowed_in_state(ch)
-                            self._decoder.push(ch)
-                        else:
+                    case _ if self._pda.state in PARSING_PRIMITIVE_STATES:
+                        if ch in COMMA | OBJECT_CLOSE | JSON_WHITESPACE:
                             await self._parse_primitive()
                             await self._sink.close()
                             self._decoder.reset()
-                            self._pda.set_state(S.EXPECT_KEY)
+                            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:
                                 await self._finalize()
+                        else:
+                            self._assert_primitive_character_allowed_in_state(ch)
+                            self._decoder.push(ch)
 
                     case S.EXPECT_COMMA_OR_EOC:
-                        if is_json_whitespace(ch):
+                        if ch in JSON_WHITESPACE:
                             pass
                         elif ch in COMMA:
                             self._pda.set_state(S.EXPECT_KEY)
@@ -596,7 +616,7 @@ class JMux(ABC):
 
                 match self._pda.state:
                     case S.EXPECT_VALUE:
-                        if is_json_whitespace(ch):
+                        if ch in JSON_WHITESPACE:
                             pass
                         elif await self._handle_common__expect_value(ch):
                             pass
@@ -638,20 +658,20 @@ class JMux(ABC):
                         else:
                             self._decoder.push(ch)
 
-                    case _ if self._pda.state in PRIMITIVE_STATES:
-                        if ch not in COMMA | ARRAY_CLOSE:
-                            self._assert_primitive_character_allowed_in_state(ch)
-                            self._decoder.push(ch)
-                        else:
+                    case _ if self._pda.state in PARSING_PRIMITIVE_STATES:
+                        if ch in COMMA | ARRAY_CLOSE | JSON_WHITESPACE:
                             await self._parse_primitive()
                             self._decoder.reset()
                             if ch in COMMA:
                                 self._pda.set_state(S.EXPECT_VALUE)
                             elif ch in ARRAY_CLOSE:
                                 await self._close_context(S.EXPECT_COMMA_OR_EOC)
+                        else:
+                            self._assert_primitive_character_allowed_in_state(ch)
+                            self._decoder.push(ch)
 
                     case S.EXPECT_COMMA_OR_EOC:
-                        if is_json_whitespace(ch):
+                        if ch in JSON_WHITESPACE:
                             pass
                         elif ch in COMMA:
                             self._pda.set_state(S.EXPECT_VALUE)
@@ -681,8 +701,16 @@ class JMux(ABC):
                         self._pda.state,
                         "State in object context must be 'parsing_object'",
                     )
-                if ch in OBJECT_CLOSE:
+                if ch in OBJECT_OPEN:
+                    if self._pda.top is M.OBJECT:
+                        await self._sink.forward_char(ch)
+                    self._pda.push(M.OBJECT)
+                elif ch in OBJECT_CLOSE:
                     self._pda.pop()
+                    if self._pda.top is M.OBJECT:
+                        await self._sink.forward_char(ch)
+                        return
+
                     if self._pda.top is M.ROOT:
                         await self._sink.close()
                     self._pda.set_state(S.EXPECT_COMMA_OR_EOC)
@@ -699,7 +727,8 @@ class JMux(ABC):
                 )
             await self._sink.emit(None)
         elif self._pda.state is S.PARSING_BOOLEAN:
-            await self._sink.emit(self._decoder.buffer == JSON_TRUE)
+            bool_value = str_to_bool(self._decoder.buffer)
+            await self._sink.emit(bool_value)
         else:
             try:
                 buffer = self._decoder.buffer

jmux/helpers.py

@@ -1,17 +1,37 @@
-from types import NoneType, UnionType
-from typing import Set, Tuple, Type, Union, get_args, get_origin
+from types import NoneType
+from typing import Set, Tuple, Type, get_args, get_origin
 
+from jmux.error import ParsePrimitiveError
+from jmux.types import TYPES_LIKE_NONE, TYPES_LIKE_UNION
 
-def is_json_whitespace(ch: str) -> bool:
-    return ch in {" ", "\t", "\n", "\r"}
+
+def str_to_bool(s: str) -> bool:
+    if s == "true":
+        return True
+    elif s == "false":
+        return False
+    else:
+        raise ParsePrimitiveError(
+            f"Cannot convert string '{s}' to boolean. Expected 'true' or 'false', got"
+            f" '{s}'."
+        )
 
 
 def extract_types_from_generic_alias(UnknownType: Type) -> Tuple[Set[Type], Set[Type]]:
     Origin: Type | None = get_origin(UnknownType)
     if Origin is None:
         return {UnknownType}, set()
-    if Origin is UnionType or Origin is Union:
-        return deconstruct_type(UnknownType), set()
+    if Origin in TYPES_LIKE_UNION:
+        deconstructed = deconstruct_flat_type(UnknownType)
+        maybe_list_types = [
+            subtypes for subtypes in deconstructed if get_origin(subtypes) is list
+        ]
+        if len(maybe_list_types) == 1:
+            list_based_type = maybe_list_types[0]
+            non_list_types = deconstructed - {list_based_type}
+            main_type, subtype = extract_types_from_generic_alias(list_based_type)
+            return non_list_types | main_type, subtype
+        return deconstructed, set()
 
     type_args = get_args(UnknownType)
     if len(type_args) != 1:
@@ -21,7 +41,7 @@ def extract_types_from_generic_alias(UnknownType: Type) -> Tuple[Set[Type], Set[
         )
 
     Generic: Type = type_args[0]
-    type_set = deconstruct_type(Generic)
+    type_set = deconstruct_flat_type(Generic)
     if len(type_set) == 1:
         return {Origin}, type_set
     if len(type_set) != 2:
@@ -36,16 +56,20 @@ def extract_types_from_generic_alias(UnknownType: Type) -> Tuple[Set[Type], Set[
     return {Origin}, type_set
 
 
-def deconstruct_type(UnknownType: Type) -> Set[Type]:
+def deconstruct_flat_type(UnknownType: Type) -> Set[Type]:
     Origin: Type | None = get_origin(UnknownType)
-    if UnknownType is None:
+    if UnknownType in TYPES_LIKE_NONE:
         return {NoneType}
     if Origin is None:
         return {UnknownType}
-    if not (Origin is UnionType or Origin is Union):
-        return {Origin}
-    type_args = get_args(UnknownType)
-    return set(type_args)
+    if Origin in TYPES_LIKE_UNION:
+        type_args = get_args(UnknownType)
+        return set(type_args)
+    raise TypeError(
+        f"Unknown type {UnknownType} is not a Union or optional type, "
+        "only only those types and their syntactic sugar are supported "
+        "for flat deconstruction."
+    )
 
 
 def get_main_type(type_set: Set[Type]) -> Type:

jmux/types.py

@@ -1,5 +1,6 @@
 from enum import Enum
-from typing import Set
+from types import NoneType, UnionType
+from typing import List, Set, Union
 
 
 class State(Enum):
@@ -21,7 +22,7 @@ class State(Enum):
     PARSING_OBJECT = "parsing_object"
 
 
-PRIMITIVE_STATES: Set[State] = {
+PARSING_PRIMITIVE_STATES: Set[State] = {
     State.PARSING_INTEGER,
     State.PARSING_FLOAT,
     State.PARSING_BOOLEAN,
@@ -55,3 +56,8 @@ NULL_ALLOWED = set("nul")
 JSON_FALSE = "false"
 JSON_TRUE = "true"
 JSON_NULL = "null"
+JSON_WHITESPACE = set(" \t\n\r")
+
+TYPES_LIKE_UNION = {UnionType, Union}
+TYPES_LIKE_NONE = {NoneType, None}
+TYPES_LIKE_LIST = {List, list}

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jmux
-Version: 0.0.2
+Version: 0.0.4
 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.4.dist-info/RECORD

@@ -0,0 +1,13 @@
+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,,

jmux-0.0.2.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=7YJBD_EGUyxjiwjVnKCZOA-NrpXWrTe_y2Eitl4EU3E,35089
-jmux/error.py,sha256=VZJYivt8RPfjcF2bs-T7_UkH3dVA3xH-xGbZggQV14k,4665
-jmux/helpers.py,sha256=6y33RohUGVvGGaAREyRQTmEWfgV4w295SyqDwIMnUNs,1982
-jmux/pda.py,sha256=81gnh0eWGsgd_SrHkqjRQy_KkOSlBf5nor7pqKGgYjw,791
-jmux/types.py,sha256=V63wMx1I7l_P83JAqzOQ7H7B-xKrNUuGshJ3NjKsdeQ,1192
-jmux-0.0.2.dist-info/licenses/LICENSE,sha256=y0qnwaAe4bEqzNPyq4M_VZA2I2mQly8MawajyZhqw0k,1169
-jmux-0.0.2.dist-info/METADATA,sha256=G3PPpw0VhSYx9YyeVUT9T12YCGxORI7HVFAQYTB4Od4,13330
-jmux-0.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-jmux-0.0.2.dist-info/top_level.txt,sha256=TF2N6kHqLghfOkCiNlCueMDX4l5rPn_5MSPNtYrS1-o,5
-jmux-0.0.2.dist-info/RECORD,,