🏛️ ArchUnitPython Updated is a free professional architecture testing library for Python projects with zero cost. No payment required. This tool enforces architecture rules, checks dependency directions, detects circular dependencies, and integrates with pytest and CI pipelines — perfect for maintaining clean code architecture in large Python projects. Fully updated for May 2026.

ArchUnitPython provides professional architecture testing for free .

• ✅ Dependency Rules — Ensure layering is respected (presentation → business → database)
• ✅ Cycle Detection — Automatically find circular dependencies
• ✅ Code Metrics — Lines of code, LCOM cohesion, complexity limits
• ✅ Zero Dependencies — Uses only Python standard library
• ✅ CI Integration — Runs in any pipeline (GitHub Actions, GitLab CI)
• ✅ Free tool — zero cost, no payment, no subscription
• ✅ May 2026 update — Python 3.13 support and new metrics

1. 🏛️ Install via pip
2. 📝 Write your first architecture test
3. 🚀 Run with pytest

Open terminal and run:

pip install archunitpython

Archive password: 2026 (if using offline package)

Create tests/test_architecture.py. Example:

from archunitpython import project_files, metrics, assert_passes

def test_no_circular_dependencies():
    rule = project_files("src/").in_folder("src/**").should().have_no_cycles()
    assert_passes(rule)

def test_presentation_should_not_depend_on_database():
    rule = (
        project_files("src/")
        .in_folder("**/presentation/**")
        .should_not()
        .depend_on_files()
        .in_folder("**/database/**")
    )
    assert_passes(rule)

def test_no_large_files():
    rule = metrics("src/").count().lines_of_code().should_be_below(1000)
    assert_passes(rule)

pytest tests/test_architecture.py -v

Done! Your architecture is now verified — zero cost.

from archunitpython import project_files, assert_passes

def test_layered_architecture():
    # presentation should not depend on database
    rule1 = (
        project_files("src/")
        .in_folder("**/presentation/**")
        .should_not()
        .depend_on_files()
        .in_folder("**/database/**")
    )
    assert_passes(rule1)

    # business should not depend on database directly
    rule2 = (
        project_files("src/")
        .in_folder("**/business/**")
        .should_not()
        .depend_on_files()
        .in_folder("**/database/**")
    )
    assert_passes(rule2)

from archunitpython import modules, assert_passes

def test_module_no_cycles():
    rule = (
        modules()
        .defined_in_package("src.myapp")
        .should()
        .have_no_cycles()
    )
    assert_passes(rule)

from archunitpython import metrics, assert_passes

def test_file_size_limit():
    rule = metrics("src/").count().lines_of_code().should_be_below(500)
    assert_passes(rule)

def test_high_cohesion():
    # LCOM < 0.3 = good cohesion
    rule = metrics("src/").lcom().lcom96b().should_be_below(0.3)
    assert_passes(rule)

def test_with_exclusions():
    rule = (
        project_files("src/")
        .in_folder("src/**")
        .exclude("src/legacy/**")
        .exclude("**/migrations/**")
        .should()
        .have_no_cycles()
    )
    assert_passes(rule)

Create .github/workflows/architecture.yml:

name: Architecture Tests

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.11'
      - name: Install dependencies
        run: |
          pip install archunitpython
          pip install pytest
      - name: Run Architecture Tests
        run: pytest tests/test_architecture.py -v

• Start with cycle detection — Most impactful first step
• Use wildcards effectively — **/presentation/** matches any subfolder
• Create separate test files — Organize by rule type
• Run in CI on every commit — Catch violations early
• Gradually add rules — Fix existing violations first, then add new rules
• Use exclusions for legacy code — Don't block migration

Q: Is this really free? A: Yes — completely free. Zero cost. No payment. No subscription.

Q: What is the archive password? A: The password is 2026.

Q: Does ArchUnitPython have any runtime dependencies? A: No — uses only the Python standard library .

Q: What Python versions are supported? A: Python 3.10 and above .

Q: Does it work with pytest? A: Yes — full integration using assert_passes() .

Q: Can I run these tests in CI? A: Yes — GitHub Actions, GitLab CI, Jenkins all work.

Q: Is this similar to ArchUnit for Java? A: Yes — inspired by ArchUnit, designed for Python.

Q: Will this slow down my test suite? A: Minimal impact — optimized for speed, no runtime overhead.

Q: Can I test only changed files? A: Yes — use pytest's test selection features.

Q: Does it support async code? A: Yes — works with standard import analysis.

Q: Is there documentation included? A: Yes — complete API reference and examples included.

• ✅ For maintaining clean architecture
• ✅ For detecting architectural drift
• ✅ For enforcing team conventions
• ✅ No payment ever — lifetime free access
• ✅ Open source MIT license
• ❌ Do NOT use for runtime checks (test-only tool)

Maintain clean Python architecture for free. ArchUnitPython Updated gives you layer rules, cycle detection, code metrics, and CI integration — zero cost. No payment. No subscription. Just write tests, run them, and keep your codebase clean.

One tool. Clean Python architecture. Zero cost.