codelaw-rules-python 0.2.0__py3-none-any.whl

codelaw_rules_python/rules/py/unused-import.cases.md

@@ -0,0 +1,289 @@
+# py/unused-import — cases
+
+### case: every import of a block
+
+```py
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import a
+    import b
+```
+
+```expect
+4:12 py/unused-import
+5:12 py/unused-import
+```
+
+```fixed
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    pass
+```
+
+### case: names nested in an annotation with a default
+
+```py
+from typing import List, Optional
+
+
+def main(args: Optional[List[str]] = None) -> int:
+    return 0
+```
+
+```expect
+(none)
+```
+
+### case: annotated assignment
+
+```py
+from typing import Any, Set
+
+
+def f():
+    seen: Set[Any] = set()
+    return seen
+```
+
+```expect
+(none)
+```
+
+### case: string inside a typing generic
+
+```py
+from typing import TYPE_CHECKING, Dict
+
+if TYPE_CHECKING:
+    from .names import NormalizedName
+
+PackageSet = Dict["NormalizedName", int]
+```
+
+```expect
+(none)
+```
+
+### case: type comments are not read, as in Ruff
+
+```py
+from types import TracebackType
+
+
+def f(a):
+    # type: (TracebackType) -> None
+    pass
+```
+
+```expect
+1:19 py/unused-import
+```
+
+### case: listed in __all__
+
+```py
+from .core import load
+
+__all__ = ["load"]
+```
+
+```expect
+(none)
+```
+
+### case: redundant alias re-exports
+
+```py
+from .core import load as load
+```
+
+```expect
+(none)
+```
+
+### case: used only in a string annotation
+
+```py
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .models import User
+
+
+def name(user: "User") -> str:
+    return ""
+```
+
+```expect
+(none)
+```
+
+### case: future imports are used by being there
+
+```py
+from __future__ import annotations
+```
+
+```expect
+(none)
+```
+
+### case: one of several names
+
+```py
+from os.path import join, split
+
+print(join("a", "b"))
+```
+
+```expect
+1:27 py/unused-import
+```
+
+```fixed
+from os.path import join
+
+print(join("a", "b"))
+```
+
+### case: import with a fallback in except
+
+```py
+try:
+    import ujson
+except ImportError:
+    ujson = None
+```
+
+```expect
+(none)
+```
+
+### case: last import of a name wins
+
+```py
+import re
+import re
+```
+
+```expect
+2:8 py/unused-import
+```
+
+### case: function-level import
+
+```py
+def f():
+    import json
+    return 1
+```
+
+```expect
+2:12 py/unused-import
+```
+
+```fixed
+def f():
+    return 1
+```
+
+### case: used inside a function
+
+```py
+import json
+
+
+def f():
+    return json.dumps({})
+```
+
+```expect
+(none)
+```
+
+### case: importing __all__ defines the exports
+
+```py
+from io import __all__
+```
+
+```expect
+(none)
+```
+
+### case: class-level import is an attribute
+
+```py
+class C:
+    from os.path import join
+```
+
+```expect
+(none)
+```
+
+### case: submodule loaded for an aliased package
+
+```py
+import multiprocessing as mp
+import multiprocessing.connection
+
+mp.connection.wait([])
+```
+
+```expect
+(none)
+```
+
+### case: __all__ built from another module's __all__
+
+```py
+from . import sub
+from .sub import *
+from .core import load
+
+__all__ = ["sub"] + sub.__all__
+```
+
+```expect
+(none)
+```
+
+### case: __all__ extended and appended
+
+```py
+from .core import load, save, drop
+
+__all__ = []
+__all__.extend(["load"])
+__all__.append("save")
+```
+
+```expect
+1:31 py/unused-import
+```
+
+```fixed
+from .core import load, save
+
+__all__ = []
+__all__.extend(["load"])
+__all__.append("save")
+```
+
+### case: a TypeAlias string uses a TYPE_CHECKING import
+
+```py
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    from decimal import Decimal
+
+Number: TypeAlias = "Decimal | int"
+```
+
+```expect
+(none)
+```

codelaw_rules_python/rules/py/unused-import.md

@@ -0,0 +1,45 @@
+---
+id: py/unused-import
+title: "Every imported name is used"
+languages: [python]
+fix: suggest
+fix_reason: "an import can run code when it loads, and removing it drops that side effect"
+stability: preview
+ported_from: [ruff/F401]
+since: 0.1.0
+---
+
+Each name an `import` binds is read somewhere in the module, listed in `__all__`, or re-exported with `import x as x`.
+
+**Why:** An unused import is dead weight: it slows start-up, can hide a missing dependency, and makes readers look for a use that isn't there.
+
+```codelaw
+native: py/unused-import
+```
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+import os
+import sys
+
+print(sys.argv)
+```
+
+#### Do
+
+```py
+import sys
+
+print(sys.argv)
+```
+
+## Differences from the source
+
+- An import counts as used when any read of its name exists, wherever it is; Ruff tracks each binding separately, so `import os` read and then imported again unused is reported by Ruff only.
+- Ruff's special handling of `__init__.py` (suggesting `__all__` or a redundant alias instead of removal) is not reproduced; the fix is `suggest` everywhere.
+- Imports inside a `try` body (the "is this installed?" pattern) are reported without an edit.

codelaw_rules_python/rules/py/unused-loop-control-variable.cases.md

@@ -0,0 +1,30 @@
+# py/unused-loop-control-variable — cases
+
+### case: one of two targets
+
+```py
+for key, value in pairs:
+    print(value)
+```
+
+```expect
+1:5 py/unused-loop-control-variable
+```
+
+```fixed
+for _key, value in pairs:
+    print(value)
+```
+
+### case: used after the loop: no rename
+
+```py
+def f(xs):
+    for x in xs:
+        pass
+    return x
+```
+
+```expect
+2:9 py/unused-loop-control-variable
+```

codelaw_rules_python/rules/py/unused-loop-control-variable.md

@@ -0,0 +1,36 @@
+---
+id: py/unused-loop-control-variable
+title: "Every loop variable is used in the loop"
+languages: [python]
+fix: suggest
+fix_reason: "the rename is offered only when the name isn't used anywhere else; otherwise a person decides"
+stability: preview
+ported_from: [ruff/B007]
+since: 0.1.0
+---
+
+A `for` loop's target names are read in the loop body, or start with `_` to say they aren't needed.
+
+**Why:** An unused loop variable often means the body uses the wrong name.
+
+```codelaw
+native: py/unused-loop-control-variable
+```
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+for i in range(3):
+    retry()
+```
+
+#### Do
+
+```py
+for _i in range(3):
+    retry()
+```

codelaw_rules_python/rules/py/unused-variable.cases.md

@@ -0,0 +1,169 @@
+# py/unused-variable — cases
+
+### case: read in a nested format spec
+
+```py
+def f(x):
+    width = 3
+    return f"{x:{width}d}"
+```
+
+```expect
+(none)
+```
+
+### case: underscore names are deliberate
+
+```py
+def f():
+    _ = compute()
+    _unused = 1
+```
+
+```expect
+(none)
+```
+
+### case: locals() reads everything
+
+```py
+def f():
+    x = 1
+    return locals()
+```
+
+```expect
+(none)
+```
+
+### case: nonlocal use
+
+```py
+def f():
+    x = 1
+    def g():
+        nonlocal x
+        x = 2
+    return g
+```
+
+```expect
+(none)
+```
+
+### case: module level is not checked
+
+```py
+x = 1
+```
+
+```expect
+(none)
+```
+
+### case: only the last assignment is reported
+
+```py
+def f():
+    x = 1
+    x = 2
+```
+
+```expect
+3:5 py/unused-variable
+```
+
+```fixed
+def f():
+    pass
+```
+
+### case: unused exception name
+
+```py
+def f():
+    try:
+        pass
+    except ValueError as err:
+        pass
+```
+
+```expect
+4:26 py/unused-variable
+```
+
+```fixed
+def f():
+    try:
+        pass
+    except ValueError:
+        pass
+```
+
+### case: loop variables are B007's business
+
+```py
+def f():
+    for i in range(3):
+        pass
+```
+
+```expect
+(none)
+```
+
+### case: augmented assignment reads
+
+```py
+def f():
+    t = 1
+    t += 1
+```
+
+```expect
+(none)
+```
+
+### case: unpacking a call result is not reported
+
+```py
+def f(s):
+    name, j = s.split()
+    return j
+```
+
+```expect
+(none)
+```
+
+### case: unpacking a tuple literal is
+
+```py
+def f():
+    head, tail = 1, 2
+    return tail
+```
+
+```expect
+2:5 py/unused-variable
+```
+
+### case: module-level except name
+
+```py
+try:
+    pass
+except ValueError as err:
+    pass
+```
+
+```expect
+3:22 py/unused-variable
+```
+
+```fixed
+try:
+    pass
+except ValueError:
+    pass
+```

codelaw_rules_python/rules/py/unused-variable.md

@@ -0,0 +1,38 @@
+---
+id: py/unused-variable
+title: "Every local variable is used"
+languages: [python]
+fix: suggest
+fix_reason: "dropping the assignment of a plain value is safe, but the right edit for unpacking or `with` targets needs a person"
+stability: preview
+ported_from: [ruff/F841]
+since: 0.1.0
+---
+
+A variable assigned in a function (including `with … as` and `except … as` targets) is read somewhere in that function.
+
+**Why:** An unused local is dead code, or a sign the value was meant to be used and isn't.
+
+```codelaw
+native: py/unused-variable
+```
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+def handle(request):
+    result = compute(request)
+    return None
+```
+
+#### Do
+
+```py
+def handle(request):
+    compute(request)
+    return None
+```

codelaw_rules_python/rules/py/useless-comparison.md

@@ -0,0 +1,41 @@
+---
+id: py/useless-comparison
+title: "No comparison whose result is thrown away"
+languages: [python]
+fix: manual
+fix_reason: "whether an assignment or an assertion was meant needs a person"
+stability: preview
+ported_from: [ruff/B015]
+since: 0.1.0
+---
+
+A comparison isn't written as a statement on its own.
+
+**Why:** Its result is discarded; usually `=` or `assert` was meant.
+
+```codelaw
+native: py/useless-comparison
+```
+
+## How to fix
+
+1. Use `=` if an assignment was meant, or `assert` if a check was.
+2. Otherwise remove the line.
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+def reset(state):
+    state.count == 0
+```
+
+#### Do
+
+```py
+def reset(state):
+    state.count = 0
+```

codelaw_rules_python/rules/py/useless-contextlib-suppress.md

@@ -0,0 +1,44 @@
+---
+id: py/useless-contextlib-suppress
+title: "`contextlib.suppress()` names an exception"
+languages: [python]
+fix: manual
+fix_reason: "the exceptions to suppress are the author's choice"
+stability: preview
+ported_from: [ruff/B022]
+since: 0.1.0
+---
+
+`contextlib.suppress()` is called with at least one exception class.
+
+**Why:** With no arguments it suppresses nothing, so the `with` block is misleading.
+
+```codelaw
+native: py/useless-contextlib-suppress
+```
+
+## How to fix
+
+1. Pass the exceptions to suppress, or remove the `with` statement.
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+import contextlib
+
+with contextlib.suppress():
+    remove("cache")
+```
+
+#### Do
+
+```py
+import contextlib
+
+with contextlib.suppress(FileNotFoundError):
+    remove("cache")
+```