comio 0.2.0__tar.gz → 0.2.1__tar.gz

{comio-0.2.0 → comio-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comio
-Version: 0.2.0
+Version: 0.2.1
 Summary: Composable I/O primitives for async Python
 Project-URL: Repository, https://github.com/sdkim96/comio
 License-Expression: MIT

{comio-0.2.0 → comio-0.2.1}/comio/adapters/jsonl.py

@@ -11,28 +11,27 @@ class Page:
 
 class JsonL:
 
-    def __init__(self, f: io.TextIOWrapper):
+    def __init__(self, f: io.TextIOBase):
         self.f = f
 
-    def read(self, cursor: Cursor | None = None, n: int | None =None) -> Page:
+    def read(self, cursor: Cursor | None = None, n: int | None = None) -> Page:
         self.f.seek(cursor or 0)
-        l = self.f.readline()
-        if l == "":
+        line = self.f.readline()
+        if line == "":
             return Page([], EOF)
-        return Page(items=[json.loads(l)], next_cursor=self.f.tell())
-    
+        return Page(items=[json.loads(line)], next_cursor=self.f.tell())
 
     def write(self, item: dict) -> None:
         self.f.write(json.dumps(item) + "\n")
         self.f.flush()
 
-    
+
 class AsyncJsonL:
 
-    def __init__(self, f: io.TextIOWrapper):
+    def __init__(self, f: io.TextIOBase):
         self.syncio = JsonL(f)
-        
-    async def read(self, cursor: Cursor | None = None, n: int | None =None) -> Page:
+
+    async def read(self, cursor: Cursor | None = None, n: int | None = None) -> Page:
         return self.syncio.read(cursor=cursor, n=n)
     
     async def write(self, item: dict) -> None:

{comio-0.2.0 → comio-0.2.1}/comio/io.py

@@ -1,17 +1,18 @@
-"""Composable I/O primitives.
+"""Composable async I/O primitives.
 
-Defines four protocol interfaces for asynchronous data flow:
+Protocols:
 
-    Reader: pull-based, paginated source  (read → Page)
-    Writer: single-item sink              (write)
-    Batch: multi-item sink               (batch)
-    Listener: push-based, streaming source  (listen → AsyncIterator)
+    Reader:   pull-based, paginated source   (read → Page)
+    Listener: push-based, streaming source   (listen → AsyncIterator)
+    Writer:   single-item sink               (write)
+    Batcher:  multi-item sink                (batch)
 
-And composable functions that wire them together:
+Functions:
 
-    scroll:  iterate pages from a Reader
-    read_all: drain a Reader into a list
-    copy:     connect any source to any sink
+    scroll:      iterate pages from a Reader
+    read_all:    drain a Reader into a list
+    copy:        buffer a Listener into a Batcher
+    as_listener: convert a Reader into a Listener
 """
 
 from __future__ import annotations
@@ -86,7 +87,7 @@ class Listener(t.Protocol, t.Generic[T_co]):
     a Listener yields items as they become available.
     """
 
-    async def listen(self) -> t.AsyncIterator[T_co]:
+    def listen(self) -> t.AsyncIterator[T_co]:
         """Start listening and yield items as they arrive.
 
         The iterator completes when the source is exhausted or closed.
@@ -117,8 +118,6 @@ class Batcher(t.Protocol, t.Generic[T_contra]):
         ...
 
 
-
-
 async def scroll(r: Reader[T_co], *, cursor: Cursor = None, n: int | None = None) -> t.AsyncIterator[Page[T_co]]:
     """Iterate pages from a Reader until the source is exhausted.
 
@@ -167,7 +166,7 @@ async def copy(src: Listener[T_co], dst: Batcher[T_co], n: int) -> None:
         n: Buffer size. Flushes every ``n`` items, plus any remainder at the end.
     """
     buf: t.List[T_co] = []
-    async for item in await src.listen():
+    async for item in src.listen():
         buf.append(item)
         if len(buf) >= n:
             await dst.batch(buf)
@@ -176,22 +175,17 @@ async def copy(src: Listener[T_co], dst: Batcher[T_co], n: int) -> None:
         await dst.batch(buf)
 
 
-async def as_listener(r: Reader[T_co], *, cursor: Cursor = None, n: int | None = None) -> t.AsyncIterator[T_co]:
-    """Convert a Reader into an item-level AsyncIterator.
-
-    Normalizes a pull-based Reader into the same shape as Listener.listen(),
-    so downstream code can treat both sources uniformly.
-
-    Args:
-        r: The reader to convert.
-        cursor: Starting position.
-        n: Page size passed to the reader.
+def as_listener(r: Reader[T_co], *, cursor: Cursor = None, n: int | None = None) -> Listener[T_co]:
+    """Convert a Reader into a Listener.
 
-    Yields:
-        Individual items from each page.
+    Returns a Listener whose ``listen()`` yields individual items
+    from the Reader's pages, so downstream code (e.g. ``copy``, ``pipe``)
+    can treat both sources uniformly.
     """
-    async for page in scroll(r, cursor=cursor, n=n):
-        for item in page.items:
-            yield item
-
+    class _Listener:
+        async def listen(self) -> t.AsyncIterator[T_co]:
+            async for page in scroll(r, cursor=cursor, n=n):
+                for item in page.items:
+                    yield item
 
+    return _Listener()

{comio-0.2.0 → comio-0.2.1}/comio/pipe.py

@@ -1,9 +1,9 @@
-"""Streaming pipe: Listener → Handler → Writer.
+"""Streaming pipe: Listener -> Handler -> Writer.
 
 Connects a push-based source to a sink through a transformation handler,
 using in-memory streams with configurable backpressure.
 
-    src ──→ [in_stream] ──→ handler ──→ [out_stream] ──→ dest
+    src --> [in_stream] --> handler --> [out_stream] --> dest
 
 Three concurrent tasks (ingress / process / egress) are managed
 by an anyio task group. When the source is exhausted, streams close
@@ -19,7 +19,6 @@ import anyio
 from .io import Listener, Writer
 
 
-
 In = t.TypeVar("In", covariant=True)
 Out = t.TypeVar("Out", contravariant=True)
 H_In = t.TypeVar("H_In", contravariant=True)
@@ -84,7 +83,7 @@ async def _pipe(
     async def ingress() -> None:
         """src → in_stream. Closes in_send when the source is exhausted."""
         async with in_send:
-            async for item in await src.listen():
+            async for item in src.listen():
                 await in_send.send(item)
 
     async def process() -> None:

{comio-0.2.0 → comio-0.2.1}/comio/sync/io.py

@@ -75,8 +75,12 @@ def copy(src: Listener[T_co], dst: Batcher[T_co], n: int) -> None:
         dst.batch(buf)
 
 
-def as_listener(r: Reader[T_co], *, cursor: Cursor = None, n: int | None = None) -> t.Iterator[T_co]:
-    """Convert a Reader into an item-level Iterator."""
-    for page in scroll(r, cursor=cursor, n=n):
-        for item in page.items:
-            yield item
+def as_listener(r: Reader[T_co], *, cursor: Cursor = None, n: int | None = None) -> Listener[T_co]:
+    """Convert a sync Reader into a Listener."""
+    class _Listener:
+        def listen(self) -> t.Iterator[T_co]:
+            for page in scroll(r, cursor=cursor, n=n):
+                for item in page.items:
+                    yield item
+
+    return _Listener()

{comio-0.2.0 → comio-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "comio"
-version = "0.2.0"
+version = "0.2.1"
 description = "Composable I/O primitives for async Python"
 readme = "README.md"
 requires-python = ">=3.11"

{comio-0.2.0 → comio-0.2.1}/tests/test_jsonl.py

@@ -2,6 +2,9 @@ import io
 import json
 import pytest
 
+import comio
+import typing as t
+
 from comio import scroll, read_all, EOF
 from comio.sync import scroll as sync_scroll, read_all as sync_read_all
 from comio.adapters.jsonl import JsonL, AsyncJsonL
@@ -146,3 +149,81 @@ async def test_async_read_all_from_cursor(sample_file):
     first = await reader.read()
     items = await read_all(reader, cursor=first.next_cursor)
     assert items == [{"id": 1}, {"id": 2}]
+
+
+class AsyncJsonLBatcher:
+    def __init__(self, f):
+        self.f = f
+
+    async def batch(self, items: t.Sequence[dict]) -> None:
+        for item in items:
+            self.f.write(json.dumps(item) + "\n")
+        self.f.flush()
+
+
+@pytest.mark.asyncio
+async def test_copy_via_as_listener(sample_file):
+    reader = AsyncJsonL(sample_file)
+    out = io.StringIO()
+    batcher = AsyncJsonLBatcher(out)
+
+    listener = comio.as_listener(reader)
+    await comio.copy(listener, batcher, n=2)
+
+    out.seek(0)
+    lines = [json.loads(l) for l in out.read().strip().split("\n")]
+    assert lines == [{"id": 0}, {"id": 1}, {"id": 2}]
+
+
+
+@pytest.mark.asyncio
+async def test_pipe(sample_file):
+    from comio import pipe
+
+    reader = AsyncJsonL(sample_file)
+    out = io.StringIO()
+    writer = AsyncJsonL(out)
+    listener = comio.as_listener(reader)
+
+    async def add_flag(item: dict) -> dict:
+        return {**item, "processed": True}
+
+    await pipe(listener, writer, add_flag)
+
+    out.seek(0)
+    lines = [json.loads(l) for l in out.read().strip().split("\n")]
+    assert lines == [
+        {"id": 0, "processed": True},
+        {"id": 1, "processed": True},
+        {"id": 2, "processed": True},
+    ]
+
+
+@pytest.mark.asyncio
+async def test_pipe_with_hooks(sample_file):
+    from comio import pipe, PipeConfig
+
+    reader = AsyncJsonL(sample_file)
+    out = io.StringIO()
+    writer = AsyncJsonL(out)
+    listener = comio.as_listener(reader)
+
+    log: list[str] = []
+
+    async def on_boot():
+        log.append("boot")
+
+    async def on_close():
+        log.append("close")
+
+    cfg = PipeConfig(on_boot=[on_boot], on_close=[on_close])
+
+    async def identity(item: dict) -> dict:
+        return item
+
+    await pipe(listener, writer, identity, cfg=cfg)
+
+    assert log == ["boot", "close"]
+    out.seek(0)
+    lines = [json.loads(l) for l in out.read().strip().split("\n")]
+    assert len(lines) == 3