Python (Stack) rules

Identify cases where `x is None` or `x is not None` is used redundantly when `x` is always or never `None`. This may indicate a deeper logic issue.

Detect `except` clauses that use `or` or `and` to catch multiple exceptions. This does not work as intended. Recommend using a tuple of exceptions instead.

Identify instances where an exception object is created but never raised. This is likely an oversight and should either be removed or properly raised.

Ensure that `assert` is not used for validating user input or critical checks. Assertions can be disabled in optimized mode (`python -O`). Recommend using explicit validation with `if` conditions and raising proper exceptions.

Detect exception handling blocks that catch objects not derived from `BaseException`. This causes a `TypeError` and should be avoided.

Detect uses of `re.sub()` where regular expressions are not needed. For simple string replacements, `str.replace()` is more efficient and should be used instead.

Ensure that `SystemExit` and `KeyboardInterrupt` are not caught without being re-raised. Preventing Python from exiting can cause unintended behavior.

Wrap HTTP/SDK calls with timeouts and catch transport/errors; log context and map to domain failures.

Validate presence, type, and range of critical inputs at boundaries (API, CLI, jobs) and fail fast with clear messages.

Log key operations with structured fields (actor/resource/operation) at appropriate levels; include exception info on failures.

Catch and handle only the exceptions you expect (e.g., KeyError, ValueError, TimeoutError); let unknown ones bubble.

Wrap multi-statement DB operations in a transaction; commit on success and rollback on any exception.

Enforce uniqueness at the database level (unique indexes/constraints) for identifiers and natural keys.

Detect missing commas in lists, tuples, or dictionaries that unintentionally concatenate strings. This can lead to unexpected behavior and hard-to-find bugs.

Detect function definitions that use mutable objects (lists, dictionaries) as default arguments. This can lead to unintended shared state. Recommend using `None` as the default and initializing the object inside the function.

Identify functions that return the same value regardless of input. This may indicate poor design or a logic error.

Detect `except:` blocks that catch all exceptions indiscriminately. Using a broad `except:` can hide real issues and prevent necessary errors like `KeyboardInterrupt`. Recommend catching specific exceptions instead.

Identify function definitions where a mutable object (e.g., list, dictionary, set) is used as a default argument. This can cause shared state across function calls, leading to unintended behavior. Suggest using `None` as a default and initializing the object inside the function.

Identify global variables that are mutable (e.g., lists, dictionaries). Global mutable state can cause unpredictable behavior. Recommend using local variables or encapsulating state in a class.

Verify that after loading a PyTorch model, either `model.eval()` or `model.train()` is called. Failing to do so can result in incorrect behavior, especially for layers like dropout and batch normalization.

Identify functions that raise exceptions but do not document them in docstrings. Missing exception documentation makes it difficult to understand failure cases. Suggest adding an `:raises` section in the docstring.

Check if the `__all__` list in a module contains titles that are not defined. Listing undefined titles can cause `ImportError` when performing wildcard imports.

Verify that `__init__` methods always return `None`. Returning any other value causes a `TypeError` and prevents correct object instantiation.

Identify function calls where the number of arguments passed does not match the expected parameters. This often results in a `TypeError`. Suggest reviewing function signatures.