archunitpython 1.0.1__tar.gz → 1.1.1__tar.gz

{archunitpython-1.0.1 → archunitpython-1.1.1}/.github/workflows/docs.yaml

@@ -41,7 +41,7 @@ jobs:
               uses: actions/configure-pages@v6
 
             - name: Upload artifact
-              uses: actions/upload-pages-artifact@v4
+              uses: actions/upload-pages-artifact@v5
               with:
                   path: './docs'
 

archunitpython-1.1.1/.releaserc.json

@@ -0,0 +1,27 @@
+{
+	"branches": ["main"],
+	"plugins": [
+		"@semantic-release/commit-analyzer",
+		"@semantic-release/release-notes-generator",
+		[
+			"@semantic-release/changelog",
+			{
+				"changelogFile": "CHANGELOG.md"
+			}
+		],
+		[
+			"@semantic-release/exec",
+			{
+				"prepareCmd": "python -c \"import re, pathlib; files=[('pyproject.toml', r'(?m)^version = \\\"[^\\\"]+\\\"$', 'version = \\\"${nextRelease.version}\\\"'), ('src/archunitpython/__init__.py', r'(?m)^__version__ = \\\"[^\\\"]+\\\"$', '__version__ = \\\"${nextRelease.version}\\\"')]; [pathlib.Path(path).write_text(re.sub(pattern, replacement, pathlib.Path(path).read_text())) for path, pattern, replacement in files]\""
+			}
+		],
+		[
+			"@semantic-release/git",
+			{
+				"assets": ["pyproject.toml", "src/archunitpython/__init__.py", "CHANGELOG.md"],
+				"message": "chore(release): ${nextRelease.version} [skip ci]\n\n${nextRelease.notes}"
+			}
+		],
+		"@semantic-release/github"
+	]
+}

archunitpython-1.1.1/BACKLOG.md

@@ -0,0 +1,62 @@
+# Backlog
+
+This backlog collects product and maintenance ideas from project research.
+
+## P0 - Maintenance And Correctness
+
+- Keep package metadata synchronized across `pyproject.toml`, `CHANGELOG.md`, and `src/archunitpython/__init__.py`.
+- Keep tool configuration valid for the supported Python range, especially mypy and Ruff target versions.
+- Add a release metadata check that fails when the exported `__version__` differs from the project version.
+- Add CI jobs that run tests, Ruff, mypy, and a package build from a clean checkout.
+
+## P1 - Adoption Workflow
+
+- Add an `.archignore` or similar file, modeled after `.gitignore`, for files that should never be analyzed.
+- Add a `.because(...)` API so rules can carry user-facing rationale into failure messages and generated architecture documentation.
+- Add configuration-file support for common rules, while keeping the fluent Python API as the primary interface.
+- Add support for monorepo and multi-package Python projects.
+
+## P1 - Python Import Semantics
+
+- Add support for namespace packages that do not contain `__init__.py`.
+- Detect dynamic imports such as `importlib.import_module()` and `__import__()`.
+- Detect conditional imports such as `try/except ImportError`.
+- Add better `TYPE_CHECKING` import handling, including options to ignore, include, or report type-only imports separately.
+- Improve external dependency rules so users can express allowed and forbidden third-party packages at module or slice level.
+- Consider a public-interface rule inspired by Tach, where modules may only import through declared package APIs.
+
+## P1 - Reporting And Documentation
+
+- Add comprehensive HTML reports with dependency graphs, metric charts, and zone visualization.
+- Auto-generate architecture documentation based on tests and rule rationales.
+- Make logged paths clickable in IDEs and common terminal integrations.
+- Add PlantUML or Mermaid export for discovered architecture graphs.
+- Improve metric export examples and document how metric thresholds should be selected.
+
+## P2 - Rule Surface
+
+- Add first-class layered architecture helpers so common clean/hexagonal/layered rules require less boilerplate.
+- Add slice isolation helpers for bounded contexts and modular monoliths.
+- Add richer custom rule hooks for dependency edges, files, classes, and metrics.
+- Add transitive dependency checks, especially for "domain must not transitively reach infrastructure" style rules.
+- Add naming and placement conventions for classes/functions, not only files.
+
+## P2 - Performance And Scale
+
+- Improve performance for very large projects through parallel file parsing.
+- Add persistent graph caching with invalidation based on file mtimes or content hashes.
+- Add benchmarks for small, medium, large, and monorepo-style projects.
+
+## P2 - Metrics
+
+- Add more LCOM edge case handling.
+- Add metric documentation with examples for good, suspicious, and failing values.
+- Add trend-friendly metric exports for CI artifacts.
+- Consider additional architecture metrics such as coupling counts per slice, fan-in/fan-out summaries, and instability per package.
+
+## P3 - Packaging And Docs
+
+- Publish to PyPI as part of the release pipeline if this is not already automated.
+- Add a Sphinx or MkDocs documentation site.
+- Add a complete example repository or examples folder covering pytest, unittest, PlantUML, metrics, and CI.
+- Add contribution guidance for new rule types and metric implementations.

{archunitpython-1.0.1 → archunitpython-1.1.1}/CHANGELOG.md

@@ -1,3 +1,22 @@
+## [1.1.1](https://github.com/LukasNiessen/ArchUnitPython/compare/v1.1.0...v1.1.1) (2026-05-24)
+
+
+### Bug Fixes
+
+* **deps:** bump actions/upload-pages-artifact ([a4452fc](https://github.com/LukasNiessen/ArchUnitPython/commit/a4452fce2ce9428882cf686227de9f09cb6a21b1))
+
+# [1.1.0](https://github.com/LukasNiessen/ArchUnitPython/compare/v1.0.1...v1.1.0) (2026-04-26)
+
+
+### Bug Fixes
+
+* linting errors ([bae7613](https://github.com/LukasNiessen/ArchUnitPython/commit/bae761376817a858a622f2320da3a4596823c891))
+
+
+### Features
+
+* add external dependencies and TYPE_CHECKING ([02b8d01](https://github.com/LukasNiessen/ArchUnitPython/commit/02b8d01b37752e5ddd815ab5c10b36f26814f438))
+
 ## [1.0.1](https://github.com/LukasNiessen/ArchUnitPython/compare/v1.0.0...v1.0.1) (2026-04-02)
 
 

{archunitpython-1.0.1 → archunitpython-1.1.1}/CONTRIBUTING.md

@@ -36,7 +36,7 @@ Releases are fully automated. When a PR is merged to `main`:
 1. CI runs lint + type checking + tests (across Python 3.10-3.13)
 2. If CI passes, [semantic-release](https://github.com/semantic-release/semantic-release) analyzes commit messages since the last release
 3. If there are `fix:` or `feat:` commits, it automatically:
-   - Bumps the version in `pyproject.toml`
+   - Bumps the version in `pyproject.toml` and `src/archunitpython/__init__.py`
    - Updates `CHANGELOG.md`
    - Publishes to PyPI
    - Creates a GitHub release with release notes

{archunitpython-1.0.1 → archunitpython-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: archunitpython
-Version: 1.0.1
+Version: 1.1.1
 Summary: Architecture testing library for Python projects. Enforce dependency rules, detect cycles, validate metrics.
 Project-URL: Homepage, https://github.com/LukasNiessen/ArchUnitPython
 Project-URL: Repository, https://github.com/LukasNiessen/ArchUnitPython.git
@@ -189,7 +189,7 @@ Ensure services/modules don't have forbidden cross-dependencies.
 
 Here is a repository with a fully functioning example that uses ArchUnitPython to ensure architectural rules:
 
-- **[RAG Pipeline Example](https://github.com/LukasNiessen/ArchUnitPython-Example-RAG)**: A mock AI/RAG pipeline with layered architecture and intentional violations demonstrating ArchUnitPython catching real problems
+- **[RAG Pipeline Test Showcase](https://github.com/LukasNiessen/ArchUnitPython-TestRepo-RAG)**: A test showcase demonstrating ArchUnitPython's architecture testing capabilities on a RAG pipeline
 
 ## 🐣 Features
 

{archunitpython-1.0.1 → archunitpython-1.1.1}/README.md

@@ -157,7 +157,7 @@ Ensure services/modules don't have forbidden cross-dependencies.
 
 Here is a repository with a fully functioning example that uses ArchUnitPython to ensure architectural rules:
 
-- **[RAG Pipeline Example](https://github.com/LukasNiessen/ArchUnitPython-Example-RAG)**: A mock AI/RAG pipeline with layered architecture and intentional violations demonstrating ArchUnitPython catching real problems
+- **[RAG Pipeline Test Showcase](https://github.com/LukasNiessen/ArchUnitPython-TestRepo-RAG)**: A test showcase demonstrating ArchUnitPython's architecture testing capabilities on a RAG pipeline
 
 ## 🐣 Features
 

{archunitpython-1.0.1 → archunitpython-1.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "archunitpython"
-version = "1.0.1"
+version = "1.1.1"
 description = "Architecture testing library for Python projects. Enforce dependency rules, detect cycles, validate metrics."
 readme = "README.md"
 license = "MIT"
@@ -67,13 +67,13 @@ python_classes = ["Test*"]
 python_functions = ["test_*"]
 
 [tool.mypy]
-python_version = "1.0.1"
+python_version = "3.10"
 strict = true
 warn_return_any = true
 warn_unused_configs = true
 
 [tool.ruff]
-target-version = "1.0.1"
+target-version = "py310"
 line-length = 100
 
 [tool.ruff.lint]

archunitpython-1.1.1/research/product-direction/architecture-testing-landscape.md

@@ -0,0 +1,56 @@
+# Architecture Testing Landscape
+
+Research date: 2026-05-23
+
+This document compares ArchUnitPython with architecture testing tools in the broader ecosystem and with Python-specific alternatives. It focuses on user-facing features that can inform product direction.
+
+## Current ArchUnitPython Position
+
+ArchUnitPython already covers three valuable surfaces:
+
+- File-level architecture rules through `project_files(...)`: dependency direction, cycle detection, naming/path conventions, external dependency checks, and custom file predicates.
+- Slice-level architecture rules through `project_slices(...)`: slice extraction from path patterns or regexes, PlantUML diagram adherence, and forbidden slice dependencies.
+- Code metrics through `metrics(...)`: count metrics, LCOM variants, abstractness, instability, distance from the main sequence, zone checks, and custom metrics.
+
+That breadth makes the project closer to ArchUnit-style libraries than to pure import linters. The main gaps are around configuration ergonomics, reporting, incremental adoption, IDE/CI workflow polish, and deeper Python import semantics.
+
+## General Architecture Testing Players
+
+| Tool | Ecosystem | Rule definition style | Dependency/layer rules | Cycles | Diagram support | Metrics | Reports/visualization | Notable strengths | ArchUnitPython comparison |
+| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
+| [ArchUnit](https://www.archunit.org/userguide/html/000_Index.html) | Java | Fluent Java API, JUnit integrations | Yes: packages, classes, layers, slices | Yes | PlantUML component diagrams | Yes: software architecture metrics | Strong test failure output; mature JUnit support | Mature reference implementation with a broad rule model and mature JUnit workflow | ArchUnitPython mirrors the core idea and already has files/slices/metrics, but lacks class/member/annotation richness and mature import options |
+| [ArchUnitNET](https://github.com/TNG/ArchUnitNET) | .NET | Fluent C# API with xUnit/NUnit/MSTest integrations | Yes: assemblies, namespaces, types, members | Yes | PlantUML support and diagram generation in the project ecosystem | Limited compared with ArchUnit | Test framework integrations | Strong .NET analogue to ArchUnit with many framework adapters | ArchUnitPython has stronger built-in code metrics, but less type/member-level expressiveness |
+| [NetArchTest](https://github.com/BenMorris/NetArchTest) | .NET | Fluent C# API | Yes: namespace/type dependency and conventions | Not a primary differentiator | No first-class PlantUML in core | No | Policy results; test framework agnostic | Simple, widely adopted dependency/convention tests for .NET | ArchUnitPython is broader on cycles, slices, PlantUML, and metrics |
+| [ts-arch](https://github.com/ts-arch/ts-arch) | TypeScript/JavaScript | Fluent API, Jest matcher | Yes: files, folders, slices | Yes | PlantUML diagram adherence | No | Jest-oriented failure output | Very close conceptual sibling: file API, slice API, PlantUML, NX monorepo support | ArchUnitPython has a similar surface plus metrics; ts-arch has stronger monorepo/NX positioning |
+| [jQAssistant](https://jqassistant.github.io/jqassistant/current/) | Mostly JVM, plugin-based | Scanner + graph database + rule concepts/constraints | Yes, via graph rules and plugins | Yes, rule-dependent | Documentation validation and living documentation workflows | Software analytics via graph queries | Reports, server/explore mode, graph-backed analysis | Enterprise-scale scanning, graph exploration, living documentation, baseline management | ArchUnitPython is much lighter and easier to embed in tests, but lacks graph database exploration and living-doc workflows |
+
+## Python Architecture Testing Libraries
+
+| Tool | Rule definition style | Dependency/layer rules | Cycles | External dependency rules | Diagram support | Metrics | Reports/visualization | Adoption workflow | How ArchUnitPython stacks up |
+| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
+| [ArchUnitPython](https://github.com/LukasNiessen/ArchUnitPython) | Fluent Python API used from pytest/unittest/any test framework | Yes: file dependencies, external modules, slices, forbidden slice dependencies | Yes: file-level cycles | Yes: external module matching | Yes: PlantUML slice adherence | Yes: count, LCOM, distance, custom metrics | Experimental metric export; no full HTML report yet | Plain test functions; `assert_passes()` or `.check()` | Broadest feature mix among the Python tools reviewed, especially because metrics and PlantUML are built in |
+| [Import Linter](https://import-linter.readthedocs.io/en/stable/index.html) | `.importlinter` configuration contracts plus CLI | Yes: forbidden, protected, layers, independence, acyclic siblings, custom contracts | Yes: acyclic siblings | Primarily first-party import contracts | No first-class PlantUML | No | Browser-based architecture UI | CLI, CI, config file, caching | More mature for config-driven import contracts and exploration; ArchUnitPython is more test-native and broader on metrics/PlantUML |
+| [Tach](https://docs.gauge.sh/getting-started/introduction/) | `tach.toml` plus CLI commands | Yes: module dependencies and public interfaces | Dependency graph focused | Yes: `check-external` for third-party imports | No | No | `show`, `map`, `report`, VS Code integration | Incremental CLI workflow, sync, pre-commit/CI, public interface enforcement | Tach is stronger for modular-boundary workflow and public APIs; ArchUnitPython is stronger for test-suite rules, metrics, and diagram validation |
+| [PyTestArch](https://zyskarch.github.io/pytestarch/latest/features/module_import_checks/) | Python query language evaluated in pytest | Yes: module dependency query language and layered architecture rules | Implicit through dependency rules; not positioned as a primary cycle API | Not a main focus | Yes: generates rules from PlantUML component diagrams | No | Optional matplotlib visualization | Pytest-centered evaluation structures | Similar to ArchUnitPython on Python tests and PlantUML; ArchUnitPython has simpler fluent API and built-in metrics |
+| [pytest-archon](https://github.com/jwbargsten/pytest-archon) | Pytest-oriented architecture assertions | Yes: forbidden dependencies and project structure rules | Yes, positioned around avoiding cycles | Not a main differentiator | No | No | Pytest failure output | Lightweight pytest helper | ArchUnitPython is broader and more ArchUnit-like; pytest-archon is smaller and focused |
+
+## Product Takeaways
+
+- ArchUnitPython should lean into being the ArchUnit-style Python test library, not just another import linter.
+- The nearest feature gap against Python tools is not raw rule breadth; it is workflow: config files, ignore files, public interfaces, incremental adoption, reporting, and IDE/CI polish.
+- Against ArchUnit and ArchUnitNET, the biggest long-term gaps are richer semantic model support, import semantics, and mature documentation/reporting.
+- Metrics are a meaningful differentiator in the Python space and should be kept visible in docs and examples.
+
+## Sources
+
+- ArchUnit User Guide: https://www.archunit.org/userguide/html/000_Index.html
+- ArchUnitNET repository: https://github.com/TNG/ArchUnitNET
+- NetArchTest repository: https://github.com/BenMorris/NetArchTest
+- ts-arch repository: https://github.com/ts-arch/ts-arch
+- jQAssistant User Manual: https://jqassistant.github.io/jqassistant/current/
+- Import Linter documentation: https://import-linter.readthedocs.io/en/stable/index.html
+- Tach documentation: https://docs.gauge.sh/getting-started/introduction/
+- PyTestArch documentation: https://zyskarch.github.io/pytestarch/latest/features/module_import_checks/
+- PyTestArch PlantUML documentation: https://zyskarch.github.io/pytestarch/latest/features/plantuml/
+- PyTestArch visualization documentation: https://zyskarch.github.io/pytestarch/latest/features/visualization/
+- pytest-archon repository: https://github.com/jwbargsten/pytest-archon

{archunitpython-1.0.1 → archunitpython-1.1.1}/src/archunitpython/__init__.py

@@ -1,6 +1,6 @@
 """ArchUnitPython - Architecture testing library for Python projects."""
 
-__version__ = "1.0.0"
+__version__ = "1.1.1"
 
 # Files API
 # Common

{archunitpython-1.0.1 → archunitpython-1.1.1}/src/archunitpython/common/extraction/extract_graph.py

@@ -8,7 +8,9 @@ import os
 from archunitpython.common.extraction.graph import Edge, Graph, ImportKind
 from archunitpython.common.fluentapi.checkable import CheckOptions
 
-_graph_cache: dict[str, Graph] = {}
+GraphCacheKey = tuple[str, tuple[str, ...], bool]
+
+_graph_cache: dict[GraphCacheKey, Graph] = {}
 
 _DEFAULT_EXCLUDE = [
     "__pycache__",
@@ -56,7 +58,13 @@ def extract_graph(
         project_path = os.getcwd()
 
     project_path = os.path.abspath(project_path)
-    cache_key = project_path
+    excludes = list(exclude_patterns) if exclude_patterns is not None else list(_DEFAULT_EXCLUDE)
+    ignore_type_checking_imports = bool(
+        options and options.ignore_type_checking_imports
+    )
+    cache_key = _build_cache_key(
+        project_path, excludes, ignore_type_checking_imports
+    )
 
     if options and options.clear_cache:
         _graph_cache.pop(cache_key, None)
@@ -64,18 +72,36 @@ def extract_graph(
     if cache_key in _graph_cache:
         return _graph_cache[cache_key]
 
-    result = _extract_graph_uncached(project_path, exclude_patterns)
+    result = _extract_graph_uncached(
+        project_path,
+        excludes,
+        ignore_type_checking_imports=ignore_type_checking_imports,
+    )
     _graph_cache[cache_key] = result
     return result
 
 
+def _build_cache_key(
+    project_path: str,
+    exclude_patterns: list[str],
+    ignore_type_checking_imports: bool,
+) -> GraphCacheKey:
+    """Build a stable cache key for graph extraction options."""
+    return (
+        project_path,
+        tuple(sorted(exclude_patterns)),
+        ignore_type_checking_imports,
+    )
+
+
 def _extract_graph_uncached(
     project_path: str,
-    exclude_patterns: list[str] | None = None,
+    exclude_patterns: list[str],
+    *,
+    ignore_type_checking_imports: bool = False,
 ) -> Graph:
     """Extract graph without caching."""
-    excludes = exclude_patterns if exclude_patterns is not None else _DEFAULT_EXCLUDE
-    py_files = _find_python_files(project_path, excludes)
+    py_files = _find_python_files(project_path, exclude_patterns)
 
     edges: list[Edge] = []
     py_files_set = set(py_files)
@@ -93,6 +119,11 @@ def _extract_graph_uncached(
         # Extract and resolve imports
         imports = _extract_imports(file_path)
         for module_name, import_kind in imports:
+            if (
+                ignore_type_checking_imports
+                and import_kind == ImportKind.TYPE_IMPORT
+            ):
+                continue
             resolved, is_external = _resolve_import(
                 module_name, file_path, project_path, import_kind
             )

{archunitpython-1.0.1 → archunitpython-1.1.1}/src/archunitpython/common/fluentapi/checkable.py

@@ -16,6 +16,7 @@ class CheckOptions:
     allow_empty_tests: bool = False
     logging: LoggingOptions | None = None
     clear_cache: bool = False
+    ignore_type_checking_imports: bool = False
 
 
 class Checkable(Protocol):

{archunitpython-1.0.1 → archunitpython-1.1.1}/src/archunitpython/common/projection/edge_projections.py

@@ -34,3 +34,20 @@ def per_edge() -> MapFunction:
         return MappedEdge(source_label=edge.source, target_label=edge.target)
 
     return mapper
+
+
+def per_external_edge() -> MapFunction:
+    """Create a mapper that only passes external edges.
+
+    Self-referencing edges are filtered out, though they are not expected for
+    external imports.
+    """
+
+    def mapper(edge: Edge) -> MappedEdge | None:
+        if not edge.external:
+            return None
+        if edge.source == edge.target:
+            return None
+        return MappedEdge(source_label=edge.source, target_label=edge.target)
+
+    return mapper

{archunitpython-1.0.1 → archunitpython-1.1.1}/src/archunitpython/files/assertion/__init__.py

@@ -5,6 +5,10 @@ from archunitpython.files.assertion.custom_file_logic import (
     gather_custom_file_violations,
 )
 from archunitpython.files.assertion.cycle_free import ViolatingCycle, gather_cycle_violations
+from archunitpython.files.assertion.depend_on_external_modules import (
+    ViolatingExternalModuleDependency,
+    gather_depend_on_external_module_violations,
+)
 from archunitpython.files.assertion.depend_on_files import (
     ViolatingFileDependency,
     gather_depend_on_file_violations,
@@ -20,9 +24,11 @@ __all__ = [
     "FileInfo",
     "ViolatingCycle",
     "ViolatingFileDependency",
+    "ViolatingExternalModuleDependency",
     "ViolatingNode",
     "gather_custom_file_violations",
     "gather_cycle_violations",
     "gather_depend_on_file_violations",
+    "gather_depend_on_external_module_violations",
     "gather_regex_matching_violations",
 ]

archunitpython-1.1.1/src/archunitpython/files/assertion/depend_on_external_modules.py

@@ -0,0 +1,64 @@
+"""Violation gathering for external module dependency rules."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from archunitpython.common.assertion.violation import Violation
+from archunitpython.common.pattern_matching import matches_pattern
+from archunitpython.common.projection.types import ProjectedEdge
+from archunitpython.common.types import Filter
+
+
+@dataclass
+class ViolatingExternalModuleDependency(Violation):
+    """An external module dependency that violates a rule."""
+
+    dependency: ProjectedEdge
+    is_negated: bool = False
+
+
+def gather_depend_on_external_module_violations(
+    edges: list[ProjectedEdge],
+    subject_filters: list[Filter],
+    module_filters: list[Filter],
+    is_negated: bool,
+) -> list[Violation]:
+    """Check if files depend on forbidden/allowed external modules.
+
+    Subject filters use AND semantics. Module filters use OR semantics, which
+    makes it possible to express useful allowlists or blocklists for external
+    module names.
+    """
+    violations: list[Violation] = []
+
+    for edge in edges:
+        source_matches = all(
+            matches_pattern(edge.source_label, filter_)
+            for filter_ in subject_filters
+        )
+        if not source_matches:
+            continue
+
+        target_matches = (
+            any(matches_pattern(edge.target_label, filter_) for filter_ in module_filters)
+            if module_filters
+            else False
+        )
+
+        if is_negated:
+            if target_matches:
+                violations.append(
+                    ViolatingExternalModuleDependency(
+                        dependency=edge, is_negated=True
+                    )
+                )
+        else:
+            if not target_matches:
+                violations.append(
+                    ViolatingExternalModuleDependency(
+                        dependency=edge, is_negated=False
+                    )
+                )
+
+    return violations

{archunitpython-1.0.1 → archunitpython-1.1.1}/src/archunitpython/files/fluentapi/files.py

@@ -16,7 +16,10 @@ from archunitpython.common.assertion.violation import EmptyTestViolation, Violat
 from archunitpython.common.extraction.extract_graph import extract_graph
 from archunitpython.common.fluentapi.checkable import CheckOptions
 from archunitpython.common.pattern_matching import matches_all_patterns
-from archunitpython.common.projection.edge_projections import per_internal_edge
+from archunitpython.common.projection.edge_projections import (
+    per_external_edge,
+    per_internal_edge,
+)
 from archunitpython.common.projection.project_cycles import project_cycles
 from archunitpython.common.projection.project_edges import project_edges
 from archunitpython.common.projection.project_nodes import project_to_nodes
@@ -28,6 +31,9 @@ from archunitpython.files.assertion.custom_file_logic import (
     gather_custom_file_violations,
 )
 from archunitpython.files.assertion.cycle_free import gather_cycle_violations
+from archunitpython.files.assertion.depend_on_external_modules import (
+    gather_depend_on_external_module_violations,
+)
 from archunitpython.files.assertion.depend_on_files import gather_depend_on_file_violations
 from archunitpython.files.assertion.matching_files import gather_regex_matching_violations
 
@@ -133,6 +139,14 @@ class PositiveMatchPatternFileConditionBuilder:
             self._project_path, self._filters, is_negated=False
         )
 
+    def depend_on_external_modules(
+        self,
+    ) -> "DependOnExternalModuleConditionBuilder":
+        """Begin external dependency assertion for module names."""
+        return DependOnExternalModuleConditionBuilder(
+            self._project_path, self._filters, is_negated=False
+        )
+
     def be_in_folder(self, folder: Pattern) -> "MatchPatternFileCondition":
         """Assert that files are in a certain folder."""
         return MatchPatternFileCondition(
@@ -182,6 +196,14 @@ class NegatedMatchPatternFileConditionBuilder:
             self._project_path, self._filters, is_negated=True
         )
 
+    def depend_on_external_modules(
+        self,
+    ) -> "DependOnExternalModuleConditionBuilder":
+        """Begin negative external dependency assertion for module names."""
+        return DependOnExternalModuleConditionBuilder(
+            self._project_path, self._filters, is_negated=True
+        )
+
     def be_in_folder(self, folder: Pattern) -> "MatchPatternFileCondition":
         """Assert that files are NOT in a certain folder."""
         return MatchPatternFileCondition(
@@ -260,6 +282,31 @@ class DependOnFileConditionBuilder:
         )
 
 
+class DependOnExternalModuleConditionBuilder:
+    """Configure external module dependency target patterns."""
+
+    def __init__(
+        self, project_path: str | None, filters: list[Filter], is_negated: bool
+    ) -> None:
+        self._project_path = project_path
+        self._filters = filters
+        self._is_negated = is_negated
+        self._module_filters: list[Filter] = []
+
+    def matching(self, module_name: Pattern) -> "DependOnExternalModuleCondition":
+        """Target external modules by dotted module name pattern.
+
+        Multiple calls are combined with OR semantics.
+        """
+        self._module_filters.append(RegexFactory.path_matcher(module_name))
+        return DependOnExternalModuleCondition(
+            self._project_path,
+            self._filters,
+            list(self._module_filters),
+            self._is_negated,
+        )
+
+
 def _get_filtered_nodes(
     project_path: str | None,
     filters: list[Filter],
@@ -346,6 +393,38 @@ class DependOnFileCondition:
         )
 
 
+class DependOnExternalModuleCondition:
+    """Checkable that verifies external module dependency rules."""
+
+    def __init__(
+        self,
+        project_path: str | None,
+        subject_filters: list[Filter],
+        module_filters: list[Filter],
+        is_negated: bool,
+    ) -> None:
+        self._project_path = project_path
+        self._subject_filters = subject_filters
+        self._module_filters = module_filters
+        self._is_negated = is_negated
+
+    def matching(self, module_name: Pattern) -> "DependOnExternalModuleCondition":
+        """Add another external module pattern using OR semantics."""
+        self._module_filters.append(RegexFactory.path_matcher(module_name))
+        return self
+
+    def check(self, options: CheckOptions | None = None) -> list[Violation]:
+        graph = extract_graph(self._project_path, options=options)
+        edges = project_edges(graph, per_external_edge())
+
+        return gather_depend_on_external_module_violations(
+            edges,
+            self._subject_filters,
+            self._module_filters,
+            self._is_negated,
+        )
+
+
 class MatchPatternFileCondition:
     """Checkable that verifies files match/don't match patterns."""
 

{archunitpython-1.0.1 → archunitpython-1.1.1}/src/archunitpython/testing/common/violation_factory.py

@@ -7,6 +7,9 @@ from dataclasses import dataclass
 from archunitpython.common.assertion.violation import EmptyTestViolation, Violation
 from archunitpython.files.assertion.custom_file_logic import CustomFileViolation
 from archunitpython.files.assertion.cycle_free import ViolatingCycle
+from archunitpython.files.assertion.depend_on_external_modules import (
+    ViolatingExternalModuleDependency,
+)
 from archunitpython.files.assertion.depend_on_files import ViolatingFileDependency
 from archunitpython.files.assertion.matching_files import ViolatingNode
 from archunitpython.metrics.assertion.metric_thresholds import (
@@ -52,6 +55,15 @@ class ViolationFactory:
                 f"'{edge.target_label}'",
             )
 
+        if isinstance(violation, ViolatingExternalModuleDependency):
+            edge = violation.dependency
+            return TestViolation(
+                message="External module dependency violation",
+                details=f"'{edge.source_label}' "
+                f"{'depends on' if violation.is_negated else 'does not depend on'} "
+                f"external module '{edge.target_label}'",
+            )
+
         if isinstance(violation, ViolatingCycle):
             cycle_str = " -> ".join(
                 e.source_label for e in violation.cycle

{archunitpython-1.0.1 → archunitpython-1.1.1}/tests/common/test_core_types.py

@@ -101,6 +101,7 @@ class TestCheckOptions:
         assert opts.allow_empty_tests is False
         assert opts.logging is None
         assert opts.clear_cache is False
+        assert opts.ignore_type_checking_imports is False
 
     def test_custom(self):
         logging = LoggingOptions(enabled=True, level="debug")
@@ -108,12 +109,14 @@ class TestCheckOptions:
             allow_empty_tests=True,
             logging=logging,
             clear_cache=True,
+            ignore_type_checking_imports=True,
         )
         assert opts.allow_empty_tests is True
         assert opts.logging is not None
         assert opts.logging.enabled is True
         assert opts.logging.level == "debug"
         assert opts.clear_cache is True
+        assert opts.ignore_type_checking_imports is True
 
 
 class TestLoggingOptions: