mirror of
https://github.com/astral-sh/ruff.git
synced 2025-09-29 13:25:17 +00:00
[flake8-async] Update ASYNC116 to match upstream (#12266)
Co-authored-by: Micha Reiser <micha@reiser.io>
This commit is contained in:
Auguste Lalande
GitHub
parent
d365f1a648
commit
880c31d164
8 changed files with 448 additions and 27 deletions
|
|
@ -55,3 +55,56 @@ async def import_from_trio():
|
|||
|
||||
# catch from import
|
||||
await sleep(86401) # error: 116, "async"
|
||||
|
||||
|
||||
async def import_anyio():
|
||||
import anyio
|
||||
|
||||
# These examples are probably not meant to ever wake up:
|
||||
await anyio.sleep(100000) # error: 116, "async"
|
||||
|
||||
# 'inf literal' overflow trick
|
||||
await anyio.sleep(1e999) # error: 116, "async"
|
||||
|
||||
await anyio.sleep(86399)
|
||||
await anyio.sleep(86400)
|
||||
await anyio.sleep(86400.01) # error: 116, "async"
|
||||
await anyio.sleep(86401) # error: 116, "async"
|
||||
|
||||
await anyio.sleep(-1) # will raise a runtime error
|
||||
await anyio.sleep(0) # handled by different check
|
||||
|
||||
# these ones _definitely_ never wake up (TODO)
|
||||
await anyio.sleep(float("inf"))
|
||||
await anyio.sleep(math.inf)
|
||||
await anyio.sleep(inf)
|
||||
|
||||
# don't require inf to be in math (TODO)
|
||||
await anyio.sleep(np.inf)
|
||||
|
||||
# don't evaluate expressions (TODO)
|
||||
one_day = 86401
|
||||
await anyio.sleep(86400 + 1)
|
||||
await anyio.sleep(60 * 60 * 24 + 1)
|
||||
await anyio.sleep(foo())
|
||||
await anyio.sleep(one_day)
|
||||
await anyio.sleep(86400 + foo())
|
||||
await anyio.sleep(86400 + ...)
|
||||
await anyio.sleep("hello")
|
||||
await anyio.sleep(...)
|
||||
|
||||
|
||||
def not_async_fun():
|
||||
import anyio
|
||||
|
||||
# does not require the call to be awaited, nor in an async fun
|
||||
anyio.sleep(86401) # error: 116, "async"
|
||||
# also checks that we don't break visit_Call
|
||||
anyio.run(anyio.sleep(86401)) # error: 116, "async"
|
||||
|
||||
|
||||
async def import_from_anyio():
|
||||
from anyio import sleep
|
||||
|
||||
# catch from import
|
||||
await sleep(86401) # error: 116, "async"
|
||||
|
|
|
|||
|
|
@ -518,8 +518,8 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
|
|||
if checker.enabled(Rule::BlockingSleepInAsyncFunction) {
|
||||
flake8_async::rules::blocking_sleep(checker, call);
|
||||
}
|
||||
if checker.enabled(Rule::SleepForeverCall) {
|
||||
flake8_async::rules::sleep_forever_call(checker, call);
|
||||
if checker.enabled(Rule::LongSleepNotForever) {
|
||||
flake8_async::rules::long_sleep_not_forever(checker, call);
|
||||
}
|
||||
if checker.any_enabled(&[Rule::Print, Rule::PPrint]) {
|
||||
flake8_print::rules::print_call(checker, call);
|
||||
|
|
|
|||
|
|
@ -298,7 +298,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
|
|||
(Flake8Async, "109") => (RuleGroup::Stable, rules::flake8_async::rules::AsyncFunctionWithTimeout),
|
||||
(Flake8Async, "110") => (RuleGroup::Stable, rules::flake8_async::rules::AsyncBusyWait),
|
||||
(Flake8Async, "115") => (RuleGroup::Stable, rules::flake8_async::rules::AsyncZeroSleep),
|
||||
(Flake8Async, "116") => (RuleGroup::Preview, rules::flake8_async::rules::SleepForeverCall),
|
||||
(Flake8Async, "116") => (RuleGroup::Preview, rules::flake8_async::rules::LongSleepNotForever),
|
||||
(Flake8Async, "210") => (RuleGroup::Stable, rules::flake8_async::rules::BlockingHttpCallInAsyncFunction),
|
||||
(Flake8Async, "220") => (RuleGroup::Stable, rules::flake8_async::rules::CreateSubprocessInAsyncFunction),
|
||||
(Flake8Async, "221") => (RuleGroup::Stable, rules::flake8_async::rules::RunProcessInAsyncFunction),
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@ mod tests {
|
|||
#[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::SleepForeverCall, Path::new("ASYNC116.py"))]
|
||||
#[test_case(Rule::LongSleepNotForever, Path::new("ASYNC116.py"))]
|
||||
#[test_case(Rule::BlockingHttpCallInAsyncFunction, Path::new("ASYNC210.py"))]
|
||||
#[test_case(Rule::CreateSubprocessInAsyncFunction, Path::new("ASYNC22x.py"))]
|
||||
#[test_case(Rule::RunProcessInAsyncFunction, Path::new("ASYNC22x.py"))]
|
||||
|
|
@ -43,6 +43,7 @@ mod tests {
|
|||
#[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__{}_{}",
|
||||
|
|
|
|||
|
|
@ -4,15 +4,17 @@ use ruff_python_ast::{Expr, ExprCall, ExprNumberLiteral, Number};
|
|||
use ruff_python_semantic::Modules;
|
||||
use ruff_text_size::Ranged;
|
||||
|
||||
use crate::{checkers::ast::Checker, importer::ImportRequest};
|
||||
use crate::checkers::ast::Checker;
|
||||
use crate::importer::ImportRequest;
|
||||
use crate::rules::flake8_async::helpers::AsyncModule;
|
||||
|
||||
/// ## What it does
|
||||
/// Checks for uses of `trio.sleep()` with an interval greater than 24 hours.
|
||||
/// Checks for uses of `trio.sleep()` or `anyio.sleep()` with a delay greater than 24 hours.
|
||||
///
|
||||
/// ## Why is this bad?
|
||||
/// `trio.sleep()` with an interval greater than 24 hours is usually intended
|
||||
/// to sleep indefinitely. Instead of using a large interval,
|
||||
/// `trio.sleep_forever()` better conveys the intent.
|
||||
/// Calling `sleep()` with a delay greater than 24 hours is usually intended
|
||||
/// to sleep indefinitely. Instead of using a large delay,
|
||||
/// `trio.sleep_forever()` or `anyio.sleep_forever()` better conveys the intent.
|
||||
///
|
||||
///
|
||||
/// ## Example
|
||||
|
|
@ -33,23 +35,31 @@ use crate::{checkers::ast::Checker, importer::ImportRequest};
|
|||
/// await trio.sleep_forever()
|
||||
/// ```
|
||||
#[violation]
|
||||
pub struct SleepForeverCall;
|
||||
pub struct LongSleepNotForever {
|
||||
module: AsyncModule,
|
||||
}
|
||||
|
||||
impl Violation for SleepForeverCall {
|
||||
impl Violation for LongSleepNotForever {
|
||||
const FIX_AVAILABILITY: FixAvailability = FixAvailability::Sometimes;
|
||||
#[derive_message_formats]
|
||||
fn message(&self) -> String {
|
||||
format!("`trio.sleep()` with >24 hour interval should usually be `trio.sleep_forever()`")
|
||||
let Self { module } = self;
|
||||
format!(
|
||||
"`{module}.sleep()` with >24 hour interval should usually be `{module}.sleep_forever()`"
|
||||
)
|
||||
}
|
||||
|
||||
fn fix_title(&self) -> Option<String> {
|
||||
Some(format!("Replace with `trio.sleep_forever()`"))
|
||||
let Self { module } = self;
|
||||
Some(format!("Replace with `{module}.sleep_forever()`"))
|
||||
}
|
||||
}
|
||||
|
||||
/// ASYNC116
|
||||
pub(crate) fn sleep_forever_call(checker: &mut Checker, call: &ExprCall) {
|
||||
if !checker.semantic().seen_module(Modules::TRIO) {
|
||||
pub(crate) fn long_sleep_not_forever(checker: &mut Checker, call: &ExprCall) {
|
||||
if !(checker.semantic().seen_module(Modules::TRIO)
|
||||
|| checker.semantic().seen_module(Modules::ANYIO))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -61,14 +71,6 @@ pub(crate) fn sleep_forever_call(checker: &mut Checker, call: &ExprCall) {
|
|||
return;
|
||||
};
|
||||
|
||||
if !checker
|
||||
.semantic()
|
||||
.resolve_qualified_name(call.func.as_ref())
|
||||
.is_some_and(|qualified_name| matches!(qualified_name.segments(), ["trio", "sleep"]))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
let Expr::NumberLiteral(ExprNumberLiteral { value, .. }) = arg else {
|
||||
return;
|
||||
};
|
||||
|
|
@ -94,11 +96,34 @@ pub(crate) fn sleep_forever_call(checker: &mut Checker, call: &ExprCall) {
|
|||
Number::Complex { .. } => return,
|
||||
}
|
||||
|
||||
let mut diagnostic = Diagnostic::new(SleepForeverCall, call.range());
|
||||
let Some(qualified_name) = checker
|
||||
.semantic()
|
||||
.resolve_qualified_name(call.func.as_ref())
|
||||
else {
|
||||
return;
|
||||
};
|
||||
|
||||
let Some(module) = AsyncModule::try_from(&qualified_name) else {
|
||||
return;
|
||||
};
|
||||
|
||||
let is_relevant_module = if checker.settings.preview.is_enabled() {
|
||||
matches!(module, AsyncModule::AnyIo | AsyncModule::Trio)
|
||||
} else {
|
||||
matches!(module, AsyncModule::Trio)
|
||||
};
|
||||
|
||||
let is_sleep = is_relevant_module && matches!(qualified_name.segments(), [_, "sleep"]);
|
||||
|
||||
if !is_sleep {
|
||||
return;
|
||||
}
|
||||
|
||||
let mut diagnostic = Diagnostic::new(LongSleepNotForever { module }, call.range());
|
||||
let replacement_function = "sleep_forever";
|
||||
diagnostic.try_set_fix(|| {
|
||||
let (import_edit, binding) = checker.importer().get_or_import_symbol(
|
||||
&ImportRequest::import_from("trio", replacement_function),
|
||||
&ImportRequest::import_from(&module.to_string(), replacement_function),
|
||||
call.func.start(),
|
||||
checker.semantic(),
|
||||
)?;
|
||||
|
|
@ -6,7 +6,7 @@ pub(crate) use blocking_open_call::*;
|
|||
pub(crate) use blocking_process_invocation::*;
|
||||
pub(crate) use blocking_sleep::*;
|
||||
pub(crate) use cancel_scope_no_checkpoint::*;
|
||||
pub(crate) use sleep_forever_call::*;
|
||||
pub(crate) use long_sleep_not_forever::*;
|
||||
pub(crate) use sync_call::*;
|
||||
|
||||
mod async_busy_wait;
|
||||
|
|
@ -17,5 +17,5 @@ mod blocking_open_call;
|
|||
mod blocking_process_invocation;
|
||||
mod blocking_sleep;
|
||||
mod cancel_scope_no_checkpoint;
|
||||
mod sleep_forever_call;
|
||||
mod long_sleep_not_forever;
|
||||
mod sync_call;
|
||||
|
|
|
|||
|
|
@ -143,3 +143,6 @@ ASYNC116.py:57:11: ASYNC116 [*] `trio.sleep()` with >24 hour interval should usu
|
|||
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():
|
||||
|
|
|
|||
|
|
@ -0,0 +1,339 @@
|
|||
---
|
||||
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"
|
||||
Loading…
Add table
Add a link
Reference in a new issue