chore(rust): clear all build warnings + retry flaky Windows linker

.github/workflows/preview-deployments.yml

@@ -18,6 +18,7 @@ jobs:
   macos:
     runs-on: macos-latest
     strategy:
+      fail-fast: false
       matrix:
         python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
     steps:
@@ -48,11 +49,20 @@ jobs:
   windows:
     runs-on: windows-latest
     strategy:
+      fail-fast: false
       matrix:
         python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
         target: [x64, x86]
     steps:
       - uses: actions/checkout@v4
+      # The Microsoft Store python alias stubs intermittently raise EACCES when a
+      # Node-based action probes PATH for python3, failing the whole job. Remove
+      # them; setup-python below installs the real interpreter on PATH.
+      - name: Remove Windows Store python aliases (avoids flaky EACCES)
+        shell: pwsh
+        run: |
+          Remove-Item "$env:LOCALAPPDATA\Microsoft\WindowsApps\python.exe" -Force -ErrorAction SilentlyContinue
+          Remove-Item "$env:LOCALAPPDATA\Microsoft\WindowsApps\python3.exe" -Force -ErrorAction SilentlyContinue
       - name: Install uv
         uses: astral-sh/setup-uv@v3
       - uses: actions/setup-python@v6
@@ -74,6 +84,7 @@ jobs:
   linux:
     runs-on: ubuntu-latest
     strategy:
+      fail-fast: false
       matrix:
         python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
         target: [x86_64, i686]

.github/workflows/python-CI.yml

@@ -41,7 +41,7 @@ jobs:
     name: ${{ matrix.os }} tests with python ${{ matrix.python-version }}
     runs-on: ${{ matrix.os }}-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       - name: Set up Python ${{ matrix.python-version }}
         uses: actions/setup-python@v6
         with:
@@ -53,4 +53,23 @@ jobs:
         with:
           python-versions: ${{ matrix.python-version }}
       - name: Test with Nox
+        if: runner.os != 'Windows'
         run: nox --non-interactive --error-on-missing-interpreter -p ${{ matrix.python-version }}
+      # Windows extension-module builds intermittently hit a transient linker
+      # failure (LNK1181: cannot open input file 'pythonXY.lib') from the hosted
+      # toolchain. Retry so a one-off linker hiccup doesn't fail the whole run.
+      - name: Test with Nox (Windows, retry transient linker failures)
+        if: runner.os == 'Windows'
+        shell: bash
+        run: |
+          for attempt in 1 2 3; do
+            echo "::group::nox attempt $attempt"
+            if nox --non-interactive --error-on-missing-interpreter -p ${{ matrix.python-version }}; then
+              echo "::endgroup::"
+              exit 0
+            fi
+            echo "::endgroup::"
+            echo "nox attempt $attempt failed; retrying..."
+          done
+          echo "nox failed after 3 attempts"
+          exit 1

.github/workflows/release-CI.yml

@@ -18,6 +18,7 @@ jobs:
   macos:
     runs-on: macos-latest
     strategy:
+      fail-fast: false
       matrix:
         python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
     steps:
@@ -52,11 +53,20 @@ jobs:
   windows:
     runs-on: windows-latest
     strategy:
+      fail-fast: false
       matrix:
         python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
         target: [x64, x86]
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+      # The Microsoft Store python alias stubs intermittently raise EACCES when a
+      # Node-based action probes PATH for python3, failing the whole job. Remove
+      # them; setup-python below installs the real interpreter on PATH.
+      - name: Remove Windows Store python aliases (avoids flaky EACCES)
+        shell: pwsh
+        run: |
+          Remove-Item "$env:LOCALAPPDATA\Microsoft\WindowsApps\python.exe" -Force -ErrorAction SilentlyContinue
+          Remove-Item "$env:LOCALAPPDATA\Microsoft\WindowsApps\python3.exe" -Force -ErrorAction SilentlyContinue
       - name: Install uv
         uses: astral-sh/setup-uv@v3
       - uses: actions/setup-python@v6
@@ -82,6 +92,7 @@ jobs:
   linux:
     runs-on: ubuntu-latest
     strategy:
+      fail-fast: false
       matrix:
         python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
         target: [x86_64, i686]
@@ -113,6 +124,7 @@ jobs:
     runs-on: ubuntu-latest
     if: github.event_name == 'push' || (github.event_name == 'workflow_dispatch' && inputs.enable_linux_cross)
     strategy:
+      fail-fast: false
       matrix:
         python:
           [

src/asyncio.rs

@@ -3,6 +3,10 @@
 // Licensed under the BSD 3-Clause License
 // See: https://github.com/emmett-framework/granian/blob/master/LICENSE
 
+// Adapted runtime scaffolding: some helpers aren't wired up on every code path
+// yet, so allow dead code at the module level rather than scattering attributes.
+#![allow(dead_code)]
+
 use pyo3::{prelude::*, sync::PyOnceLock};
 use std::convert::Into;
 use std::ffi::CString;

src/callbacks.rs

@@ -3,6 +3,10 @@
 // Licensed under the BSD 3-Clause License
 // See: https://github.com/emmett-framework/granian/blob/master/LICENSE
 
+// Adapted runtime scaffolding: some helpers aren't wired up on every code path
+// yet, so allow dead code at the module level rather than scattering attributes.
+#![allow(dead_code)]
+
 use pyo3::{exceptions::PyStopIteration, prelude::*, IntoPyObjectExt};
 use std::sync::{atomic, Arc, OnceLock, RwLock};
 use tokio::sync::Notify;

src/conversion.rs

@@ -3,6 +3,9 @@
 // Licensed under the BSD 3-Clause License
 // See: https://github.com/emmett-framework/granian/blob/master/LICENSE
 
+// Adapted scaffolding: not every conversion variant is constructed yet.
+#![allow(dead_code)]
+
 use pyo3::prelude::*;
 pub(crate) enum FutureResultToPy {
     None,

src/executors/mod.rs

@@ -87,10 +87,10 @@ fn extract_response_type_fast(output: &Bound<'_, PyAny>) -> PyResult<ResponseTyp
     let py = output.py();
 
     // 1. PyResponse pyclass downcast — zero getattr calls.
-    //    `downcast_exact` (not `downcast`) so that user `Response` subclasses
+    //    `cast_exact` (not `downcast`) so that user `Response` subclasses
     //    with overridden properties fall through to the getattr-based slow
     //    path below, preserving their custom read semantics.
-    if let Ok(py_resp) = output.downcast_exact::<PyResponse>() {
+    if let Ok(py_resp) = output.cast_exact::<PyResponse>() {
         let borrowed = py_resp.borrow();
         let description =
             crate::types::get_description_from_pyobject(borrowed.description.bind(py))?;
@@ -110,10 +110,10 @@ fn extract_response_type_fast(output: &Bound<'_, PyAny>) -> PyResult<ResponseTyp
     //    Uses subclass-aware `downcast` to match the Python router's
     //    `isinstance(res, (dict, list, ...))` check; orjson serializes
     //    dict/list subclasses as their base type by default.
-    if output.downcast::<PyDict>().is_ok() || output.downcast::<PyList>().is_ok() {
+    if output.cast::<PyDict>().is_ok() || output.cast::<PyList>().is_ok() {
         let dumps = orjson_dumps(py)?;
         let encoded = dumps.call1((output,))?;
-        let bytes = encoded.downcast::<PyBytes>()?.as_bytes().to_vec();
+        let bytes = encoded.cast::<PyBytes>()?.as_bytes().to_vec();
         return Ok(ResponseType::Standard(response_from_bytes(
             bytes,
             json_headers(),
@@ -122,14 +122,14 @@ fn extract_response_type_fast(output: &Bound<'_, PyAny>) -> PyResult<ResponseTyp
 
     // 3. Bare str/bytes — `downcast` (subclass-aware) to match the Python
     //    router's `isinstance` gate.
-    if let Ok(s) = output.downcast::<PyString>() {
+    if let Ok(s) = output.cast::<PyString>() {
         let bytes = s.to_string().into_bytes();
         return Ok(ResponseType::Standard(response_from_bytes(
             bytes,
             text_plain_headers(),
         )));
     }
-    if let Ok(b) = output.downcast::<PyBytes>() {
+    if let Ok(b) = output.cast::<PyBytes>() {
         let bytes = b.as_bytes().to_vec();
         return Ok(ResponseType::Standard(response_from_bytes(
             bytes,
@@ -162,7 +162,7 @@ where
     T: Clone + for<'py> IntoPyObject<'py>,
     for<'py> <T as IntoPyObject<'py>>::Error: std::fmt::Debug,
 {
-    let handler = function.handler.bind(py).downcast()?;
+    let handler = function.handler.bind(py).cast()?;
 
     // 0-param handlers: skip Request→Python conversion entirely
     if function.number_of_params == 0 {
@@ -279,7 +279,7 @@ where
     for<'py> <T as IntoPyObject<'py>>::Error: std::fmt::Debug,
 {
     if function.is_async {
-        let output: Py<PyAny> = Python::with_gil(|py| -> PyResult<_> {
+        let output: Py<PyAny> = Python::attach(|py| -> PyResult<_> {
             let coroutine = get_function_output(function, py, input)?;
             let awaitable = match context {
                 Some(ctx) => wrap_coro_in_context(py, ctx.bind(py), coroutine)?,
@@ -289,7 +289,7 @@ where
         })?
         .await?;
 
-        Python::with_gil(|py| -> Result<MiddlewareReturn> {
+        Python::attach(|py| -> Result<MiddlewareReturn> {
             // Try response extraction first, then request
             match output.extract::<Response>(py) {
                 Ok(response) => Ok(MiddlewareReturn::Response(response)),
@@ -300,7 +300,7 @@ where
             }
         })
     } else {
-        Python::with_gil(|py| -> Result<MiddlewareReturn> {
+        Python::attach(|py| -> Result<MiddlewareReturn> {
             let output = match context {
                 Some(ctx) => get_function_output_in_context(function, py, ctx.bind(py), input)?,
                 None => get_function_output(function, py, input)?,
@@ -332,7 +332,7 @@ where
     for<'py> <T as IntoPyObject<'py>>::Error: std::fmt::Debug,
     for<'py> <U as IntoPyObject<'py>>::Error: std::fmt::Debug,
 {
-    let handler = function.handler.bind(py).downcast()?;
+    let handler = function.handler.bind(py).cast()?;
 
     if function.number_of_params == 0 {
         return handler.call0();
@@ -471,7 +471,7 @@ pub async fn execute_after_middleware_function(
     context: Option<&Py<PyAny>>,
 ) -> Result<MiddlewareReturn> {
     if function.is_async {
-        let output: Py<PyAny> = Python::with_gil(|py| -> PyResult<_> {
+        let output: Py<PyAny> = Python::attach(|py| -> PyResult<_> {
             let coroutine = get_function_output_with_two_args(function, py, request, response)?;
             let awaitable = match context {
                 Some(ctx) => wrap_coro_in_context(py, ctx.bind(py), coroutine)?,
@@ -481,7 +481,7 @@ pub async fn execute_after_middleware_function(
         })?
         .await?;
 
-        Python::with_gil(|py| -> Result<MiddlewareReturn> {
+        Python::attach(|py| -> Result<MiddlewareReturn> {
             // Try response extraction first, then request
             match output.extract::<Response>(py) {
                 Ok(response) => Ok(MiddlewareReturn::Response(response)),
@@ -492,7 +492,7 @@ pub async fn execute_after_middleware_function(
             }
         })
     } else {
-        Python::with_gil(|py| -> Result<MiddlewareReturn> {
+        Python::attach(|py| -> Result<MiddlewareReturn> {
             let output = match context {
                 Some(ctx) => get_function_output_with_two_args_in_context(
                     function,
@@ -522,7 +522,7 @@ pub async fn execute_http_function(
     context: Option<&Py<PyAny>>,
 ) -> PyResult<ResponseType> {
     if function.is_async {
-        let output = Python::with_gil(|py| -> PyResult<_> {
+        let output = Python::attach(|py| -> PyResult<_> {
             let coroutine = get_function_output(function, py, request)?;
             let awaitable = match context {
                 Some(ctx) => wrap_coro_in_context(py, ctx.bind(py), coroutine)?,
@@ -532,9 +532,9 @@ pub async fn execute_http_function(
         })?
         .await?;
 
-        Python::with_gil(|py| extract_response_type(output, py))
+        Python::attach(|py| extract_response_type(output, py))
     } else {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let output = match context {
                 Some(ctx) => get_function_output_in_context(function, py, ctx.bind(py), request)?,
                 None => get_function_output(function, py, request)?,
@@ -560,15 +560,15 @@ pub async fn execute_startup_handler(
 ) -> Result<()> {
     if let Some(function) = event_handler {
         if function.is_async {
-            Python::with_gil(|py| {
+            Python::attach(|py| {
                 pyo3_async_runtimes::into_future_with_locals(
                     task_locals,
                     function.handler.bind(py).call0()?,
                 )
             })?
             .await?;
         } else {
-            Python::with_gil(|py| function.handler.call0(py))?;
+            Python::attach(|py| function.handler.call0(py))?;
         }
     }
     Ok(())

src/executors/web_socket_executors.rs

@@ -13,8 +13,8 @@ pub fn execute_ws_function(
     ws: &WebSocketConnector,
 ) {
     if function.is_async {
-        let fut = match Python::with_gil(|py| {
-            let handler = function.handler.bind(py).downcast()?;
+        let fut = match Python::attach(|py| {
+            let handler = function.handler.bind(py).cast()?;
             let result = handler.call1((ws.clone(),))?;
             pyo3_async_runtimes::into_future_with_locals(task_locals, result)
         }) {
@@ -26,7 +26,7 @@ pub fn execute_ws_function(
         };
         let f = async move {
             match fut.await {
-                Ok(output) => Python::with_gil(|py| match output.extract::<Option<String>>(py) {
+                Ok(output) => Python::attach(|py| match output.extract::<Option<String>>(py) {
                     Ok(msg) => msg,
                     Err(e) => {
                         log::error!("Failed to extract WebSocket handler result: {}", e);
@@ -47,8 +47,8 @@ pub fn execute_ws_function(
         });
         ctx.spawn(f);
     } else {
-        Python::with_gil(|py| {
-            let handler = match function.handler.bind(py).downcast() {
+        Python::attach(|py| {
+            let handler = match function.handler.bind(py).cast() {
                 Ok(h) => h,
                 Err(e) => {
                     log::error!("Failed to get sync WebSocket handler: {}", e);

src/routers/http_router.rs

@@ -50,7 +50,7 @@ impl Router<(FunctionInfo, HashMap<String, String>), HttpMethod> for HttpRouter
                 route_params.insert(key.to_string(), value.to_string());
             }
 
-            let function_info = Python::with_gil(|_| res.value.to_owned());
+            let function_info = Python::attach(|_| res.value.to_owned());
             return Some((function_info, route_params));
         }
 

src/routers/middleware_router.rs

@@ -60,7 +60,7 @@ impl Router<(Vec<FunctionInfo>, HashMap<String, String>), MiddlewareType> for Mi
             route_params.insert(key.to_string(), value.to_string());
         }
 
-        let functions = Python::with_gil(|_| res.value.to_owned());
+        let functions = Python::attach(|_| res.value.to_owned());
 
         Some((functions, route_params))
     }

src/runtime.rs

@@ -3,6 +3,10 @@
 // Licensed under the BSD 3-Clause License
 // See: https://github.com/emmett-framework/granian/blob/master/LICENSE
 
+// Adapted runtime scaffolding: some helpers aren't wired up on every code path
+// yet, so allow dead code at the module level rather than scattering attributes.
+#![allow(dead_code)]
+
 use futures::FutureExt;
 use pyo3::{prelude::*, IntoPyObjectExt};
 use std::{future::Future, sync::Arc, sync::OnceLock};