rsloop 0.1.0__tar.gz → 0.1.2__tar.gz

{rsloop-0.1.0 → rsloop-0.1.2}/.github/workflows/wheels.yml

@@ -19,8 +19,13 @@ jobs:
         include:
           - os_name: linux
             runner: ubuntu-latest
-          - os_name: macos
+            rust_target: x86_64-unknown-linux-gnu
+          - os_name: macos-intel
             runner: macos-15-intel
+            rust_target: x86_64-apple-darwin
+          - os_name: macos-arm64
+            runner: macos-15
+            rust_target: aarch64-apple-darwin
 
     steps:
       - name: Check out repository
@@ -45,7 +50,7 @@ jobs:
         uses: Swatinem/rust-cache@v2
 
       - name: Build wheels
-        run: scripts/build-wheels.sh --out dist
+        run: scripts/build-wheels.sh --out dist --target "${{ matrix.rust_target }}"
 
       - name: Upload wheel artifacts
         uses: actions/upload-artifact@v4

{rsloop-0.1.0 → rsloop-0.1.2}/Cargo.lock

@@ -943,7 +943,7 @@ dependencies = [
 
 [[package]]
 name = "rsloop"
-version = "0.1.0"
+version = "0.1.1"
 dependencies = [
  "crossbeam-channel",
  "futures",

{rsloop-0.1.0 → rsloop-0.1.2}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rsloop"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2021"
 description = "An event loop for asyncio written in Rust"
 license = "Apache-2.0"

{rsloop-0.1.0 → rsloop-0.1.2}/LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright [yyyy] [name of copyright owner]
+   Copyright 2026 Yehor Smoliakov
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

{rsloop-0.1.0 → rsloop-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rsloop
-Version: 0.1.0
+Version: 0.1.2
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
@@ -32,16 +32,35 @@ Project-URL: Repository, https://github.com/RustedBytes/rsloop
 
 <img src="./rsloop.png" alt="rsloop logo" align="center">
 
-# `rsloop`: An event loop for asyncio written in Rust
+# An event loop for asyncio written in Rust
 
-`rsloop` is a PyO3-based `asyncio` event loop. Each `rsloop.Loop` still owns a
-dedicated Rust runtime thread for timers, readiness polling, signal watchers,
-and transport coordination, but Python callbacks, tasks, and coroutines are
-driven on the thread that calls `run_forever()` / `run_until_complete()`
-(typically the main thread). The package exposes a Python module at
+[![PyPI - Version](https://img.shields.io/pypi/v/rsloop)](https://pypi.org/project/rsloop/)
+[![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. Each `rsloop.Loop` owns a
+dedicated Rust runtime thread that handles loop coordination and I/O-related
+runtime work, while Python callbacks, tasks, and coroutines are executed on
+the thread that calls `run_forever()` / `run_until_complete()` (typically the
+main thread). The package exposes a Python module at
 `rsloop._loop` plus a small Python wrapper in `python/rsloop/__init__.py`.
 
-The project metadata currently targets Python `>=3.8`.
+The project metadata currently targets Python `>=3.8`. The current
+implementation is Unix-focused and intended for Linux and macOS; Windows is
+not supported by this codebase.
+
+## Install
+
+Install the published package from PyPI:
+
+```bash
+pip install rsloop
+```
+
+With `uv`:
+
+```bash
+uv add rsloop
+```
 
 ## Current Surface Area
 
@@ -93,7 +112,8 @@ Today’s codebase provides:
   - `create_unix_connection`
   - `connect_accepted_socket`
   - returned `Server` and `StreamTransport` objects
-  - `transport.close()` / `transport.abort()` fully close socket transports
+  - `transport.close()` / `transport.abort()` are implemented for socket
+    transports
 - pipe transports:
   - `connect_read_pipe`
   - `connect_write_pipe`
@@ -145,6 +165,12 @@ level transport implementation lives in `src/stream_transport.rs`.
   - `get_write_buffer_size()` returns `0`
   - `get_write_buffer_limits()` returns `(0, 0)`
   - `set_write_buffer_limits()` is a no-op
+- several asyncio compatibility parameters are currently accepted only for API
+  shape and are not implemented:
+  - `create_connection(..., server_hostname=..., happy_eyeballs_delay=..., interleave=..., all_errors=...)`
+  - TLS timeout parameters such as `ssl_handshake_timeout` /
+    `ssl_shutdown_timeout`
+  - `shutdown_default_executor(timeout=...)`
 - subprocess support is intentionally incomplete:
   - `preexec_fn` is unsupported
   - text mode is rejected for higher-level
@@ -180,19 +206,6 @@ Build release wheels for CPython 3.8 through 3.14, plus the free-threaded
 scripts/build-wheels.sh
 ```
 
-## Publishing
-
-PyPI releases are published from Git tags that start with `v`, for example
-`v0.1.0`. The GitHub Actions workflow builds wheels by calling
-`scripts/build-wheels.sh`, builds an `sdist`, and then publishes the combined
-artifacts to PyPI with GitHub trusted publishing.
-
-Before the first release, configure the `rsloop` project on PyPI as a trusted
-publisher for this repository/workflow.
-
-Use a release build for benchmarks and runtime comparisons. A debug extension
-will make the Rust loop look much slower than it really is.
-
 ## Profiling
 
 Profiling support is behind the Cargo feature `profiler` and is disabled by
@@ -228,6 +241,7 @@ This writes an SVG flamegraph that you can open directly in a browser. Run the
 profile against a release build or the stack samples will be dominated by debug
 overhead. If the extension was built without `--features profiler`,
 `start_profiler()` and `profile()` will raise a runtime error.
+Only `format="flamegraph"` is currently implemented.
 
 ## Usage
 

{rsloop-0.1.0 → rsloop-0.1.2}/README.md

@@ -1,15 +1,34 @@
 <img src="./rsloop.png" alt="rsloop logo" align="center">
 
-# `rsloop`: An event loop for asyncio written in Rust
+# An event loop for asyncio written in Rust
 
-`rsloop` is a PyO3-based `asyncio` event loop. Each `rsloop.Loop` still owns a
-dedicated Rust runtime thread for timers, readiness polling, signal watchers,
-and transport coordination, but Python callbacks, tasks, and coroutines are
-driven on the thread that calls `run_forever()` / `run_until_complete()`
-(typically the main thread). The package exposes a Python module at
+[![PyPI - Version](https://img.shields.io/pypi/v/rsloop)](https://pypi.org/project/rsloop/)
+[![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. Each `rsloop.Loop` owns a
+dedicated Rust runtime thread that handles loop coordination and I/O-related
+runtime work, while Python callbacks, tasks, and coroutines are executed on
+the thread that calls `run_forever()` / `run_until_complete()` (typically the
+main thread). The package exposes a Python module at
 `rsloop._loop` plus a small Python wrapper in `python/rsloop/__init__.py`.
 
-The project metadata currently targets Python `>=3.8`.
+The project metadata currently targets Python `>=3.8`. The current
+implementation is Unix-focused and intended for Linux and macOS; Windows is
+not supported by this codebase.
+
+## Install
+
+Install the published package from PyPI:
+
+```bash
+pip install rsloop
+```
+
+With `uv`:
+
+```bash
+uv add rsloop
+```
 
 ## Current Surface Area
 
@@ -61,7 +80,8 @@ Today’s codebase provides:
   - `create_unix_connection`
   - `connect_accepted_socket`
   - returned `Server` and `StreamTransport` objects
-  - `transport.close()` / `transport.abort()` fully close socket transports
+  - `transport.close()` / `transport.abort()` are implemented for socket
+    transports
 - pipe transports:
   - `connect_read_pipe`
   - `connect_write_pipe`
@@ -113,6 +133,12 @@ level transport implementation lives in `src/stream_transport.rs`.
   - `get_write_buffer_size()` returns `0`
   - `get_write_buffer_limits()` returns `(0, 0)`
   - `set_write_buffer_limits()` is a no-op
+- several asyncio compatibility parameters are currently accepted only for API
+  shape and are not implemented:
+  - `create_connection(..., server_hostname=..., happy_eyeballs_delay=..., interleave=..., all_errors=...)`
+  - TLS timeout parameters such as `ssl_handshake_timeout` /
+    `ssl_shutdown_timeout`
+  - `shutdown_default_executor(timeout=...)`
 - subprocess support is intentionally incomplete:
   - `preexec_fn` is unsupported
   - text mode is rejected for higher-level
@@ -148,19 +174,6 @@ Build release wheels for CPython 3.8 through 3.14, plus the free-threaded
 scripts/build-wheels.sh
 ```
 
-## Publishing
-
-PyPI releases are published from Git tags that start with `v`, for example
-`v0.1.0`. The GitHub Actions workflow builds wheels by calling
-`scripts/build-wheels.sh`, builds an `sdist`, and then publishes the combined
-artifacts to PyPI with GitHub trusted publishing.
-
-Before the first release, configure the `rsloop` project on PyPI as a trusted
-publisher for this repository/workflow.
-
-Use a release build for benchmarks and runtime comparisons. A debug extension
-will make the Rust loop look much slower than it really is.
-
 ## Profiling
 
 Profiling support is behind the Cargo feature `profiler` and is disabled by
@@ -196,6 +209,7 @@ This writes an SVG flamegraph that you can open directly in a browser. Run the
 profile against a release build or the stack samples will be dominated by debug
 overhead. If the extension was built without `--features profiler`,
 `start_profiler()` and `profile()` will raise a runtime error.
+Only `format="flamegraph"` is currently implemented.
 
 ## Usage
 

{rsloop-0.1.0 → rsloop-0.1.2}/examples/03_streams.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import asyncio
 
 import rsloop

{rsloop-0.1.0 → rsloop-0.1.2}/examples/04_unix_and_accepted_socket.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import asyncio
 import os
 import socket

{rsloop-0.1.0 → rsloop-0.1.2}/examples/05_pipes_signals_subprocesses.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import asyncio
 import os
 import signal

{rsloop-0.1.0 → rsloop-0.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "rsloop"
-version = "0.1.0"
+version = "0.1.2"
 description = "An event loop for asyncio written in Rust"
 readme = "README.md"
 license = { file = "LICENSE" }

{rsloop-0.1.0 → rsloop-0.1.2}/python/rsloop/__init__.py

@@ -25,6 +25,31 @@ __all__: tuple[str, ...] = (
     "stop_profiler",
 )
 _T = __typing.TypeVar("_T")
+__ORIG_SET_EVENT_LOOP = __asyncio.set_event_loop
+
+
+def __set_event_loop(loop: Loop | None) -> None:
+    try:
+        __ORIG_SET_EVENT_LOOP(loop)
+        return
+    except (AssertionError, TypeError):
+        if loop is None or not isinstance(loop, Loop):
+            raise
+
+    # Python 3.8 rejects non-stdlib loop objects in set_event_loop() with a
+    # hard isinstance() assertion. Mirror the stdlib policy bookkeeping so
+    # get_event_loop() still returns the current rsloop instance.
+    policy = __asyncio.get_event_loop_policy()
+    local = getattr(policy, "_local", None)
+    if local is None:
+        raise
+    local._set_called = True
+    local._loop = loop
+
+
+if __asyncio.set_event_loop is __ORIG_SET_EVENT_LOOP:
+    __asyncio.set_event_loop = __set_event_loop
+    __asyncio.events.set_event_loop = __set_event_loop
 
 
 def new_event_loop() -> Loop:

{rsloop-0.1.0 → rsloop-0.1.2}/scripts/build-wheels.sh

@@ -10,10 +10,11 @@ usage() {
 Build release wheels for rsloop with uv-managed Python interpreters.
 
 Usage:
-  scripts/build-wheels.sh [--out DIR] [--skip-python-install] [-- maturin args...]
+  scripts/build-wheels.sh [--out DIR] [--target TRIPLE] [--skip-python-install] [-- maturin args...]
 
 Options:
   -o, --out DIR           Output directory for built wheels (default: dist/wheels)
+  -t, --target TRIPLE     Rust compilation target to pass to maturin
       --skip-python-install
                           Reuse installed interpreters instead of running `uv python install`
   -h, --help              Show this help
@@ -21,10 +22,12 @@ Options:
 Environment:
   RSLOOP_PYTHON_VERSIONS  Space-separated version list to override the defaults
                           (default: 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.14t)
+  RSLOOP_RUST_TARGET      Rust compilation target to pass to maturin
 
 Examples:
   scripts/build-wheels.sh
   scripts/build-wheels.sh --out wheelhouse
+  scripts/build-wheels.sh --target aarch64-apple-darwin
   RSLOOP_PYTHON_VERSIONS="3.12 3.13 3.14t" scripts/build-wheels.sh -- --features profiler
 EOF
 }
@@ -40,6 +43,7 @@ resolve_path() {
 
 OUTPUT_DIR="$DEFAULT_OUTPUT_DIR"
 INSTALL_PYTHONS=1
+RUST_TARGET="${RSLOOP_RUST_TARGET:-}"
 MATURIN_ARGS=()
 
 while (($#)); do
@@ -52,6 +56,14 @@ while (($#)); do
       OUTPUT_DIR="$2"
       shift 2
       ;;
+    -t|--target)
+      if (($# < 2)); then
+        echo "missing value for $1" >&2
+        exit 1
+      fi
+      RUST_TARGET="$2"
+      shift 2
+      ;;
     --skip-python-install)
       INSTALL_PYTHONS=0
       shift
@@ -92,15 +104,25 @@ fi
 for version in "${PYTHON_VERSIONS[@]}"; do
   interpreter="$(uv python find "$version")"
   echo "Building release wheel for Python ${version} (${interpreter})"
-  uv run \
-    --no-project \
-    --python "$interpreter" \
-    --with maturin \
-    maturin build \
-    --release \
-    --interpreter "$interpreter" \
-    --out "$OUTPUT_DIR" \
-    "${MATURIN_ARGS[@]}"
+  maturin_cmd=(
+    uv run
+    --no-project
+    --python "$interpreter"
+    --with maturin
+    maturin build
+    --release
+    --interpreter "$interpreter"
+    --out "$OUTPUT_DIR"
+  )
+  if [[ -n "$RUST_TARGET" ]]; then
+    maturin_cmd+=(
+      --target "$RUST_TARGET"
+    )
+  fi
+  if ((${#MATURIN_ARGS[@]})); then
+    maturin_cmd+=("${MATURIN_ARGS[@]}")
+  fi
+  "${maturin_cmd[@]}"
 done
 
 echo "Wheels written to $OUTPUT_DIR"

{rsloop-0.1.0 → rsloop-0.1.2}/src/callbacks.rs

@@ -13,7 +13,6 @@ pub type CallbackId = u64;
 
 enum CallbackArgs {
     None,
-    One(Py<PyAny>),
     Many(Py<PyTuple>),
 }
 
@@ -50,12 +49,6 @@ impl ReadyCallback {
     ) -> Self {
         let args = match args.bind(py).len() {
             0 => CallbackArgs::None,
-            1 => CallbackArgs::One(
-                args.bind(py)
-                    .get_item(0)
-                    .expect("single callback arg missing")
-                    .unbind(),
-            ),
             _ => CallbackArgs::Many(args),
         };
 
@@ -127,13 +120,6 @@ impl ReadyCallback {
                 )
                 .map(Bound::unbind)
             },
-            CallbackArgs::One(arg) => unsafe {
-                Bound::from_owned_ptr_or_err(
-                    py,
-                    ffi::PyObject_CallOneArg(self.callback.as_ptr(), arg.as_ptr()),
-                )
-                .map(Bound::unbind)
-            },
             CallbackArgs::Many(args) => self.callback.call1(py, args.clone_ref(py)),
         }
     }
@@ -141,9 +127,6 @@ impl ReadyCallback {
     pub fn clone_args_tuple(&self, py: Python<'_>) -> Py<PyTuple> {
         match &self.args {
             CallbackArgs::None => PyTuple::empty(py).unbind(),
-            CallbackArgs::One(arg) => PyTuple::new(py, [arg.clone_ref(py)])
-                .expect("failed to clone single callback arg")
-                .unbind(),
             CallbackArgs::Many(args) => args.clone_ref(py),
         }
     }

{rsloop-0.1.0 → rsloop-0.1.2}/src/python_api.rs

@@ -8,7 +8,6 @@ use std::sync::OnceLock;
 use std::time::Duration;
 
 use pyo3::exceptions::{PyNotImplementedError, PyRuntimeError, PyTypeError, PyValueError};
-use pyo3::ffi;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyModule, PySlice, PyTuple};
 use pyo3_async_runtimes::TaskLocals;
@@ -123,13 +122,7 @@ fn create_asyncio_future_for_loop(py: Python<'_>, loop_obj: &Py<PyAny>) -> PyRes
 }
 
 fn create_asyncio_future_for_running_loop(py: Python<'_>) -> PyResult<Py<PyAny>> {
-    unsafe {
-        Bound::from_owned_ptr_or_err(
-            py,
-            ffi::compat::PyObject_CallNoArgs(asyncio_future_cls(py)?.as_ptr()),
-        )
-        .map(Bound::unbind)
-    }
+    asyncio_future_cls(py)?.call0(py)
 }
 
 fn create_asyncio_task_for_loop(
@@ -151,13 +144,7 @@ fn create_asyncio_task_for_loop(
 }
 
 fn create_asyncio_task_for_running_loop(py: Python<'_>, coro: Py<PyAny>) -> PyResult<Py<PyAny>> {
-    unsafe {
-        Bound::from_owned_ptr_or_err(
-            py,
-            ffi::PyObject_CallOneArg(asyncio_task_cls(py)?.as_ptr(), coro.as_ptr()),
-        )
-        .map(Bound::unbind)
-    }
+    asyncio_task_cls(py)?.call1(py, (coro,))
 }
 
 fn call_protocol_factory(

rsloop-0.1.2/tests/test_run.py

@@ -0,0 +1,25 @@
+import asyncio
+import unittest
+
+import rsloop
+
+
+class RunTests(unittest.TestCase):
+    def test_set_event_loop_accepts_rsloop_loop(self) -> None:
+        loop = rsloop.new_event_loop()
+        try:
+            asyncio.set_event_loop(loop)
+            self.assertIs(asyncio.get_event_loop(), loop)
+        finally:
+            asyncio.set_event_loop(None)
+            loop.close()
+
+    def test_run_executes_coroutine(self) -> None:
+        async def main() -> str:
+            return "ok"
+
+        self.assertEqual(rsloop.run(main()), "ok")
+
+
+if __name__ == "__main__":
+    unittest.main()

{rsloop-0.1.0 → rsloop-0.1.2}/uv.lock

@@ -4,5 +4,5 @@ requires-python = ">=3.8"
 
 [[package]]
 name = "rsloop"
-version = "0.1.0"
+version = "0.1.2"
 source = { editable = "." }