streamable 2.1.0b1__tar.gz → 2.1.0b2__tar.gz

streamable-2.1.0b2/MANIFEST.in

@@ -0,0 +1 @@
+prune tests

{streamable-2.1.0b1 → streamable-2.1.0b2}/PKG-INFO

@@ -1,10 +1,25 @@
 Metadata-Version: 2.4
 Name: streamable
-Version: 2.1.0b1
+Version: 2.1.0b2
 Summary: sync/async iterable streams for Python
 Author-email: ebonnal <bonnal.enzo.dev@gmail.com>
-License: Apache 2.
+License: Apache-2.0
 Project-URL: Homepage, https://github.com/ebonnal/streamable
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Typing :: Typed
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE

{streamable-2.1.0b1 → streamable-2.1.0b2}/pyproject.toml

@@ -7,10 +7,27 @@ name = "streamable"
 dynamic = ["version"]
 description = "sync/async iterable streams for Python"
 readme = { file = "README.md", content-type = "text/markdown" }
-license = { text = "Apache 2." }
+license = { text = "Apache-2.0" }
 authors = [{ name = "ebonnal", email = "bonnal.enzo.dev@gmail.com" }]
 urls = { Homepage = "https://github.com/ebonnal/streamable" }
 requires-python = ">=3.8"
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Framework :: AsyncIO",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
+    "Typing :: Typed",
+]
 dependencies = []
 
 [project.optional-dependencies]

{streamable-2.1.0b1 → streamable-2.1.0b2}/streamable/__init__.py

@@ -12,4 +12,4 @@ ClosableAsyncIterator.__module__ = __name__
 
 __all__ = ["stream", "star", "Observation", "ClosableAsyncIterator"]
 
-__version__ = "2.1.0b1"
+__version__ = "2.1.0b2"

{streamable-2.1.0b1 → streamable-2.1.0b2}/streamable.egg-info/PKG-INFO

@@ -1,10 +1,25 @@
 Metadata-Version: 2.4
 Name: streamable
-Version: 2.1.0b1
+Version: 2.1.0b2
 Summary: sync/async iterable streams for Python
 Author-email: ebonnal <bonnal.enzo.dev@gmail.com>
-License: Apache 2.
+License: Apache-2.0
 Project-URL: Homepage, https://github.com/ebonnal/streamable
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Typing :: Typed
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE

{streamable-2.1.0b1 → streamable-2.1.0b2}/streamable.egg-info/SOURCES.txt

@@ -1,4 +1,5 @@
 LICENSE
+MANIFEST.in
 README.md
 pyproject.toml
 streamable/__init__.py
@@ -32,23 +33,4 @@ streamable/visitors/_base.py
 streamable/visitors/_eq.py
 streamable/visitors/_involves_async.py
 streamable/visitors/_iter.py
-streamable/visitors/_repr.py
-tests/test_buffer.py
-tests/test_catch.py
-tests/test_closing.py
-tests/test_do.py
-tests/test_eq.py
-tests/test_filter.py
-tests/test_flatten.py
-tests/test_group.py
-tests/test_map.py
-tests/test_observe.py
-tests/test_other.py
-tests/test_readme.py
-tests/test_ref_cycles.py
-tests/test_repr.py
-tests/test_skip.py
-tests/test_take.py
-tests/test_throttle.py
-tests/test_tools.py
-tests/test_visitor.py
+streamable/visitors/_repr.py

streamable-2.1.0b1/tests/test_buffer.py

@@ -1,91 +0,0 @@
-import sys
-from typing import Any, Callable, List
-
-import pytest
-
-from streamable import stream
-from tests.tools.func import async_slow_identity, slow_identity
-from tests.tools.iter import (
-    ITERABLE_TYPES,
-    IterableType,
-    aiter_or_iter,
-    alist_or_list,
-    anext_or_next,
-    stopiteration_type,
-)
-from tests.tools.source import INTEGERS, ints
-
-
-@pytest.mark.parametrize("itype", ITERABLE_TYPES)
-def test_buffer_raises_on_invalid_up_to(itype: IterableType) -> None:
-    with pytest.raises(ValueError, match="`up_to` must be >= 1 but got: 0"):
-        alist_or_list(stream([1]).buffer(0), itype)
-
-
-@pytest.mark.parametrize("itype", ITERABLE_TYPES)
-def test_buffer_preserves_elements(itype: IterableType) -> None:
-    assert alist_or_list(ints.buffer(5), itype) == list(INTEGERS)
-
-
-@pytest.mark.parametrize("buffer_size", [1, 10, None])
-@pytest.mark.parametrize(
-    "itype, slow_identity",
-    [("sync", slow_identity), ("async", async_slow_identity)],
-)
-def test_buffer_size_is_respected(
-    itype: IterableType, buffer_size: int, slow_identity: Callable[..., Any]
-) -> None:
-    buffered: List[int] = []
-    buffering_ints = ints.do(buffered.append).buffer(buffer_size).map(slow_identity)
-    buffering_ints_iter = aiter_or_iter(buffering_ints, itype)
-    assert buffered == []
-    assert anext_or_next(buffering_ints_iter, itype) == 0
-    assert (
-        buffered == list(INTEGERS)[: (buffer_size + 1) if buffer_size else sys.maxsize]
-    )
-    assert anext_or_next(buffering_ints_iter, itype) == 1
-    assert (
-        buffered == list(INTEGERS)[: (buffer_size + 2) if buffer_size else sys.maxsize]
-    )
-
-
-@pytest.mark.parametrize(
-    "itype, slow_identity",
-    [("sync", slow_identity), ("async", async_slow_identity)],
-)
-def test_buffer_with_exceptions(
-    itype: IterableType, slow_identity: Callable[..., Any]
-) -> None:
-    buffered: List[int] = []
-    buffersize = 3
-    buffering_ints = (
-        stream("0-23--6")
-        .map(int)
-        .do(buffered.append)
-        .buffer(buffersize)
-        .map(slow_identity)
-    )
-    buffering_ints_iter = aiter_or_iter(buffering_ints, itype)
-    assert buffered == []
-    assert anext_or_next(buffering_ints_iter, itype) == 0
-    assert buffered == [0, 2, 3]
-    with pytest.raises(ValueError):
-        anext_or_next(buffering_ints_iter, itype)
-    assert anext_or_next(buffering_ints_iter, itype) == 2
-    assert buffered == [0, 2, 3]
-    assert anext_or_next(buffering_ints_iter, itype) == 3
-    assert buffered == [0, 2, 3, 6]
-    with pytest.raises(ValueError):
-        anext_or_next(buffering_ints_iter, itype)
-    with pytest.raises(ValueError):
-        anext_or_next(buffering_ints_iter, itype)
-    assert anext_or_next(buffering_ints_iter, itype) == 6
-    assert buffered == [0, 2, 3, 6]
-    with pytest.raises(stopiteration_type(itype)):
-        anext_or_next(buffering_ints_iter, itype)
-
-
-@pytest.mark.parametrize("itype", ITERABLE_TYPES)
-def test_buffer_chain_of_background_task(itype: IterableType) -> None:
-    s = stream(INTEGERS).buffer(2).buffer(2)
-    assert alist_or_list(s, itype) == list(INTEGERS)

streamable-2.1.0b1/tests/test_catch.py

@@ -1,269 +0,0 @@
-from typing import Any, Callable, List, Union
-
-import pytest
-
-from streamable import stream
-from streamable._tools._func import asyncify
-from tests.tools.error import TestError
-from tests.tools.func import async_identity, identity, inverse, throw_func
-from tests.tools.iter import (
-    ITERABLE_TYPES,
-    IterableType,
-    aiter_or_iter,
-    alist_or_list,
-    anext_or_next,
-)
-from tests.tools.source import INTEGERS, ints
-
-
-@pytest.mark.parametrize("itype", ITERABLE_TYPES)
-def test_catch_yields_elements_without_exceptions(itype: IterableType) -> None:
-    s = ints.catch(Exception)
-    assert alist_or_list(s, itype) == list(INTEGERS)
-
-
-@pytest.mark.parametrize("itype", ITERABLE_TYPES)
-def test_catch_ignores_matching_exceptions(itype: IterableType) -> None:
-    s = stream("12-34").map(int).catch(ValueError)
-    assert alist_or_list(s, itype) == [1, 2, 3, 4]
-
-
-@pytest.mark.parametrize("itype", ITERABLE_TYPES)
-def test_catch_raises_non_matching_exceptions(itype: IterableType) -> None:
-    chars = "1-2034"
-    s = stream(chars).map(int).do(inverse).catch(ValueError)
-    stream_iter = aiter_or_iter(s, itype)
-    assert anext_or_next(stream_iter, itype) == 1
-    # ValueError caught for `int("-")`
-    assert anext_or_next(stream_iter, itype) == 2
-    with pytest.raises(ZeroDivisionError):
-        anext_or_next(stream_iter, itype)
-    assert anext_or_next(stream_iter, itype) == 3
-    assert anext_or_next(stream_iter, itype) == 4
-
-
-@pytest.mark.parametrize("itype", ITERABLE_TYPES)
-def test_catch_handles_thousands_of_consecutive_exceptions(itype: IterableType) -> None:
-    s = stream(range(2000)).map(throw_func(TestError)).catch(TestError)
-    assert alist_or_list(s, itype) == []
-
-
-@pytest.mark.parametrize("itype", ITERABLE_TYPES)
-def test_catch_chained(itype: IterableType) -> None:
-    chars = "1-2034"
-    s = stream(chars).map(int).do(inverse).catch(ValueError).catch(ZeroDivisionError)
-    assert alist_or_list(s, itype) == [1, 2, 3, 4]
-
-
-@pytest.mark.parametrize("itype", ITERABLE_TYPES)
-def test_catch_tuple(itype: IterableType) -> None:
-    chars = "1-2034"
-    s = stream(chars).map(int).do(inverse).catch((ValueError, ZeroDivisionError))
-    assert alist_or_list(s, itype) == [1, 2, 3, 4]
-
-
-@pytest.mark.parametrize("adapt", [identity, asyncify])
-@pytest.mark.parametrize("itype", ITERABLE_TYPES)
-def test_catch_where(itype: IterableType, adapt: Callable[[Any], Any]) -> None:
-    inputs: List[Union[str, float]] = ["0", float("nan"), "1", "-", "2"]
-    s: stream[int] = (
-        stream(inputs)
-        .map(int)
-        .catch(ValueError, where=adapt(lambda e: "cannot convert float NaN" in str(e)))
-    )
-    stream_iter = aiter_or_iter(s, itype)
-    assert anext_or_next(stream_iter, itype) == 0
-    # caught ValueError caused by `int("nan")`
-    assert anext_or_next(stream_iter, itype) == 1
-    # but did not catch ValueError caused by `int("-")`
-    with pytest.raises(
-        ValueError, match=r"invalid literal for int\(\) with base 10: '-'"
-    ):
-        anext_or_next(stream_iter, itype)
-    assert anext_or_next(stream_iter, itype) == 2
-
-
-@pytest.mark.parametrize("adapt", [identity, asyncify])
-@pytest.mark.parametrize("itype", ITERABLE_TYPES)
-def test_catch_replace_with_none(
-    itype: IterableType, adapt: Callable[[Any], Any]
-) -> None:
-    s = stream("1-23").map(int).catch(ValueError, replace=adapt(lambda e: None))
-    elems: List[Union[int, None]] = alist_or_list(s, itype)
-    assert elems == [1, None, 2, 3]
-
-
-@pytest.mark.parametrize("adapt", [identity, asyncify])
-@pytest.mark.parametrize("itype", ITERABLE_TYPES)
-def test_catch_do(itype: IterableType, adapt: Callable[[Any], Any]) -> None:
-    ints = [1, 0, 2, 3]
-    errors: List[Exception] = []
-    s = stream(ints).do(inverse).catch(ZeroDivisionError, do=adapt(errors.append))
-    assert alist_or_list(s, itype) == [1, 2, 3]
-    assert len(errors) == 1
-    assert isinstance(errors[0], ZeroDivisionError)
-
-
-@pytest.mark.parametrize("adapt", [identity, asyncify])
-@pytest.mark.parametrize("itype", ITERABLE_TYPES)
-def test_catch_with_do_raising(
-    itype: IterableType, adapt: Callable[[Any], Any]
-) -> None:
-    """If `do` raises an exception, it is re-raised in place of the caught one."""
-    ints = [0, 1, 0, 1, 0]
-    errors: List[Exception] = []
-    s = (
-        stream(ints)
-        .map(lambda n: round(1 / n, 2))
-        .catch(ZeroDivisionError, do=throw_func(TestError))
-        .catch(TestError, do=adapt(errors.append))
-    )
-    assert alist_or_list(s, itype) == [1, 1]
-    assert len(errors) == ints.count(0)
-
-
-@pytest.mark.parametrize("adapt", [identity, asyncify])
-@pytest.mark.parametrize("itype", ITERABLE_TYPES)
-def test_catch_with_replace_raising(
-    itype: IterableType, adapt: Callable[[Any], Any]
-) -> None:
-    ints = [0, 1, 0, 1, 0]
-    s = (
-        stream(ints)
-        .map(lambda n: round(1 / n, 2))
-        .catch(ZeroDivisionError, replace=throw_func(TestError))
-        .catch(TestError, replace=adapt(lambda e: None))
-    )
-    assert alist_or_list(s, itype) == [None, 1, None, 1, None]
-
-
-@pytest.mark.parametrize("where", [identity, async_identity])
-@pytest.mark.parametrize("adapt_do", [identity, asyncify])
-@pytest.mark.parametrize("adapt_replace", [identity, asyncify])
-@pytest.mark.parametrize("itype", ITERABLE_TYPES)
-def test_catch_sync_async_params_combination(
-    where: Callable[[Exception], Any],
-    adapt_do: Callable[[Callable[[Any], Any]], Callable[[Any], Any]],
-    adapt_replace: Callable[[Callable[[Any], Any]], Callable[[Any], Any]],
-    itype: IterableType,
-) -> None:
-    """Catch supports passing a mix of regular and async functions for where, do and replace."""
-    errors: List[Exception] = []
-    s = (
-        stream([0, 1, 0, 1, 0])
-        .do(inverse)
-        .catch(
-            ZeroDivisionError,
-            where=where,
-            do=adapt_do(errors.append),
-            replace=adapt_replace(lambda e: None),
-        )
-    )
-    assert alist_or_list(s, itype) == [None, 1, None, 1, None]
-    assert len(errors) == 3
-
-
-@pytest.mark.parametrize("itype", ITERABLE_TYPES)
-def test_catch_stop(itype: IterableType) -> None:
-    s = stream("01-3").map(int).catch(ValueError, stop=True)
-    assert alist_or_list(s, itype) == [0, 1]
-
-
-@pytest.mark.parametrize("itype", ITERABLE_TYPES)
-def test_catch_stop_with_falsy_where(itype: IterableType) -> None:
-    """If `stop=True` but the exception does not satisfy `where`, the iteration should not stop."""
-    s = (
-        stream("01-3")
-        .map(int)
-        .catch(ValueError, where=lambda e: False, stop=True)
-        .catch(ValueError)
-    )
-    assert alist_or_list(s, itype) == [0, 1, 3]
-
-
-@pytest.mark.parametrize("adapt", [identity, asyncify])
-@pytest.mark.parametrize("itype", ITERABLE_TYPES)
-def test_catch_stop_with_where_raising(
-    itype: IterableType, adapt: Callable[[Any], Any]
-) -> None:
-    """`stop=True` does not terminate the iteration if `where` raises."""
-    ints = [0, 1, 0, 1, 0]
-    s = (
-        stream(ints)
-        .map(lambda n: round(1 / n, 2))
-        .catch(ZeroDivisionError, where=throw_func(TestError), stop=True)
-        .catch(TestError)
-    )
-    assert alist_or_list(s, itype) == [1, 1]
-
-
-@pytest.mark.parametrize("adapt", [identity, asyncify])
-@pytest.mark.parametrize("itype", ITERABLE_TYPES)
-def test_catch_stop_with_do_raising(
-    itype: IterableType, adapt: Callable[[Any], Any]
-) -> None:
-    """`stop=True` terminates the iteration even if `do` raises."""
-    ints = [1, 0, 1, 0]
-    s = (
-        stream(ints)
-        .map(lambda n: round(1 / n, 2))
-        .catch(ZeroDivisionError, do=throw_func(TestError), stop=True)
-        .catch(TestError)
-    )
-    assert alist_or_list(s, itype) == [1]
-
-
-@pytest.mark.parametrize("adapt", [identity, asyncify])
-@pytest.mark.parametrize("itype", ITERABLE_TYPES)
-def test_catch_stop_with_replace_raising(
-    itype: IterableType, adapt: Callable[[Any], Any]
-) -> None:
-    """`stop=True` terminates the iteration even if `replace` raises."""
-    ints = [1, 0, 1, 0]
-    s = (
-        stream(ints)
-        .map(lambda n: round(1 / n, 2))
-        .catch(ZeroDivisionError, replace=throw_func(TestError), stop=True)
-        .catch(TestError)
-    )
-    assert alist_or_list(s, itype) == [1]
-
-
-@pytest.mark.parametrize("itype", ITERABLE_TYPES)
-def test_catch_stop_with_replacement(itype: IterableType) -> None:
-    """Test `stop` on exception, with replacement as last elem."""
-    s = stream("01-3").map(int).catch(ValueError, stop=True, replace=lambda e: None)
-    assert alist_or_list(s, itype) == [0, 1, None]
-
-
-@pytest.mark.parametrize("adapt", [identity, asyncify])
-@pytest.mark.parametrize("itype", ITERABLE_TYPES)
-def test_catch_replace_occurs_after_do(
-    itype: IterableType, adapt: Callable[[Any], Any]
-) -> None:
-    errors: List[Exception] = []
-    s = (
-        stream("-")
-        .map(int)
-        .catch(
-            ValueError, do=adapt(errors.append), replace=adapt(lambda e: len(errors))
-        )
-    )
-    assert alist_or_list(s, itype) == [len(errors)] == [1]
-
-
-@pytest.mark.parametrize("adapt", [identity, asyncify])
-@pytest.mark.parametrize("itype", ITERABLE_TYPES)
-def test_catch_do_occurs_after_where(
-    itype: IterableType, adapt: Callable[[Any], Any]
-) -> None:
-    errors: List[Exception] = []
-    s = (
-        stream("-")
-        .map(int)
-        .catch(ValueError, where=adapt(lambda e: False), do=adapt(errors.append))
-    )
-    with pytest.raises(ValueError):
-        anext_or_next(aiter_or_iter(s, itype), itype)
-
-    assert errors == []