rsloop 0.1.51__tar.gz → 0.1.53__tar.gz

{rsloop-0.1.51 → rsloop-0.1.53}/.github/workflows/wheels.yml

@@ -41,7 +41,7 @@ jobs:
           - os_name: windows-arm64
             runner: windows-11-arm
             rust_target: aarch64-pc-windows-msvc
-            python_versions: "3.11 3.12 3.13 3.14"
+            python_versions: "3.11 3.12 3.13 3.14 3.15"
           - os_name: macos-intel
             runner: macos-15-intel
             rust_target: x86_64-apple-darwin

{rsloop-0.1.51 → rsloop-0.1.53}/Cargo.lock

@@ -869,7 +869,7 @@ dependencies = [
 
 [[package]]
 name = "rsloop"
-version = "0.1.51"
+version = "0.1.53"
 dependencies = [
  "async-channel 2.5.0",
  "async-io",

{rsloop-0.1.51 → rsloop-0.1.53}/Cargo.toml

@@ -1,45 +1,37 @@
 [package]
 name = "rsloop"
-version = "0.1.51"
+version = "0.1.53"
 edition = "2024"
 description = "An event loop for asyncio written in Rust"
-license = "Apache-2.0"
+documentation = "https://github.com/RustedBytes/rsloop#readme"
 readme = "README.md"
-repository = "https://github.com/RustedBytes/rsloop"
 homepage = "https://github.com/RustedBytes/rsloop"
-documentation = "https://github.com/RustedBytes/rsloop#readme"
+repository = "https://github.com/RustedBytes/rsloop"
+license = "Apache-2.0"
+
+[package.metadata.kani.flags]
+# Force every proof that reaches a loop to state and review its own bound.
+default-unwind = "1"
 
 [lib]
-name = "rsloop"
 crate-type = ["cdylib", "rlib"]
-
-[features]
-default = []
-# Embedded-runtime modules are opt-in; production wheels retain the default
-# networking/timer build unless a feature is explicitly requested.
-fs = []
-process = ["dep:async-channel"]
-signal = ["dep:once_cell", "dep:errno"]
-pipe = []
-stdio = []
-splice = []
-blocking-default = ["dep:rusty_pool"]
+name = "rsloop"
 
 [dependencies]
-errno = { version = "0.3", optional = true }
 async-channel = { version = "2", optional = true }
 async-io = "2"
 async-std = "1"
 crossbeam-channel = "0.5"
 crossbeam-queue = "0.3"
+errno = { version = "0.3", optional = true }
 futures = { version = "0.3", default-features = false, features = ["std"] }
 futures-util = "0.3"
 libc = "0.2"
 memchr = "2"
 mio = "1"
+once_cell = { version = "1", optional = true }
 oneshot = { version = "0.2", features = ["async", "std"] }
 pin-project-lite = "0.2"
-once_cell = { version = "1", optional = true }
 pyo3 = { version = "0.29.2" }
 pyo3-async-runtimes = { version = "0.29", features = ["async-std-runtime"] }
 rustls = "0.23"
@@ -50,48 +42,57 @@ signal-hook = "0.4"
 slab = "0.4"
 socket2 = "0.6"
 tokio = { version = "1", default-features = false, features = ["io-util"] }
+
+[dev-dependencies]
+proptest = { version = "1", default-features = false, features = ["std"] }
+
+[build-dependencies]
+pyo3-build-config = "0.29.2"
+
 [target.'cfg(target_os = "linux")'.dependencies]
 io-uring = "0.7"
 
-[target.'cfg(unix)'.dependencies]
-mio = { version = "1", features = ["os-poll", "os-ext"] }
+[target."cfg(unix)".dependencies]
+mio = { version = "1", features = ["os-ext", "os-poll"] }
 
-[target.'cfg(windows)'.dependencies]
+[target."cfg(windows)".dependencies]
 windows-sys = { version = "0.61", features = ["Wdk_Foundation", "Wdk_Storage_FileSystem", "Wdk_System_IO", "Wdk_System_SystemServices", "Win32_Foundation", "Win32_Networking_WinSock", "Win32_Security", "Win32_Storage_FileSystem", "Win32_System_Console", "Win32_System_IO", "Win32_System_Pipes", "Win32_System_SystemInformation", "Win32_System_Threading"] }
 
-[build-dependencies]
-pyo3-build-config = "0.29.2"
-
-[dev-dependencies]
-proptest = { version = "1", default-features = false, features = ["std"] }
+[features]
+default = []
+blocking-default = ["dep:rusty_pool"]
+# Embedded-runtime modules are opt-in; production wheels retain the default
+# networking/timer build unless a feature is explicitly requested.
+fs = []
+pipe = []
+process = ["dep:async-channel"]
+signal = ["dep:errno", "dep:once_cell"]
+splice = []
+stdio = []
 
 [lints.clippy]
+await_holding_lock = "warn"
+await_holding_refcell_ref = "warn"
+cast_ptr_alignment = "warn"
+complexity = { level = "warn", priority = -1 }
 # Enforce bug, concurrency, and performance checks rather than style preferences.
 correctness = { level = "deny", priority = -1 }
-suspicious = { level = "warn", priority = -1 }
-perf = { level = "warn", priority = -1 }
-complexity = { level = "warn", priority = -1 }
-style = { level = "allow", priority = -1 }
-pedantic = { level = "allow", priority = -1 }
 # Keep safety checks even when they belong to an otherwise disabled group.
 missing_safety_doc = "warn"
-cast_ptr_alignment = "warn"
-await_holding_lock = "warn"
-await_holding_refcell_ref = "warn"
+pedantic = { level = "allow", priority = -1 }
+perf = { level = "warn", priority = -1 }
+style = { level = "allow", priority = -1 }
+suspicious = { level = "warn", priority = -1 }
 
 [lints.rust]
 unexpected_cfgs = { level = "warn", check-cfg = ["cfg(kani)", "cfg(musl_v1_2_3)", "cfg(syscall_accept4)", "cfg(feature, values(\"blocking-default\", \"fs\", \"pipe\", \"process\", \"signal\", \"splice\", \"stdio\"))"] }
 
-[package.metadata.kani.flags]
-# Force every proof that reaches a loop to state and review its own bound.
-default-unwind = "1"
+[profile.bench]
+inherits = "release"
 
 [profile.release]
 opt-level = 3
 lto = "fat"
-codegen-units = 1
 incremental = false
+codegen-units = 1
 # strip = true
-
-[profile.bench]
-inherits = "release"

rsloop-0.1.53/PKG-INFO

@@ -0,0 +1,202 @@
+Metadata-Version: 2.4
+Name: rsloop
+Version: 0.1.53
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+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: Programming Language :: Python :: Free Threading :: 2 - Beta
+Classifier: Programming Language :: Rust
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: System :: Networking
+License-File: LICENSE
+Summary: An event loop for asyncio written in Rust
+Keywords: asyncio,event-loop,pyo3,python,rust
+Home-Page: https://github.com/RustedBytes/rsloop
+Author: Yehor Smoliakov <egorsmkv@gmail.com>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Homepage, https://github.com/RustedBytes/rsloop
+Project-URL: Issues, https://github.com/RustedBytes/rsloop/issues
+Project-URL: Repository, https://github.com/RustedBytes/rsloop
+
+<img src="./docs/rsloop.png" alt="rsloop logo" align="center">
+
+# An event loop for asyncio written in Rust
+
+[![PyPI - Version](https://img.shields.io/pypi/v/rsloop)](https://pypi.org/project/rsloop/)
+[![Tests](https://github.com/RustedBytes/rsloop/actions/workflows/tests.yml/badge.svg)](https://github.com/RustedBytes/rsloop/actions/workflows/tests.yml)
+[![PyPI Downloads](https://static.pepy.tech/personalized-badge/rsloop?period=total&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=downloads)](https://pepy.tech/projects/rsloop)
+
+`rsloop` is a PyO3-based `asyncio` event loop implemented in Rust.
+
+Each `rsloop.Loop` owns a dedicated Rust runtime thread for loop coordination
+and I/O work. That thread runs an rsloop-specialized `vibeio` runtime, using
+io_uring on Linux, IOCP on Windows, and native kqueue readiness on macOS.
+Native-stream TCP reads and Unix-domain socket reads run on that runtime. On Unix, generic
+TCP protocol readers use a second `vibeio` runtime on the Python loop thread
+(io_uring on Linux), avoiding cross-thread delivery of each read. Non-TLS accepts
+run on either runtime depending on where the server starts. Python callbacks,
+tasks, and coroutines run on the thread that calls
+`run_forever()` or `run_until_complete()` (usually the main Python thread).
+
+The package exposes:
+
+- a native extension module at `rsloop._loop`
+- a Python wrapper in [`python/rsloop/__init__.py`](./python/rsloop/__init__.py)
+- `rsloop.Loop`, `rsloop.EventLoopPolicy`, `rsloop.new_event_loop()`,
+  `rsloop.run(...)`, `rsloop.install()`, `rsloop.uninstall()`, and
+  `rsloop.build_info()`
+
+Repository metadata supports CPython 3.10 through 3.15.
+The native runtime requires Linux 6.1+, macOS 13+, or Windows 10+ so its hot
+paths can rely on modern completion, timer, and scheduler primitives.
+Free-threaded CPython (`3.14t`) is supported: the extension declares
+`gil_used = false`, so importing it no longer re-enables the GIL. See
+[Free-Threaded CPython](./docs/free-threading.md) for what that does and does not
+buy you.
+
+## Documentation
+
+Project documentation now lives in [`docs/`](./docs/).
+
+If you are new to the repository, start with:
+
+- [`docs/index.md`](./docs/index.md)
+- [`docs/getting-started.md`](./docs/getting-started.md)
+- [`docs/supported-features.md`](./docs/supported-features.md)
+- [`docs/fast-streams.md`](./docs/fast-streams.md)
+- [`docs/free-threading.md`](./docs/free-threading.md)
+- [`docs/rust-extensions.md`](./docs/rust-extensions.md)
+- [`docs/how-it-works.md`](./docs/how-it-works.md)
+- [`docs/project-structure.md`](./docs/project-structure.md)
+- [`docs/development.md`](./docs/development.md) for building, testing, and profiling
+
+To browse the docs locally with MkDocs:
+
+```bash
+uvx --from mkdocs mkdocs serve
+```
+
+## Install
+
+From PyPI:
+
+```bash
+pip install rsloop
+```
+
+With `uv`:
+
+```bash
+uv add rsloop
+```
+
+From [conda-forge](https://conda-forge.org), using [pixi](https://pixi.prefix.dev/latest/#installation):
+
+```bash
+pixi add rsloop
+```
+
+## Usage
+
+Simple entry point:
+
+```python
+import rsloop
+
+
+async def main(): ...
+
+
+rsloop.run(main())
+```
+
+Install as the default asyncio event loop policy:
+
+```python
+import asyncio
+import rsloop
+
+rsloop.install()
+try:
+    asyncio.run(main())
+finally:
+    rsloop.uninstall()
+```
+
+Manual loop creation also works:
+
+```python
+import asyncio
+import rsloop
+
+loop = rsloop.new_event_loop()
+asyncio.set_event_loop(loop)
+try:
+    loop.run_until_complete(...)
+finally:
+    asyncio.set_event_loop(None)
+    loop.close()
+```
+
+Importing `rsloop` also patches `asyncio.set_event_loop()` so Python 3.10 can
+accept an `rsloop.Loop` instance, matching the behavior exercised by
+[`tests/test_run.py`](./tests/test_run.py).
+
+## Examples
+
+Run the repository examples from the project root:
+
+```bash
+uv run python examples/01_basics.py
+uv run python examples/02_fd_and_sockets.py
+uv run python examples/03_streams.py
+uv run python examples/04_unix_and_accepted_socket.py
+uv run python examples/05_pipes_signals_subprocesses.py
+```
+
+Example files:
+[`examples/01_basics.py`](./examples/01_basics.py),
+[`examples/02_fd_and_sockets.py`](./examples/02_fd_and_sockets.py),
+[`examples/03_streams.py`](./examples/03_streams.py),
+[`examples/04_unix_and_accepted_socket.py`](./examples/04_unix_and_accepted_socket.py),
+[`examples/05_pipes_signals_subprocesses.py`](./examples/05_pipes_signals_subprocesses.py).
+
+The repository also includes:
+
+- [`examples/fastapi_service.py`](./examples/fastapi_service.py) for running the same
+  FastAPI app on stdlib `asyncio`, `uvloop`, or `rsloop`
+- [`examples/granian_service.py`](./examples/granian_service.py) for registering
+  `rsloop` as Granian's worker event loop
+- [`benches/compare_event_loops.py`](./benches/compare_event_loops.py)
+  for callback, task, and TCP stream comparisons
+- [`benches/compare_granian.py`](./benches/compare_granian.py) for Granian HTTP
+  throughput and latency comparisons with `oha`
+
+## Benchmarks
+
+See [benchmark results and reproduction commands](./docs/benchmarks.md).
+
+## Acknowledgements
+
+`rsloop` builds on the Python `asyncio` model and is implemented with
+[PyO3](https://pyo3.rs/) on the Rust side. Runtime and socket I/O are powered by
+[vibeio](https://crates.io/crates/vibeio).
+
+## License
+
+This project is licensed under the Apache License, Version 2.0. See
+[`LICENSE`](./LICENSE) for the full text.
+

rsloop-0.1.53/README.md

@@ -0,0 +1,168 @@
+<img src="./docs/rsloop.png" alt="rsloop logo" align="center">
+
+# An event loop for asyncio written in Rust
+
+[![PyPI - Version](https://img.shields.io/pypi/v/rsloop)](https://pypi.org/project/rsloop/)
+[![Tests](https://github.com/RustedBytes/rsloop/actions/workflows/tests.yml/badge.svg)](https://github.com/RustedBytes/rsloop/actions/workflows/tests.yml)
+[![PyPI Downloads](https://static.pepy.tech/personalized-badge/rsloop?period=total&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=downloads)](https://pepy.tech/projects/rsloop)
+
+`rsloop` is a PyO3-based `asyncio` event loop implemented in Rust.
+
+Each `rsloop.Loop` owns a dedicated Rust runtime thread for loop coordination
+and I/O work. That thread runs an rsloop-specialized `vibeio` runtime, using
+io_uring on Linux, IOCP on Windows, and native kqueue readiness on macOS.
+Native-stream TCP reads and Unix-domain socket reads run on that runtime. On Unix, generic
+TCP protocol readers use a second `vibeio` runtime on the Python loop thread
+(io_uring on Linux), avoiding cross-thread delivery of each read. Non-TLS accepts
+run on either runtime depending on where the server starts. Python callbacks,
+tasks, and coroutines run on the thread that calls
+`run_forever()` or `run_until_complete()` (usually the main Python thread).
+
+The package exposes:
+
+- a native extension module at `rsloop._loop`
+- a Python wrapper in [`python/rsloop/__init__.py`](./python/rsloop/__init__.py)
+- `rsloop.Loop`, `rsloop.EventLoopPolicy`, `rsloop.new_event_loop()`,
+  `rsloop.run(...)`, `rsloop.install()`, `rsloop.uninstall()`, and
+  `rsloop.build_info()`
+
+Repository metadata supports CPython 3.10 through 3.15.
+The native runtime requires Linux 6.1+, macOS 13+, or Windows 10+ so its hot
+paths can rely on modern completion, timer, and scheduler primitives.
+Free-threaded CPython (`3.14t`) is supported: the extension declares
+`gil_used = false`, so importing it no longer re-enables the GIL. See
+[Free-Threaded CPython](./docs/free-threading.md) for what that does and does not
+buy you.
+
+## Documentation
+
+Project documentation now lives in [`docs/`](./docs/).
+
+If you are new to the repository, start with:
+
+- [`docs/index.md`](./docs/index.md)
+- [`docs/getting-started.md`](./docs/getting-started.md)
+- [`docs/supported-features.md`](./docs/supported-features.md)
+- [`docs/fast-streams.md`](./docs/fast-streams.md)
+- [`docs/free-threading.md`](./docs/free-threading.md)
+- [`docs/rust-extensions.md`](./docs/rust-extensions.md)
+- [`docs/how-it-works.md`](./docs/how-it-works.md)
+- [`docs/project-structure.md`](./docs/project-structure.md)
+- [`docs/development.md`](./docs/development.md) for building, testing, and profiling
+
+To browse the docs locally with MkDocs:
+
+```bash
+uvx --from mkdocs mkdocs serve
+```
+
+## Install
+
+From PyPI:
+
+```bash
+pip install rsloop
+```
+
+With `uv`:
+
+```bash
+uv add rsloop
+```
+
+From [conda-forge](https://conda-forge.org), using [pixi](https://pixi.prefix.dev/latest/#installation):
+
+```bash
+pixi add rsloop
+```
+
+## Usage
+
+Simple entry point:
+
+```python
+import rsloop
+
+
+async def main(): ...
+
+
+rsloop.run(main())
+```
+
+Install as the default asyncio event loop policy:
+
+```python
+import asyncio
+import rsloop
+
+rsloop.install()
+try:
+    asyncio.run(main())
+finally:
+    rsloop.uninstall()
+```
+
+Manual loop creation also works:
+
+```python
+import asyncio
+import rsloop
+
+loop = rsloop.new_event_loop()
+asyncio.set_event_loop(loop)
+try:
+    loop.run_until_complete(...)
+finally:
+    asyncio.set_event_loop(None)
+    loop.close()
+```
+
+Importing `rsloop` also patches `asyncio.set_event_loop()` so Python 3.10 can
+accept an `rsloop.Loop` instance, matching the behavior exercised by
+[`tests/test_run.py`](./tests/test_run.py).
+
+## Examples
+
+Run the repository examples from the project root:
+
+```bash
+uv run python examples/01_basics.py
+uv run python examples/02_fd_and_sockets.py
+uv run python examples/03_streams.py
+uv run python examples/04_unix_and_accepted_socket.py
+uv run python examples/05_pipes_signals_subprocesses.py
+```
+
+Example files:
+[`examples/01_basics.py`](./examples/01_basics.py),
+[`examples/02_fd_and_sockets.py`](./examples/02_fd_and_sockets.py),
+[`examples/03_streams.py`](./examples/03_streams.py),
+[`examples/04_unix_and_accepted_socket.py`](./examples/04_unix_and_accepted_socket.py),
+[`examples/05_pipes_signals_subprocesses.py`](./examples/05_pipes_signals_subprocesses.py).
+
+The repository also includes:
+
+- [`examples/fastapi_service.py`](./examples/fastapi_service.py) for running the same
+  FastAPI app on stdlib `asyncio`, `uvloop`, or `rsloop`
+- [`examples/granian_service.py`](./examples/granian_service.py) for registering
+  `rsloop` as Granian's worker event loop
+- [`benches/compare_event_loops.py`](./benches/compare_event_loops.py)
+  for callback, task, and TCP stream comparisons
+- [`benches/compare_granian.py`](./benches/compare_granian.py) for Granian HTTP
+  throughput and latency comparisons with `oha`
+
+## Benchmarks
+
+See [benchmark results and reproduction commands](./docs/benchmarks.md).
+
+## Acknowledgements
+
+`rsloop` builds on the Python `asyncio` model and is implemented with
+[PyO3](https://pyo3.rs/) on the Rust side. Runtime and socket I/O are powered by
+[vibeio](https://crates.io/crates/vibeio).
+
+## License
+
+This project is licensed under the Apache License, Version 2.0. See
+[`LICENSE`](./LICENSE) for the full text.

{rsloop-0.1.51 → rsloop-0.1.53}/benches/compare_event_loops.py

@@ -533,9 +533,7 @@ def run_child(
     if not lines:
         raise RuntimeError(f"{loop_name}/{workload} produced no output")
     payload = next(
-        json.loads(line)
-        for line in reversed(lines)
-        if line.lstrip().startswith("{")
+        json.loads(line) for line in reversed(lines) if line.lstrip().startswith("{")
     )
     return ChildResult(
         loop=payload["loop"],