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

codelaw_rules_python/rules/py/format-invalid.md

@@ -0,0 +1,38 @@
+---
+id: py/format-invalid
+title: "A `.format` string is well formed"
+languages: [python]
+fix: manual
+fix_reason: "whether the brace is a field or literal text has to be decided"
+stability: preview
+ported_from: [ruff/F521]
+since: 0.1.0
+---
+
+A string literal passed through `.format()` has balanced braces; literal braces are written `{{` and `}}`.
+
+**Why:** A stray brace raises `ValueError` when the string is formatted.
+
+```codelaw
+native: py/format-invalid
+```
+
+## How to fix
+
+1. Close the field, or double a literal brace (`{{`, `}}`).
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+message = "{".format(1)
+```
+
+#### Do
+
+```py
+message = "{}".format(1)
+```

codelaw_rules_python/rules/py/format-missing-argument.md

@@ -0,0 +1,38 @@
+---
+id: py/format-missing-argument
+title: "Every `.format` field has an argument"
+languages: [python]
+fix: manual
+fix_reason: "the missing value has to be supplied"
+stability: preview
+ported_from: [ruff/F524]
+since: 0.1.0
+---
+
+A `.format()` call passes an argument for every `{}`, `{0}` and `{name}` field.
+
+**Why:** A missing argument raises `IndexError` or `KeyError` when the string is formatted.
+
+```codelaw
+native: py/format-missing-argument
+```
+
+## How to fix
+
+1. Pass the missing argument, or remove the field.
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+message = "{} is {}".format("Ada")
+```
+
+#### Do
+
+```py
+message = "{} is {}".format("Ada", 36)
+```

codelaw_rules_python/rules/py/format-mixed-numbering.md

@@ -0,0 +1,38 @@
+---
+id: py/format-mixed-numbering
+title: "A `.format` string doesn't mix `{}` and `{0}`"
+languages: [python]
+fix: manual
+fix_reason: "which numbering the author wants has to be chosen"
+stability: preview
+ported_from: [ruff/F525]
+since: 0.1.0
+---
+
+A `.format()` string numbers its fields automatically (`{}`) or explicitly (`{0}`), not both.
+
+**Why:** Python raises `ValueError: cannot switch from manual field specification to automatic field numbering`.
+
+```codelaw
+native: py/format-mixed-numbering
+```
+
+## How to fix
+
+1. Number every field, or none of them.
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+message = "{0} is {}".format("Ada", 36)
+```
+
+#### Do
+
+```py
+message = "{0} is {1}".format("Ada", 36)
+```

codelaw_rules_python/rules/py/format-unused-named-argument.md

@@ -0,0 +1,37 @@
+---
+id: py/format-unused-named-argument
+title: "Every keyword passed to `.format` is used"
+languages: [python]
+fix: auto
+stability: preview
+ported_from: [ruff/F522]
+since: 0.1.0
+---
+
+A `.format()` call has no keyword arguments the string never names.
+
+**Why:** An unused keyword is usually a misspelled field name.
+
+```codelaw
+native: py/format-unused-named-argument
+```
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+message = "{name}".format(name="Ada", age=36)
+```
+
+#### Do
+
+```py
+message = "{name}".format(name="Ada")
+```
+
+## Differences from the source
+
+The fix is offered only when the removed values are plain names or literals.

codelaw_rules_python/rules/py/format-unused-positional-argument.md

@@ -0,0 +1,37 @@
+---
+id: py/format-unused-positional-argument
+title: "Every positional argument to `.format` is used"
+languages: [python]
+fix: auto
+stability: preview
+ported_from: [ruff/F523]
+since: 0.1.0
+---
+
+A `.format()` call has no positional arguments the string never refers to.
+
+**Why:** An extra argument is usually a missing `{}` field.
+
+```codelaw
+native: py/format-unused-positional-argument
+```
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+message = "{}".format("Ada", 36)
+```
+
+#### Do
+
+```py
+message = "{}".format("Ada")
+```
+
+## Differences from the source
+
+The fix removes unused arguments only from the end of the list, and only plain names or literals.

codelaw_rules_python/rules/py/forward-annotation-syntax-error.md

@@ -0,0 +1,44 @@
+---
+id: py/forward-annotation-syntax-error
+title: "A string annotation is valid Python"
+languages: [python]
+fix: manual
+fix_reason: "the intended type can't be inferred from broken text"
+stability: preview
+ported_from: [ruff/F722]
+since: 0.1.0
+---
+
+A type annotation written as a string parses as a Python expression.
+
+**Why:** Type checkers and `typing.get_type_hints()` fail on an annotation they can't parse.
+
+```codelaw
+native: py/forward-annotation-syntax-error
+```
+
+## How to fix
+
+1. Correct the annotation so it parses.
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+def total(values: "list[int") -> int:
+    return sum(values)
+```
+
+#### Do
+
+```py
+def total(values: "list[int]") -> int:
+    return sum(values)
+```
+
+## Differences from the source
+
+Strings inside `Literal[...]` and `Annotated[...]` are not treated as annotations.

codelaw_rules_python/rules/py/function-call-in-default-argument.md

@@ -0,0 +1,51 @@
+---
+id: py/function-call-in-default-argument
+title: "No function calls in default arguments"
+languages: [python]
+fix: manual
+fix_reason: "whether the value should be computed per call or once at import needs a person"
+stability: preview
+options:
+  extend_immutable_calls: { type: "string[]", default: [], description: "more calls whose results are immutable, by qualified name" }
+ported_from: [ruff/B008]
+since: 0.1.0
+---
+
+A parameter's default isn't computed by a function call, except calls known to return immutable values (`tuple()`, `frozenset()`, `int()`, `re.compile()`, `datetime.timedelta()`, …).
+
+**Why:** The call runs once, when the function is defined, so every call shares the same result — a stale timestamp, or one shared object.
+
+```codelaw
+native: py/function-call-in-default-argument
+```
+
+## How to fix
+
+1. Default to `None` and compute the value in the body, or
+2. compute it once into a module-level constant and use that as the default.
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+import time
+
+
+def log(message, when=time.time()):
+    print(when, message)
+```
+
+#### Do
+
+```py
+import time
+
+
+def log(message, when=None):
+    if when is None:
+        when = time.time()
+    print(when, message)
+```

codelaw_rules_python/rules/py/function-uses-loop-variable.cases.md

@@ -0,0 +1,57 @@
+# py/function-uses-loop-variable — cases
+
+### case: every read is reported
+
+```py
+for i in range(3):
+    def f():
+        return i + i
+```
+
+```expect
+3:16 py/function-uses-loop-variable
+3:20 py/function-uses-loop-variable
+```
+
+### case: key functions run immediately
+
+```py
+for i in range(3):
+    rows.sort(key=lambda r: r[i])
+```
+
+```expect
+(none)
+```
+
+### case: map runs immediately
+
+```py
+for i in range(3):
+    list(map(lambda x: x + i, xs))
+```
+
+```expect
+(none)
+```
+
+### case: comprehension variable
+
+```py
+fs = [lambda: i for i in range(3)]
+```
+
+```expect
+1:15 py/function-uses-loop-variable
+```
+
+### case: parameter with the same name
+
+```py
+for i in range(3):
+    f = lambda i: i
+```
+
+```expect
+(none)
+```

codelaw_rules_python/rules/py/function-uses-loop-variable.md

@@ -0,0 +1,42 @@
+---
+id: py/function-uses-loop-variable
+title: "Closures don't capture a loop variable by name"
+languages: [python]
+fix: manual
+fix_reason: "binding the value now (a default argument, `functools.partial`) changes the function's signature"
+stability: preview
+ported_from: [ruff/B023]
+since: 0.1.0
+---
+
+A function or lambda defined in a loop doesn't read a variable the loop rebinds, unless it is called or consumed straight away.
+
+**Why:** Python closures look names up when they run, so every closure sees the loop's last value.
+
+```codelaw
+native: py/function-uses-loop-variable
+```
+
+## How to fix
+
+1. Bind the current value with a default argument (`lambda name=name: …`) or `functools.partial`.
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+callbacks = []
+for name in ["a", "b"]:
+    callbacks.append(lambda: print(name))
+```
+
+#### Do
+
+```py
+callbacks = []
+for name in ["a", "b"]:
+    callbacks.append(lambda name=name: print(name))
+```

codelaw_rules_python/rules/py/getattr-with-constant.cases.md

@@ -0,0 +1,31 @@
+# py/getattr-with-constant — cases
+
+### case: with a default it stays
+
+```py
+name = getattr(user, "name", None)
+```
+
+```expect
+(none)
+```
+
+### case: private names are mangled
+
+```py
+x = getattr(self, "__secret")
+```
+
+```expect
+(none)
+```
+
+### case: not an identifier
+
+```py
+x = getattr(obj, "a-b")
+```
+
+```expect
+(none)
+```

codelaw_rules_python/rules/py/getattr-with-constant.md

@@ -0,0 +1,33 @@
+---
+id: py/getattr-with-constant
+title: "No `getattr` with a constant name"
+languages: [python]
+fix: auto
+stability: preview
+ported_from: [ruff/B009]
+since: 0.1.0
+---
+
+`getattr(obj, "name")` with a constant, valid attribute name is written `obj.name`.
+
+**Why:** `getattr` with a constant name is no safer than attribute access, only harder to read.
+
+```codelaw
+native: py/getattr-with-constant
+```
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+name = getattr(user, "name")
+```
+
+#### Do
+
+```py
+name = user.name
+```

codelaw_rules_python/rules/py/if-tuple.md

@@ -0,0 +1,40 @@
+---
+id: py/if-tuple
+title: "`if` doesn't test a tuple"
+languages: [python]
+fix: manual
+fix_reason: "the intended condition can't be inferred from the tuple"
+stability: preview
+ported_from: [ruff/F634]
+since: 0.1.0
+---
+
+An `if` or `elif` condition isn't a non-empty tuple.
+
+**Why:** A non-empty tuple is always true, so the branch always runs.
+
+```codelaw
+native: py/if-tuple
+```
+
+## How to fix
+
+1. Write the condition you meant, usually the tuple's first element.
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+if (ready, "waiting"):
+    start()
+```
+
+#### Do
+
+```py
+if ready:
+    start()
+```

codelaw_rules_python/rules/py/import-shadowed-by-loop-var.md

@@ -0,0 +1,45 @@
+---
+id: py/import-shadowed-by-loop-var
+title: "A loop variable doesn't reuse an imported name"
+languages: [python]
+fix: manual
+fix_reason: "the new loop variable name is a choice the author has to make"
+stability: preview
+ported_from: [ruff/F402]
+since: 0.1.0
+---
+
+A `for` loop's target doesn't rebind a name that an import in the same scope bound.
+
+**Why:** After the loop the name no longer refers to the module, so later uses break in ways that are hard to trace.
+
+```codelaw
+native: py/import-shadowed-by-loop-var
+```
+
+## How to fix
+
+1. Rename the loop variable.
+2. Update its uses inside the loop body.
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+import path
+
+for path in ["a.txt", "b.txt"]:
+    print(path)
+```
+
+#### Do
+
+```py
+import path
+
+for name in ["a.txt", "b.txt"]:
+    print(path.join(name))
+```

codelaw_rules_python/rules/py/invalid-print-syntax.md

@@ -0,0 +1,42 @@
+---
+id: py/invalid-print-syntax
+title: "No Python 2 `print >>`"
+languages: [python]
+fix: manual
+fix_reason: "the rewrite depends on how the Python 2 arguments were meant"
+stability: preview
+ported_from: [ruff/F633]
+since: 0.1.0
+---
+
+`print` is called as a function; the Python 2 form `print >> stream, value` isn't used.
+
+**Why:** In Python 3 it shifts the `print` function right, raising `TypeError`.
+
+```codelaw
+native: py/invalid-print-syntax
+```
+
+## How to fix
+
+1. Rewrite as `print(value, file=stream)`.
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+import sys
+
+print >> sys.stderr, "error"
+```
+
+#### Do
+
+```py
+import sys
+
+print("error", file=sys.stderr)
+```

codelaw_rules_python/rules/py/is-literal.md

@@ -0,0 +1,36 @@
+---
+id: py/is-literal
+title: "Literals are compared with `==`, not `is`"
+languages: [python]
+fix: suggest
+fix_reason: "`==` calls the object's `__eq__`, which can behave differently from identity"
+stability: preview
+ported_from: [ruff/F632]
+since: 0.1.0
+---
+
+`is` and `is not` aren't used to compare with a string, bytes or number literal.
+
+**Why:** Whether two equal literals are the same object is an implementation detail; Python warns about it with `SyntaxWarning`.
+
+```codelaw
+native: py/is-literal
+```
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+if name is "admin":
+    grant()
+```
+
+#### Do
+
+```py
+if name == "admin":
+    grant()
+```

codelaw_rules_python/rules/py/jump-statement-in-finally.cases.md

@@ -0,0 +1,15 @@
+# py/jump-statement-in-finally — cases
+
+### case: break inside a loop inside finally
+
+```py
+try:
+    pass
+finally:
+    for x in y:
+        break
+```
+
+```expect
+(none)
+```

codelaw_rules_python/rules/py/jump-statement-in-finally.md

@@ -0,0 +1,47 @@
+---
+id: py/jump-statement-in-finally
+title: "No `return`, `break` or `continue` in `finally`"
+languages: [python]
+fix: manual
+fix_reason: "how errors should propagate has to be decided"
+stability: preview
+ported_from: [ruff/B012]
+since: 0.1.0
+---
+
+A `finally` block doesn't leave through `return`, `break` or `continue`.
+
+**Why:** Leaving `finally` that way silently discards any exception in flight.
+
+```codelaw
+native: py/jump-statement-in-finally
+```
+
+## How to fix
+
+1. Move the `return`, `break` or `continue` out of the `finally` block.
+2. Handle the exception explicitly with `except` if it should be swallowed.
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+def read(path):
+    try:
+        return load(path)
+    finally:
+        return None
+```
+
+#### Do
+
+```py
+def read(path):
+    try:
+        return load(path)
+    finally:
+        close(path)
+```