This rule raises an issue when a class defines one or more rich comparison methods (__lt__, __le__, __gt__, __ge__) without using the functools.total_ordering decorator or defining all of them.

Why is this an issue?

Python classes can implement rich comparison methods to enable sorting and comparison operations. These methods include:

• __lt__ for less than (<)
• __le__ for less than or equal to (<=)
• __gt__ for greater than (>)
• __ge__ for greater than or equal to (>=)
• __eq__ for equality (==)
• __ne__ for inequality (!=)

When you define only some of these methods, Python cannot automatically infer the missing ones. This leads to inconsistent behavior:

• sorting algorithms may fail or produce incorrect results
• comparison operations may raise TypeError exceptions
• code that expects symmetric comparisons, such as a < b being true implying b > a is also true, may behave unexpectedly

Python provides the functools.total_ordering decorator specifically to solve this problem. It allows you to define just __eq__ and one other comparison method, and it automatically generates the rest. This ensures consistent and correct comparison behavior across all operations.

What is the potential impact?

Incomplete comparison method implementations can cause several problems:

• Sorting failures: built-in functions like sorted() or list methods like sort() may raise exceptions or produce incorrect ordering
• Unexpected comparison results: code that relies on comparison symmetry may produce wrong results, leading to logic errors
• Maintenance difficulties: future developers may not realize that certain comparison operations are missing, leading to bugs when they use those operations
• Container behavior: data structures like heaps or priority queues that depend on comparisons may malfunction

While this typically will not cause security vulnerabilities, it can lead to application logic errors that are difficult to diagnose and debug.

How to fix it

Either use the @functools.total_ordering decorator and define __eq__ and one ordering method, typically __lt__, or define all four ordering methods (__lt__, __le__, __gt__, __ge__) explicitly.

Code examples

Noncompliant code example

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __lt__(self, other):  # Noncompliant
        return self.age < other.age

Compliant solution

from functools import total_ordering

@total_ordering
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __eq__(self, other):
        return self.age == other.age

    def __lt__(self, other):
        return self.age < other.age

Noncompliant code example

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __lt__(self, other):  # Noncompliant
        return self.x < other.x

Compliant solution

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __lt__(self, other):
        return self.x < other.x

    def __le__(self, other):
        return self.x <= other.x

    def __gt__(self, other):
        return self.x > other.x

    def __ge__(self, other):
        return self.x >= other.x

How does this work?

The @functools.total_ordering decorator automatically generates all missing comparison methods from the ones you define. This ensures consistent and correct comparison behavior across all operations.

Resources

Documentation

• Python Documentation - functools.total_ordering
• Python Documentation - Rich Comparison Methods
• PEP 207 - Rich Comparisons