rsloop 0.1.8__tar.gz → 0.1.9__tar.gz

{rsloop-0.1.8 → rsloop-0.1.9}/Cargo.lock

@@ -1080,7 +1080,7 @@ dependencies = [
 
 [[package]]
 name = "rsloop"
-version = "0.1.8"
+version = "0.1.9"
 dependencies = [
  "async-std",
  "compio",

{rsloop-0.1.8 → rsloop-0.1.9}/Cargo.toml

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

{rsloop-0.1.8 → rsloop-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rsloop
-Version: 0.1.8
+Version: 0.1.9
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
@@ -268,7 +268,7 @@ Or manage the session manually:
 ```python
 import rsloop
 
-rsloop.start_profiler(frequency=999)
+rsloop.start_profiler()
 try:
     rsloop.run(main())
 finally:
@@ -279,10 +279,6 @@ This starts a Tracy client inside the process. Build a release binary, open
 `tracy-profiler.exe`, then connect to the running process while the profiled
 code is executing.
 
-The `frequency` argument is accepted for compatibility with the old `pprof`
-integration but is ignored by Tracy. `path` / `format` are also retained as
-compatibility arguments on `stop_profiler()` / `profile()` and are ignored.
-
 The current Tracy feature set is aimed at local Windows profiling:
 `enable`, `only-localhost`, `sampling`, and `flush-on-exit`. The last one helps
 short-lived runs flush data before exit.

{rsloop-0.1.8 → rsloop-0.1.9}/README.md

@@ -236,7 +236,7 @@ Or manage the session manually:
 ```python
 import rsloop
 
-rsloop.start_profiler(frequency=999)
+rsloop.start_profiler()
 try:
     rsloop.run(main())
 finally:
@@ -247,10 +247,6 @@ This starts a Tracy client inside the process. Build a release binary, open
 `tracy-profiler.exe`, then connect to the running process while the profiled
 code is executing.
 
-The `frequency` argument is accepted for compatibility with the old `pprof`
-integration but is ignored by Tracy. `path` / `format` are also retained as
-compatibility arguments on `stop_profiler()` / `profile()` and are ignored.
-
 The current Tracy feature set is aimed at local Windows profiling:
 `enable`, `only-localhost`, `sampling`, and `flush-on-exit`. The last one helps
 short-lived runs flush data before exit.

{rsloop-0.1.8 → rsloop-0.1.9}/benchmarks/README.md

@@ -33,7 +33,7 @@ uv run --with uvloop python benchmarks/compare_event_loops.py \
 ```
 
 To launch an unmeasured Tracy session for each `rsloop` workload before the
-measured runs, add a profile directory placeholder:
+measured runs, add a label directory:
 
 ```bash
 uv run --with maturin maturin develop --release --features profiler
@@ -43,9 +43,10 @@ uv run --with uvloop python benchmarks/compare_event_loops.py \
   --profile-rsloop-dir benchmarks/profiles
 ```
 
-No files are written by Tracy. The directory argument is only used to label the
-unmeasured profiling pass before the warmup and measured runs. Open the Tracy
-desktop profiler and connect while that pass is running.
+No files are written by Tracy. The directory argument is only used to derive a
+human-readable label for the unmeasured profiling pass before the warmup and
+measured runs. Open the Tracy desktop profiler and connect while that pass is
+running.
 
 The runner executes each loop/workload in a fresh subprocess and reports:
 

{rsloop-0.1.8 → rsloop-0.1.9}/benchmarks/compare_event_loops.py

@@ -13,7 +13,7 @@ import statistics
 import subprocess
 import sys
 import time
-from dataclasses import dataclass
+from dataclasses import dataclass, replace
 from typing import Callable
 
 
@@ -37,7 +37,9 @@ class ChildResult:
     workload: str
     seconds: float
     operations: int
+    baseline_rss_bytes: int
     peak_rss_bytes: int
+    peak_rss_delta_bytes: int
 
     @property
     def ops_per_sec(self) -> float:
@@ -120,16 +122,10 @@ def parse_args() -> argparse.Namespace:
         default=None,
         help="Optional directory placeholder used to label one rsloop Tracy run per workload before measured runs",
     )
-    parser.add_argument(
-        "--profile-frequency",
-        type=int,
-        default=999,
-        help="Compatibility option retained from the old pprof profiler; ignored by Tracy",
-    )
     parser.add_argument("--child", action="store_true", help=argparse.SUPPRESS)
     parser.add_argument("--loop", choices=LOOP_CHOICES, help=argparse.SUPPRESS)
     parser.add_argument("--workload", choices=WORKLOAD_CHOICES, help=argparse.SUPPRESS)
-    parser.add_argument("--profile-output", help=argparse.SUPPRESS)
+    parser.add_argument("--profile-label", help=argparse.SUPPRESS)
     return parser.parse_args()
 
 
@@ -158,8 +154,6 @@ def validate_args(args: argparse.Namespace) -> None:
         raise SystemExit("--tcp-roundtrips must be > 0")
     if args.payload_size <= 0:
         raise SystemExit("--payload-size must be > 0")
-    if args.profile_frequency <= 0:
-        raise SystemExit("--profile-frequency must be > 0")
 
 
 def env_flag(name: str) -> bool:
@@ -208,6 +202,7 @@ def is_loop_available(loop_name: str) -> tuple[bool, str | None]:
 
 def get_peak_rss_bytes() -> int:
     if sys.platform == "win32":
+
         class PROCESS_MEMORY_COUNTERS(ctypes.Structure):
             _fields_ = [
                 ("cb", wintypes.DWORD),
@@ -253,6 +248,25 @@ def get_peak_rss_bytes() -> int:
     return int(peak_rss * 1024)
 
 
+def get_current_rss_bytes() -> int:
+    if sys.platform != "linux":
+        return 0
+
+    try:
+        with open("/proc/self/status", "r", encoding="utf-8") as f:
+            for line in f:
+                if not line.startswith("VmRSS:"):
+                    continue
+                parts = line.split()
+                if len(parts) < 2:
+                    break
+                return int(parts[1]) * 1024
+    except OSError:
+        return 0
+
+    return 0
+
+
 def format_bytes(num_bytes: int) -> str:
     units = ["B", "KiB", "MiB", "GiB", "TiB"]
     value = float(num_bytes)
@@ -300,7 +314,9 @@ async def bench_callbacks(loop_name: str, iterations: int) -> ChildResult:
         "callbacks",
         time.perf_counter() - start,
         iterations,
+        baseline_rss_bytes=0,
         peak_rss_bytes=0,
+        peak_rss_delta_bytes=0,
     )
 
 
@@ -319,7 +335,9 @@ async def bench_tasks(loop_name: str, iterations: int, batch_size: int) -> Child
         "tasks",
         time.perf_counter() - start,
         iterations,
+        baseline_rss_bytes=0,
         peak_rss_bytes=0,
+        peak_rss_delta_bytes=0,
     )
 
 
@@ -372,7 +390,9 @@ async def bench_tcp_streams(
             "tcp_streams",
             duration,
             roundtrips,
+            baseline_rss_bytes=0,
             peak_rss_bytes=0,
+            peak_rss_delta_bytes=0,
         )
     finally:
         server.close()
@@ -382,6 +402,7 @@ async def bench_tcp_streams(
 def child_main(args: argparse.Namespace) -> int:
     gc.collect()
     gc.disable()
+    baseline_rss_bytes = 0
     try:
         if args.workload == "callbacks":
             coro = bench_callbacks(args.loop, args.callbacks)
@@ -392,10 +413,12 @@ def child_main(args: argparse.Namespace) -> int:
         else:  # pragma: no cover - parser guards this
             raise AssertionError(f"unsupported workload: {args.workload}")
 
-        profile_requested = args.profile_output is not None or (
+        profile_requested = args.profile_label is not None or (
             args.loop == "rsloop" and env_flag(RSLOOP_PROFILE_ENV)
         )
-        if profile_requested and not args.profile_output:
+        loop_factory_for(args.loop)
+        baseline_rss_bytes = get_current_rss_bytes()
+        if profile_requested and not args.profile_label:
             print(
                 f"[profile] Tracy enabled via {RSLOOP_PROFILE_ENV}=1 for {args.loop}/{args.workload}",
                 flush=True,
@@ -404,19 +427,24 @@ def child_main(args: argparse.Namespace) -> int:
             if args.loop != "rsloop":
                 raise RuntimeError("profiling is only supported for rsloop")
             rsloop = importlib.import_module("rsloop")
-            with rsloop.profile(args.profile_output, frequency=args.profile_frequency):
+            if args.profile_label:
+                print(f"[profile] Tracy session label: {args.profile_label}", flush=True)
+            with rsloop.profile():
                 result = run_with_loop(args.loop, coro)
         else:
             result = run_with_loop(args.loop, coro)
     finally:
         gc.enable()
 
-    result = ChildResult(
-        loop=result.loop,
-        workload=result.workload,
-        seconds=result.seconds,
-        operations=result.operations,
+    result = replace(
+        result,
+        baseline_rss_bytes=baseline_rss_bytes,
         peak_rss_bytes=get_peak_rss_bytes(),
+        peak_rss_delta_bytes=0,
+    )
+    result = replace(
+        result,
+        peak_rss_delta_bytes=max(0, result.peak_rss_bytes - result.baseline_rss_bytes),
     )
 
     print(
@@ -427,7 +455,9 @@ def child_main(args: argparse.Namespace) -> int:
                 "seconds": result.seconds,
                 "operations": result.operations,
                 "ops_per_sec": result.ops_per_sec,
+                "baseline_rss_bytes": result.baseline_rss_bytes,
                 "peak_rss_bytes": result.peak_rss_bytes,
+                "peak_rss_delta_bytes": result.peak_rss_delta_bytes,
             }
         )
     )
@@ -440,7 +470,7 @@ def run_child(
     workload: str,
     args: argparse.Namespace,
     *,
-    profile_output: str | None = None,
+    profile_label: str | None = None,
 ) -> ChildResult:
     cmd = [
         sys.executable,
@@ -460,11 +490,9 @@ def run_child(
         str(args.tcp_roundtrips),
         "--payload-size",
         str(args.payload_size),
-        "--profile-frequency",
-        str(args.profile_frequency),
     ]
-    if profile_output is not None:
-        cmd.extend(["--profile-output", profile_output])
+    if profile_label is not None:
+        cmd.extend(["--profile-label", profile_label])
     env = os.environ.copy()
     if loop_name == "rsloop":
         env["RSLOOP_USE_FAST_STREAMS"] = "1" if args.rsloop_fast_streams else "0"
@@ -492,17 +520,23 @@ def run_child(
         workload=payload["workload"],
         seconds=payload["seconds"],
         operations=payload["operations"],
+        baseline_rss_bytes=payload.get("baseline_rss_bytes", 0),
         peak_rss_bytes=payload["peak_rss_bytes"],
+        peak_rss_delta_bytes=payload.get("peak_rss_delta_bytes", 0),
     )
 
 
 def print_workload_table(workload: str, runs: dict[str, list[ChildResult]]) -> None:
-    rows: list[tuple[str, float, float, float, int, int]] = []
+    rows: list[tuple[str, float, float, float, int, int, int, int]] = []
     for loop_name, loop_runs in runs.items():
         seconds = [item.seconds for item in loop_runs]
+        baseline_rss_values = [item.baseline_rss_bytes for item in loop_runs]
         peak_rss_values = [item.peak_rss_bytes for item in loop_runs]
+        peak_rss_delta_values = [item.peak_rss_delta_bytes for item in loop_runs]
         median_seconds = statistics.median(seconds)
+        median_baseline_rss = int(statistics.median(baseline_rss_values))
         median_peak_rss = int(statistics.median(peak_rss_values))
+        median_peak_rss_delta = int(statistics.median(peak_rss_delta_values))
         operations = loop_runs[0].operations
         ops_per_sec = (
             operations / median_seconds if median_seconds > 0 else float("inf")
@@ -514,7 +548,9 @@ def print_workload_table(workload: str, runs: dict[str, list[ChildResult]]) -> N
                 ops_per_sec,
                 min(seconds),
                 operations,
+                median_baseline_rss,
                 median_peak_rss,
+                median_peak_rss_delta,
             )
         )
 
@@ -523,19 +559,45 @@ def print_workload_table(workload: str, runs: dict[str, list[ChildResult]]) -> N
 
     print()
     print(f"{workload} ({rows[0][4]:,} ops)")
-    print(
-        f"{'loop':<10} {'median_s':>12} {'best_s':>12} {'ops_per_s':>14} {'peak_rss':>12} {'vs_fastest':>12}"
-    )
-    for loop_name, median_seconds, ops_per_sec, best_seconds, _, median_peak_rss in rows:
-        relative = median_seconds / fastest if fastest > 0 else 1.0
+    if sys.platform == "linux":
         print(
-            f"{loop_name:<10} "
-            f"{median_seconds:>12.6f} "
-            f"{best_seconds:>12.6f} "
-            f"{ops_per_sec:>14,.0f} "
-            f"{format_bytes(median_peak_rss):>12} "
-            f"{relative:>11.2f}x"
+            f"{'loop':<10} {'median_s':>12} {'best_s':>12} {'ops_per_s':>14} {'baseline_rss':>14} {'peak_rss':>12} {'peak_delta':>12} {'vs_fastest':>12}"
         )
+    else:
+        print(
+            f"{'loop':<10} {'median_s':>12} {'best_s':>12} {'ops_per_s':>14} {'peak_rss':>12} {'vs_fastest':>12}"
+        )
+    for (
+        loop_name,
+        median_seconds,
+        ops_per_sec,
+        best_seconds,
+        _,
+        median_baseline_rss,
+        median_peak_rss,
+        median_peak_rss_delta,
+    ) in rows:
+        relative = median_seconds / fastest if fastest > 0 else 1.0
+        if sys.platform == "linux":
+            print(
+                f"{loop_name:<10} "
+                f"{median_seconds:>12.6f} "
+                f"{best_seconds:>12.6f} "
+                f"{ops_per_sec:>14,.0f} "
+                f"{format_bytes(median_baseline_rss):>14} "
+                f"{format_bytes(median_peak_rss):>12} "
+                f"{format_bytes(median_peak_rss_delta):>12} "
+                f"{relative:>11.2f}x"
+            )
+        else:
+            print(
+                f"{loop_name:<10} "
+                f"{median_seconds:>12.6f} "
+                f"{best_seconds:>12.6f} "
+                f"{ops_per_sec:>14,.0f} "
+                f"{format_bytes(median_peak_rss):>12} "
+                f"{relative:>11.2f}x"
+            )
 
 
 def parent_main(args: argparse.Namespace) -> int:
@@ -584,16 +646,14 @@ def parent_main(args: argparse.Namespace) -> int:
             print(f"Running {workload} on {loop_name}...")
             if profile_rsloop_dir and loop_name == "rsloop":
                 os.makedirs(profile_rsloop_dir, exist_ok=True)
-                profile_output = os.path.join(
-                    profile_rsloop_dir, f"rsloop-{workload}.svg"
-                )
-                print(f"  starting Tracy session labeled {profile_output}")
+                profile_label = os.path.join(profile_rsloop_dir, f"rsloop-{workload}")
+                print(f"  starting Tracy session labeled {profile_label}")
                 run_child(
                     script_path,
                     loop_name,
                     workload,
                     args,
-                    profile_output=profile_output,
+                    profile_label=profile_label,
                 )
             for _ in range(args.warmups):
                 run_child(script_path, loop_name, workload, args)
@@ -611,7 +671,9 @@ def parent_main(args: argparse.Namespace) -> int:
                             "seconds": item.seconds,
                             "operations": item.operations,
                             "ops_per_sec": item.ops_per_sec,
+                            "baseline_rss_bytes": item.baseline_rss_bytes,
                             "peak_rss_bytes": item.peak_rss_bytes,
+                            "peak_rss_delta_bytes": item.peak_rss_delta_bytes,
                         }
                         for item in measured
                     ],

{rsloop-0.1.8 → rsloop-0.1.9}/justfile

@@ -3,5 +3,9 @@ set shell := ["bash", "-euo", "pipefail", "-c"]
 tls-test-certs outdir="tests/fixtures/tls":
     ./scripts/generate-test-tls-certs.sh {{outdir}}
 
+fmt:
+    uv run ruff format .
+    cargo fmt --all
+
 test:
     uv run python -m unittest discover -s tests

{rsloop-0.1.8 → rsloop-0.1.9}/pyproject.toml

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

{rsloop-0.1.8 → rsloop-0.1.9}/python/rsloop/__init__.py

@@ -105,32 +105,24 @@ def profiler_running() -> bool:
     return __profiler_running()
 
 
-def start_profiler(*, frequency: int = 999) -> None:
-    __start_profiler(frequency=frequency)
+def start_profiler() -> None:
+    """Start a Tracy profiling session."""
+    __start_profiler()
 
 
-def stop_profiler(
-    path: str | __os.PathLike[str] | None = None,
-    *,
-    format: str | None = None,
-) -> str | None:
-    resolved = None if path is None else __os.fspath(path)
-    return __stop_profiler(resolved, format=format)
+def stop_profiler() -> None:
+    """Stop the active Tracy profiling session."""
+    __stop_profiler()
 
 
 @__contextlib.contextmanager
-def profile(
-    path: str | __os.PathLike[str] | None = None,
-    *,
-    frequency: int = 999,
-    format: str | None = None,
-) -> __typing.Iterator[str | None]:
-    resolved_path = None if path is None else __os.fspath(path)
-    start_profiler(frequency=frequency)
+def profile() -> __typing.Iterator[None]:
+    """Context manager wrapper around ``start_profiler()`` / ``stop_profiler()``."""
+    start_profiler()
     try:
-        yield resolved_path
+        yield None
     finally:
-        stop_profiler(resolved_path, format=format)
+        stop_profiler()
 
 
 __ORIG_OPEN_CONNECTION = __asyncio.open_connection

{rsloop-0.1.8 → rsloop-0.1.9}/src/callbacks.rs

@@ -33,6 +33,7 @@ pub struct ReadyCallback {
     kind: CallbackKind,
     callback: Py<PyAny>,
     args: CallbackArgs,
+    args_tuple: Py<PyTuple>,
     context: Py<PyAny>,
     context_needs_run: bool,
     cancelled: AtomicBool,
@@ -45,19 +46,20 @@ impl ReadyCallback {
         id: CallbackId,
         kind: CallbackKind,
         callback: Py<PyAny>,
-        args: Py<PyTuple>,
+        args_tuple: Py<PyTuple>,
         context: Py<PyAny>,
         context_needs_run: bool,
     ) -> Self {
-        let args = match args.bind(py).len() {
+        let args = match args_tuple.bind(py).len() {
             0 => CallbackArgs::None,
             1 => CallbackArgs::One(
-                args.bind(py)
+                args_tuple
+                    .bind(py)
                     .get_item(0)
                     .expect("single callback arg")
                     .unbind(),
             ),
-            _ => CallbackArgs::Many(args),
+            _ => CallbackArgs::Many(args_tuple.clone_ref(py)),
         };
 
         Self {
@@ -65,6 +67,7 @@ impl ReadyCallback {
             kind,
             callback,
             args,
+            args_tuple,
             context,
             context_needs_run,
             cancelled: AtomicBool::new(false),
@@ -146,13 +149,7 @@ 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.bind(py)])
-                .expect("single callback arg tuple")
-                .unbind(),
-            CallbackArgs::Many(args) => args.clone_ref(py),
-        }
+        self.args_tuple.clone_ref(py)
     }
 
     #[inline]

{rsloop-0.1.8 → rsloop-0.1.9}/src/profiler.rs

@@ -21,23 +21,8 @@ mod imp {
         ACTIVE_PROFILER.get_or_init(|| Mutex::new(None))
     }
 
-    fn ensure_ignored_format(format: Option<&str>) -> PyResult<()> {
-        if let Some(format) = format {
-            return Err(PyValueError::new_err(format!(
-                "Tracy does not support file output formats; got format={format:?}"
-            )));
-        }
-        Ok(())
-    }
-
-    #[pyfunction(signature = (*, frequency = 999))]
-    pub fn start_profiler(frequency: i32) -> PyResult<()> {
-        if frequency <= 0 {
-            return Err(PyValueError::new_err(
-                "profiler frequency must be greater than zero",
-            ));
-        }
-
+    #[pyfunction]
+    pub fn start_profiler() -> PyResult<()> {
         let mut active = active_profiler()
             .lock()
             .map_err(|_| PyRuntimeError::new_err("profiler state mutex is poisoned"))?;
@@ -45,7 +30,6 @@ mod imp {
             return Err(PyRuntimeError::new_err("profiler is already running"));
         }
 
-        let _ = frequency;
         let client = Client::start();
         client.set_thread_name("python-main");
         let session_span = client.clone().span_alloc(
@@ -70,10 +54,8 @@ mod imp {
             .unwrap_or(false)
     }
 
-    #[pyfunction(signature = (path = None, *, format = None))]
-    pub fn stop_profiler(path: Option<String>, format: Option<&str>) -> PyResult<Option<String>> {
-        ensure_ignored_format(format)?;
-
+    #[pyfunction]
+    pub fn stop_profiler() -> PyResult<()> {
         let active = active_profiler()
             .lock()
             .map_err(|_| PyRuntimeError::new_err("profiler state mutex is poisoned"))?
@@ -83,7 +65,7 @@ mod imp {
             slot.borrow_mut().take();
         });
         drop(active.client);
-        Ok(path)
+        Ok(())
     }
 }
 
@@ -100,15 +82,13 @@ mod imp {
         false
     }
 
-    #[pyfunction(signature = (*, frequency = 999))]
-    pub fn start_profiler(frequency: i32) -> PyResult<()> {
-        let _ = frequency;
+    #[pyfunction]
+    pub fn start_profiler() -> PyResult<()> {
         Err(PyRuntimeError::new_err(PROFILER_DISABLED_MESSAGE))
     }
 
-    #[pyfunction(signature = (path = None, *, format = None))]
-    pub fn stop_profiler(path: Option<String>, format: Option<&str>) -> PyResult<Option<String>> {
-        let _ = (path, format);
+    #[pyfunction]
+    pub fn stop_profiler() -> PyResult<()> {
         Err(PyRuntimeError::new_err(PROFILER_DISABLED_MESSAGE))
     }
 }

{rsloop-0.1.8 → rsloop-0.1.9}/src/stream_transport.rs

@@ -815,6 +815,7 @@ impl StreamTransportCore {
 
     pub(crate) fn drain_pending_read_events_with_py(&self, py: Python<'_>) -> PyResult<()> {
         profiling::scope!("StreamTransportCore::drain_pending_read_events_with_py");
+        let mut pending_data: Option<Vec<u8>> = None;
         loop {
             let mut pending = {
                 let mut queue = self
@@ -831,8 +832,6 @@ impl StreamTransportCore {
                 drained
             };
 
-            let mut pending_data: Option<Vec<u8>> = None;
-
             while let Some(event) = pending.pop_front() {
                 match event {
                     PendingReadEvent::Data(data) => {
@@ -1051,7 +1050,20 @@ impl StreamTransportCore {
 
     fn data_received_with_py(&self, py: Python<'_>, data: &[u8]) -> PyResult<()> {
         profiling::scope!("StreamTransportCore::data_received_with_py");
-        let (data_received, get_buffer, buffer_updated, fast_path, context, context_needs_run) = {
+        let fast_path = {
+            let state = self.state.lock().expect("poisoned transport state");
+            state
+                .callbacks
+                .stream_reader_fast_path
+                .as_ref()
+                .map(|value| value.clone_ref(py))
+        };
+
+        if let Some(fast_path) = fast_path.as_ref() {
+            return fast_path.feed_data(py, data);
+        }
+
+        let (data_received, get_buffer, buffer_updated, context, context_needs_run) = {
             let state = self.state.lock().expect("poisoned transport state");
             (
                 state
@@ -1069,20 +1081,11 @@ impl StreamTransportCore {
                     .buffer_updated
                     .as_ref()
                     .map(|value| value.clone_ref(py)),
-                state
-                    .callbacks
-                    .stream_reader_fast_path
-                    .as_ref()
-                    .map(|value| value.clone_ref(py)),
                 state.context.clone_ref(py),
                 state.context_needs_run,
             )
         };
 
-        if let Some(fast_path) = fast_path.as_ref() {
-            return fast_path.feed_data(py, data);
-        }
-
         if let (Some(get_buffer), Some(buffer_updated)) =
             (get_buffer.as_ref(), buffer_updated.as_ref())
         {

{rsloop-0.1.8 → rsloop-0.1.9}/uv.lock

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