pyeo

Pyeo is an advanced static analysis tool tailored specifically to enforce the principles advocated by Elegant Objects (elegantobjects.org) in Python projects. It serves as a quality control instrument to ensure that your Python code adheres to the core tenets of elegance, simplicity, and maintainability.

The project is inspired by the team that made fun of me because of the lego build. STT lambda ❤️️

pip install eo-styleguide

Simple example of usage:

from typing import Protocol, final

import attrs


class House(Protocol):
    def area(self) -> int: ...


@final
@attrs.define(frozen=True)
class HttpHouse(House):

    def area(self) -> int:
        return 10

mypy file.py && flake8 file.py

Contents

• Principles

  • No null (why?)

  • No code in constructors (why?)

  • No getters and setters (why?)

  • No mutable objects (why?)

  • No readers, parsers, controllers, sorters, and so on (why?)

  • No static methods, not even private ones (why?)

  • No instanceof, type casting, or reflection (why?)

  • No public methods without a contract (interface) (why?)

  • No statements in test methods except assert (why?)

  • No ORM or ActiveRecord (why? and why?)

  • No implementation inheritance (why? and why?)

No null

Mypy helps prevent AttributeError and other type-related errors by providing static type checking for Python code. It allows specifying variable types, function arguments, and return types to catch potential type issues before the program runs. By using Mypy, developers can identify and fix problems related to attribute access and other type mismatches, leading to improved code quality and easier maintenance.

Example:

class Employee(object):
    def __init__(self, user_id: int):
        self._user_id = user_id

def get_by_id(user_id: int) -> Employee:
    if user_id < 0:
        return None
    return Employee(user_id)

Mypy return next violation:

error: Incompatible return value type (got "None", expected "Employee")  [return-value]

So, we must use typing.Optional or | (union) operator.

It's works:

def get_by_id(user_id: int) -> Optional[Employee]: ...
def get_by_id(user_id: int) -> Employee | None: ...

No code in constructors

You can use @attrs.define for skip this. It decorator create ctor for your classes automatically. However, we implement check that your primary and secondary ctors not contain code, with the exception of attributes assingment. Please check CodeFreeCtorVisitor.

No getters and setters

Actually we realize functional for to prohibit the use of @property and @setter method decorators. You can use @attrs.define(frozen=True) in order to make an object immutable.

Prohibit the use of @property decorator not protect from evil of getters, so if you can ideas how we can implement more complex check, create issue please.

No mutable objects

attrs.define(frozen=True) is a parameter used in the attrs library to create classes with attributes that cannot be modified after the instance is created (i.e., immutable or "frozen" classes).

The attrs library allows defining classes using the @attr.s decorator or by explicitly calling the attr.define function, and frozen=True is one of the parameters for specifying attribute behavior in the class.

When you use attrs.define(frozen=True) for a class, all its attributes become read-only after the instance is created, making the class "frozen" or "immutable," preventing any changes to its attribute values.

See NoMutableObjectsVisitor

No er suffix

We check you class name not contain -er or (C|c)lient suffix by check in NoErNamesFeature

No static methods

A static method is a procedure that happens to live in a class: there is no object behind it, so everything it works on arrives as arguments, which is exactly what objects exist to hide. A private method is no better: it is an object that never got a class of its own.

PEO400 reports every method decorated with @staticmethod, synchronous or async. Private methods are reported as NPM100 by flake8-no-private-methods, which comes with pyeo.

No reflection

An object should be asked to do something, not asked what it is: a check of its type makes the caller decide on its behalf, and every new type means one more branch in someone else's code.

PEO700 reports, everywhere in the code:

• calls to isinstance, issubclass, hasattr, getattr, setattr and delattr
• type with one argument; type(name, bases, namespace) builds a class and stays allowed
• typing.cast and cast
• class patterns of match statements, such as case list():

Where reflection cannot be avoided, say so with # noqa: PEO700 on that line.

No public methods without a contract

In Python, typing.Protocol is a class introduced in Python 3.8 as part of the typing module. It is used to define structural subtyping or "duck typing" for classes, which allows you to create interfaces without using explicit inheritance.

flake8-override plugin check that all of public class methods has protocol.

No statements in tests

TODO

No ORM

Detect using ORM or ActiveRecord tools on project by design/code review

No inheritance

Each class must be typing.final. Check by flake8-final