From 45f459bafd0663fd650dcd5750247f10a9f9126b Mon Sep 17 00:00:00 2001 From: Micha Reiser Date: Mon, 12 Aug 2024 15:58:00 +0200 Subject: [PATCH] Stabilize `ASYNC100`, `ASYNC109`, `ASYNC110`, `ASYNC115` and `ASYNC116` behavior changes (#12844) Closes https://github.com/astral-sh/ruff/issues/12268 --- .../src/rules/flake8_async/helpers.rs | 38 -- .../ruff_linter/src/rules/flake8_async/mod.rs | 26 +- .../flake8_async/rules/async_busy_wait.rs | 32 +- .../rules/async_function_with_timeout.rs | 18 +- .../flake8_async/rules/async_zero_sleep.rs | 6 +- .../rules/cancel_scope_no_checkpoint.rs | 20 +- .../rules/long_sleep_not_forever.rs | 6 +- ...e8_async__tests__ASYNC100_ASYNC100.py.snap | 81 +++++ ..._async__tests__ASYNC109_ASYNC109_1.py.snap | 14 + ...e8_async__tests__ASYNC110_ASYNC110.py.snap | 27 ++ ...e8_async__tests__ASYNC115_ASYNC115.py.snap | 114 ++++++ ...e8_async__tests__ASYNC116_ASYNC116.py.snap | 191 ++++++++++ ..._tests__preview__ASYNC100_ASYNC100.py.snap | 101 ------ ...ests__preview__ASYNC109_ASYNC109_0.py.snap | 18 - ...ests__preview__ASYNC109_ASYNC109_1.py.snap | 18 - ..._tests__preview__ASYNC110_ASYNC110.py.snap | 47 --- ..._tests__preview__ASYNC115_ASYNC115.py.snap | 248 ------------- ..._tests__preview__ASYNC116_ASYNC116.py.snap | 339 ------------------ 18 files changed, 449 insertions(+), 895 deletions(-) delete mode 100644 crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__preview__ASYNC100_ASYNC100.py.snap delete mode 100644 crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__preview__ASYNC109_ASYNC109_0.py.snap delete mode 100644 crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__preview__ASYNC109_ASYNC109_1.py.snap delete mode 100644 crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__preview__ASYNC110_ASYNC110.py.snap delete mode 100644 crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__preview__ASYNC115_ASYNC115.py.snap delete mode 100644 crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__preview__ASYNC116_ASYNC116.py.snap diff --git a/crates/ruff_linter/src/rules/flake8_async/helpers.rs b/crates/ruff_linter/src/rules/flake8_async/helpers.rs index 99c7b2444021a..65cd7bff273ad 100644 --- a/crates/ruff_linter/src/rules/flake8_async/helpers.rs +++ b/crates/ruff_linter/src/rules/flake8_async/helpers.rs @@ -115,44 +115,6 @@ impl MethodName { | MethodName::TrioCancelScope ) } - - /// Returns associated module - pub(super) fn module(self) -> AsyncModule { - match self { - MethodName::AsyncIoTimeout | MethodName::AsyncIoTimeoutAt => AsyncModule::AsyncIo, - MethodName::AnyIoMoveOnAfter - | MethodName::AnyIoFailAfter - | MethodName::AnyIoCancelScope => AsyncModule::AnyIo, - MethodName::TrioAcloseForcefully - | MethodName::TrioCancelScope - | MethodName::TrioCancelShieldedCheckpoint - | MethodName::TrioCheckpoint - | MethodName::TrioCheckpointIfCancelled - | MethodName::TrioFailAfter - | MethodName::TrioFailAt - | MethodName::TrioMoveOnAfter - | MethodName::TrioMoveOnAt - | MethodName::TrioOpenFile - | MethodName::TrioOpenProcess - | MethodName::TrioOpenSslOverTcpListeners - | MethodName::TrioOpenSslOverTcpStream - | MethodName::TrioOpenTcpListeners - | MethodName::TrioOpenTcpStream - | MethodName::TrioOpenUnixSocket - | MethodName::TrioPermanentlyDetachCoroutineObject - | MethodName::TrioReattachDetachedCoroutineObject - | MethodName::TrioRunProcess - | MethodName::TrioServeListeners - | MethodName::TrioServeSslOverTcp - | MethodName::TrioServeTcp - | MethodName::TrioSleep - | MethodName::TrioSleepForever - | MethodName::TrioTemporarilyDetachCoroutineObject - | MethodName::TrioWaitReadable - | MethodName::TrioWaitTaskRescheduled - | MethodName::TrioWaitWritable => AsyncModule::Trio, - } - } } impl MethodName { diff --git a/crates/ruff_linter/src/rules/flake8_async/mod.rs b/crates/ruff_linter/src/rules/flake8_async/mod.rs index c6a7c9012037a..39da7b6e00973 100644 --- a/crates/ruff_linter/src/rules/flake8_async/mod.rs +++ b/crates/ruff_linter/src/rules/flake8_async/mod.rs @@ -9,11 +9,10 @@ mod tests { use anyhow::Result; use test_case::test_case; + use crate::assert_messages; use crate::registry::Rule; - use crate::settings::types::PreviewMode; use crate::settings::LinterSettings; use crate::test::test_path; - use crate::{assert_messages, settings}; #[test_case(Rule::CancelScopeNoCheckpoint, Path::new("ASYNC100.py"))] #[test_case(Rule::TrioSyncCall, Path::new("ASYNC105.py"))] @@ -37,27 +36,4 @@ mod tests { assert_messages!(snapshot, diagnostics); Ok(()) } - - #[test_case(Rule::CancelScopeNoCheckpoint, Path::new("ASYNC100.py"))] - #[test_case(Rule::AsyncFunctionWithTimeout, Path::new("ASYNC109_0.py"))] - #[test_case(Rule::AsyncFunctionWithTimeout, Path::new("ASYNC109_1.py"))] - #[test_case(Rule::AsyncBusyWait, Path::new("ASYNC110.py"))] - #[test_case(Rule::AsyncZeroSleep, Path::new("ASYNC115.py"))] - #[test_case(Rule::LongSleepNotForever, Path::new("ASYNC116.py"))] - fn preview_rules(rule_code: Rule, path: &Path) -> Result<()> { - let snapshot = format!( - "preview__{}_{}", - rule_code.noqa_code(), - path.to_string_lossy() - ); - let diagnostics = test_path( - Path::new("flake8_async").join(path).as_path(), - &settings::LinterSettings { - preview: PreviewMode::Enabled, - ..settings::LinterSettings::for_rule(rule_code) - }, - )?; - assert_messages!(snapshot, diagnostics); - Ok(()) - } } diff --git a/crates/ruff_linter/src/rules/flake8_async/rules/async_busy_wait.rs b/crates/ruff_linter/src/rules/flake8_async/rules/async_busy_wait.rs index fdf610249cd44..9ee406c75b826 100644 --- a/crates/ruff_linter/src/rules/flake8_async/rules/async_busy_wait.rs +++ b/crates/ruff_linter/src/rules/flake8_async/rules/async_busy_wait.rs @@ -5,7 +5,6 @@ use ruff_text_size::Ranged; use crate::checkers::ast::Checker; use crate::rules::flake8_async::helpers::AsyncModule; -use crate::settings::types::PreviewMode; /// ## What it does /// Checks for the use of an async sleep function in a `while` loop. @@ -71,26 +70,15 @@ pub(crate) fn async_busy_wait(checker: &mut Checker, while_stmt: &ast::StmtWhile return; }; - if matches!(checker.settings.preview, PreviewMode::Disabled) { - if matches!(qualified_name.segments(), ["trio", "sleep" | "sleep_until"]) { - checker.diagnostics.push(Diagnostic::new( - AsyncBusyWait { - module: AsyncModule::Trio, - }, - while_stmt.range(), - )); - } - } else { - if matches!( - qualified_name.segments(), - ["trio" | "anyio", "sleep" | "sleep_until"] | ["asyncio", "sleep"] - ) { - checker.diagnostics.push(Diagnostic::new( - AsyncBusyWait { - module: AsyncModule::try_from(&qualified_name).unwrap(), - }, - while_stmt.range(), - )); - } + if matches!( + qualified_name.segments(), + ["trio" | "anyio", "sleep" | "sleep_until"] | ["asyncio", "sleep"] + ) { + checker.diagnostics.push(Diagnostic::new( + AsyncBusyWait { + module: AsyncModule::try_from(&qualified_name).unwrap(), + }, + while_stmt.range(), + )); } } diff --git a/crates/ruff_linter/src/rules/flake8_async/rules/async_function_with_timeout.rs b/crates/ruff_linter/src/rules/flake8_async/rules/async_function_with_timeout.rs index 07e7c16e40bf5..09a01d678cefb 100644 --- a/crates/ruff_linter/src/rules/flake8_async/rules/async_function_with_timeout.rs +++ b/crates/ruff_linter/src/rules/flake8_async/rules/async_function_with_timeout.rs @@ -6,7 +6,6 @@ use ruff_text_size::Ranged; use crate::checkers::ast::Checker; use crate::rules::flake8_async::helpers::AsyncModule; -use crate::settings::types::PreviewMode; /// ## What it does /// Checks for `async` functions with a `timeout` argument. @@ -87,17 +86,8 @@ pub(crate) fn async_function_with_timeout( AsyncModule::AsyncIo }; - if matches!(checker.settings.preview, PreviewMode::Disabled) { - if matches!(module, AsyncModule::Trio) { - checker.diagnostics.push(Diagnostic::new( - AsyncFunctionWithTimeout { module }, - timeout.range(), - )); - } - } else { - checker.diagnostics.push(Diagnostic::new( - AsyncFunctionWithTimeout { module }, - timeout.range(), - )); - } + checker.diagnostics.push(Diagnostic::new( + AsyncFunctionWithTimeout { module }, + timeout.range(), + )); } diff --git a/crates/ruff_linter/src/rules/flake8_async/rules/async_zero_sleep.rs b/crates/ruff_linter/src/rules/flake8_async/rules/async_zero_sleep.rs index 9f9ef57cbd7d6..3b09122e52e30 100644 --- a/crates/ruff_linter/src/rules/flake8_async/rules/async_zero_sleep.rs +++ b/crates/ruff_linter/src/rules/flake8_async/rules/async_zero_sleep.rs @@ -83,11 +83,7 @@ pub(crate) fn async_zero_sleep(checker: &mut Checker, call: &ExprCall) { }; if let Some(module) = AsyncModule::try_from(&qualified_name) { - let is_relevant_module = if checker.settings.preview.is_enabled() { - matches!(module, AsyncModule::Trio | AsyncModule::AnyIo) - } else { - matches!(module, AsyncModule::Trio) - }; + let is_relevant_module = matches!(module, AsyncModule::Trio | AsyncModule::AnyIo); let is_sleep = is_relevant_module && matches!(qualified_name.segments(), [_, "sleep"]); diff --git a/crates/ruff_linter/src/rules/flake8_async/rules/cancel_scope_no_checkpoint.rs b/crates/ruff_linter/src/rules/flake8_async/rules/cancel_scope_no_checkpoint.rs index c5b5deaf8ab85..26a5297ce3911 100644 --- a/crates/ruff_linter/src/rules/flake8_async/rules/cancel_scope_no_checkpoint.rs +++ b/crates/ruff_linter/src/rules/flake8_async/rules/cancel_scope_no_checkpoint.rs @@ -5,8 +5,7 @@ use ruff_python_ast::visitor::Visitor; use ruff_python_ast::{StmtWith, WithItem}; use crate::checkers::ast::Checker; -use crate::rules::flake8_async::helpers::{AsyncModule, MethodName}; -use crate::settings::types::PreviewMode; +use crate::rules::flake8_async::helpers::MethodName; /// ## What it does /// Checks for timeout context managers which do not contain a checkpoint. @@ -88,17 +87,8 @@ pub(crate) fn cancel_scope_no_checkpoint( return; } - if matches!(checker.settings.preview, PreviewMode::Disabled) { - if matches!(method_name.module(), AsyncModule::Trio) { - checker.diagnostics.push(Diagnostic::new( - CancelScopeNoCheckpoint { method_name }, - with_stmt.range, - )); - } - } else { - checker.diagnostics.push(Diagnostic::new( - CancelScopeNoCheckpoint { method_name }, - with_stmt.range, - )); - } + checker.diagnostics.push(Diagnostic::new( + CancelScopeNoCheckpoint { method_name }, + with_stmt.range, + )); } diff --git a/crates/ruff_linter/src/rules/flake8_async/rules/long_sleep_not_forever.rs b/crates/ruff_linter/src/rules/flake8_async/rules/long_sleep_not_forever.rs index 9af0440d48b6a..4ab4460113adc 100644 --- a/crates/ruff_linter/src/rules/flake8_async/rules/long_sleep_not_forever.rs +++ b/crates/ruff_linter/src/rules/flake8_async/rules/long_sleep_not_forever.rs @@ -107,11 +107,7 @@ pub(crate) fn long_sleep_not_forever(checker: &mut Checker, call: &ExprCall) { return; }; - let is_relevant_module = if checker.settings.preview.is_enabled() { - matches!(module, AsyncModule::AnyIo | AsyncModule::Trio) - } else { - matches!(module, AsyncModule::Trio) - }; + let is_relevant_module = matches!(module, AsyncModule::AnyIo | AsyncModule::Trio); let is_sleep = is_relevant_module && matches!(qualified_name.segments(), [_, "sleep"]); diff --git a/crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__ASYNC100_ASYNC100.py.snap b/crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__ASYNC100_ASYNC100.py.snap index 86f0972a0b290..0eca205a5b468 100644 --- a/crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__ASYNC100_ASYNC100.py.snap +++ b/crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__ASYNC100_ASYNC100.py.snap @@ -18,3 +18,84 @@ ASYNC100.py:18:5: ASYNC100 A `with trio.move_on_after(...):` context does not co 19 | | ... | |___________^ ASYNC100 | + +ASYNC100.py:40:5: ASYNC100 A `with anyio.move_on_after(...):` context does not contain any `await` statements. This makes it pointless, as the timeout can only be triggered by a checkpoint. + | +39 | async def func(): +40 | with anyio.move_on_after(delay=0.2): + | _____^ +41 | | ... + | |___________^ ASYNC100 + | + +ASYNC100.py:45:5: ASYNC100 A `with anyio.fail_after(...):` context does not contain any `await` statements. This makes it pointless, as the timeout can only be triggered by a checkpoint. + | +44 | async def func(): +45 | with anyio.fail_after(): + | _____^ +46 | | ... + | |___________^ ASYNC100 + | + +ASYNC100.py:50:5: ASYNC100 A `with anyio.CancelScope(...):` context does not contain any `await` statements. This makes it pointless, as the timeout can only be triggered by a checkpoint. + | +49 | async def func(): +50 | with anyio.CancelScope(): + | _____^ +51 | | ... + | |___________^ ASYNC100 + | + +ASYNC100.py:55:5: ASYNC100 A `with anyio.CancelScope(...):` context does not contain any `await` statements. This makes it pointless, as the timeout can only be triggered by a checkpoint. + | +54 | async def func(): +55 | with anyio.CancelScope(), nullcontext(): + | _____^ +56 | | ... + | |___________^ ASYNC100 + | + +ASYNC100.py:60:5: ASYNC100 A `with anyio.CancelScope(...):` context does not contain any `await` statements. This makes it pointless, as the timeout can only be triggered by a checkpoint. + | +59 | async def func(): +60 | with nullcontext(), anyio.CancelScope(): + | _____^ +61 | | ... + | |___________^ ASYNC100 + | + +ASYNC100.py:65:5: ASYNC100 A `with asyncio.timeout(...):` context does not contain any `await` statements. This makes it pointless, as the timeout can only be triggered by a checkpoint. + | +64 | async def func(): +65 | async with asyncio.timeout(delay=0.2): + | _____^ +66 | | ... + | |___________^ ASYNC100 + | + +ASYNC100.py:70:5: ASYNC100 A `with asyncio.timeout_at(...):` context does not contain any `await` statements. This makes it pointless, as the timeout can only be triggered by a checkpoint. + | +69 | async def func(): +70 | async with asyncio.timeout_at(when=0.2): + | _____^ +71 | | ... + | |___________^ ASYNC100 + | + +ASYNC100.py:80:5: ASYNC100 A `with asyncio.timeout(...):` context does not contain any `await` statements. This makes it pointless, as the timeout can only be triggered by a checkpoint. + | +79 | async def func(): +80 | async with asyncio.timeout(delay=0.2), asyncio.TaskGroup(), asyncio.timeout(delay=0.2): + | _____^ +81 | | ... + | |___________^ ASYNC100 + | + +ASYNC100.py:90:5: ASYNC100 A `with asyncio.timeout(...):` context does not contain any `await` statements. This makes it pointless, as the timeout can only be triggered by a checkpoint. + | +89 | async def func(): +90 | async with asyncio.timeout(delay=0.2), asyncio.timeout(delay=0.2): + | _____^ +91 | | ... + | |___________^ ASYNC100 + | diff --git a/crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__ASYNC109_ASYNC109_1.py.snap b/crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__ASYNC109_ASYNC109_1.py.snap index 78704f6637673..5f24e498454fb 100644 --- a/crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__ASYNC109_ASYNC109_1.py.snap +++ b/crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__ASYNC109_ASYNC109_1.py.snap @@ -1,4 +1,18 @@ --- source: crates/ruff_linter/src/rules/flake8_async/mod.rs --- +ASYNC109_1.py:5:16: ASYNC109 Async function definition with a `timeout` parameter + | +5 | async def func(timeout): + | ^^^^^^^ ASYNC109 +6 | ... + | + = help: Use `asyncio.timeout` instead +ASYNC109_1.py:9:16: ASYNC109 Async function definition with a `timeout` parameter + | + 9 | async def func(timeout=10): + | ^^^^^^^^^^ ASYNC109 +10 | ... + | + = help: Use `asyncio.timeout` instead diff --git a/crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__ASYNC110_ASYNC110.py.snap b/crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__ASYNC110_ASYNC110.py.snap index e1f8905dd9c37..c878faddf086a 100644 --- a/crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__ASYNC110_ASYNC110.py.snap +++ b/crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__ASYNC110_ASYNC110.py.snap @@ -18,3 +18,30 @@ ASYNC110.py:12:5: ASYNC110 Use `trio.Event` instead of awaiting `trio.sleep` in 13 | | await trio.sleep_until(10) | |__________________________________^ ASYNC110 | + +ASYNC110.py:22:5: ASYNC110 Use `asyncio.Event` instead of awaiting `asyncio.sleep` in a `while` loop + | +21 | async def func(): +22 | while True: + | _____^ +23 | | await anyio.sleep(10) + | |_____________________________^ ASYNC110 + | + +ASYNC110.py:27:5: ASYNC110 Use `asyncio.Event` instead of awaiting `asyncio.sleep` in a `while` loop + | +26 | async def func(): +27 | while True: + | _____^ +28 | | await anyio.sleep_until(10) + | |___________________________________^ ASYNC110 + | + +ASYNC110.py:37:5: ASYNC110 Use `anyio.Event` instead of awaiting `anyio.sleep` in a `while` loop + | +36 | async def func(): +37 | while True: + | _____^ +38 | | await asyncio.sleep(10) + | |_______________________________^ ASYNC110 + | diff --git a/crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__ASYNC115_ASYNC115.py.snap b/crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__ASYNC115_ASYNC115.py.snap index 71d341d400af1..3e40da955dd3e 100644 --- a/crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__ASYNC115_ASYNC115.py.snap +++ b/crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__ASYNC115_ASYNC115.py.snap @@ -132,3 +132,117 @@ ASYNC115.py:59:11: ASYNC115 [*] Use `trio.lowlevel.checkpoint()` instead of `tri 60 60 | 61 61 | 62 62 | def func(): + +ASYNC115.py:85:11: ASYNC115 [*] Use `asyncio.lowlevel.checkpoint()` instead of `asyncio.sleep(0)` + | +83 | from anyio import sleep +84 | +85 | await anyio.sleep(0) # ASYNC115 + | ^^^^^^^^^^^^^^ ASYNC115 +86 | await anyio.sleep(1) # OK +87 | await anyio.sleep(0, 1) # OK + | + = help: Replace with `asyncio.lowlevel.checkpoint()` + +ℹ Safe fix +49 49 | +50 50 | +51 51 | from trio import Event, sleep + 52 |+from asyncio import lowlevel +52 53 | +53 54 | +54 55 | def func(): +-------------------------------------------------------------------------------- +82 83 | import anyio +83 84 | from anyio import sleep +84 85 | +85 |- await anyio.sleep(0) # ASYNC115 + 86 |+ await lowlevel.checkpoint() # ASYNC115 +86 87 | await anyio.sleep(1) # OK +87 88 | await anyio.sleep(0, 1) # OK +88 89 | await anyio.sleep(...) # OK + +ASYNC115.py:91:5: ASYNC115 [*] Use `asyncio.lowlevel.checkpoint()` instead of `asyncio.sleep(0)` + | +89 | await anyio.sleep() # OK +90 | +91 | anyio.sleep(0) # ASYNC115 + | ^^^^^^^^^^^^^^ ASYNC115 +92 | foo = 0 +93 | anyio.sleep(foo) # OK + | + = help: Replace with `asyncio.lowlevel.checkpoint()` + +ℹ Safe fix +49 49 | +50 50 | +51 51 | from trio import Event, sleep + 52 |+from asyncio import lowlevel +52 53 | +53 54 | +54 55 | def func(): +-------------------------------------------------------------------------------- +88 89 | await anyio.sleep(...) # OK +89 90 | await anyio.sleep() # OK +90 91 | +91 |- anyio.sleep(0) # ASYNC115 + 92 |+ lowlevel.checkpoint() # ASYNC115 +92 93 | foo = 0 +93 94 | anyio.sleep(foo) # OK +94 95 | anyio.sleep(1) # OK + +ASYNC115.py:97:5: ASYNC115 [*] Use `asyncio.lowlevel.checkpoint()` instead of `asyncio.sleep(0)` + | +95 | time.sleep(0) # OK +96 | +97 | sleep(0) # ASYNC115 + | ^^^^^^^^ ASYNC115 +98 | +99 | bar = "bar" + | + = help: Replace with `asyncio.lowlevel.checkpoint()` + +ℹ Safe fix +49 49 | +50 50 | +51 51 | from trio import Event, sleep + 52 |+from asyncio import lowlevel +52 53 | +53 54 | +54 55 | def func(): +-------------------------------------------------------------------------------- +94 95 | anyio.sleep(1) # OK +95 96 | time.sleep(0) # OK +96 97 | +97 |- sleep(0) # ASYNC115 + 98 |+ lowlevel.checkpoint() # ASYNC115 +98 99 | +99 100 | bar = "bar" +100 101 | anyio.sleep(bar) + +ASYNC115.py:128:15: ASYNC115 [*] Use `asyncio.lowlevel.checkpoint()` instead of `asyncio.sleep(0)` + | +126 | import anyio +127 | +128 | anyio.run(anyio.sleep(0)) # ASYNC115 + | ^^^^^^^^^^^^^^ ASYNC115 + | + = help: Replace with `asyncio.lowlevel.checkpoint()` + +ℹ Safe fix +49 49 | +50 50 | +51 51 | from trio import Event, sleep + 52 |+from asyncio import lowlevel +52 53 | +53 54 | +54 55 | def func(): +-------------------------------------------------------------------------------- +125 126 | def func(): +126 127 | import anyio +127 128 | +128 |- anyio.run(anyio.sleep(0)) # ASYNC115 + 129 |+ anyio.run(lowlevel.checkpoint()) # ASYNC115 +129 130 | +130 131 | +131 132 | def func(): diff --git a/crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__ASYNC116_ASYNC116.py.snap b/crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__ASYNC116_ASYNC116.py.snap index 83b6209e1dfd1..3421bd0105a7d 100644 --- a/crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__ASYNC116_ASYNC116.py.snap +++ b/crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__ASYNC116_ASYNC116.py.snap @@ -146,3 +146,194 @@ ASYNC116.py:57:11: ASYNC116 [*] `trio.sleep()` with >24 hour interval should usu 58 59 | 59 60 | 60 61 | async def import_anyio(): + +ASYNC116.py:64:11: ASYNC116 [*] `asyncio.sleep()` with >24 hour interval should usually be `asyncio.sleep_forever()` + | +63 | # These examples are probably not meant to ever wake up: +64 | await anyio.sleep(100000) # error: 116, "async" + | ^^^^^^^^^^^^^^^^^^^ ASYNC116 +65 | +66 | # 'inf literal' overflow trick + | + = help: Replace with `asyncio.sleep_forever()` + +ℹ Unsafe fix +2 2 | # ASYNCIO_NO_ERROR - no asyncio.sleep_forever, so check intentionally doesn't trigger. +3 3 | import math +4 4 | from math import inf + 5 |+from asyncio import sleep_forever +5 6 | +6 7 | +7 8 | async def import_trio(): +-------------------------------------------------------------------------------- +61 62 | import anyio +62 63 | +63 64 | # These examples are probably not meant to ever wake up: +64 |- await anyio.sleep(100000) # error: 116, "async" + 65 |+ await sleep_forever() # error: 116, "async" +65 66 | +66 67 | # 'inf literal' overflow trick +67 68 | await anyio.sleep(1e999) # error: 116, "async" + +ASYNC116.py:67:11: ASYNC116 [*] `asyncio.sleep()` with >24 hour interval should usually be `asyncio.sleep_forever()` + | +66 | # 'inf literal' overflow trick +67 | await anyio.sleep(1e999) # error: 116, "async" + | ^^^^^^^^^^^^^^^^^^ ASYNC116 +68 | +69 | await anyio.sleep(86399) + | + = help: Replace with `asyncio.sleep_forever()` + +ℹ Unsafe fix +2 2 | # ASYNCIO_NO_ERROR - no asyncio.sleep_forever, so check intentionally doesn't trigger. +3 3 | import math +4 4 | from math import inf + 5 |+from asyncio import sleep_forever +5 6 | +6 7 | +7 8 | async def import_trio(): +-------------------------------------------------------------------------------- +64 65 | await anyio.sleep(100000) # error: 116, "async" +65 66 | +66 67 | # 'inf literal' overflow trick +67 |- await anyio.sleep(1e999) # error: 116, "async" + 68 |+ await sleep_forever() # error: 116, "async" +68 69 | +69 70 | await anyio.sleep(86399) +70 71 | await anyio.sleep(86400) + +ASYNC116.py:71:11: ASYNC116 [*] `asyncio.sleep()` with >24 hour interval should usually be `asyncio.sleep_forever()` + | +69 | await anyio.sleep(86399) +70 | await anyio.sleep(86400) +71 | await anyio.sleep(86400.01) # error: 116, "async" + | ^^^^^^^^^^^^^^^^^^^^^ ASYNC116 +72 | await anyio.sleep(86401) # error: 116, "async" + | + = help: Replace with `asyncio.sleep_forever()` + +ℹ Unsafe fix +2 2 | # ASYNCIO_NO_ERROR - no asyncio.sleep_forever, so check intentionally doesn't trigger. +3 3 | import math +4 4 | from math import inf + 5 |+from asyncio import sleep_forever +5 6 | +6 7 | +7 8 | async def import_trio(): +-------------------------------------------------------------------------------- +68 69 | +69 70 | await anyio.sleep(86399) +70 71 | await anyio.sleep(86400) +71 |- await anyio.sleep(86400.01) # error: 116, "async" + 72 |+ await sleep_forever() # error: 116, "async" +72 73 | await anyio.sleep(86401) # error: 116, "async" +73 74 | +74 75 | await anyio.sleep(-1) # will raise a runtime error + +ASYNC116.py:72:11: ASYNC116 [*] `asyncio.sleep()` with >24 hour interval should usually be `asyncio.sleep_forever()` + | +70 | await anyio.sleep(86400) +71 | await anyio.sleep(86400.01) # error: 116, "async" +72 | await anyio.sleep(86401) # error: 116, "async" + | ^^^^^^^^^^^^^^^^^^ ASYNC116 +73 | +74 | await anyio.sleep(-1) # will raise a runtime error + | + = help: Replace with `asyncio.sleep_forever()` + +ℹ Unsafe fix +2 2 | # ASYNCIO_NO_ERROR - no asyncio.sleep_forever, so check intentionally doesn't trigger. +3 3 | import math +4 4 | from math import inf + 5 |+from asyncio import sleep_forever +5 6 | +6 7 | +7 8 | async def import_trio(): +-------------------------------------------------------------------------------- +69 70 | await anyio.sleep(86399) +70 71 | await anyio.sleep(86400) +71 72 | await anyio.sleep(86400.01) # error: 116, "async" +72 |- await anyio.sleep(86401) # error: 116, "async" + 73 |+ await sleep_forever() # error: 116, "async" +73 74 | +74 75 | await anyio.sleep(-1) # will raise a runtime error +75 76 | await anyio.sleep(0) # handled by different check + +ASYNC116.py:101:5: ASYNC116 [*] `asyncio.sleep()` with >24 hour interval should usually be `asyncio.sleep_forever()` + | +100 | # does not require the call to be awaited, nor in an async fun +101 | anyio.sleep(86401) # error: 116, "async" + | ^^^^^^^^^^^^^^^^^^ ASYNC116 +102 | # also checks that we don't break visit_Call +103 | anyio.run(anyio.sleep(86401)) # error: 116, "async" + | + = help: Replace with `asyncio.sleep_forever()` + +ℹ Unsafe fix +2 2 | # ASYNCIO_NO_ERROR - no asyncio.sleep_forever, so check intentionally doesn't trigger. +3 3 | import math +4 4 | from math import inf + 5 |+from asyncio import sleep_forever +5 6 | +6 7 | +7 8 | async def import_trio(): +-------------------------------------------------------------------------------- +98 99 | import anyio +99 100 | +100 101 | # does not require the call to be awaited, nor in an async fun +101 |- anyio.sleep(86401) # error: 116, "async" + 102 |+ sleep_forever() # error: 116, "async" +102 103 | # also checks that we don't break visit_Call +103 104 | anyio.run(anyio.sleep(86401)) # error: 116, "async" +104 105 | + +ASYNC116.py:103:15: ASYNC116 [*] `asyncio.sleep()` with >24 hour interval should usually be `asyncio.sleep_forever()` + | +101 | anyio.sleep(86401) # error: 116, "async" +102 | # also checks that we don't break visit_Call +103 | anyio.run(anyio.sleep(86401)) # error: 116, "async" + | ^^^^^^^^^^^^^^^^^^ ASYNC116 + | + = help: Replace with `asyncio.sleep_forever()` + +ℹ Unsafe fix +2 2 | # ASYNCIO_NO_ERROR - no asyncio.sleep_forever, so check intentionally doesn't trigger. +3 3 | import math +4 4 | from math import inf + 5 |+from asyncio import sleep_forever +5 6 | +6 7 | +7 8 | async def import_trio(): +-------------------------------------------------------------------------------- +100 101 | # does not require the call to be awaited, nor in an async fun +101 102 | anyio.sleep(86401) # error: 116, "async" +102 103 | # also checks that we don't break visit_Call +103 |- anyio.run(anyio.sleep(86401)) # error: 116, "async" + 104 |+ anyio.run(sleep_forever()) # error: 116, "async" +104 105 | +105 106 | +106 107 | async def import_from_anyio(): + +ASYNC116.py:110:11: ASYNC116 [*] `asyncio.sleep()` with >24 hour interval should usually be `asyncio.sleep_forever()` + | +109 | # catch from import +110 | await sleep(86401) # error: 116, "async" + | ^^^^^^^^^^^^ ASYNC116 + | + = help: Replace with `asyncio.sleep_forever()` + +ℹ Unsafe fix +2 2 | # ASYNCIO_NO_ERROR - no asyncio.sleep_forever, so check intentionally doesn't trigger. +3 3 | import math +4 4 | from math import inf + 5 |+from asyncio import sleep_forever +5 6 | +6 7 | +7 8 | async def import_trio(): +-------------------------------------------------------------------------------- +107 108 | from anyio import sleep +108 109 | +109 110 | # catch from import +110 |- await sleep(86401) # error: 116, "async" + 111 |+ await sleep_forever() # error: 116, "async" diff --git a/crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__preview__ASYNC100_ASYNC100.py.snap b/crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__preview__ASYNC100_ASYNC100.py.snap deleted file mode 100644 index 0eca205a5b468..0000000000000 --- a/crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__preview__ASYNC100_ASYNC100.py.snap +++ /dev/null @@ -1,101 +0,0 @@ ---- -source: crates/ruff_linter/src/rules/flake8_async/mod.rs ---- -ASYNC100.py:8:5: ASYNC100 A `with trio.fail_after(...):` context does not contain any `await` statements. This makes it pointless, as the timeout can only be triggered by a checkpoint. - | -7 | async def func(): -8 | with trio.fail_after(): - | _____^ -9 | | ... - | |___________^ ASYNC100 - | - -ASYNC100.py:18:5: ASYNC100 A `with trio.move_on_after(...):` context does not contain any `await` statements. This makes it pointless, as the timeout can only be triggered by a checkpoint. - | -17 | async def func(): -18 | with trio.move_on_after(): - | _____^ -19 | | ... - | |___________^ ASYNC100 - | - -ASYNC100.py:40:5: ASYNC100 A `with anyio.move_on_after(...):` context does not contain any `await` statements. This makes it pointless, as the timeout can only be triggered by a checkpoint. - | -39 | async def func(): -40 | with anyio.move_on_after(delay=0.2): - | _____^ -41 | | ... - | |___________^ ASYNC100 - | - -ASYNC100.py:45:5: ASYNC100 A `with anyio.fail_after(...):` context does not contain any `await` statements. This makes it pointless, as the timeout can only be triggered by a checkpoint. - | -44 | async def func(): -45 | with anyio.fail_after(): - | _____^ -46 | | ... - | |___________^ ASYNC100 - | - -ASYNC100.py:50:5: ASYNC100 A `with anyio.CancelScope(...):` context does not contain any `await` statements. This makes it pointless, as the timeout can only be triggered by a checkpoint. - | -49 | async def func(): -50 | with anyio.CancelScope(): - | _____^ -51 | | ... - | |___________^ ASYNC100 - | - -ASYNC100.py:55:5: ASYNC100 A `with anyio.CancelScope(...):` context does not contain any `await` statements. This makes it pointless, as the timeout can only be triggered by a checkpoint. - | -54 | async def func(): -55 | with anyio.CancelScope(), nullcontext(): - | _____^ -56 | | ... - | |___________^ ASYNC100 - | - -ASYNC100.py:60:5: ASYNC100 A `with anyio.CancelScope(...):` context does not contain any `await` statements. This makes it pointless, as the timeout can only be triggered by a checkpoint. - | -59 | async def func(): -60 | with nullcontext(), anyio.CancelScope(): - | _____^ -61 | | ... - | |___________^ ASYNC100 - | - -ASYNC100.py:65:5: ASYNC100 A `with asyncio.timeout(...):` context does not contain any `await` statements. This makes it pointless, as the timeout can only be triggered by a checkpoint. - | -64 | async def func(): -65 | async with asyncio.timeout(delay=0.2): - | _____^ -66 | | ... - | |___________^ ASYNC100 - | - -ASYNC100.py:70:5: ASYNC100 A `with asyncio.timeout_at(...):` context does not contain any `await` statements. This makes it pointless, as the timeout can only be triggered by a checkpoint. - | -69 | async def func(): -70 | async with asyncio.timeout_at(when=0.2): - | _____^ -71 | | ... - | |___________^ ASYNC100 - | - -ASYNC100.py:80:5: ASYNC100 A `with asyncio.timeout(...):` context does not contain any `await` statements. This makes it pointless, as the timeout can only be triggered by a checkpoint. - | -79 | async def func(): -80 | async with asyncio.timeout(delay=0.2), asyncio.TaskGroup(), asyncio.timeout(delay=0.2): - | _____^ -81 | | ... - | |___________^ ASYNC100 - | - -ASYNC100.py:90:5: ASYNC100 A `with asyncio.timeout(...):` context does not contain any `await` statements. This makes it pointless, as the timeout can only be triggered by a checkpoint. - | -89 | async def func(): -90 | async with asyncio.timeout(delay=0.2), asyncio.timeout(delay=0.2): - | _____^ -91 | | ... - | |___________^ ASYNC100 - | diff --git a/crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__preview__ASYNC109_ASYNC109_0.py.snap b/crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__preview__ASYNC109_ASYNC109_0.py.snap deleted file mode 100644 index 1a624f6dc47f6..0000000000000 --- a/crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__preview__ASYNC109_ASYNC109_0.py.snap +++ /dev/null @@ -1,18 +0,0 @@ ---- -source: crates/ruff_linter/src/rules/flake8_async/mod.rs ---- -ASYNC109_0.py:8:16: ASYNC109 Async function definition with a `timeout` parameter - | -8 | async def func(timeout): - | ^^^^^^^ ASYNC109 -9 | ... - | - = help: Use `trio.fail_after` instead - -ASYNC109_0.py:12:16: ASYNC109 Async function definition with a `timeout` parameter - | -12 | async def func(timeout=10): - | ^^^^^^^^^^ ASYNC109 -13 | ... - | - = help: Use `trio.fail_after` instead diff --git a/crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__preview__ASYNC109_ASYNC109_1.py.snap b/crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__preview__ASYNC109_ASYNC109_1.py.snap deleted file mode 100644 index 5f24e498454fb..0000000000000 --- a/crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__preview__ASYNC109_ASYNC109_1.py.snap +++ /dev/null @@ -1,18 +0,0 @@ ---- -source: crates/ruff_linter/src/rules/flake8_async/mod.rs ---- -ASYNC109_1.py:5:16: ASYNC109 Async function definition with a `timeout` parameter - | -5 | async def func(timeout): - | ^^^^^^^ ASYNC109 -6 | ... - | - = help: Use `asyncio.timeout` instead - -ASYNC109_1.py:9:16: ASYNC109 Async function definition with a `timeout` parameter - | - 9 | async def func(timeout=10): - | ^^^^^^^^^^ ASYNC109 -10 | ... - | - = help: Use `asyncio.timeout` instead diff --git a/crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__preview__ASYNC110_ASYNC110.py.snap b/crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__preview__ASYNC110_ASYNC110.py.snap deleted file mode 100644 index c878faddf086a..0000000000000 --- a/crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__preview__ASYNC110_ASYNC110.py.snap +++ /dev/null @@ -1,47 +0,0 @@ ---- -source: crates/ruff_linter/src/rules/flake8_async/mod.rs ---- -ASYNC110.py:7:5: ASYNC110 Use `trio.Event` instead of awaiting `trio.sleep` in a `while` loop - | -6 | async def func(): -7 | while True: - | _____^ -8 | | await trio.sleep(10) - | |____________________________^ ASYNC110 - | - -ASYNC110.py:12:5: ASYNC110 Use `trio.Event` instead of awaiting `trio.sleep` in a `while` loop - | -11 | async def func(): -12 | while True: - | _____^ -13 | | await trio.sleep_until(10) - | |__________________________________^ ASYNC110 - | - -ASYNC110.py:22:5: ASYNC110 Use `asyncio.Event` instead of awaiting `asyncio.sleep` in a `while` loop - | -21 | async def func(): -22 | while True: - | _____^ -23 | | await anyio.sleep(10) - | |_____________________________^ ASYNC110 - | - -ASYNC110.py:27:5: ASYNC110 Use `asyncio.Event` instead of awaiting `asyncio.sleep` in a `while` loop - | -26 | async def func(): -27 | while True: - | _____^ -28 | | await anyio.sleep_until(10) - | |___________________________________^ ASYNC110 - | - -ASYNC110.py:37:5: ASYNC110 Use `anyio.Event` instead of awaiting `anyio.sleep` in a `while` loop - | -36 | async def func(): -37 | while True: - | _____^ -38 | | await asyncio.sleep(10) - | |_______________________________^ ASYNC110 - | diff --git a/crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__preview__ASYNC115_ASYNC115.py.snap b/crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__preview__ASYNC115_ASYNC115.py.snap deleted file mode 100644 index 3e40da955dd3e..0000000000000 --- a/crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__preview__ASYNC115_ASYNC115.py.snap +++ /dev/null @@ -1,248 +0,0 @@ ---- -source: crates/ruff_linter/src/rules/flake8_async/mod.rs ---- -ASYNC115.py:5:11: ASYNC115 [*] Use `trio.lowlevel.checkpoint()` instead of `trio.sleep(0)` - | -3 | from trio import sleep -4 | -5 | await trio.sleep(0) # ASYNC115 - | ^^^^^^^^^^^^^ ASYNC115 -6 | await trio.sleep(1) # OK -7 | await trio.sleep(0, 1) # OK - | - = help: Replace with `trio.lowlevel.checkpoint()` - -ℹ Safe fix -2 2 | import trio -3 3 | from trio import sleep -4 4 | -5 |- await trio.sleep(0) # ASYNC115 - 5 |+ await trio.lowlevel.checkpoint() # ASYNC115 -6 6 | await trio.sleep(1) # OK -7 7 | await trio.sleep(0, 1) # OK -8 8 | await trio.sleep(...) # OK - -ASYNC115.py:11:5: ASYNC115 [*] Use `trio.lowlevel.checkpoint()` instead of `trio.sleep(0)` - | - 9 | await trio.sleep() # OK -10 | -11 | trio.sleep(0) # ASYNC115 - | ^^^^^^^^^^^^^ ASYNC115 -12 | foo = 0 -13 | trio.sleep(foo) # OK - | - = help: Replace with `trio.lowlevel.checkpoint()` - -ℹ Safe fix -8 8 | await trio.sleep(...) # OK -9 9 | await trio.sleep() # OK -10 10 | -11 |- trio.sleep(0) # ASYNC115 - 11 |+ trio.lowlevel.checkpoint() # ASYNC115 -12 12 | foo = 0 -13 13 | trio.sleep(foo) # OK -14 14 | trio.sleep(1) # OK - -ASYNC115.py:17:5: ASYNC115 [*] Use `trio.lowlevel.checkpoint()` instead of `trio.sleep(0)` - | -15 | time.sleep(0) # OK -16 | -17 | sleep(0) # ASYNC115 - | ^^^^^^^^ ASYNC115 -18 | -19 | bar = "bar" - | - = help: Replace with `trio.lowlevel.checkpoint()` - -ℹ Safe fix -14 14 | trio.sleep(1) # OK -15 15 | time.sleep(0) # OK -16 16 | -17 |- sleep(0) # ASYNC115 - 17 |+ trio.lowlevel.checkpoint() # ASYNC115 -18 18 | -19 19 | bar = "bar" -20 20 | trio.sleep(bar) - -ASYNC115.py:48:14: ASYNC115 [*] Use `trio.lowlevel.checkpoint()` instead of `trio.sleep(0)` - | -46 | import trio -47 | -48 | trio.run(trio.sleep(0)) # ASYNC115 - | ^^^^^^^^^^^^^ ASYNC115 - | - = help: Replace with `trio.lowlevel.checkpoint()` - -ℹ Safe fix -45 45 | def func(): -46 46 | import trio -47 47 | -48 |- trio.run(trio.sleep(0)) # ASYNC115 - 48 |+ trio.run(trio.lowlevel.checkpoint()) # ASYNC115 -49 49 | -50 50 | -51 51 | from trio import Event, sleep - -ASYNC115.py:55:5: ASYNC115 [*] Use `trio.lowlevel.checkpoint()` instead of `trio.sleep(0)` - | -54 | def func(): -55 | sleep(0) # ASYNC115 - | ^^^^^^^^ ASYNC115 - | - = help: Replace with `trio.lowlevel.checkpoint()` - -ℹ Safe fix -48 48 | trio.run(trio.sleep(0)) # ASYNC115 -49 49 | -50 50 | -51 |-from trio import Event, sleep - 51 |+from trio import Event, sleep, lowlevel -52 52 | -53 53 | -54 54 | def func(): -55 |- sleep(0) # ASYNC115 - 55 |+ lowlevel.checkpoint() # ASYNC115 -56 56 | -57 57 | -58 58 | async def func(): - -ASYNC115.py:59:11: ASYNC115 [*] Use `trio.lowlevel.checkpoint()` instead of `trio.sleep(0)` - | -58 | async def func(): -59 | await sleep(seconds=0) # ASYNC115 - | ^^^^^^^^^^^^^^^^ ASYNC115 - | - = help: Replace with `trio.lowlevel.checkpoint()` - -ℹ Safe fix -48 48 | trio.run(trio.sleep(0)) # ASYNC115 -49 49 | -50 50 | -51 |-from trio import Event, sleep - 51 |+from trio import Event, sleep, lowlevel -52 52 | -53 53 | -54 54 | def func(): --------------------------------------------------------------------------------- -56 56 | -57 57 | -58 58 | async def func(): -59 |- await sleep(seconds=0) # ASYNC115 - 59 |+ await lowlevel.checkpoint() # ASYNC115 -60 60 | -61 61 | -62 62 | def func(): - -ASYNC115.py:85:11: ASYNC115 [*] Use `asyncio.lowlevel.checkpoint()` instead of `asyncio.sleep(0)` - | -83 | from anyio import sleep -84 | -85 | await anyio.sleep(0) # ASYNC115 - | ^^^^^^^^^^^^^^ ASYNC115 -86 | await anyio.sleep(1) # OK -87 | await anyio.sleep(0, 1) # OK - | - = help: Replace with `asyncio.lowlevel.checkpoint()` - -ℹ Safe fix -49 49 | -50 50 | -51 51 | from trio import Event, sleep - 52 |+from asyncio import lowlevel -52 53 | -53 54 | -54 55 | def func(): --------------------------------------------------------------------------------- -82 83 | import anyio -83 84 | from anyio import sleep -84 85 | -85 |- await anyio.sleep(0) # ASYNC115 - 86 |+ await lowlevel.checkpoint() # ASYNC115 -86 87 | await anyio.sleep(1) # OK -87 88 | await anyio.sleep(0, 1) # OK -88 89 | await anyio.sleep(...) # OK - -ASYNC115.py:91:5: ASYNC115 [*] Use `asyncio.lowlevel.checkpoint()` instead of `asyncio.sleep(0)` - | -89 | await anyio.sleep() # OK -90 | -91 | anyio.sleep(0) # ASYNC115 - | ^^^^^^^^^^^^^^ ASYNC115 -92 | foo = 0 -93 | anyio.sleep(foo) # OK - | - = help: Replace with `asyncio.lowlevel.checkpoint()` - -ℹ Safe fix -49 49 | -50 50 | -51 51 | from trio import Event, sleep - 52 |+from asyncio import lowlevel -52 53 | -53 54 | -54 55 | def func(): --------------------------------------------------------------------------------- -88 89 | await anyio.sleep(...) # OK -89 90 | await anyio.sleep() # OK -90 91 | -91 |- anyio.sleep(0) # ASYNC115 - 92 |+ lowlevel.checkpoint() # ASYNC115 -92 93 | foo = 0 -93 94 | anyio.sleep(foo) # OK -94 95 | anyio.sleep(1) # OK - -ASYNC115.py:97:5: ASYNC115 [*] Use `asyncio.lowlevel.checkpoint()` instead of `asyncio.sleep(0)` - | -95 | time.sleep(0) # OK -96 | -97 | sleep(0) # ASYNC115 - | ^^^^^^^^ ASYNC115 -98 | -99 | bar = "bar" - | - = help: Replace with `asyncio.lowlevel.checkpoint()` - -ℹ Safe fix -49 49 | -50 50 | -51 51 | from trio import Event, sleep - 52 |+from asyncio import lowlevel -52 53 | -53 54 | -54 55 | def func(): --------------------------------------------------------------------------------- -94 95 | anyio.sleep(1) # OK -95 96 | time.sleep(0) # OK -96 97 | -97 |- sleep(0) # ASYNC115 - 98 |+ lowlevel.checkpoint() # ASYNC115 -98 99 | -99 100 | bar = "bar" -100 101 | anyio.sleep(bar) - -ASYNC115.py:128:15: ASYNC115 [*] Use `asyncio.lowlevel.checkpoint()` instead of `asyncio.sleep(0)` - | -126 | import anyio -127 | -128 | anyio.run(anyio.sleep(0)) # ASYNC115 - | ^^^^^^^^^^^^^^ ASYNC115 - | - = help: Replace with `asyncio.lowlevel.checkpoint()` - -ℹ Safe fix -49 49 | -50 50 | -51 51 | from trio import Event, sleep - 52 |+from asyncio import lowlevel -52 53 | -53 54 | -54 55 | def func(): --------------------------------------------------------------------------------- -125 126 | def func(): -126 127 | import anyio -127 128 | -128 |- anyio.run(anyio.sleep(0)) # ASYNC115 - 129 |+ anyio.run(lowlevel.checkpoint()) # ASYNC115 -129 130 | -130 131 | -131 132 | def func(): diff --git a/crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__preview__ASYNC116_ASYNC116.py.snap b/crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__preview__ASYNC116_ASYNC116.py.snap deleted file mode 100644 index 3421bd0105a7d..0000000000000 --- a/crates/ruff_linter/src/rules/flake8_async/snapshots/ruff_linter__rules__flake8_async__tests__preview__ASYNC116_ASYNC116.py.snap +++ /dev/null @@ -1,339 +0,0 @@ ---- -source: crates/ruff_linter/src/rules/flake8_async/mod.rs ---- -ASYNC116.py:11:11: ASYNC116 [*] `trio.sleep()` with >24 hour interval should usually be `trio.sleep_forever()` - | -10 | # These examples are probably not meant to ever wake up: -11 | await trio.sleep(100000) # error: 116, "async" - | ^^^^^^^^^^^^^^^^^^ ASYNC116 -12 | -13 | # 'inf literal' overflow trick - | - = help: Replace with `trio.sleep_forever()` - -ℹ Unsafe fix -8 8 | import trio -9 9 | -10 10 | # These examples are probably not meant to ever wake up: -11 |- await trio.sleep(100000) # error: 116, "async" - 11 |+ await trio.sleep_forever() # error: 116, "async" -12 12 | -13 13 | # 'inf literal' overflow trick -14 14 | await trio.sleep(1e999) # error: 116, "async" - -ASYNC116.py:14:11: ASYNC116 [*] `trio.sleep()` with >24 hour interval should usually be `trio.sleep_forever()` - | -13 | # 'inf literal' overflow trick -14 | await trio.sleep(1e999) # error: 116, "async" - | ^^^^^^^^^^^^^^^^^ ASYNC116 -15 | -16 | await trio.sleep(86399) - | - = help: Replace with `trio.sleep_forever()` - -ℹ Unsafe fix -11 11 | await trio.sleep(100000) # error: 116, "async" -12 12 | -13 13 | # 'inf literal' overflow trick -14 |- await trio.sleep(1e999) # error: 116, "async" - 14 |+ await trio.sleep_forever() # error: 116, "async" -15 15 | -16 16 | await trio.sleep(86399) -17 17 | await trio.sleep(86400) - -ASYNC116.py:18:11: ASYNC116 [*] `trio.sleep()` with >24 hour interval should usually be `trio.sleep_forever()` - | -16 | await trio.sleep(86399) -17 | await trio.sleep(86400) -18 | await trio.sleep(86400.01) # error: 116, "async" - | ^^^^^^^^^^^^^^^^^^^^ ASYNC116 -19 | await trio.sleep(86401) # error: 116, "async" - | - = help: Replace with `trio.sleep_forever()` - -ℹ Unsafe fix -15 15 | -16 16 | await trio.sleep(86399) -17 17 | await trio.sleep(86400) -18 |- await trio.sleep(86400.01) # error: 116, "async" - 18 |+ await trio.sleep_forever() # error: 116, "async" -19 19 | await trio.sleep(86401) # error: 116, "async" -20 20 | -21 21 | await trio.sleep(-1) # will raise a runtime error - -ASYNC116.py:19:11: ASYNC116 [*] `trio.sleep()` with >24 hour interval should usually be `trio.sleep_forever()` - | -17 | await trio.sleep(86400) -18 | await trio.sleep(86400.01) # error: 116, "async" -19 | await trio.sleep(86401) # error: 116, "async" - | ^^^^^^^^^^^^^^^^^ ASYNC116 -20 | -21 | await trio.sleep(-1) # will raise a runtime error - | - = help: Replace with `trio.sleep_forever()` - -ℹ Unsafe fix -16 16 | await trio.sleep(86399) -17 17 | await trio.sleep(86400) -18 18 | await trio.sleep(86400.01) # error: 116, "async" -19 |- await trio.sleep(86401) # error: 116, "async" - 19 |+ await trio.sleep_forever() # error: 116, "async" -20 20 | -21 21 | await trio.sleep(-1) # will raise a runtime error -22 22 | await trio.sleep(0) # handled by different check - -ASYNC116.py:48:5: ASYNC116 [*] `trio.sleep()` with >24 hour interval should usually be `trio.sleep_forever()` - | -47 | # does not require the call to be awaited, nor in an async fun -48 | trio.sleep(86401) # error: 116, "async" - | ^^^^^^^^^^^^^^^^^ ASYNC116 -49 | # also checks that we don't break visit_Call -50 | trio.run(trio.sleep(86401)) # error: 116, "async" - | - = help: Replace with `trio.sleep_forever()` - -ℹ Unsafe fix -45 45 | import trio -46 46 | -47 47 | # does not require the call to be awaited, nor in an async fun -48 |- trio.sleep(86401) # error: 116, "async" - 48 |+ trio.sleep_forever() # error: 116, "async" -49 49 | # also checks that we don't break visit_Call -50 50 | trio.run(trio.sleep(86401)) # error: 116, "async" -51 51 | - -ASYNC116.py:50:14: ASYNC116 [*] `trio.sleep()` with >24 hour interval should usually be `trio.sleep_forever()` - | -48 | trio.sleep(86401) # error: 116, "async" -49 | # also checks that we don't break visit_Call -50 | trio.run(trio.sleep(86401)) # error: 116, "async" - | ^^^^^^^^^^^^^^^^^ ASYNC116 - | - = help: Replace with `trio.sleep_forever()` - -ℹ Unsafe fix -47 47 | # does not require the call to be awaited, nor in an async fun -48 48 | trio.sleep(86401) # error: 116, "async" -49 49 | # also checks that we don't break visit_Call -50 |- trio.run(trio.sleep(86401)) # error: 116, "async" - 50 |+ trio.run(trio.sleep_forever()) # error: 116, "async" -51 51 | -52 52 | -53 53 | async def import_from_trio(): - -ASYNC116.py:57:11: ASYNC116 [*] `trio.sleep()` with >24 hour interval should usually be `trio.sleep_forever()` - | -56 | # catch from import -57 | await sleep(86401) # error: 116, "async" - | ^^^^^^^^^^^^ ASYNC116 - | - = help: Replace with `trio.sleep_forever()` - -ℹ Unsafe fix -2 2 | # ASYNCIO_NO_ERROR - no asyncio.sleep_forever, so check intentionally doesn't trigger. -3 3 | import math -4 4 | from math import inf - 5 |+from trio import sleep_forever -5 6 | -6 7 | -7 8 | async def import_trio(): --------------------------------------------------------------------------------- -54 55 | from trio import sleep -55 56 | -56 57 | # catch from import -57 |- await sleep(86401) # error: 116, "async" - 58 |+ await sleep_forever() # error: 116, "async" -58 59 | -59 60 | -60 61 | async def import_anyio(): - -ASYNC116.py:64:11: ASYNC116 [*] `asyncio.sleep()` with >24 hour interval should usually be `asyncio.sleep_forever()` - | -63 | # These examples are probably not meant to ever wake up: -64 | await anyio.sleep(100000) # error: 116, "async" - | ^^^^^^^^^^^^^^^^^^^ ASYNC116 -65 | -66 | # 'inf literal' overflow trick - | - = help: Replace with `asyncio.sleep_forever()` - -ℹ Unsafe fix -2 2 | # ASYNCIO_NO_ERROR - no asyncio.sleep_forever, so check intentionally doesn't trigger. -3 3 | import math -4 4 | from math import inf - 5 |+from asyncio import sleep_forever -5 6 | -6 7 | -7 8 | async def import_trio(): --------------------------------------------------------------------------------- -61 62 | import anyio -62 63 | -63 64 | # These examples are probably not meant to ever wake up: -64 |- await anyio.sleep(100000) # error: 116, "async" - 65 |+ await sleep_forever() # error: 116, "async" -65 66 | -66 67 | # 'inf literal' overflow trick -67 68 | await anyio.sleep(1e999) # error: 116, "async" - -ASYNC116.py:67:11: ASYNC116 [*] `asyncio.sleep()` with >24 hour interval should usually be `asyncio.sleep_forever()` - | -66 | # 'inf literal' overflow trick -67 | await anyio.sleep(1e999) # error: 116, "async" - | ^^^^^^^^^^^^^^^^^^ ASYNC116 -68 | -69 | await anyio.sleep(86399) - | - = help: Replace with `asyncio.sleep_forever()` - -ℹ Unsafe fix -2 2 | # ASYNCIO_NO_ERROR - no asyncio.sleep_forever, so check intentionally doesn't trigger. -3 3 | import math -4 4 | from math import inf - 5 |+from asyncio import sleep_forever -5 6 | -6 7 | -7 8 | async def import_trio(): --------------------------------------------------------------------------------- -64 65 | await anyio.sleep(100000) # error: 116, "async" -65 66 | -66 67 | # 'inf literal' overflow trick -67 |- await anyio.sleep(1e999) # error: 116, "async" - 68 |+ await sleep_forever() # error: 116, "async" -68 69 | -69 70 | await anyio.sleep(86399) -70 71 | await anyio.sleep(86400) - -ASYNC116.py:71:11: ASYNC116 [*] `asyncio.sleep()` with >24 hour interval should usually be `asyncio.sleep_forever()` - | -69 | await anyio.sleep(86399) -70 | await anyio.sleep(86400) -71 | await anyio.sleep(86400.01) # error: 116, "async" - | ^^^^^^^^^^^^^^^^^^^^^ ASYNC116 -72 | await anyio.sleep(86401) # error: 116, "async" - | - = help: Replace with `asyncio.sleep_forever()` - -ℹ Unsafe fix -2 2 | # ASYNCIO_NO_ERROR - no asyncio.sleep_forever, so check intentionally doesn't trigger. -3 3 | import math -4 4 | from math import inf - 5 |+from asyncio import sleep_forever -5 6 | -6 7 | -7 8 | async def import_trio(): --------------------------------------------------------------------------------- -68 69 | -69 70 | await anyio.sleep(86399) -70 71 | await anyio.sleep(86400) -71 |- await anyio.sleep(86400.01) # error: 116, "async" - 72 |+ await sleep_forever() # error: 116, "async" -72 73 | await anyio.sleep(86401) # error: 116, "async" -73 74 | -74 75 | await anyio.sleep(-1) # will raise a runtime error - -ASYNC116.py:72:11: ASYNC116 [*] `asyncio.sleep()` with >24 hour interval should usually be `asyncio.sleep_forever()` - | -70 | await anyio.sleep(86400) -71 | await anyio.sleep(86400.01) # error: 116, "async" -72 | await anyio.sleep(86401) # error: 116, "async" - | ^^^^^^^^^^^^^^^^^^ ASYNC116 -73 | -74 | await anyio.sleep(-1) # will raise a runtime error - | - = help: Replace with `asyncio.sleep_forever()` - -ℹ Unsafe fix -2 2 | # ASYNCIO_NO_ERROR - no asyncio.sleep_forever, so check intentionally doesn't trigger. -3 3 | import math -4 4 | from math import inf - 5 |+from asyncio import sleep_forever -5 6 | -6 7 | -7 8 | async def import_trio(): --------------------------------------------------------------------------------- -69 70 | await anyio.sleep(86399) -70 71 | await anyio.sleep(86400) -71 72 | await anyio.sleep(86400.01) # error: 116, "async" -72 |- await anyio.sleep(86401) # error: 116, "async" - 73 |+ await sleep_forever() # error: 116, "async" -73 74 | -74 75 | await anyio.sleep(-1) # will raise a runtime error -75 76 | await anyio.sleep(0) # handled by different check - -ASYNC116.py:101:5: ASYNC116 [*] `asyncio.sleep()` with >24 hour interval should usually be `asyncio.sleep_forever()` - | -100 | # does not require the call to be awaited, nor in an async fun -101 | anyio.sleep(86401) # error: 116, "async" - | ^^^^^^^^^^^^^^^^^^ ASYNC116 -102 | # also checks that we don't break visit_Call -103 | anyio.run(anyio.sleep(86401)) # error: 116, "async" - | - = help: Replace with `asyncio.sleep_forever()` - -ℹ Unsafe fix -2 2 | # ASYNCIO_NO_ERROR - no asyncio.sleep_forever, so check intentionally doesn't trigger. -3 3 | import math -4 4 | from math import inf - 5 |+from asyncio import sleep_forever -5 6 | -6 7 | -7 8 | async def import_trio(): --------------------------------------------------------------------------------- -98 99 | import anyio -99 100 | -100 101 | # does not require the call to be awaited, nor in an async fun -101 |- anyio.sleep(86401) # error: 116, "async" - 102 |+ sleep_forever() # error: 116, "async" -102 103 | # also checks that we don't break visit_Call -103 104 | anyio.run(anyio.sleep(86401)) # error: 116, "async" -104 105 | - -ASYNC116.py:103:15: ASYNC116 [*] `asyncio.sleep()` with >24 hour interval should usually be `asyncio.sleep_forever()` - | -101 | anyio.sleep(86401) # error: 116, "async" -102 | # also checks that we don't break visit_Call -103 | anyio.run(anyio.sleep(86401)) # error: 116, "async" - | ^^^^^^^^^^^^^^^^^^ ASYNC116 - | - = help: Replace with `asyncio.sleep_forever()` - -ℹ Unsafe fix -2 2 | # ASYNCIO_NO_ERROR - no asyncio.sleep_forever, so check intentionally doesn't trigger. -3 3 | import math -4 4 | from math import inf - 5 |+from asyncio import sleep_forever -5 6 | -6 7 | -7 8 | async def import_trio(): --------------------------------------------------------------------------------- -100 101 | # does not require the call to be awaited, nor in an async fun -101 102 | anyio.sleep(86401) # error: 116, "async" -102 103 | # also checks that we don't break visit_Call -103 |- anyio.run(anyio.sleep(86401)) # error: 116, "async" - 104 |+ anyio.run(sleep_forever()) # error: 116, "async" -104 105 | -105 106 | -106 107 | async def import_from_anyio(): - -ASYNC116.py:110:11: ASYNC116 [*] `asyncio.sleep()` with >24 hour interval should usually be `asyncio.sleep_forever()` - | -109 | # catch from import -110 | await sleep(86401) # error: 116, "async" - | ^^^^^^^^^^^^ ASYNC116 - | - = help: Replace with `asyncio.sleep_forever()` - -ℹ Unsafe fix -2 2 | # ASYNCIO_NO_ERROR - no asyncio.sleep_forever, so check intentionally doesn't trigger. -3 3 | import math -4 4 | from math import inf - 5 |+from asyncio import sleep_forever -5 6 | -6 7 | -7 8 | async def import_trio(): --------------------------------------------------------------------------------- -107 108 | from anyio import sleep -108 109 | -109 110 | # catch from import -110 |- await sleep(86401) # error: 116, "async" - 111 |+ await sleep_forever() # error: 116, "async"