update gitignore and add tests

Author: RichardZhu2

.coveragerc

@@ -0,0 +1,5 @@
+[report]
+exclude_also = 
+    # pragma: no cover
+    if TYPE_CHECKING:
+    raise NotImplementedError

.gitignore

@@ -2,4 +2,8 @@
 .vscode/
 
 __pycache__/
-.venv
+.pytest_cache/
+.venv/
+src/*.egg-info/
+
+.tox/

pyproject.toml

@@ -3,7 +3,6 @@ requires = ["setuptools", "setuptools-scm", "wheel"]
 build-backend = "setuptools.build_meta"
 
 [tool.setuptools_scm]
-write_to = "src/pyper/_version.py"
 
 [project]
 name = "python-pyper"
@@ -33,3 +32,6 @@ classifiers = [
 Documentation = "https://pyper-dev.github.io/pyper/"
 Repository = "https://github.com/pyper-dev/pyper"
 Issues = "https://github.com/pyper-dev/pyper/issues"
+
+[tool.pytest.ini_options]
+asyncio_default_fixture_loop_scope = "function"

tests/requirements.txt

@@ -0,0 +1,3 @@
+pytest>=8.3.3
+pytest_asyncio>=0.24
+tox>=4.23

tests/test_async.py

@@ -0,0 +1,92 @@
+from pyper import task
+import pytest
+
+
+def f1(data):
+    return data
+
+def f2(data):
+    yield data
+
+def f3(data):
+    raise RuntimeError
+
+async def af1(data):
+    return data
+
+async def af2(data):
+    yield data
+
+async def af3(data):
+    raise RuntimeError
+
+async def af4(data):
+    async for row in data:
+        yield row
+
+async def consumer(data):
+    total = 0
+    async for i in data:
+        total += i
+    return total
+
+@pytest.mark.asyncio
+async def test_pipeline():
+    p = task(f1) >> task(f2)
+    assert p(1).__next__() == 1
+
+@pytest.mark.asyncio
+async def test_joined_pipeline():
+    p = task(af1) >> task(af2) >> task(af4, join=True)
+    assert await p(1).__anext__() == 1
+
+@pytest.mark.asyncio
+async def test_consumer():
+    p = task(af1) >> task(af2) & consumer
+    assert await p(1) == 1
+
+@pytest.mark.asyncio
+async def test_invalid_first_stage_concurrency():
+    try:
+        p = task(af1, concurrency=2) >> task(af2) & consumer
+        await p(1)
+    except Exception as e:
+        assert isinstance(e, RuntimeError)
+    else:
+        raise AssertionError
+    
+@pytest.mark.asyncio
+async def test_invalid_first_stage_join():
+    try:
+        p = task(af1, join=True) >> task(af2) & consumer
+        await p(1)
+    except Exception as e:
+        assert isinstance(e, RuntimeError)
+    else:
+        raise AssertionError
+
+@pytest.mark.asyncio
+async def test_error_handling():
+    try:
+        p = task(af1) >> task(af2) >> task(af3) & consumer
+        await p(1)
+    except Exception as e:
+        assert isinstance(e, RuntimeError)
+    else:
+        raise AssertionError
+    
+@pytest.mark.asyncio
+async def test_unified_pipeline():
+    p = task(af1) >> task(f1) >> task(af2) >> task(f2) & consumer
+    assert await p(1) == 1
+
+@pytest.mark.asyncio
+async def test_error_handling_in_daemon():
+    try:
+        p = task(af1) >> task(af2) >> task(f3, daemon=True) & consumer
+        await p(1)
+    except Exception as e:
+        assert isinstance(e, RuntimeError)
+    else:
+        raise AssertionError
+    

tests/test_sync.py

@@ -0,0 +1,85 @@
+import time
+from pyper import task
+
+
+def f1(data):
+    return data
+
+def f2(data):
+    yield data
+
+def f3(data):
+    for row in data:
+        yield row
+
+def f4(a1, a2, a3, data, k1, k2):
+    return data
+
+def f5(data):
+    # Make queue monitor timeout on main thread
+    time.sleep(1.2)
+    raise RuntimeError
+
+def consumer(data):
+    total = 0
+    for i in data:
+        total += i
+    return total
+
+def test_pipeline():
+    p = task(f1) >> task(f2)
+    assert p(1).__next__() == 1
+
+def test_joined_pipeline():
+    p = task(f1) >> task(f2) >> task(f3, join=True)
+    assert p(1).__next__() == 1
+
+def test_bind():
+    p = task(f1) >> task(f4, bind=task.bind(1, 1, 1, k1=1, k2=2))
+    assert p(1).__next__() == 1
+
+def test_redundant_bind_ok():
+    p = task(f1) >> task(f2, bind=task.bind())
+    assert p(1).__next__() == 1
+
+def test_consumer():
+    p = task(f1) >> task(f2) & consumer
+    assert p(1) == 1
+
+def test_invalid_first_stage_concurrency():
+    try:
+        p = task(f1, concurrency=2) >> task(f2) & consumer
+        p(1)
+    except Exception as e:
+        assert isinstance(e, RuntimeError)
+    else:
+        raise AssertionError
+    
+def test_invalid_first_stage_join():
+    try:
+        p = task(f1, join=True) >> task(f2) & consumer
+        p(1)
+    except Exception as e:
+        assert isinstance(e, RuntimeError)
+    else:
+        raise AssertionError
+
+def test_error_handling():
+    try:
+        p = task(f1) >> task(f2) >> task(f5) & consumer
+        p(1)
+    except Exception as e:
+        print(e)
+        assert isinstance(e, RuntimeError)
+    else:
+        raise AssertionError
+
+def test_error_handling_in_daemon():
+    try:
+        p = task(f5, daemon=True) >> task(f2) & consumer
+        p(1)
+    except Exception as e:
+        print(e)
+        assert isinstance(e, RuntimeError)
+    else:
+        raise AssertionError

tests/test_task.py

@@ -0,0 +1,151 @@
+from pyper import task, AsyncPipeline, Pipeline
+
+
+def func(x):
+    return x
+
+def gen(x):
+    yield x
+
+async def afunc(x):
+    return x
+
+async def agen(x):
+    yield x
+
+class Func:
+    def __call__(self, x):
+        return x
+    
+class Gen:
+    def __call__(self, x):
+        yield x
+    
+class AFunc:
+    async def __call__(self, x):
+        return x
+    
+class AGen:
+    async def __call__(self, x):
+        yield x
+
+def test_as_decorator():
+    p = task(func)
+    assert isinstance(p, Pipeline)
+
+def test_as_decorator_with_params():
+    p = task(join=True, concurrency=2, throttle=2)(func)
+    assert isinstance(p, Pipeline)
+
+def test_as_wrapper_with_params():
+    p = task(func, join=True, concurrency=2, throttle=2)
+    assert isinstance(p, Pipeline)
+
+def _try_invalid_concurrency(value, exc_type):
+    try:
+        task(func, concurrency=value)
+    except Exception as e:
+        return isinstance(e, exc_type)
+    return False
+
+def test_raise_for_invalid_concurrency():
+    assert _try_invalid_concurrency(0, ValueError)
+    assert _try_invalid_concurrency(-1, ValueError)
+    assert _try_invalid_concurrency("1",TypeError)
+    assert _try_invalid_concurrency(1.5, TypeError)
+
+def _try_invalid_throttle(value, exc_type):
+    try:
+        task(func, throttle=value)
+    except Exception as e:
+        return isinstance(e, exc_type)
+    return False
+
+def test_raise_for_invalid_throttle():
+    assert _try_invalid_throttle(-1, ValueError)
+    assert _try_invalid_throttle("1",TypeError)
+    assert _try_invalid_throttle(1.5, TypeError)
+
+def test_raise_for_invalid_daemon():
+    try:
+        task(afunc, daemon=True)
+    except Exception as e:
+        assert isinstance(e, ValueError)
+    else:
+        raise AssertionError
+
+def test_raise_for_invalid_func():
+    try:
+        task(1)
+    except Exception as e:
+        assert isinstance(e, TypeError)
+    else:
+        raise AssertionError
+
+def test_async_task():
+    p = task(afunc)
+    assert isinstance(p, AsyncPipeline)
+
+def test_piped_async_task():
+    p = task(afunc) >> task(func)
+    assert isinstance(p, AsyncPipeline)
+
+def test_invalid_pipe():
+    try:
+        task(func) >> 1
+    except Exception as e:
+        assert isinstance(e, TypeError)
+    else:
+        raise AssertionError
+
+def test_invalid_async_pipe():
+    try:
+        task(afunc) >> 1
+    except Exception as e:
+        assert isinstance(e, TypeError)
+    else:
+        raise AssertionError
+
+def test_invalid_consumer():
+    try:
+        task(func) & 1
+    except Exception as e:
+        assert isinstance(e, TypeError)
+    else:
+        raise AssertionError
+
+def test_invalid_async_consumer():
+    try:
+        task(afunc) & func
+    except Exception as e:
+        assert isinstance(e, TypeError)
+    else:
+        raise AssertionError
+
+def test_gen_inspect():
+    is_gen = lambda f: task(f).tasks[0].is_gen
+    assert is_gen(gen)
+    assert is_gen(agen)
+    assert is_gen(Gen())
+    assert is_gen(AGen())
+    assert not is_gen(func)
+    assert not is_gen(afunc)
+    assert not is_gen(Func())
+    assert not is_gen(AFunc())
+    assert not is_gen(lambda x: x)
+
+def test_async_inspect():
+    is_async = lambda f: task(f).tasks[0].is_async
+    assert is_async(afunc)
+    assert is_async(agen)
+    assert is_async(AFunc())
+    assert is_async(AGen())
+    assert not is_async(func)
+    assert not is_async(Func())
+    assert not is_async(gen)
+    assert not is_async(Gen())
+    assert not is_async(lambda x: x)
+
+def test_repr():
+    p = task(func)
+    assert "Pipeline" in repr(p)

tox.ini

@@ -0,0 +1,17 @@
+[tox]
+envlist = py{3.12}
+
+[testenv]
+deps =
+   pytest
+   pytest-asyncio
+   pytest-cov
+commands =
+   coverage erase
+   pytest --cov={envsitepackagesdir}/pyper tests
+   coverage report -m
+setenv =
+    COVERAGE_FILE = .tox/.coverage
+
+[coverage]
+rcfile = .coveragerc