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.
Pyeo is proudly based on the robust foundation of Mypy, a leading static type checker for Python. Mypy not only provides excellent type analysis capabilities but also offers a convenient-to-use API and abstractions for working with Python AST (Abstract Syntax Tree). This unique combination empowers Pyeo a seamless static analysis experience, allowing for a deeper understanding of your code's structure and semantics.
The project is inspired by the team that made fun of me because of the lego build. STT lambda ❤️️
pip install eo-styleguidesetup.cfg/mypy.ini
[mypy]
plugins = pyeo.main
pyproject.toml
[tool.mypy]
plugins = ["pyeo.main"]
Simple example of usage:
from typing import Protocol, final
import attrs
# use the "elegant" decorator so that the plugin finds classes to check
from pyeo import elegant
class House(Protocol):
def area(self) -> int: ...
@elegant
@final
@attrs.define(frozen=True)
class HttpHouse(House):
def area(self) -> int:
return 10- Principles
-
No ORM or ActiveRecord (why? and why?)
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: ...
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 NoCodeInCtorFeature.
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.
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.
We check you class name not contain -er or (C|c)lient suffix by check in NoErNamesFeature
Check by NoStaticmethodsFeature
Prohibit next function calls:
isinstancetypeissubclasshasattr
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.
EachMethodHasProtocolFeature rule check that all of public class methods has protocol.
TODO
Detect using ORM or ActiveRecord tools on project by design/code review
Each @elegant object must be typing.final. Check by FinalClassFeature