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

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

@@ -0,0 +1,132 @@
+# py/undefined-name — cases
+
+### case: class body sees its own names
+
+```py
+class C:
+    x = 1
+    y = x + 1
+```
+
+```expect
+(none)
+```
+
+### case: methods don't see class names
+
+```py
+class C:
+    x = 1
+    def m(self):
+        return x
+```
+
+```expect
+4:16 py/undefined-name
+```
+
+### case: __class__ in a method
+
+```py
+class C:
+    def m(self):
+        return __class__
+```
+
+```expect
+(none)
+```
+
+### case: guarded by NameError
+
+```py
+try:
+    unicode
+except NameError:
+    unicode = str
+```
+
+```expect
+(none)
+```
+
+### case: star import makes everything possible
+
+```py
+from os.path import *
+print(join)
+```
+
+```expect
+(none)
+```
+
+### case: comprehension variable
+
+```py
+values = [x for x in range(3)]
+```
+
+```expect
+(none)
+```
+
+### case: module dunders
+
+```py
+print(__file__, __name__, __doc__)
+```
+
+```expect
+(none)
+```
+
+### case: del of an undefined name
+
+```py
+del missing
+```
+
+```expect
+1:5 py/undefined-name
+```
+
+### case: PEP 695 type parameters reach annotations, bases and methods
+
+```py
+class Base[T]:
+    pass
+
+
+def first[T](xs: list[T]) -> T:
+    return xs[0]
+
+
+class Box[T](Base[T]):
+    def get(self) -> T:
+        item: T = self.item
+        return item
+
+
+type Pair[K] = tuple[K, K]
+p: Pair[int] = (1, 2)
+```
+
+```expect
+(none)
+```
+
+### case: a type parameter is not visible outside its declaration
+
+```py
+def first[T](xs: list[T], default=T) -> T:
+    return xs[0]
+
+
+x: T
+```
+
+```expect
+1:35 py/undefined-name
+5:4 py/undefined-name
+```

codelaw_rules_python/rules/py/undefined-name.md

@@ -0,0 +1,42 @@
+---
+id: py/undefined-name
+title: "Every name read is defined"
+languages: [python]
+fix: manual
+fix_reason: "whether to import, define or correct the name needs a person"
+stability: preview
+options:
+  builtins: { type: "string[]", default: [], description: "extra names to treat as builtins" }
+ported_from: [ruff/F821]
+since: 0.1.0
+---
+
+Every name the module reads is bound in an enclosing scope, imported, or one of Python's builtins.
+
+**Why:** An undefined name raises `NameError` when the line runs — usually a typo or a missing import.
+
+```codelaw
+native: py/undefined-name
+```
+
+## How to fix
+
+1. Correct a misspelled name, or import or define it.
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+def total(items):
+    return sum(item.price for item in itmes)
+```
+
+#### Do
+
+```py
+def total(items):
+    return sum(item.price for item in items)
+```

codelaw_rules_python/rules/py/unintentional-type-annotation.cases.md

@@ -0,0 +1,13 @@
+# py/unintentional-type-annotation — cases
+
+### case: self attributes are declarations
+
+```py
+class C:
+    def __init__(self):
+        self.x: int
+```
+
+```expect
+(none)
+```

codelaw_rules_python/rules/py/unintentional-type-annotation.md

@@ -0,0 +1,38 @@
+---
+id: py/unintentional-type-annotation
+title: "No annotation where an assignment was meant"
+languages: [python]
+fix: manual
+fix_reason: "whether an assignment was meant needs a person"
+stability: preview
+ported_from: [ruff/B032]
+since: 0.1.0
+---
+
+An attribute or item isn't annotated without a value (`obj.x: 1`, `d["k"]: v`).
+
+**Why:** This is almost always a typo for `=`: nothing is assigned.
+
+```codelaw
+native: py/unintentional-type-annotation
+```
+
+## How to fix
+
+1. Replace `:` with `=` if an assignment was meant.
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+config["debug"]: True
+```
+
+#### Do
+
+```py
+config["debug"] = True
+```

codelaw_rules_python/rules/py/unreliable-callable-check.md

@@ -0,0 +1,36 @@
+---
+id: py/unreliable-callable-check
+title: "Test for callables with `callable()`"
+languages: [python]
+fix: suggest
+fix_reason: "objects that define `__getattr__` can answer differently to the two tests"
+stability: preview
+ported_from: [ruff/B004]
+since: 0.1.0
+---
+
+Code tests whether an object can be called with `callable(x)`, not by looking for a `__call__` attribute.
+
+**Why:** `hasattr(x, "__call__")` can be fooled by `__getattr__` and misses some callables.
+
+```codelaw
+native: py/unreliable-callable-check
+```
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+if hasattr(handler, "__call__"):
+    handler()
+```
+
+#### Do
+
+```py
+if callable(handler):
+    handler()
+```

codelaw_rules_python/rules/py/unsorted-imports.cases.md

@@ -0,0 +1,159 @@
+# py/unsorted-imports — cases
+
+### case: same module ordered by first name
+
+```py
+from multiprocessing import pool
+from multiprocessing import Pool as ProcessPool
+```
+
+```expect
+1:1 py/unsorted-imports
+```
+
+```fixed
+from multiprocessing import Pool as ProcessPool
+from multiprocessing import pool
+```
+
+### case: members and merging
+
+```py
+from collections import deque, OrderedDict
+from collections import abc
+```
+
+```expect
+1:1 py/unsorted-imports
+```
+
+```fixed
+from collections import OrderedDict, abc, deque
+```
+
+### case: relative imports furthest first
+
+```py
+from . import a
+from .. import b
+```
+
+```expect
+1:1 py/unsorted-imports
+```
+
+```fixed
+from .. import b
+from . import a
+```
+
+### case: a comment moves with its import
+
+```py
+import sys
+# json is fast enough
+import json
+```
+
+```expect
+1:1 py/unsorted-imports
+```
+
+```fixed
+# json is fast enough
+import json
+import sys
+```
+
+### case: blocks are separate
+
+```py
+import sys
+
+x = 1
+
+import os
+```
+
+```expect
+(none)
+```
+
+### case: nested blocks
+
+```py
+def f():
+    import sys
+    import os
+```
+
+```expect
+2:5 py/unsorted-imports
+```
+
+```fixed
+def f():
+    import os
+    import sys
+```
+
+### case: future first
+
+```py
+import os
+from __future__ import annotations
+```
+
+```expect
+1:1 py/unsorted-imports
+```
+
+```fixed
+from __future__ import annotations
+
+import os
+```
+
+### case: case-insensitive module order
+
+```py
+import apple
+import Zebra
+import requests
+```
+
+```expect
+1:1 py/unsorted-imports
+```
+
+```fixed
+import apple
+import requests
+import Zebra
+```
+
+### case: already sorted with sections
+
+```py
+import os
+import sys
+
+import requests
+
+from . import local
+```
+
+```expect
+(none)
+```
+
+### case: isort: skip
+
+```py
+import sys  # isort: skip
+import os
+```
+
+```expect
+(none)
+```

codelaw_rules_python/rules/py/unsorted-imports.md

@@ -0,0 +1,60 @@
+---
+id: py/unsorted-imports
+title: "Imports are sorted"
+languages: [python]
+fix: auto
+stability: preview
+options:
+  known_first_party: { type: "string[]", default: [], description: "top-level modules that belong to this project" }
+  line_length: { type: integer, default: 88, description: "the width a from-import may reach before it is wrapped" }
+ported_from: [ruff/I001]
+since: 0.1.0
+---
+
+Each block of consecutive imports is in isort's order: sections (`__future__`, standard library, third party, first party, local), plain `import x` before `from x import y` within a section, then by module name, and the names of a `from` import sorted (constants, classes, then the rest).
+
+**Why:** A fixed order makes imports easy to scan and stops merge conflicts from reordering.
+
+```codelaw
+native: py/unsorted-imports
+```
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+import sys
+import os
+```
+
+#### Don't
+
+```py
+import requests
+import os
+```
+
+#### Do
+
+```py
+import os
+import sys
+```
+
+#### Do
+
+```py
+import os
+
+import requests
+```
+
+## Differences from the source
+
+- The rule checks order. Line wrapping and the blank lines after the import block belong to the formatter; the fix separates sections with one blank line and wraps a `from` import past `line_length`, as isort does.
+- First-party modules are those listed in `known_first_party`; Ruff also detects them from the project's source folders.
+- `import a, b` is not reported here (that is `py/multiple-imports-on-one-line`), and `from m import a, b as c` is not reported for mixing aliases; the fix still writes each on its own line.
+- A block with comments the fix can't place (inside a parenthesised import, or loose between imports) is reported without an edit.

codelaw_rules_python/rules/py/unused-annotation.md

@@ -0,0 +1,36 @@
+---
+id: py/unused-annotation
+title: "Every annotated local is used"
+languages: [python]
+fix: auto
+stability: preview
+ported_from: [ruff/F842]
+since: 0.1.0
+---
+
+A local variable annotated without a value (`x: int`) is used somewhere in the function.
+
+**Why:** A local annotation that nothing uses declares nothing; local annotations aren't even evaluated.
+
+```codelaw
+native: py/unused-annotation
+```
+
+## Examples
+
+### Python
+
+#### Don't
+
+```py
+def total():
+    count: int
+    return 0
+```
+
+#### Do
+
+```py
+def total():
+    return 0
+```