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

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

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

codelaw_rules_python/rules/py/raise-literal.md

@@ -0,0 +1,38 @@
+---
+id: py/raise-literal
+title: "Raise exceptions, not literals"
+languages: [python]
+fix: manual
+fix_reason: "the exception class to raise is the author's choice"
+stability: preview
+ported_from: [ruff/B016]
+since: 0.1.0
+---
+
+`raise` is given an exception, not a string or number literal.
+
+**Why:** Raising a literal is a `TypeError` in Python 3.
+
+```codelaw
+native: py/raise-literal
+```
+
+## How to fix
+
+1. Raise an exception class with the literal as its message.
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+raise "failed"
+```
+
+#### Do
+
+```py
+raise RuntimeError("failed")
+```

codelaw_rules_python/rules/py/raise-not-implemented.md

@@ -0,0 +1,38 @@
+---
+id: py/raise-not-implemented
+title: "Raise `NotImplementedError`, not `NotImplemented`"
+languages: [python]
+fix: suggest
+fix_reason: "callers catching the `TypeError` the broken code raised would now see a different exception"
+stability: preview
+ported_from: [ruff/F901]
+since: 0.1.0
+---
+
+`raise` uses `NotImplementedError`, not the `NotImplemented` constant.
+
+**Why:** `NotImplemented` is a value for binary operators; raising it is a `TypeError`.
+
+```codelaw
+native: py/raise-not-implemented
+```
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+class Shape:
+    def area(self):
+        raise NotImplemented
+```
+
+#### Do
+
+```py
+class Shape:
+    def area(self):
+        raise NotImplementedError
+```

codelaw_rules_python/rules/py/raise-without-from-inside-except.cases.md

@@ -0,0 +1,46 @@
+# py/raise-without-from-inside-except — cases
+
+### case: raise inside a nested try
+
+```py
+try:
+    run()
+except ValueError:
+    try:
+        raise KeyError()
+    except KeyError:
+        pass
+```
+
+```expect
+(none)
+```
+
+### case: re-raising
+
+```py
+try:
+    run()
+except ValueError as e:
+    raise e
+except KeyError:
+    raise
+```
+
+```expect
+(none)
+```
+
+### case: in a nested function
+
+```py
+try:
+    run()
+except ValueError:
+    def f():
+        raise TypeError()
+```
+
+```expect
+(none)
+```

codelaw_rules_python/rules/py/raise-without-from-inside-except.md

@@ -0,0 +1,45 @@
+---
+id: py/raise-without-from-inside-except
+title: "Raising in `except` says `from`"
+languages: [python]
+fix: manual
+fix_reason: "whether to chain the original error or hide it is the author's choice"
+stability: preview
+ported_from: [ruff/B904]
+since: 0.1.0
+---
+
+A `raise` inside an `except` block that raises a new exception says `from err` or `from None`.
+
+**Why:** Without it, the traceback reads as if a second error happened while handling the first.
+
+```codelaw
+native: py/raise-without-from-inside-except
+```
+
+## How to fix
+
+1. Bind the caught exception (`except E as err:`).
+2. Raise with `from err`, or `from None` to hide the original deliberately.
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+try:
+    value = int(text)
+except ValueError:
+    raise TypeError("not a number")
+```
+
+#### Do
+
+```py
+try:
+    value = int(text)
+except ValueError as err:
+    raise TypeError("not a number") from err
+```

codelaw_rules_python/rules/py/re-sub-positional-args.md

@@ -0,0 +1,42 @@
+---
+id: py/re-sub-positional-args
+title: "`re.sub` count and flags by keyword"
+languages: [python]
+fix: manual
+fix_reason: "which parameter the value was meant for needs a person"
+stability: preview
+ported_from: [ruff/B034]
+since: 0.1.0
+---
+
+`re.sub()`, `re.subn()` and `re.split()` receive `count`, `maxsplit` and `flags` as keyword arguments.
+
+**Why:** Their positions are easy to confuse: `re.sub(p, r, s, re.IGNORECASE)` passes the flag as `count`.
+
+```codelaw
+native: py/re-sub-positional-args
+```
+
+## How to fix
+
+1. Pass `count=`, `maxsplit=` and `flags=` by name.
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+import re
+
+text = re.sub("a", "b", text, 1)
+```
+
+#### Do
+
+```py
+import re
+
+text = re.sub("a", "b", text, count=1)
+```

codelaw_rules_python/rules/py/redefined-while-unused.cases.md

@@ -0,0 +1,186 @@
+# py/redefined-while-unused — cases
+
+### case: redefinition in another branch
+
+```py
+import sys
+
+if __name__ == "__main__":
+    import sys
+    print(sys.argv)
+```
+
+```expect
+(none)
+```
+
+### case: import used in a string annotation
+
+```py
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .console import Console
+
+
+def f(c: "Console") -> None:
+    pass
+
+
+if __name__ == "__main__":
+    from rich.console import Console
+    Console()
+```
+
+```expect
+(none)
+```
+
+### case: try/except alternatives
+
+```py
+try:
+    import json
+except ImportError:
+    import simplejson as json
+```
+
+```expect
+(none)
+```
+
+### case: if/else alternatives
+
+```py
+if fast:
+    def run(): pass
+else:
+    def run(): pass
+```
+
+```expect
+(none)
+```
+
+### case: property setter
+
+```py
+class C:
+    @property
+    def p(self): pass
+    @p.setter
+    def p(self, v): pass
+```
+
+```expect
+(none)
+```
+
+### case: overloads
+
+```py
+from typing import overload
+@overload
+def f(a: int): ...
+@overload
+def f(a: str): ...
+def f(a): pass
+```
+
+```expect
+(none)
+```
+
+### case: import replaced by assignment
+
+```py
+import os
+os = 1
+```
+
+```expect
+2:1 py/redefined-while-unused
+```
+
+### case: plain variables may be reassigned
+
+```py
+x = 1
+x = 2
+```
+
+```expect
+(none)
+```
+
+### case: used in between
+
+```py
+import os
+print(os.name)
+import os
+```
+
+```expect
+(none)
+```
+
+### case: methods in a class
+
+```py
+class C:
+    def m(self): pass
+    def m(self): pass
+```
+
+```expect
+3:9 py/redefined-while-unused
+```
+
+### case: two submodules of one package
+
+```py
+import urllib.parse, urllib.request
+```
+
+```expect
+(none)
+```
+
+### case: global rebinding from a function
+
+```py
+xmlrpclib = None
+def f():
+    global xmlrpclib
+    import xmlrpc.client as xmlrpclib
+```
+
+```expect
+(none)
+```
+
+### case: optional accelerator
+
+```py
+def cmp_to_key(f): pass
+try:
+    from _functools import cmp_to_key
+except ImportError:
+    pass
+```
+
+```expect
+(none)
+```
+
+### case: right-hand side reads the old binding
+
+```py
+def _coro(): pass
+_coro = _coro()
+```
+
+```expect
+(none)
+```

codelaw_rules_python/rules/py/redefined-while-unused.md

@@ -0,0 +1,53 @@
+---
+id: py/redefined-while-unused
+title: "A definition isn't replaced before it is used"
+languages: [python]
+fix: manual
+fix_reason: "which definition is meant, and whether to rename or remove the other, needs a person"
+stability: preview
+ported_from: [ruff/F811]
+since: 0.1.0
+---
+
+A function, class or import isn't redefined (by another `def`, `class`, import or assignment) before anything reads it.
+
+**Why:** The first definition is dead: usually a copy-paste mistake, or a name clash with an import.
+
+```codelaw
+native: py/redefined-while-unused
+```
+
+## How to fix
+
+1. Decide which definition is meant.
+2. Rename or remove the other one.
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+def load():
+    return 1
+
+
+def load():
+    return 2
+```
+
+#### Do
+
+```py
+def load():
+    return 1
+
+
+def reload():
+    return 2
+```
+
+## Differences from the source
+
+A read anywhere between the two definitions counts as a use, including inside a function body Python only runs later.

codelaw_rules_python/rules/py/redundant-tuple-in-exception-handler.md

@@ -0,0 +1,39 @@
+---
+id: py/redundant-tuple-in-exception-handler
+title: "No one-element tuple in `except`"
+languages: [python]
+fix: auto
+stability: preview
+ported_from: [ruff/B013]
+since: 0.1.0
+---
+
+An `except` clause catching one exception names it directly, not as a one-element tuple.
+
+**Why:** `except (ValueError,):` means the same as `except ValueError:`, with extra noise.
+
+```codelaw
+native: py/redundant-tuple-in-exception-handler
+```
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+try:
+    run()
+except (ValueError,):
+    retry()
+```
+
+#### Do
+
+```py
+try:
+    run()
+except ValueError:
+    retry()
+```

codelaw_rules_python/rules/py/return-outside-function.md

@@ -0,0 +1,41 @@
+---
+id: py/return-outside-function
+title: "`return` only inside a function"
+languages: [python]
+fix: manual
+fix_reason: "the surrounding code has to be restructured"
+stability: preview
+ported_from: [ruff/F706]
+since: 0.1.0
+---
+
+`return` appears only inside a function.
+
+**Why:** At module or class level it is a `SyntaxError`.
+
+```codelaw
+native: py/return-outside-function
+```
+
+## How to fix
+
+1. Move the code into a function, or remove the `return`.
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+class Config:
+    return None
+```
+
+#### Do
+
+```py
+class Config:
+    def load(self):
+        return None
+```

codelaw_rules_python/rules/py/reuse-of-groupby-generator.cases.md

@@ -0,0 +1,40 @@
+# py/reuse-of-groupby-generator — cases
+
+### case: single use as a generator source
+
+```py
+import itertools
+for k, g in itertools.groupby(items):
+    out.extend(e for e in g)
+```
+
+```expect
+(none)
+```
+
+### case: use in an inner for of a comprehension
+
+```py
+import itertools
+for k, g in itertools.groupby(items):
+    out = [x for y in ys for x in g]
+```
+
+```expect
+3:35 py/reuse-of-groupby-generator
+```
+
+### case: separate branches
+
+```py
+import itertools
+for k, g in itertools.groupby(rows):
+    if k:
+        a = list(g)
+    else:
+        b = list(g)
+```
+
+```expect
+(none)
+```

codelaw_rules_python/rules/py/reuse-of-groupby-generator.md

@@ -0,0 +1,46 @@
+---
+id: py/reuse-of-groupby-generator
+title: "A `groupby` group is used once"
+languages: [python]
+fix: manual
+fix_reason: "how to keep the items (a list, `itertools.tee`) is the author's choice"
+stability: preview
+ported_from: [ruff/B031]
+since: 0.1.0
+---
+
+The group iterator from `itertools.groupby()` is consumed once inside its loop.
+
+**Why:** Each group is a one-shot iterator; a second pass, or a pass inside a nested loop, sees nothing.
+
+```codelaw
+native: py/reuse-of-groupby-generator
+```
+
+## How to fix
+
+1. Materialise the group once with `list(group)` and reuse the list.
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+import itertools
+
+for key, group in itertools.groupby(rows):
+    first = list(group)
+    rest = list(group)
+```
+
+#### Do
+
+```py
+import itertools
+
+for key, group in itertools.groupby(rows):
+    items = list(group)
+    first, rest = items[:1], items[1:]
+```

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

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