Showing all detectors for the Python language with info severity.

Catch and swallow exception

Swallowing exceptions, without re-throwing or logging them, is a bad practice.

Low maintainability with low class cohesion

Classes with low class cohesion contain unrelated operations which make them difficult to understand and less likely to be used.

Confusion between equality and identity in conditional expression

Confusion between equality ==, != and identity is in conditional expressions can lead to unintended behavior.

Bad exception handling

Throwing a base or generic exception might cause important error information to be lost. This can make your code difficult to maintain.

Set SNS Return Subscription ARN

To always return the subscription ARN, set the ReturnSubscriptionArn argument to True.

Violation of PEP8 programming recommendations

Violating PEP8 programming recommendations might make code difficult to read and can introduce ambiguity.

Pytorch assign in place mod

Detects if a torch variable is modified in place inside an assignment.

Inefficient string concatenation inside loop

Inefficient string concatenation inside loops results in new object creation which adds quadratic runtime cost.

Stack trace exposure

Stack traces can be hard to use for debugging.

Batch request with unchecked failures

Not checking which items have failed can lead to loss of data.

Unnecessary iteration

Iteration when only one item is needed from a list is inefficient.