Rule your architecture like a real developer
pytest-archon is a little tool that helps you structure (large) Python projects. This
tool allows you to define architectural boundaries in your code, also known as
Explicitly defined architectural boundaries helps you keep your code in shape. It avoids the creation of circular dependencies. New people on the project are made aware of the structure through a simple set of rules, instead of lore.
The simple way:
pip install pytest-archon
pytest-archon can be used to define architectural boundaries from (unit) tests. Because they're tests, they can be closely tied to the actual application.
You can use pytest-archon in tests by simply importing the
archrule function. Using
this function you can construct import tests:
from pytest_archon import archrule def test_rule_basic(): ( archrule("name", comment="some comment") .match("pytest_archon.col*") .exclude("pytest_archon.colgate") .should_not_import("pytest_archon.import_finder") .should_import("pytest_archon.core*") .check("pytest_archon") )
- To match the modules and constraints,
fnmatch syntax is used (the
default). You can also use
by supplying the
.should_not_import()can be combined and can occur multiple times.
.may_import()can be used in combination with
.check()needs either a module object or a string
check() method can have a few optional parameters, that alter the way the checks
- Without parameters, the whole file is checked for imports. So imports done in functions and methods are also found. Transitive dependencies are also checked
only_toplevel_imports=Truewill only check for toplevel imports. Conditional imports and import in functions and methods are ignored.
skip_type_checking=Truewill check all imports, but skip imports defined in
only_direct_imports=Truewill only check for imports performed by the module directly and will not check transitive imports.
skip_type_checking=Truehas no effect.
- Options can be combined.
|Check toplevel imports||Check
||Check conditional imports, and imports in functions and methods||Check transitive imports|
|no options enabled||✓||✓||✓||✓|
def test_domain(): # test if the domain model does not import other submodules # (the domain model should be standing on its own and be used by other modules) ( archrule("domain", comment="domain does not import any other submodules") .match("packageX.domain*") # matches packageX.domain and packageX.domain.* .should_not_import("packageX*") .may_import("packageX.domain.*") .check("packageX") )
util module is used at more than one place
You can also supply custom constraints as predicate functions.
If you, for example, have a common or util module, you might want to make sure that it is used at least at two places (otherwise it would not make sense to have a separate module).
from pytest_archon import archrule def test_utils_are_shared(): def have_at_least_two_users(util_module, direct_imports, all_imports): # iterate through all imports and find modules using the util_module in question users = [k for k, v in all_imports.items() if util_module in v] # return True if more than two modules use the util_module return len(users) > 2 archrule("util_is_shared").match("pkg.util").should(have_at_least_two_users).check("pkg")
The blog post How to tame your Python codebase is also a good overview.
- Archunit (Java)
- import-linter (Python)
- pytestarch (Python)
- Maintain A Clean Architecture With Dependency Rules - sourcery.ai (Python)
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.
Hashes for pytest_archon-0.0.5-py3-none-any.whl