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

codelaw_rules_python/rules/py/star-arg-unpacking-after-keyword-arg.md

@@ -0,0 +1,38 @@
+---
+id: py/star-arg-unpacking-after-keyword-arg
+title: "No `*args` after a keyword argument"
+languages: [python]
+fix: manual
+fix_reason: "reordering arguments can change which parameter each value binds to"
+stability: preview
+ported_from: [ruff/B026]
+since: 0.1.0
+---
+
+In a call, `*args` comes before keyword arguments.
+
+**Why:** `f(x=1, *args)` fills positions before `x`, which reads backwards and can raise `TypeError` for a duplicate argument.
+
+```codelaw
+native: py/star-arg-unpacking-after-keyword-arg
+```
+
+## How to fix
+
+1. Move `*args` before the keyword arguments and check the call still binds as intended.
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+run(name="build", *steps)
+```
+
+#### Do
+
+```py
+run(*steps, name="build")
+```

codelaw_rules_python/rules/py/star-import-usage.cases.md

@@ -0,0 +1,35 @@
+# py/star-import-usage — cases
+
+### case: names in __all__
+
+```py
+from os.path import *
+__all__ = ["join", "local"]
+local = 1
+```
+
+```expect
+2:12 py/star-import-usage
+```
+
+### case: submodule bound by a relative star import
+
+```py
+from .events import *
+print(events.__all__)
+```
+
+```expect
+(none)
+```
+
+### case: builtins
+
+```py
+from os.path import *
+print(len([]))
+```
+
+```expect
+(none)
+```

codelaw_rules_python/rules/py/star-import-usage.md

@@ -0,0 +1,43 @@
+---
+id: py/star-import-usage
+title: "No names that may only come from a star import"
+languages: [python]
+fix: manual
+fix_reason: "the module the name comes from has to be confirmed by a person"
+stability: preview
+ported_from: [ruff/F405]
+since: 0.1.0
+---
+
+In a module with `from module import *`, every name the module reads is defined locally or imported by name.
+
+**Why:** With a star import in play, a misspelled name and a name the star import provides look the same; neither can be checked.
+
+```codelaw
+native: py/star-import-usage
+```
+
+## How to fix
+
+1. Find which star-imported module provides the name.
+2. Import it by name from that module.
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+from os.path import *
+
+print(join("a", "b"))
+```
+
+#### Do
+
+```py
+from os.path import join
+
+print(join("a", "b"))
+```

codelaw_rules_python/rules/py/static-key-dict-comprehension.md

@@ -0,0 +1,38 @@
+---
+id: py/static-key-dict-comprehension
+title: "A dict comprehension's key varies"
+languages: [python]
+fix: manual
+fix_reason: "the intended key can't be inferred"
+stability: preview
+ported_from: [ruff/B035]
+since: 0.1.0
+---
+
+A dict comprehension's key depends on the loop variables.
+
+**Why:** A constant key gives a dict with one entry, keeping only the last value.
+
+```codelaw
+native: py/static-key-dict-comprehension
+```
+
+## How to fix
+
+1. Use a key that depends on the loop variable.
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+sizes = {"size": len(name) for name in names}
+```
+
+#### Do
+
+```py
+sizes = {name: len(name) for name in names}
+```

codelaw_rules_python/rules/py/strip-with-multi-characters.md

@@ -0,0 +1,39 @@
+---
+id: py/strip-with-multi-characters
+title: "`.strip()` isn't given a word"
+languages: [python]
+fix: manual
+fix_reason: "whether a character set or a suffix was meant needs a person"
+stability: preview
+ported_from: [ruff/B005]
+since: 0.1.0
+---
+
+`.strip()`, `.lstrip()` and `.rstrip()` aren't passed a multi-character string with repeated characters.
+
+**Why:** They remove any of the given characters, not a prefix or suffix; `"note.txt".rstrip(".txt")` gives `"no"`.
+
+```codelaw
+native: py/strip-with-multi-characters
+```
+
+## How to fix
+
+1. Use `.removeprefix()` / `.removesuffix()` to remove a fixed string.
+2. Keep `.strip()` only for a set of characters, written without repeats.
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+name = filename.rstrip(".txt")
+```
+
+#### Do
+
+```py
+name = filename.removesuffix(".txt")
+```

codelaw_rules_python/rules/py/too-many-expressions-in-star-assignment.md

@@ -0,0 +1,38 @@
+---
+id: py/too-many-expressions-in-star-assignment
+title: "A starred assignment stays within Python's limits"
+languages: [python]
+fix: manual
+fix_reason: "how to restructure the unpacking is a design choice"
+stability: preview
+ported_from: [ruff/F621]
+since: 0.1.0
+---
+
+An unpacking assignment with a starred target has fewer than 256 targets before the star and fewer than 2^24 after it.
+
+**Why:** Past those limits the assignment is a `SyntaxError`.
+
+```codelaw
+native: py/too-many-expressions-in-star-assignment
+```
+
+## How to fix
+
+1. Unpack into a list and index it instead of naming every target.
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57, a58, a59, a60, a61, a62, a63, a64, a65, a66, a67, a68, a69, a70, a71, a72, a73, a74, a75, a76, a77, a78, a79, a80, a81, a82, a83, a84, a85, a86, a87, a88, a89, a90, a91, a92, a93, a94, a95, a96, a97, a98, a99, a100, a101, a102, a103, a104, a105, a106, a107, a108, a109, a110, a111, a112, a113, a114, a115, a116, a117, a118, a119, a120, a121, a122, a123, a124, a125, a126, a127, a128, a129, a130, a131, a132, a133, a134, a135, a136, a137, a138, a139, a140, a141, a142, a143, a144, a145, a146, a147, a148, a149, a150, a151, a152, a153, a154, a155, a156, a157, a158, a159, a160, a161, a162, a163, a164, a165, a166, a167, a168, a169, a170, a171, a172, a173, a174, a175, a176, a177, a178, a179, a180, a181, a182, a183, a184, a185, a186, a187, a188, a189, a190, a191, a192, a193, a194, a195, a196, a197, a198, a199, a200, a201, a202, a203, a204, a205, a206, a207, a208, a209, a210, a211, a212, a213, a214, a215, a216, a217, a218, a219, a220, a221, a222, a223, a224, a225, a226, a227, a228, a229, a230, a231, a232, a233, a234, a235, a236, a237, a238, a239, a240, a241, a242, a243, a244, a245, a246, a247, a248, a249, a250, a251, a252, a253, a254, a255, *rest = values
+```
+
+#### Do
+
+```py
+first, *rest = values
+```

codelaw_rules_python/rules/py/true-false-comparison.cases.md

@@ -0,0 +1,33 @@
+# py/true-false-comparison — cases
+
+### case: comparing with False
+
+```py
+if done == False:
+    wait()
+```
+
+```expect
+1:4 py/true-false-comparison
+```
+
+```fixed
+if not done:
+    wait()
+```
+
+### case: compound operand is parenthesised
+
+```py
+if a or b != True:
+    stop()
+```
+
+```expect
+1:9 py/true-false-comparison
+```
+
+```fixed
+if a or not b:
+    stop()
+```

codelaw_rules_python/rules/py/true-false-comparison.md

@@ -0,0 +1,36 @@
+---
+id: py/true-false-comparison
+title: "Don't compare with `True` or `False`"
+languages: [python]
+fix: suggest
+fix_reason: "`x == True` is false for truthy values such as `1` or `[0]`; testing `x` makes them true"
+stability: preview
+ported_from: [ruff/E712]
+since: 0.1.0
+---
+
+A condition tests a value directly (`if ready:`, `if not ready:`) instead of comparing it with `True` or `False`.
+
+**Why:** `== True` is noise and is false for truthy values that aren't exactly `True`.
+
+```codelaw
+native: py/true-false-comparison
+```
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+if ready == True:
+    start()
+```
+
+#### Do
+
+```py
+if ready:
+    start()
+```

codelaw_rules_python/rules/py/type-comparison.md

@@ -0,0 +1,41 @@
+---
+id: py/type-comparison
+title: "Don't compare types with `==`"
+languages: [python]
+fix: manual
+fix_reason: "`isinstance` accepts subclasses, which may or may not be intended"
+stability: preview
+ported_from: [ruff/E721]
+since: 0.1.0
+---
+
+Types are compared with `is` / `is not`, or checked with `isinstance()`, not with `==` or `!=` against `type(x)`.
+
+**Why:** `type(x) == T` ignores subclasses and can be fooled by a metaclass's `__eq__`.
+
+```codelaw
+native: py/type-comparison
+```
+
+## How to fix
+
+1. Use `isinstance(x, T)` when subclasses should match.
+2. Use `type(x) is T` when only the exact type should.
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+if type(value) == int:
+    count(value)
+```
+
+#### Do
+
+```py
+if isinstance(value, int):
+    count(value)
+```

codelaw_rules_python/rules/py/unary-prefix-increment.md

@@ -0,0 +1,40 @@
+---
+id: py/unary-prefix-increment
+title: "No `++x` or `--x`"
+languages: [python]
+fix: manual
+fix_reason: "whether an increment or a plain value was meant needs a person"
+stability: preview
+ported_from: [ruff/B002]
+since: 0.1.0
+---
+
+Code doesn't write `++x` or `--x`.
+
+**Why:** Python has no increment operator: `++x` is `+(+x)`, which leaves `x` unchanged.
+
+```codelaw
+native: py/unary-prefix-increment
+```
+
+## How to fix
+
+1. Write `x += 1` (or `x -= 1`) if an increment was meant.
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+count = 1
+++count
+```
+
+#### Do
+
+```py
+count = 1
+count += 1
+```

codelaw_rules_python/rules/py/undefined-export.md

@@ -0,0 +1,55 @@
+---
+id: py/undefined-export
+title: "`__all__` names only defined names"
+languages: [python]
+exclude: ["**/__init__.py"]
+fix: manual
+fix_reason: "whether the name should be defined or dropped from `__all__` needs a person"
+stability: preview
+ported_from: [ruff/F822]
+since: 0.1.0
+---
+
+Every name in a module's `__all__` is defined or imported in that module.
+
+**Why:** `from module import *` raises `AttributeError` on a missing name, and readers trust `__all__` as the module's API.
+
+```codelaw
+native: py/undefined-export
+```
+
+## How to fix
+
+1. Define or import the name, or remove it from `__all__`.
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+__all__ = ["load", "save"]
+
+
+def load():
+    pass
+```
+
+#### Do
+
+```py
+__all__ = ["load", "save"]
+
+
+def load():
+    pass
+
+
+def save():
+    pass
+```
+
+## Differences from the source
+
+`__init__.py` files are excluded, as in Ruff, because their `__all__` may list submodules.

codelaw_rules_python/rules/py/undefined-future-feature.md

@@ -0,0 +1,39 @@
+---
+id: py/undefined-future-feature
+title: "`from __future__` names only real features"
+languages: [python]
+fix: manual
+fix_reason: "the intended feature can't be guessed from a misspelling"
+stability: preview
+ported_from: [ruff/F407]
+since: 0.1.0
+---
+
+Every name imported from `__future__` is a feature Python defines.
+
+**Why:** An unknown feature is a `SyntaxError` when the module is compiled.
+
+```codelaw
+native: py/undefined-future-feature
+```
+
+## How to fix
+
+1. Check the name against the `__future__` module's features.
+2. Correct it or remove the import.
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+from __future__ import braces
+```
+
+#### Do
+
+```py
+from __future__ import annotations
+```

codelaw_rules_python/rules/py/undefined-local.cases.md

@@ -0,0 +1,80 @@
+# py/undefined-local — cases
+
+### case: annotations of a nested function
+
+```py
+from typing import Any, Iterator
+
+
+def _unique(fn):
+    def unique(*args: Any, **kw: Any) -> Iterator[Any]:
+        return fn(*args, **kw)
+    return unique
+```
+
+```expect
+(none)
+```
+
+### case: builtin annotation in a nested function
+
+```py
+def outer():
+    def parse_line(line: str) -> str:
+        return line
+    return parse_line
+```
+
+```expect
+(none)
+```
+
+### case: read in the right-hand side
+
+```py
+x = 1
+def f():
+    x = x + 1
+```
+
+```expect
+3:9 py/undefined-local
+```
+
+### case: assigned first
+
+```py
+x = 1
+def f():
+    x = 2
+    return x
+```
+
+```expect
+(none)
+```
+
+### case: global declaration
+
+```py
+x = 1
+def f():
+    global x
+    x += 1
+```
+
+```expect
+(none)
+```
+
+### case: no outer name
+
+```py
+def f():
+    print(y)
+    y = 1
+```
+
+```expect
+(none)
+```

codelaw_rules_python/rules/py/undefined-local.md

@@ -0,0 +1,48 @@
+---
+id: py/undefined-local
+title: "A local isn't read before the function assigns it"
+languages: [python]
+fix: manual
+fix_reason: "whether to declare it `global`, `nonlocal` or rename the local needs a person"
+stability: preview
+ported_from: [ruff/F823]
+since: 0.1.0
+---
+
+A function doesn't read a name before assigning it, when that name also exists in an enclosing scope.
+
+**Why:** Assigning makes the name local for the whole function, so the earlier read raises `UnboundLocalError` instead of seeing the outer value.
+
+```codelaw
+native: py/undefined-local
+```
+
+## How to fix
+
+1. Declare the name `global` or `nonlocal` if the outer one is meant.
+2. Otherwise rename the local variable.
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+count = 0
+
+
+def increment():
+    count += 1
+```
+
+#### Do
+
+```py
+count = 0
+
+
+def increment():
+    global count
+    count += 1
+```