archunitpython 1.1.2__py3-none-any.whl → 1.2.1__py3-none-any.whl

archunitpython/layers/__init__.py

@@ -0,0 +1,8 @@
+"""Layer-level architecture rules."""
+
+from archunitpython.layers.fluentapi.layers import layers, project_layers
+
+__all__ = [
+    "layers",
+    "project_layers",
+]

archunitpython/layers/assertion/__init__.py

@@ -0,0 +1,9 @@
+from archunitpython.layers.assertion.layer_dependencies import (
+    LayerDependencyViolation,
+    gather_layer_dependency_violations,
+)
+
+__all__ = [
+    "LayerDependencyViolation",
+    "gather_layer_dependency_violations",
+]

archunitpython/layers/assertion/layer_dependencies.py

@@ -0,0 +1,83 @@
+"""Violation gathering for layer 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 LayerDependencyViolation(Violation):
+    """A dependency from one named layer to a disallowed named layer."""
+
+    dependency: ProjectedEdge
+    source_layer: str
+    target_layer: str
+    rule: str
+
+
+@dataclass(frozen=True)
+class LayerDefinition:
+    """A named architectural layer with one or more file filters."""
+
+    name: str
+    filters: tuple[Filter, ...]
+
+    def matches(self, file_path: str) -> bool:
+        return any(matches_pattern(file_path, filter_) for filter_ in self.filters)
+
+
+def gather_layer_dependency_violations(
+    edges: list[ProjectedEdge],
+    layers: list[LayerDefinition],
+    allowed_dependencies: dict[str, set[str]],
+    forbidden_dependencies: dict[str, set[str]],
+) -> list[Violation]:
+    """Check cross-layer dependencies against allowlist/blocklist rules."""
+    violations: list[Violation] = []
+
+    for edge in edges:
+        source_layer = _find_layer(edge.source_label, layers)
+        target_layer = _find_layer(edge.target_label, layers)
+
+        if source_layer is None or target_layer is None:
+            continue
+        if source_layer == target_layer:
+            continue
+
+        forbidden_targets = forbidden_dependencies.get(source_layer, set())
+        if target_layer in forbidden_targets:
+            violations.append(
+                LayerDependencyViolation(
+                    dependency=edge,
+                    source_layer=source_layer,
+                    target_layer=target_layer,
+                    rule="may_not_depend_on_layers",
+                )
+            )
+            continue
+
+        if source_layer in allowed_dependencies:
+            allowed_targets = allowed_dependencies[source_layer]
+            if target_layer not in allowed_targets:
+                violations.append(
+                    LayerDependencyViolation(
+                        dependency=edge,
+                        source_layer=source_layer,
+                        target_layer=target_layer,
+                        rule="may_only_depend_on_layers",
+                    )
+                )
+
+    return violations
+
+
+def _find_layer(file_path: str, layers: list[LayerDefinition]) -> str | None:
+    for layer in layers:
+        if layer.matches(file_path):
+            return layer.name
+    return None

archunitpython/layers/fluentapi/__init__.py

@@ -0,0 +1,6 @@
+from archunitpython.layers.fluentapi.layers import layers, project_layers
+
+__all__ = [
+    "layers",
+    "project_layers",
+]

archunitpython/layers/fluentapi/layers.py

@@ -0,0 +1,116 @@
+"""Fluent API builder chain for layer-level architecture rules."""
+
+from __future__ import annotations
+
+from archunitpython.common.assertion.violation import Violation
+from archunitpython.common.extraction.extract_graph import extract_graph
+from archunitpython.common.fluentapi.checkable import CheckOptions
+from archunitpython.common.projection.edge_projections import per_internal_edge
+from archunitpython.common.projection.project_edges import project_edges
+from archunitpython.common.regex_factory import RegexFactory
+from archunitpython.common.types import Filter, Pattern
+from archunitpython.layers.assertion.layer_dependencies import (
+    LayerDefinition,
+    gather_layer_dependency_violations,
+)
+
+
+def project_layers(project_path: str | None = None) -> "LayeredArchitecture":
+    """Entry point for layer-level architecture rules."""
+    return LayeredArchitecture(project_path)
+
+
+layers = project_layers
+
+
+class LayeredArchitecture:
+    """Builder and checkable for named layer dependency policies."""
+
+    def __init__(self, project_path: str | None = None) -> None:
+        self._project_path = project_path
+        self._layers: dict[str, list[Filter]] = {}
+        self._allowed_dependencies: dict[str, set[str]] = {}
+        self._forbidden_dependencies: dict[str, set[str]] = {}
+
+    def layer(self, name: str) -> "LayerDefinitionBuilder":
+        """Start defining a named layer."""
+        self._layers.setdefault(name, [])
+        return LayerDefinitionBuilder(self, name)
+
+    def where_layer(self, name: str) -> "LayerDependencyRuleBuilder":
+        """Start defining dependency rules for a named layer."""
+        self._layers.setdefault(name, [])
+        return LayerDependencyRuleBuilder(self, name)
+
+    def check(self, options: CheckOptions | None = None) -> list[Violation]:
+        graph = extract_graph(self._project_path, options=options)
+        edges = project_edges(graph, per_internal_edge())
+        layer_definitions = [
+            LayerDefinition(name=name, filters=tuple(filters))
+            for name, filters in self._layers.items()
+            if filters
+        ]
+
+        return gather_layer_dependency_violations(
+            edges,
+            layer_definitions,
+            self._allowed_dependencies,
+            self._forbidden_dependencies,
+        )
+
+    def _add_layer_filter(self, name: str, filter_: Filter) -> None:
+        self._layers.setdefault(name, []).append(filter_)
+
+    def _allow_only(self, source_layer: str, target_layers: tuple[str, ...]) -> None:
+        self._allowed_dependencies[source_layer] = set(target_layers)
+
+    def _forbid(self, source_layer: str, target_layers: tuple[str, ...]) -> None:
+        self._forbidden_dependencies.setdefault(source_layer, set()).update(target_layers)
+
+
+class LayerDefinitionBuilder:
+    """Configure the file patterns that make up one layer."""
+
+    def __init__(self, architecture: LayeredArchitecture, layer_name: str) -> None:
+        self._architecture = architecture
+        self._layer_name = layer_name
+
+    def defined_by(self, path: Pattern) -> LayeredArchitecture:
+        """Define this layer by a full path pattern."""
+        self._architecture._add_layer_filter(
+            self._layer_name,
+            RegexFactory.path_matcher(path),
+        )
+        return self._architecture
+
+    def defined_by_folder(self, folder: Pattern) -> LayeredArchitecture:
+        """Define this layer by a folder pattern."""
+        self._architecture._add_layer_filter(
+            self._layer_name,
+            RegexFactory.folder_matcher(folder),
+        )
+        return self._architecture
+
+
+class LayerDependencyRuleBuilder:
+    """Configure allowed or forbidden dependencies for one layer."""
+
+    def __init__(self, architecture: LayeredArchitecture, layer_name: str) -> None:
+        self._architecture = architecture
+        self._layer_name = layer_name
+
+    def may_only_depend_on_layers(
+        self,
+        *layer_names: str,
+    ) -> LayeredArchitecture:
+        """Allow this layer to depend only on the listed other layers."""
+        self._architecture._allow_only(self._layer_name, layer_names)
+        return self._architecture
+
+    def may_not_depend_on_layers(
+        self,
+        *layer_names: str,
+    ) -> LayeredArchitecture:
+        """Forbid this layer from depending on the listed other layers."""
+        self._architecture._forbid(self._layer_name, layer_names)
+        return self._architecture

archunitpython/metrics/assertion/metric_thresholds.py

@@ -31,9 +31,7 @@ class FileCountViolation(Violation):
     comparison: MetricComparison
 
 
-def check_threshold(
-    value: float, threshold: float, comparison: MetricComparison
-) -> bool:
+def check_threshold(value: float, threshold: float, comparison: MetricComparison) -> bool:
     """Check if a value violates a threshold.
 
     Returns True if the value is a VIOLATION.

archunitpython/metrics/calculation/distance.py

@@ -103,8 +103,6 @@ def calculate_distance_metrics_for_project(
         average_instability=sum(m.instability for m in metrics) / len(metrics),
         average_distance=sum(m.distance for m in metrics) / len(metrics),
         files_in_zone_of_pain=sum(1 for m in metrics if m.in_zone_of_pain),
-        files_in_zone_of_uselessness=sum(
-            1 for m in metrics if m.in_zone_of_uselessness
-        ),
+        files_in_zone_of_uselessness=sum(1 for m in metrics if m.in_zone_of_uselessness),
         total_files=len(files),
     )

archunitpython/metrics/extraction/extract_class_info.py

@@ -129,9 +129,7 @@ def _extract_class(node: ast.ClassDef, file_path: str) -> ClassInfo:
     for item in ast.walk(node):
         if isinstance(item, ast.Assign):
             for target in item.targets:
-                if isinstance(target, ast.Attribute) and isinstance(
-                    target.value, ast.Name
-                ):
+                if isinstance(target, ast.Attribute) and isinstance(target.value, ast.Name):
                     if target.value.id == "self":
                         field_name = target.attr
                         if field_name not in fields:
@@ -142,9 +140,7 @@ def _extract_class(node: ast.ClassDef, file_path: str) -> ClassInfo:
         if isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef)):
             method_name = item.name
             accessed = _find_field_accesses(item, set(fields.keys()))
-            methods.append(
-                MethodInfo(name=method_name, accessed_fields=accessed)
-            )
+            methods.append(MethodInfo(name=method_name, accessed_fields=accessed))
             # Update field access tracking
             for field_name in accessed:
                 if field_name in fields:
@@ -159,9 +155,7 @@ def _extract_class(node: ast.ClassDef, file_path: str) -> ClassInfo:
     )
 
 
-def _extract_enhanced_class(
-    node: ast.ClassDef, file_path: str
-) -> EnhancedClassInfo:
+def _extract_enhanced_class(node: ast.ClassDef, file_path: str) -> EnhancedClassInfo:
     """Extract EnhancedClassInfo from a ClassDef AST node."""
     base = _extract_class(node, file_path)
 

archunitpython/metrics/fluentapi/export_utils.py

@@ -35,11 +35,7 @@ class MetricsExporter:
             HTML content as a string. Also writes to file if output_path specified.
         """
         opts = options or ExportOptions()
-        timestamp = (
-            datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-            if opts.include_timestamp
-            else ""
-        )
+        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") if opts.include_timestamp else ""
 
         css = opts.custom_css or _DEFAULT_CSS
 
@@ -55,7 +51,7 @@ class MetricsExporter:
 </head>
 <body>
   <h1>{opts.title}</h1>
-  {f'<p class="timestamp">Generated: {timestamp}</p>' if timestamp else ''}
+  {f'<p class="timestamp">Generated: {timestamp}</p>' if timestamp else ""}
   <table>
     <thead>
       <tr><th>Metric</th><th>Value</th></tr>

archunitpython/metrics/fluentapi/metrics.py

@@ -97,9 +97,7 @@ class MetricsBuilder:
         )
 
 
-def _get_filtered_classes(
-    project_path: str | None, filters: list[Filter]
-) -> list[ClassInfo]:
+def _get_filtered_classes(project_path: str | None, filters: list[Filter]) -> list[ClassInfo]:
     classes = extract_class_info(project_path)
     if not filters:
         return classes
@@ -119,39 +117,25 @@ class CountMetricsBuilder:
         self._filters = filters
 
     def method_count(self) -> "ClassMetricThresholdBuilder":
-        return ClassMetricThresholdBuilder(
-            self._project_path, self._filters, MethodCountMetric()
-        )
+        return ClassMetricThresholdBuilder(self._project_path, self._filters, MethodCountMetric())
 
     def field_count(self) -> "ClassMetricThresholdBuilder":
-        return ClassMetricThresholdBuilder(
-            self._project_path, self._filters, FieldCountMetric()
-        )
+        return ClassMetricThresholdBuilder(self._project_path, self._filters, FieldCountMetric())
 
     def lines_of_code(self) -> "FileMetricThresholdBuilder":
-        return FileMetricThresholdBuilder(
-            self._project_path, self._filters, LinesOfCodeMetric()
-        )
+        return FileMetricThresholdBuilder(self._project_path, self._filters, LinesOfCodeMetric())
 
     def statements(self) -> "FileMetricThresholdBuilder":
-        return FileMetricThresholdBuilder(
-            self._project_path, self._filters, StatementCountMetric()
-        )
+        return FileMetricThresholdBuilder(self._project_path, self._filters, StatementCountMetric())
 
     def imports(self) -> "FileMetricThresholdBuilder":
-        return FileMetricThresholdBuilder(
-            self._project_path, self._filters, ImportCountMetric()
-        )
+        return FileMetricThresholdBuilder(self._project_path, self._filters, ImportCountMetric())
 
     def classes(self) -> "FileMetricThresholdBuilder":
-        return FileMetricThresholdBuilder(
-            self._project_path, self._filters, ClassCountMetric()
-        )
+        return FileMetricThresholdBuilder(self._project_path, self._filters, ClassCountMetric())
 
     def functions(self) -> "FileMetricThresholdBuilder":
-        return FileMetricThresholdBuilder(
-            self._project_path, self._filters, FunctionCountMetric()
-        )
+        return FileMetricThresholdBuilder(self._project_path, self._filters, FunctionCountMetric())
 
 
 class ClassMetricThresholdBuilder:
@@ -340,19 +324,13 @@ class DistanceMetricsBuilder:
         self._filters = filters
 
     def abstractness(self) -> "DistanceThresholdBuilder":
-        return DistanceThresholdBuilder(
-            self._project_path, self._filters, "abstractness"
-        )
+        return DistanceThresholdBuilder(self._project_path, self._filters, "abstractness")
 
     def instability(self) -> "DistanceThresholdBuilder":
-        return DistanceThresholdBuilder(
-            self._project_path, self._filters, "instability"
-        )
+        return DistanceThresholdBuilder(self._project_path, self._filters, "instability")
 
     def distance_from_main_sequence(self) -> "DistanceThresholdBuilder":
-        return DistanceThresholdBuilder(
-            self._project_path, self._filters, "distance"
-        )
+        return DistanceThresholdBuilder(self._project_path, self._filters, "distance")
 
     def not_in_zone_of_pain(self) -> "ZoneCondition":
         return ZoneCondition(self._project_path, self._filters, "pain")
@@ -440,11 +418,7 @@ class ZoneCondition:
 
         for file_result in files:
             dm = calculate_file_distance_metrics(file_result, files)
-            in_zone = (
-                dm.in_zone_of_pain
-                if self._zone_type == "pain"
-                else dm.in_zone_of_uselessness
-            )
+            in_zone = dm.in_zone_of_pain if self._zone_type == "pain" else dm.in_zone_of_uselessness
 
             if in_zone:
                 violations.append(

archunitpython/slices/fluentapi/slices.py

@@ -61,15 +61,11 @@ class SliceConditionBuilder:
 
     def should(self) -> "PositiveConditionBuilder":
         """Begin positive assertion (slices SHOULD ...)."""
-        return PositiveConditionBuilder(
-            self._project_path, self._pattern, self._regex
-        )
+        return PositiveConditionBuilder(self._project_path, self._pattern, self._regex)
 
     def should_not(self) -> "NegativeConditionBuilder":
         """Begin negative assertion (slices SHOULD NOT ...)."""
-        return NegativeConditionBuilder(
-            self._project_path, self._pattern, self._regex
-        )
+        return NegativeConditionBuilder(self._project_path, self._pattern, self._regex)
 
 
 class PositiveConditionBuilder:
@@ -133,9 +129,7 @@ class NegativeConditionBuilder:
         self._regex = regex
         self._forbidden_deps: list[tuple[str, str]] = []
 
-    def contain_dependency(
-        self, source: str, target: str
-    ) -> "NegativeSliceCondition":
+    def contain_dependency(self, source: str, target: str) -> "NegativeSliceCondition":
         """Assert that a specific dependency should NOT exist."""
         return NegativeSliceCondition(
             self._project_path,
@@ -170,9 +164,7 @@ class PositiveSliceCondition:
         mapper = self._get_mapper()
         edges = project_edges(graph, mapper)
 
-        return gather_positive_violations(
-            edges, rules, contained_nodes, self._coherence_options
-        )
+        return gather_positive_violations(edges, rules, contained_nodes, self._coherence_options)
 
     def _get_mapper(self) -> MapFunction:
         if self._pattern:

archunitpython/slices/uml/generate_rules.py

@@ -43,9 +43,7 @@ def generate_rule(puml_content: str) -> tuple[list[Rule], list[str]]:
             continue
 
         # Match component declarations: component [Name] or component [Name] #Color
-        comp_match = re.match(
-            r"component\s+\[([^\]]+)\]", stripped
-        )
+        comp_match = re.match(r"component\s+\[([^\]]+)\]", stripped)
         if comp_match:
             name = comp_match.group(1).strip()
             if name not in contained_nodes:
@@ -53,9 +51,7 @@ def generate_rule(puml_content: str) -> tuple[list[Rule], list[str]]:
             continue
 
         # Match relationships: [Source] --> [Target] or [Source] -> [Target]
-        rel_match = re.match(
-            r"\[([^\]]+)\]\s*-+>\s*\[([^\]]+)\]", stripped
-        )
+        rel_match = re.match(r"\[([^\]]+)\]\s*-+>\s*\[([^\]]+)\]", stripped)
         if rel_match:
             source = rel_match.group(1).strip()
             target = rel_match.group(2).strip()

archunitpython/testing/common/violation_factory.py

@@ -12,6 +12,7 @@ from archunitpython.files.assertion.depend_on_external_modules import (
 )
 from archunitpython.files.assertion.depend_on_files import ViolatingFileDependency
 from archunitpython.files.assertion.matching_files import ViolatingNode
+from archunitpython.layers.assertion.layer_dependencies import LayerDependencyViolation
 from archunitpython.metrics.assertion.metric_thresholds import (
     FileCountViolation,
     MetricViolation,
@@ -65,9 +66,7 @@ class ViolationFactory:
             )
 
         if isinstance(violation, ViolatingCycle):
-            cycle_str = " -> ".join(
-                e.source_label for e in violation.cycle
-            )
+            cycle_str = " -> ".join(e.source_label for e in violation.cycle)
             return TestViolation(
                 message="Circular dependency detected",
                 details=f"Cycle: {cycle_str}",
@@ -79,6 +78,15 @@ class ViolationFactory:
                 details=f"File: {violation.file_info.path}",
             )
 
+        if isinstance(violation, LayerDependencyViolation):
+            edge = violation.dependency
+            return TestViolation(
+                message="Layer dependency violation",
+                details=f"Layer '{violation.source_layer}' depends on "
+                f"disallowed layer '{violation.target_layer}' via "
+                f"'{edge.source_label}' -> '{edge.target_label}'",
+            )
+
         if isinstance(violation, MetricViolation):
             return TestViolation(
                 message=f"Metric '{violation.metric_name}' violation",