datacurrent 1.0.0__tar.gz

datacurrent-1.0.0/CHANGELOG.md

@@ -0,0 +1,59 @@
+# Changelog
+
+All notable changes to DataCurrent are documented here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the project uses
+[Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.0] — 2026-11-08
+
+First stable release. Built and verified locally; not published to PyPI.
+
+### Added
+
+- `Stream` engine: construction from iterables, async iterables, factories,
+  queues, values and other streams; single-consumer semantics with explicit
+  `StreamConsumedError`; replayable sources for retries.
+- Operators: `map` (bounded, ordered concurrency), `filter`, `flat_map`,
+  `take`, `skip`, `batch`, `buffer`, `distinct`, `enumerate`, `window`,
+  `debounce`, `throttle`, `zip`, `merge`, `concat`, `timeout`, `retry`,
+  `recover`, `tap`.
+- Terminal operations: `collect`, `count`, `drain`, `first`, `last`, `reduce`.
+- Bounded `BoundedQueue` with `block`, `drop_newest`, `drop_oldest` and `error`
+  overflow policies, high-watermark statistics and producer suspension.
+- `ConcurrencyLimiter`, `TaskTracker`, `gather_limited` and `consume()` with
+  bounded concurrency and cancellation-safe cleanup.
+- `RetryPolicy` with exponential backoff, jitter, attempt limits and exception
+  predicates; `retry_async` helper; `with_timeout`.
+- In-memory `Channel` broadcast with per-subscriber bounded queues and drop
+  accounting.
+- `EventBus` with `Event` envelopes, wildcard topic routing, handler isolation,
+  stream subscriptions, draining shutdown and statistics.
+- Transports: `SSEStream` (WHATWG parser, `Last-Event-ID`, reconnection),
+  `HTTPStream` (chunked iteration, line iteration, byte limits) and
+  `WebSocketStream` (text/binary/JSON, heartbeats, size limits, reconnection),
+  backed by `httpx` and `websockets`, which install with the package.
+- `StreamTransport` extension base for custom protocols.
+- FastAPI / Starlette helpers: SSE responses, streaming responses, WebSocket
+  message streams and lifespan cleanup.
+- Observability: `Metrics`, `Counter`, per-stream `StreamStats`, structured
+  logging with credential redaction.
+- Complete exception hierarchy rooted at `DataCurrentError`.
+- 279 tests: unit, property-based, stress, networking with local servers,
+  packaging and executable examples (100% line and branch coverage).
+- 16 runnable examples, full documentation, reproducible benchmarks and a
+  cross-platform developer task runner.
+
+### Security
+
+- TLS verification is not disabled anywhere by default.
+- Credentials in URLs, headers and secrets are redacted from logs and errors.
+- Message-size and body-size limits are configurable and enforced.
+- Resource cleanup is guaranteed on cancellation and early exit.
+
+### Known limitations
+
+- No durable broker adapters (Redis, Kafka, RabbitMQ, NATS) in this release.
+- No OpenTelemetry exporter; metrics are exposed as snapshots only.
+- asyncio only; AnyIO/Trio backends are not supported.
+- The project name has not been trademark-cleared and the package is not on
+  PyPI.

datacurrent-1.0.0/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2026 CoderProandTester
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

datacurrent-1.0.0/MANIFEST.in

@@ -0,0 +1,15 @@
+include README.md
+include LICENSE
+include CHANGELOG.md
+include MANIFEST.in
+recursive-include datacurrent *.py py.typed
+prune tests
+prune examples
+prune benchmarks
+prune docs
+prune scripts
+prune .venv
+prune dist
+prune build
+global-exclude *.py[cod]
+global-exclude __pycache__

datacurrent-1.0.0/PKG-INFO

@@ -0,0 +1,250 @@
+Metadata-Version: 2.4
+Name: datacurrent
+Version: 1.0.0
+Summary: Python streaming, made simple: async streams, operators, backpressure and real-time transports.
+Author: DataCurrent contributors
+License: MIT
+Keywords: streaming,async,asyncio,real-time,data pipeline,stream processing,backpressure,reactive,event bus,pubsub,websocket,server-sent events,http streaming,concurrency,observability,http,https
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+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 :: Only
+Classifier: Topic :: Internet
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.27
+Requires-Dist: websockets>=12
+Provides-Extra: starlette
+Requires-Dist: starlette>=0.36; extra == "starlette"
+Provides-Extra: fastapi
+Requires-Dist: fastapi>=0.110; extra == "fastapi"
+Provides-Extra: all
+Requires-Dist: starlette>=0.36; extra == "all"
+Requires-Dist: fastapi>=0.110; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: pytest-cov>=5; extra == "dev"
+Requires-Dist: hypothesis>=6; extra == "dev"
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: twine>=5; extra == "dev"
+Requires-Dist: ruff>=0.6; extra == "dev"
+Requires-Dist: mypy>=1.11; extra == "dev"
+Requires-Dist: fastapi>=0.110; extra == "dev"
+Dynamic: license-file
+
+# DataCurrent
+
+### Python streaming, made simple.
+
+DataCurrent is a production-ready asynchronous streaming library. It gives you
+one consistent API for lists, async generators, queues, WebSockets, Server-Sent
+Events and streaming HTTP responses.
+
+**Version 1.0.0 · Stable / Production**
+
+- 279 tests passing, with 100% line and branch coverage.
+- Required networking dependencies install automatically.
+- No broker, database, API key or hosted service.
+
+## Install
+
+```bash
+pip install datacurrent
+```
+
+Python 3.11 or newer is required. `httpx` and `websockets` are installed with the
+package, so HTTP streaming, SSE and WebSocket clients work immediately.
+
+Framework helpers are optional:
+
+```bash
+pip install "datacurrent[fastapi]"
+pip install "datacurrent[starlette]"
+pip install "datacurrent[all]"
+```
+
+## Quick start
+
+```python
+import asyncio
+from datacurrent import Stream
+
+
+async def main() -> None:
+    result = await (
+        Stream.from_iterable(range(10))
+        .filter(lambda number: number % 2 == 0)
+        .map(lambda number: number * number)
+        .take(4)
+        .collect()
+    )
+    print(result)  # [0, 4, 16, 36]
+
+
+asyncio.run(main())
+```
+
+Streams are lazy and single-consumer:
+
+```python
+stream = Stream.from_iterable([1, 2, 3])
+
+async for item in stream:
+    print(item)
+
+# A second iteration raises StreamConsumedError.
+```
+
+Common terminals:
+
+```python
+await Stream.from_iterable([1, 2, 3]).collect()  # [1, 2, 3]
+await Stream.from_iterable([1, 2, 3]).count()  # 3
+await Stream.from_iterable([3, 1, 2]).reduce(max)  # 3
+await Stream.empty().first("fallback")  # "fallback"
+```
+
+Async callbacks work everywhere a callback is accepted:
+
+```python
+users = await Stream.from_iterable(user_ids).map(fetch_user, concurrency=8).collect()
+```
+
+## Operators
+
+`map`, `filter`, `flat_map`, `take`, `skip`, `batch`, `buffer`, `distinct`,
+`enumerate`, `window`, `debounce`, `throttle`, `timeout`, `retry`, `recover`,
+`tap`, `zip`, `merge` and `concat`.
+
+```python
+batches = Stream.from_iterable(range(1_000)).filter(lambda number: number % 3 == 0).batch(100)
+
+async for batch in batches:
+    print(len(batch))
+```
+
+## Backpressure
+
+Buffers are bounded and block the producer by default. Data is not silently
+dropped.
+
+```python
+stream = Stream.from_iterable(range(100_000)).buffer(size=64)
+```
+
+Lossy behaviour must be explicit and is counted:
+
+```python
+stream = Stream.from_iterable(range(10_000)).buffer(
+    size=16,
+    overflow="drop_oldest",
+)
+items = await stream.collect()
+print(len(items), stream.stats["dropped"])
+```
+
+Policies: `block`, `drop_newest`, `drop_oldest`, `error`.
+
+## Real-time data
+
+### WebSocket
+
+```python
+from datacurrent import WebSocketStream
+
+async with WebSocketStream.connect("wss://example.com/events") as stream:
+    await stream.send_json({"subscribe": "trades"})
+    async for message in stream:
+        print(message)
+```
+
+### Server-Sent Events
+
+```python
+from datacurrent import SSEStream
+
+async with SSEStream.connect("https://example.com/events") as stream:
+    async for event in stream:
+        print(event.event, event.json())
+```
+
+### Streaming HTTP
+
+```python
+from datacurrent import HTTPStream
+
+async with HTTPStream("https://example.com/feed.ndjson") as response:
+    async for line in response.iter_lines():
+        handle(line)
+```
+
+### Fan-out and events
+
+```python
+from datacurrent import Channel, EventBus
+
+channel = Channel(buffer_size=64)
+first = channel.subscribe()
+second = channel.subscribe()
+await channel.publish("deploy finished")
+
+bus = EventBus()
+
+
+@bus.subscribe("user.*")
+async def on_user(event):
+    print(event.topic, event.data)
+
+
+await bus.publish("user.created", {"user_id": 123})
+```
+
+## Retries
+
+```python
+from datacurrent import RetryPolicy
+
+stream = Stream.from_factory(connect_and_read).retry(
+    RetryPolicy(max_attempts=3, base_delay=0.2, jitter=0.1)
+)
+```
+
+Retries require a replayable source, such as a factory or a list. A consumed
+generator raises `NonReplayableStreamError` instead of silently restarting.
+
+## Why DataCurrent
+
+- One model for iterables, queues, HTTP, SSE and WebSockets.
+- Backpressure by default, with explicit and counted drop policies.
+- Bounded concurrency and cancellation-safe cleanup.
+- No infrastructure: no broker, database or external account.
+- Explicit delivery semantics; no false durability claims.
+- Typed API and sync or async callbacks throughout.
+
+HTTP clients such as `httpx` and `aiohttp` handle requests; DataCurrent adds the
+stream engine around them. Reactive libraries provide operator algebra, while
+broker frameworks require Kafka, Redis or RabbitMQ. DataCurrent is the
+in-process streaming layer that works without any of them.
+
+## Compatibility and limits
+
+- Python 3.11+ on asyncio; no Trio or AnyIO backend.
+- In-memory `Channel` and `EventBus` delivery is at most once.
+- No durable broker adapters or OpenTelemetry exporter in 1.0.0.
+- Not published to PyPI; the project name is provisional.
+
+## License
+
+MIT.

datacurrent-1.0.0/README.md

@@ -0,0 +1,204 @@
+# DataCurrent
+
+### Python streaming, made simple.
+
+DataCurrent is a production-ready asynchronous streaming library. It gives you
+one consistent API for lists, async generators, queues, WebSockets, Server-Sent
+Events and streaming HTTP responses.
+
+**Version 1.0.0 · Stable / Production**
+
+- 279 tests passing, with 100% line and branch coverage.
+- Required networking dependencies install automatically.
+- No broker, database, API key or hosted service.
+
+## Install
+
+```bash
+pip install datacurrent
+```
+
+Python 3.11 or newer is required. `httpx` and `websockets` are installed with the
+package, so HTTP streaming, SSE and WebSocket clients work immediately.
+
+Framework helpers are optional:
+
+```bash
+pip install "datacurrent[fastapi]"
+pip install "datacurrent[starlette]"
+pip install "datacurrent[all]"
+```
+
+## Quick start
+
+```python
+import asyncio
+from datacurrent import Stream
+
+
+async def main() -> None:
+    result = await (
+        Stream.from_iterable(range(10))
+        .filter(lambda number: number % 2 == 0)
+        .map(lambda number: number * number)
+        .take(4)
+        .collect()
+    )
+    print(result)  # [0, 4, 16, 36]
+
+
+asyncio.run(main())
+```
+
+Streams are lazy and single-consumer:
+
+```python
+stream = Stream.from_iterable([1, 2, 3])
+
+async for item in stream:
+    print(item)
+
+# A second iteration raises StreamConsumedError.
+```
+
+Common terminals:
+
+```python
+await Stream.from_iterable([1, 2, 3]).collect()  # [1, 2, 3]
+await Stream.from_iterable([1, 2, 3]).count()  # 3
+await Stream.from_iterable([3, 1, 2]).reduce(max)  # 3
+await Stream.empty().first("fallback")  # "fallback"
+```
+
+Async callbacks work everywhere a callback is accepted:
+
+```python
+users = await Stream.from_iterable(user_ids).map(fetch_user, concurrency=8).collect()
+```
+
+## Operators
+
+`map`, `filter`, `flat_map`, `take`, `skip`, `batch`, `buffer`, `distinct`,
+`enumerate`, `window`, `debounce`, `throttle`, `timeout`, `retry`, `recover`,
+`tap`, `zip`, `merge` and `concat`.
+
+```python
+batches = Stream.from_iterable(range(1_000)).filter(lambda number: number % 3 == 0).batch(100)
+
+async for batch in batches:
+    print(len(batch))
+```
+
+## Backpressure
+
+Buffers are bounded and block the producer by default. Data is not silently
+dropped.
+
+```python
+stream = Stream.from_iterable(range(100_000)).buffer(size=64)
+```
+
+Lossy behaviour must be explicit and is counted:
+
+```python
+stream = Stream.from_iterable(range(10_000)).buffer(
+    size=16,
+    overflow="drop_oldest",
+)
+items = await stream.collect()
+print(len(items), stream.stats["dropped"])
+```
+
+Policies: `block`, `drop_newest`, `drop_oldest`, `error`.
+
+## Real-time data
+
+### WebSocket
+
+```python
+from datacurrent import WebSocketStream
+
+async with WebSocketStream.connect("wss://example.com/events") as stream:
+    await stream.send_json({"subscribe": "trades"})
+    async for message in stream:
+        print(message)
+```
+
+### Server-Sent Events
+
+```python
+from datacurrent import SSEStream
+
+async with SSEStream.connect("https://example.com/events") as stream:
+    async for event in stream:
+        print(event.event, event.json())
+```
+
+### Streaming HTTP
+
+```python
+from datacurrent import HTTPStream
+
+async with HTTPStream("https://example.com/feed.ndjson") as response:
+    async for line in response.iter_lines():
+        handle(line)
+```
+
+### Fan-out and events
+
+```python
+from datacurrent import Channel, EventBus
+
+channel = Channel(buffer_size=64)
+first = channel.subscribe()
+second = channel.subscribe()
+await channel.publish("deploy finished")
+
+bus = EventBus()
+
+
+@bus.subscribe("user.*")
+async def on_user(event):
+    print(event.topic, event.data)
+
+
+await bus.publish("user.created", {"user_id": 123})
+```
+
+## Retries
+
+```python
+from datacurrent import RetryPolicy
+
+stream = Stream.from_factory(connect_and_read).retry(
+    RetryPolicy(max_attempts=3, base_delay=0.2, jitter=0.1)
+)
+```
+
+Retries require a replayable source, such as a factory or a list. A consumed
+generator raises `NonReplayableStreamError` instead of silently restarting.
+
+## Why DataCurrent
+
+- One model for iterables, queues, HTTP, SSE and WebSockets.
+- Backpressure by default, with explicit and counted drop policies.
+- Bounded concurrency and cancellation-safe cleanup.
+- No infrastructure: no broker, database or external account.
+- Explicit delivery semantics; no false durability claims.
+- Typed API and sync or async callbacks throughout.
+
+HTTP clients such as `httpx` and `aiohttp` handle requests; DataCurrent adds the
+stream engine around them. Reactive libraries provide operator algebra, while
+broker frameworks require Kafka, Redis or RabbitMQ. DataCurrent is the
+in-process streaming layer that works without any of them.
+
+## Compatibility and limits
+
+- Python 3.11+ on asyncio; no Trio or AnyIO backend.
+- In-memory `Channel` and `EventBus` delivery is at most once.
+- No durable broker adapters or OpenTelemetry exporter in 1.0.0.
+- Not published to PyPI; the project name is provisional.
+
+## License
+
+MIT.

datacurrent-1.0.0/datacurrent/__init__.py

@@ -0,0 +1,157 @@
+"""DataCurrent — Python streaming, made simple.
+
+Async streams, composable operators, real backpressure and modular real-time
+transports for Python applications.
+
+    from datacurrent import Stream
+
+    stream = Stream.from_iterable([1, 2, 3]).map(lambda n: n * 2)
+    async for value in stream:
+        print(value)
+"""
+
+from __future__ import annotations
+
+from ._version import VERSION, __version__
+from .buffering import BoundedQueue, BufferPolicy, BufferStats
+from .concurrency import ConcurrencyLimiter, TaskTracker, gather_limited
+from .config import (
+    DEFAULT_BUFFER_SIZE,
+    DEFAULT_CONCURRENCY,
+    DEFAULT_MAX_MESSAGE_SIZE,
+    DEFAULT_TIMEOUT,
+    OverflowPolicy,
+    StreamConfig,
+)
+from .core import (
+    Stream,
+    StreamIterator,
+    concat_sources,
+    consume,
+    drain_into,
+    merge_sources,
+    pipeline,
+)
+from .events import Event, EventBus, Subscription, matches
+from .exceptions import (
+    BufferOverflowError,
+    ConfigurationError,
+    ConnectionFailedError,
+    DataCurrentError,
+    EmptyStreamError,
+    EventBusError,
+    MessageTooLargeError,
+    NonReplayableStreamError,
+    OptionalDependencyError,
+    QueueClosedError,
+    QueueEmptyError,
+    RetryError,
+    SSEProtocolError,
+    StreamClosedError,
+    StreamConsumedError,
+    StreamError,
+    StreamProtocolError,
+    StreamTimeoutError,
+    SubscriptionClosedError,
+    TransportError,
+    WebSocketClosedError,
+)
+from .observability import (
+    Counter,
+    Metrics,
+    StreamStats,
+    get_logger,
+    redact_headers,
+    redact_secret,
+    redact_url,
+)
+from .reliability import RetryPolicy, retry_async, with_timeout
+from .transports import (
+    Channel,
+    HTTPStream,
+    SSEEvent,
+    SSEStream,
+    StreamTransport,
+    WebSocketStream,
+    format_heartbeat,
+    format_sse,
+    parse_sse,
+)
+
+__all__ = [
+    # Constants
+    "DEFAULT_BUFFER_SIZE",
+    "DEFAULT_CONCURRENCY",
+    "DEFAULT_MAX_MESSAGE_SIZE",
+    "DEFAULT_TIMEOUT",
+    "VERSION",
+    # Buffering
+    "BoundedQueue",
+    "BufferOverflowError",
+    "BufferPolicy",
+    "BufferStats",
+    # Transports
+    "Channel",
+    # Concurrency
+    "ConcurrencyLimiter",
+    "ConfigurationError",
+    "ConnectionFailedError",
+    "Counter",
+    # Exceptions
+    "DataCurrentError",
+    "EmptyStreamError",
+    # Events
+    "Event",
+    "EventBus",
+    "EventBusError",
+    "HTTPStream",
+    "MessageTooLargeError",
+    # Observability
+    "Metrics",
+    "NonReplayableStreamError",
+    "OptionalDependencyError",
+    "OverflowPolicy",
+    "QueueClosedError",
+    "QueueEmptyError",
+    "RetryError",
+    # Reliability
+    "RetryPolicy",
+    "SSEEvent",
+    "SSEProtocolError",
+    "SSEStream",
+    # Core engine
+    "Stream",
+    "StreamClosedError",
+    "StreamConfig",
+    "StreamConsumedError",
+    "StreamError",
+    "StreamIterator",
+    "StreamProtocolError",
+    "StreamStats",
+    "StreamTimeoutError",
+    "StreamTransport",
+    "Subscription",
+    "SubscriptionClosedError",
+    "TaskTracker",
+    "TransportError",
+    "WebSocketClosedError",
+    "WebSocketStream",
+    # Version
+    "__version__",
+    "concat_sources",
+    "consume",
+    "drain_into",
+    "format_heartbeat",
+    "format_sse",
+    "gather_limited",
+    "get_logger",
+    "matches",
+    "merge_sources",
+    "parse_sse",
+    "pipeline",
+    "redact_headers",
+    "redact_secret",
+    "redact_url",
+    "retry_async",
+    "with_timeout",
+]

datacurrent-1.0.0/datacurrent/_version.py

@@ -0,0 +1,6 @@
+"""Single source of truth for the DataCurrent version."""
+
+from __future__ import annotations
+
+__version__ = "1.0.0"
+VERSION = tuple(int(part) for part in __version__.split("."))