jmux 0.0.3__tar.gz → 0.0.5__tar.gz

{jmux-0.0.3 → jmux-0.0.5}/.github/workflows/ci.yml

@@ -8,16 +8,13 @@ on:
       - "v*.*.*"
   pull_request: {}
 
-env:
-  UV_FROZEN: true
-
 jobs:
   check:
     runs-on: ubuntu-latest
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.12", "3.13"]
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
 
     steps:
       - uses: actions/checkout@v4

{jmux-0.0.3 → jmux-0.0.5}/.gitignore

@@ -24,6 +24,7 @@ var/
 *.egg
 
 # Virtual environment
+uv.lock
 venv/
 ENV/
 env/
@@ -76,4 +77,7 @@ Thumbs.db
 
 # Local project configs
 .env
-.env.*
+.env.*
+
+# Cursor
+.cursor/

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jmux
-Version: 0.0.3
+Version: 0.0.5
 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.3 → jmux-0.0.5}/pyproject.toml

@@ -7,7 +7,7 @@ name = "jmux"
 dynamic = ["version"]
 description = "JMux: A Python package for demultiplexing a JSON string into multiple awaitable variables."
 readme = "README.md"
-requires-python = ">=3.12"
+requires-python = ">=3.10"
 classifiers = [
   "Programming Language :: Python :: 3",
   "Operating System :: OS Independent",

{jmux-0.0.3 → jmux-0.0.5}/src/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-0.0.3 → jmux-0.0.5}/src/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,
@@ -59,11 +64,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
@@ -216,17 +223,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(
@@ -252,6 +253,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,
@@ -329,58 +404,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.
@@ -556,7 +579,10 @@ class JMux(ABC):
                             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:

{jmux-0.0.3 → jmux-0.0.5}/src/jmux/helpers.py

@@ -1,7 +1,8 @@
-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 str_to_bool(s: str) -> bool:
@@ -20,8 +21,17 @@ def extract_types_from_generic_alias(UnknownType: Type) -> Tuple[Set[Type], Set[
     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:
@@ -31,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:
@@ -46,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-0.0.3 → jmux-0.0.5}/src/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-0.0.3 → jmux-0.0.5}/src/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):
@@ -56,3 +57,7 @@ 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.3 → jmux-0.0.5/src/jmux.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jmux
-Version: 0.0.3
+Version: 0.0.5
 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.3 → jmux-0.0.5}/src/jmux.egg-info/SOURCES.txt

@@ -2,7 +2,6 @@
 LICENSE
 README.md
 pyproject.toml
-uv.lock
 .github/workflows/ci.yml
 src/jmux/__init__.py
 src/jmux/awaitable.py

{jmux-0.0.3 → jmux-0.0.5}/tests/test_demux__parse.py

@@ -282,7 +282,7 @@ parse_incorrect_stream__params = [
     parse_incorrect_stream__params,
 )
 @pytest.mark.anyio
-async def test_json_demux__parse_incorrect_stream__assert_error(
+async def test_json_demux__parse_stream__assert_error(
     stream: str, MaybeExpectedError: Type[Exception] | None
 ):
     class SObject(JMux):
@@ -375,7 +375,7 @@ parse_incorrect_stream_with_optionals__params = [
     parse_incorrect_stream_with_optionals__params,
 )
 @pytest.mark.anyio
-async def test_json_demux__parse_incorrect_stream_with_optionals__assert_error(
+async def test_json_demux__parse_stream_with_optionals__assert_error(
     stream: str, MaybeExpectedError: Type[Exception] | None
 ):
     class SObject(JMux):
@@ -416,6 +416,10 @@ parse_correct_stream__double_nested__params = [
     ('{"key_first_nested": {"key_second_nested": {"key_str": "val"}, "key_str": "val', None),
     ('{"key_first_nested": {"key_second_nested": {"key_str": "val"}, "key_str": "val"}', None),
     ('{"key_first_nested": {"key_second_nested": {"key_str": "val"}, "key_str": "val"}}', None),
+    ('{"key_first_nested": {"key_second_nested": {"key_str": "val"}, "key_str": null}}', None),
+    ('{"key_first_nested": {"key_second_nested": {"key_str": "val"}, "key_str": null\n}}', None),
+    ('{"key_first_nested": null}', None),
+    ('{"key_first_nested": null\n}', None),
 ]
 # fmt: on
 @pytest.mark.parametrize(
@@ -423,7 +427,7 @@ parse_correct_stream__double_nested__params = [
     parse_correct_stream__double_nested__params,
 )
 @pytest.mark.anyio
-async def test_json_demux__parse_correct_stream__double_nested(
+async def test_json_demux__parse_stream__double_nested(
     stream: str, MaybeExpectedError: Type[Exception] | None
 ):
     class SObject(JMux):

{jmux-0.0.3 → jmux-0.0.5}/tests/test_demux__validate.py

@@ -72,6 +72,14 @@ class CorrectPydantic_2(BaseModel):
     key_bool: bool | None
 
 
+class CorrectJMux_3(JMux):
+    arr_str: StreamableValues[str]
+
+
+class CorrectPydantic_3(BaseModel):
+    arr_str: list[str] | None
+
+
 class IncorrectJMux_1(JMux):
     key_str: AwaitableValue[str]
 
@@ -107,6 +115,7 @@ class IncorrectPydantic_3(BaseModel):
     [
         (CorrectJMux_1, CorrectPydantic_1, None),
         (CorrectJMux_2, CorrectPydantic_2, None),
+        (CorrectJMux_3, CorrectPydantic_3, None),
         (IncorrectJMux_1, IncorrectPydantic_1, ObjectMissmatchedError),
         (IncorrectJMux_2, IncorrectPydantic_2, ObjectMissmatchedError),
         (IncorrectJMux_3, IncorrectPydantic_3, ObjectMissmatchedError),

{jmux-0.0.3 → jmux-0.0.5}/tests/test_helpers.py

@@ -1,5 +1,5 @@
 from types import NoneType
-from typing import List, Optional, Set, Tuple, Type
+from typing import List, Optional, Set, Tuple, Type, Union
 
 import pytest
 
@@ -9,26 +9,43 @@ from jmux.awaitable import (
     UnderlyingGenericMixin,
 )
 from jmux.demux import JMux
-from jmux.helpers import deconstruct_type, extract_types_from_generic_alias
+from jmux.helpers import deconstruct_flat_type, extract_types_from_generic_alias
 
 
 @pytest.mark.parametrize(
     "TargetType,expected_tuple",
     [
         (int, {int}),
+        (Union[int], {int}),
+        #
         (Optional[int], {int, NoneType}),
         (int | None, {int, NoneType}),
+        #
+        (Union[int, None], {int, NoneType}),
+        (int | NoneType, {int, NoneType}),
+        (Union[int, NoneType], {int, NoneType}),
+        #
         (int | str, {str, int}),
+        (Union[int, str], {str, int}),
+        #
         (int | str | NoneType, {str, int, NoneType}),
+        (Union[int, str, NoneType], {str, int, NoneType}),
+        #
         (JMux, {JMux}),
+        (Union[JMux], {JMux}),
+        #
         (JMux | None, {JMux, NoneType}),
+        (Union[JMux, None], {JMux, NoneType}),
+        (Union[JMux, NoneType], {JMux, NoneType}),
+        #
         (JMux | NoneType, {JMux, NoneType}),
+        (Union[JMux, NoneType], {JMux, NoneType}),
     ],
 )
-def test_extract_types(
+def test_deconstruct_flat_types(
     TargetType: Type[UnderlyingGenericMixin], expected_tuple: Tuple[Type, Set[Type]]
 ):
-    underlying_types = deconstruct_type(TargetType)
+    underlying_types = deconstruct_flat_type(TargetType)
 
     assert underlying_types == expected_tuple
 
@@ -46,7 +63,13 @@ class NestedObject(JMux):
         (Optional[int], ({int, NoneType}, set())),
         (int | None, ({int, NoneType}, set())),
         (List[int], ({list}, {int})),
+        (list[int], ({list}, {int})),
         (List[int | None], ({list}, {int, NoneType})),
+        (list[int | None], ({list}, {int, NoneType})),
+        (List[int] | None, ({list, NoneType}, {int})),
+        (list[int] | None, ({list, NoneType}, {int})),
+        (Optional[List[int]], ({list, NoneType}, {int})),
+        (Optional[list[int]], ({list, NoneType}, {int})),
         (AwaitableValue[int], ({AwaitableValue}, {int})),
         (AwaitableValue[float], ({AwaitableValue}, {float})),
         (AwaitableValue[str], ({AwaitableValue}, {str})),