archunitpython 1.6.1__py3-none-any.whl → 1.8.0__py3-none-any.whl

archunitpython/__init__.py

@@ -1,12 +1,13 @@
 """ArchUnitPython - Architecture testing library for Python projects."""
 
-__version__ = "1.6.1"
+__version__ = "1.8.0"
 
 # Files API
 # Common
 from archunitpython.common import (
     CheckOptions,
     EmptyTestViolation,
+    LoggingOptions,
     TechnicalError,
     UserError,
     Violation,
@@ -50,6 +51,7 @@ __all__ = [
     "Violation",
     "EmptyTestViolation",
     "CheckOptions",
+    "LoggingOptions",
     "TechnicalError",
     "UserError",
     "extract_graph",

archunitpython/common/extraction/extract_graph.py

@@ -9,6 +9,7 @@ from dataclasses import dataclass
 
 from archunitpython.common.extraction.graph import Edge, Graph, ImportKind
 from archunitpython.common.fluentapi.checkable import CheckOptions
+from archunitpython.common.logging.inspection import debug, debug_enabled
 
 GraphCacheKey = tuple[str, tuple[str, ...], bool]
 
@@ -45,6 +46,7 @@ class _LocatedImport:
     line_number: int
     resolution_kind: ImportKind | None = None
     fallback_module_name: str | None = None
+    aliases: tuple[str, ...] = ()
 
 
 @dataclass(frozen=True)
@@ -56,8 +58,7 @@ class _IgnoreDirective:
         if not self.modules:
             return True
         return any(
-            import_.module_name == module
-            or import_.module_name.startswith(f"{module}.")
+            import_.module_name == module or import_.module_name.startswith(f"{module}.")
             for module in self.modules
         )
 
@@ -96,21 +97,46 @@ def extract_graph(
     ignore_type_checking_imports = bool(options and options.ignore_type_checking_imports)
     cache_key = _build_cache_key(project_path, excludes, ignore_type_checking_imports)
 
+    debug(
+        "Extraction root: %s; excludes: %s; ignore type-only imports: %s",
+        project_path,
+        excludes,
+        ignore_type_checking_imports,
+    )
     if options and options.clear_cache:
+        debug("Clearing graph cache for %s", project_path)
         _graph_cache.pop(cache_key, None)
 
     if cache_key in _graph_cache:
+        debug("Graph cache hit: %d edges", len(_graph_cache[cache_key]))
+        _inspect_graph(_graph_cache[cache_key])
         return _graph_cache[cache_key]
+    debug("Graph cache miss")
 
     result = _extract_graph_uncached(
         project_path,
         excludes,
         ignore_type_checking_imports=ignore_type_checking_imports,
     )
+    _inspect_graph(result)
     _graph_cache[cache_key] = result
     return result
 
 
+def _inspect_graph(graph: Graph) -> None:
+    if not debug_enabled():
+        return
+    debug("Extracted graph: %d edges (including self-edges)", len(graph))
+    for edge in graph:
+        debug(
+            "Dependency: %s -> %s; external=%s; kinds=%s",
+            edge.source,
+            edge.target,
+            edge.external,
+            edge.import_kinds,
+        )
+
+
 def _build_cache_key(
     project_path: str,
     exclude_patterns: list[str],
@@ -166,6 +192,7 @@ def _extract_graph_uncached(
     normalized_py_file_set = {_normalize(f) for f in py_files_set}
 
     for file_path in py_files:
+        debug("Processing file: %s", file_path)
         # Add self-referencing edge (ensures the file appears as a node)
         edges.append(
             Edge(
@@ -177,39 +204,32 @@ def _extract_graph_uncached(
 
         imports = _extract_located_imports(file_path)
         for located_import in imports:
-            module_name = located_import.module_name
             import_kind = located_import.import_kind
-            if (
-                ignore_type_checking_imports
-                and import_kind == ImportKind.TYPE_IMPORT
-            ):
-                continue
-            resolution_kind = located_import.resolution_kind or import_kind
-            resolved, is_external = _resolve_import(
-                module_name, file_path, project_path, resolution_kind
-            )
-            if is_external and located_import.fallback_module_name is not None:
-                fallback, fallback_is_external = _resolve_import(
-                    located_import.fallback_module_name,
+            if ignore_type_checking_imports and import_kind == ImportKind.TYPE_IMPORT:
+                debug(
+                    "Skipped type-only import: %s:%s -> %s",
                     file_path,
-                    project_path,
-                    resolution_kind,
+                    located_import.line_number,
+                    located_import.module_name,
                 )
-                if fallback and not fallback_is_external:
-                    resolved, is_external = fallback, False
-            if resolved and resolved != _normalize(file_path):
-                # Check if the resolved path is in our project
-                if not is_external and resolved not in normalized_py_file_set:
-                    continue
-
-                edges.append(
-                    Edge(
-                        source=_normalize(file_path),
-                        target=resolved,
-                        external=is_external,
-                        import_kinds=_edge_import_kinds(located_import),
+                continue
+            for resolved, is_external in _resolve_import_targets(
+                located_import, file_path, project_path
+            ):
+                if resolved and resolved != _normalize(file_path):
+                    # Check if the resolved path is in our project
+                    if not is_external and resolved not in normalized_py_file_set:
+                        debug("Skipped excluded dependency: %s -> %s", file_path, resolved)
+                        continue
+
+                    edges.append(
+                        Edge(
+                            source=_normalize(file_path),
+                            target=resolved,
+                            external=is_external,
+                            import_kinds=_edge_import_kinds(located_import),
+                        )
                     )
-                )
 
     return _merge_edges(edges)
 
@@ -237,6 +257,7 @@ def _find_python_files(root: str, exclude: list[str]) -> list[str]:
                 full_path, root, exclude, is_dir=False
             ):
                 py_files.append(os.path.abspath(full_path))
+                debug("Discovered file: %s", full_path)
 
     return py_files
 
@@ -323,9 +344,7 @@ def _extract_located_imports(file_path: str) -> list[_LocatedImport]:
                 conditional_import_ranges,
             )
             for alias in node.names:
-                imports.append(
-                    _LocatedImport(alias.name, kind, node.lineno, syntax_kind)
-                )
+                imports.append(_LocatedImport(alias.name, kind, node.lineno, syntax_kind))
 
         elif isinstance(node, ast.ImportFrom):
             syntax_kind = (
@@ -339,17 +358,17 @@ def _extract_located_imports(file_path: str) -> list[_LocatedImport]:
                 type_checking_ranges,
                 conditional_import_ranges,
             )
-            fallback_module_name = (
-                "." * node.level if node.level and node.module is None else None
-            )
+            fallback_module_name = "." * node.level if node.level and node.module is None else None
+            aliases = _module_aliases(node) if node.module else ()
             for module_name in _import_from_module_names(node):
                 imports.append(
                     _LocatedImport(
-                        module_name,
-                        kind,
-                        node.lineno,
-                        syntax_kind,
-                        fallback_module_name,
+                        module_name=module_name,
+                        import_kind=kind,
+                        line_number=node.lineno,
+                        resolution_kind=syntax_kind,
+                        fallback_module_name=fallback_module_name,
+                        aliases=aliases,
                     )
                 )
 
@@ -362,15 +381,9 @@ def _extract_located_imports(file_path: str) -> list[_LocatedImport]:
                 conditional_import_ranges,
             )
             for module_name in _extract_dynamic_import_names(node):
-                imports.append(
-                    _LocatedImport(module_name, kind, node.lineno, syntax_kind)
-                )
+                imports.append(_LocatedImport(module_name, kind, node.lineno, syntax_kind))
 
-    return [
-        import_
-        for import_ in imports
-        if not _is_ignored_import(import_, ignore_directives)
-    ]
+    return [import_ for import_ in imports if not _is_ignored_import(import_, ignore_directives)]
 
 
 def _find_ignore_directives(source: str) -> dict[int, _IgnoreDirective]:
@@ -429,6 +442,11 @@ def _extract_dynamic_import_names(node: ast.Call) -> list[str]:
     return []
 
 
+def _module_aliases(node: ast.ImportFrom) -> tuple[str, ...]:
+    """Return aliases that may refer to imported submodules."""
+    return tuple(alias.name for alias in node.names if alias.name != "*")
+
+
 def _import_from_module_names(node: ast.ImportFrom) -> tuple[str, ...]:
     """Return resolvable module names for a from-import statement."""
     dots = "." * (node.level or 0)
@@ -558,14 +576,10 @@ def _resolve_import(
     Returns (resolved_path, is_external).
     The path is normalized with forward slashes.
     """
-    if (
-        kind
-        in (
-            ImportKind.RELATIVE_IMPORT,
-            ImportKind.TYPE_IMPORT,
-        )
-        and import_name.startswith(".")
-    ):
+    if kind in (
+        ImportKind.RELATIVE_IMPORT,
+        ImportKind.TYPE_IMPORT,
+    ) and import_name.startswith("."):
         # Relative import
         return _resolve_relative_import(import_name, source_file, project_root)
 
@@ -573,6 +587,58 @@ def _resolve_import(
     return _resolve_absolute_import(import_name, project_root)
 
 
+def _resolve_import_targets(
+    import_: _LocatedImport,
+    source_file: str,
+    project_root: str,
+) -> list[tuple[str, bool]]:
+    """Resolve an import, including namespace-package submodule aliases."""
+    resolution_kind = import_.resolution_kind or import_.import_kind
+    resolved, is_external = _resolve_import(
+        import_.module_name,
+        source_file,
+        project_root,
+        resolution_kind,
+    )
+    if is_external and import_.fallback_module_name is not None:
+        fallback, fallback_is_external = _resolve_import(
+            import_.fallback_module_name,
+            source_file,
+            project_root,
+            resolution_kind,
+        )
+        if fallback and not fallback_is_external:
+            resolved, is_external = fallback, False
+    if not is_external or not import_.aliases:
+        return [(resolved, is_external)]
+
+    alias_targets: list[tuple[str, bool]] = []
+    found_internal_alias = False
+    for alias in import_.aliases:
+        alias_module = _join_import_alias(import_.module_name, alias)
+        alias_resolved, alias_is_external = _resolve_import(
+            alias_module,
+            source_file,
+            project_root,
+            resolution_kind,
+        )
+        alias_targets.append((alias_resolved, alias_is_external))
+        found_internal_alias = found_internal_alias or not alias_is_external
+
+    if found_internal_alias:
+        return alias_targets
+    return [(resolved, is_external)]
+
+
+def _join_import_alias(module_name: str, alias: str) -> str:
+    """Join a from-import module name with a candidate submodule alias."""
+    if not module_name:
+        return alias
+    if set(module_name) == {"."}:
+        return f"{module_name}{alias}"
+    return f"{module_name}.{alias}"
+
+
 def _resolve_relative_import(
     import_name: str,
     source_file: str,

archunitpython/common/fluentapi/inspection.py

@@ -0,0 +1,79 @@
+"""Observational instrumentation for the existing check contract."""
+
+from __future__ import annotations
+
+from functools import wraps
+from time import perf_counter
+from typing import Callable, TypeVar, cast
+
+from archunitpython.common.assertion.violation import Violation
+from archunitpython.common.fluentapi.checkable import CheckOptions
+from archunitpython.common.logging.inspection import InspectionSession, current_session
+
+F = TypeVar("F", bound=Callable[..., list[Violation]])
+
+
+def inspect_check(check: F) -> F:
+    """Trace a check while preserving its options, results, and exceptions."""
+
+    @wraps(check)
+    def inspected(self: object, options: CheckOptions | None = None) -> list[Violation]:
+        logging_options = options.logging if options else None
+        session = (
+            InspectionSession(logging_options)
+            if logging_options and logging_options.enabled
+            else None
+        )
+        token = current_session.set(session)
+        started = perf_counter() if session else 0.0
+        rule_name = type(self).__name__
+        try:
+            if session:
+                session.emit("info", "Starting check: %s", rule_name)
+                # Describe only known rule configuration, never user callbacks.
+                for name in (
+                    "_project_path",
+                    "_filters",
+                    "_subject_filters",
+                    "_object_filters",
+                    "_module_filters",
+                    "_pre_filters",
+                    "_check_filters",
+                    "_is_negated",
+                    "_pattern",
+                    "_regex",
+                    "_source",
+                    "_target",
+                    "_layers",
+                    "_allowed_dependencies",
+                    "_forbidden_dependencies",
+                    "_threshold",
+                    "_comparison",
+                    "_metric_attr",
+                    "_name",
+                    "_zone_type",
+                ):
+                    if session.options.level == "debug" and name in vars(self):
+                        session.emit("debug", "%s: %s", name.removeprefix("_"), vars(self)[name])
+            violations = check(self, options)
+            if session:
+                session.emit(
+                    "warn" if violations else "info",
+                    "Finished check: %s - %d violation(s) (%.3fs)",
+                    rule_name,
+                    len(violations),
+                    perf_counter() - started,
+                )
+                for violation in violations:
+                    session.emit("warn", "Violation: %s", violation)
+            return violations
+        except Exception as error:
+            if session:
+                session.emit("error", "Check failed: %s - %s", rule_name, error)
+            raise
+        finally:
+            current_session.reset(token)
+            if session:
+                session.close()
+
+    return cast(F, inspected)

archunitpython/common/logging/inspection.py

@@ -0,0 +1,99 @@
+"""Per-check diagnostic sessions, isolated from architecture evaluation."""
+
+from __future__ import annotations
+
+import logging
+import sys
+from contextvars import ContextVar
+from datetime import datetime
+from pathlib import Path
+from typing import TextIO
+from uuid import uuid4
+
+from archunitpython.common.logging.types import LoggingOptions
+
+_LEVELS = {
+    "debug": logging.DEBUG,
+    "info": logging.INFO,
+    "warn": logging.WARNING,
+    "error": logging.ERROR,
+}
+
+
+class InspectionSession:
+    """Own a check's output without attaching process-wide logging handlers.
+
+    Diagnostics are best effort: formatting and output errors must never replace
+    a rule result or an exception raised by the analysis itself.
+    """
+
+    def __init__(self, options: LoggingOptions) -> None:
+        self.options = options
+        self._file: TextIO | None = None
+        self._file_attempted = False
+
+    def emit(self, level: str, message: str, *args: object) -> None:
+        if _LEVELS[level] < _LEVELS.get(self.options.level, logging.INFO):
+            return
+        try:
+            text = message % args if args else message
+        except Exception:
+            return
+        if self.options.console:
+            try:
+                logger = logging.getLogger("archunitpython")
+                if logger.hasHandlers():
+                    logger.log(_LEVELS[level], text)
+                else:
+                    sys.stderr.write(f"[{level.upper()}] {text}\n")
+            except Exception:
+                pass
+        if self.options.log_file:
+            try:
+                if not self._file_attempted:
+                    self._file_attempted = True
+                    path = (
+                        Path(self.options.log_path)
+                        if self.options.log_path
+                        else Path("logs")
+                        / (
+                            datetime.now().strftime("archunit-%Y-%m-%d_%H-%M-%S-")
+                            + uuid4().hex
+                            + ".log"
+                        )
+                    )
+                    path.parent.mkdir(parents=True, exist_ok=True)
+                    self._file = path.open(
+                        "a" if self.options.append_to_log_file else "w", encoding="utf-8"
+                    )
+                if self._file is not None:
+                    self._file.write(f"[{datetime.now().isoformat()}] [{level.upper()}] {text}\n")
+                    self._file.flush()
+            except Exception:
+                self.close()
+
+    def close(self) -> None:
+        if self._file is not None:
+            try:
+                self._file.close()
+            except Exception:
+                pass
+            self._file = None
+
+
+current_session: ContextVar[InspectionSession | None] = ContextVar(
+    "archunitpython_inspection", default=None
+)
+
+
+def debug(message: str, *args: object) -> None:
+    """Lazily emit details only inside an enabled debug check."""
+    session = current_session.get()
+    if session is not None:
+        session.emit("debug", message, *args)
+
+
+def debug_enabled() -> bool:
+    """Guard expensive diagnostic traversal before constructing its details."""
+    session = current_session.get()
+    return session is not None and session.options.level == "debug"

archunitpython/common/logging/types.py

@@ -16,3 +16,5 @@ class LoggingOptions:
     level: LogLevel = "info"
     log_file: bool = False
     append_to_log_file: bool = False
+    console: bool = True
+    log_path: str | None = None

archunitpython/common/pattern_matching.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from archunitpython.common.logging.inspection import debug
 from archunitpython.common.types import Filter
 
 
@@ -47,7 +48,9 @@ def matches_pattern(file_path: str, filter_: Filter) -> bool:
     else:
         target_string = normalize_path(file_path)
 
-    return bool(filter_.regexp.search(target_string))
+    matched = bool(filter_.regexp.search(target_string))
+    debug("Selector %s against %s (%s): %s", filter_.regexp.pattern, target_string, target, matched)
+    return matched
 
 
 def matches_pattern_classname(class_name: str, file_path: str, filter_: Filter) -> bool:
@@ -65,7 +68,9 @@ def matches_pattern_classname(class_name: str, file_path: str, filter_: Filter)
     else:
         target_string = normalize_path(file_path)
 
-    return bool(filter_.regexp.search(target_string))
+    matched = bool(filter_.regexp.search(target_string))
+    debug("Selector %s against %s (%s): %s", filter_.regexp.pattern, target_string, target, matched)
+    return matched
 
 
 def matches_all_patterns(file_path: str, filters: list[Filter]) -> bool:

archunitpython/common/projection/project_edges.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from collections import defaultdict
 
 from archunitpython.common.extraction.graph import Edge
+from archunitpython.common.logging.inspection import debug
 from archunitpython.common.projection.types import MapFunction, ProjectedEdge
 
 
@@ -29,11 +30,19 @@ def project_edges(
     for edge in graph:
         mapped = mapper(edge)
         if mapped is None:
+            debug("Projection omitted: %s -> %s", edge.source, edge.target)
             continue
+        debug(
+            "Projection: %s -> %s becomes %s -> %s",
+            edge.source,
+            edge.target,
+            mapped.source_label,
+            mapped.target_label,
+        )
         key = (mapped.source_label, mapped.target_label)
         groups[key].append(edge)
 
-    return [
+    projected = [
         ProjectedEdge(
             source_label=source_label,
             target_label=target_label,
@@ -41,3 +50,5 @@ def project_edges(
         )
         for (source_label, target_label), edges in groups.items()
     ]
+    debug("Projection complete: %d raw edges -> %d projected edges", len(graph), len(projected))
+    return projected

archunitpython/files/fluentapi/files.py

@@ -15,6 +15,7 @@ from collections.abc import Sequence
 from archunitpython.common.assertion.violation import EmptyTestViolation, Violation
 from archunitpython.common.extraction.extract_graph import extract_graph
 from archunitpython.common.fluentapi.checkable import CheckOptions, RuleRationaleMixin
+from archunitpython.common.fluentapi.inspection import inspect_check
 from archunitpython.common.pattern_matching import matches_all_patterns
 from archunitpython.common.projection.edge_projections import (
     per_external_edge,
@@ -329,6 +330,7 @@ class CycleFreeFileCondition(RuleRationaleMixin):
         self._project_path = project_path
         self._filters = filters
 
+    @inspect_check
     def check(self, options: CheckOptions | None = None) -> list[Violation]:
         graph = extract_graph(self._project_path, options=options)
         edges = project_edges(graph, per_internal_edge())
@@ -365,6 +367,7 @@ class DependOnFileCondition(RuleRationaleMixin):
         self._object_filters = object_filters
         self._is_negated = is_negated
 
+    @inspect_check
     def check(self, options: CheckOptions | None = None) -> list[Violation]:
         graph = extract_graph(self._project_path, options=options)
         edges = project_edges(graph, per_internal_edge())
@@ -397,6 +400,7 @@ class DependOnExternalModuleCondition(RuleRationaleMixin):
         self._module_filters.append(RegexFactory.path_matcher(module_name))
         return self
 
+    @inspect_check
     def check(self, options: CheckOptions | None = None) -> list[Violation]:
         graph = extract_graph(self._project_path, options=options)
         edges = project_edges(graph, per_external_edge())
@@ -424,6 +428,7 @@ class MatchPatternFileCondition(RuleRationaleMixin):
         self._check_filters = check_filters
         self._is_negated = is_negated
 
+    @inspect_check
     def check(self, options: CheckOptions | None = None) -> list[Violation]:
         nodes = _get_filtered_nodes(self._project_path, self._pre_filters, options)
 
@@ -451,6 +456,7 @@ class CustomFileCheckableCondition(RuleRationaleMixin):
         self._message = message
         self._is_negated = is_negated
 
+    @inspect_check
     def check(self, options: CheckOptions | None = None) -> list[Violation]:
         graph = extract_graph(self._project_path, options=options)
         nodes = project_to_nodes(graph)

archunitpython/layers/fluentapi/layers.py

@@ -5,6 +5,7 @@ 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.fluentapi.inspection import inspect_check
 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
@@ -42,6 +43,7 @@ class LayeredArchitecture:
         self._layers.setdefault(name, [])
         return LayerDependencyRuleBuilder(self, name)
 
+    @inspect_check
     def check(self, options: CheckOptions | None = None) -> list[Violation]:
         graph = extract_graph(self._project_path, options=options)
         edges = project_edges(graph, per_internal_edge())

archunitpython/metrics/extraction/extract_class_info.py

@@ -9,6 +9,7 @@ from archunitpython.common.extraction.extract_graph import (
     _find_python_files,
     _resolve_exclude_patterns,
 )
+from archunitpython.common.logging.inspection import debug
 from archunitpython.metrics.common.types import (
     ClassInfo,
     EnhancedClassInfo,
@@ -41,6 +42,7 @@ def extract_class_info(
 
     classes: list[ClassInfo] = []
     for file_path in py_files:
+        debug("Analyzing classes in: %s", file_path)
         classes.extend(_process_source_file(file_path))
 
     return classes
@@ -61,6 +63,7 @@ def extract_enhanced_class_info(
 
     results: list[FileAnalysisResult] = []
     for file_path in py_files:
+        debug("Analyzing classes in: %s", file_path)
         result = _process_source_file_enhanced(file_path)
         if result.classes:
             results.append(result)
@@ -88,6 +91,13 @@ def _process_source_file(file_path: str) -> list[ClassInfo]:
         if isinstance(node, ast.ClassDef):
             class_info = _extract_class(node, norm_path)
             classes.append(class_info)
+            debug(
+                "Class: %s in %s; %d methods; %d fields",
+                class_info.name,
+                norm_path,
+                len(class_info.methods),
+                len(class_info.fields),
+            )
 
     return classes
 
@@ -112,6 +122,13 @@ def _process_source_file_enhanced(file_path: str) -> FileAnalysisResult:
         if isinstance(node, ast.ClassDef):
             enhanced = _extract_enhanced_class(node, norm_path)
             result.classes.append(enhanced)
+            debug(
+                "Enhanced class: %s in %s; abstract=%s; protocol=%s",
+                enhanced.name,
+                norm_path,
+                enhanced.is_abstract,
+                enhanced.is_protocol,
+            )
             result.total_types += 1
             if enhanced.is_protocol:
                 result.protocols += 1

archunitpython/metrics/fluentapi/metrics.py

@@ -12,6 +12,8 @@ from typing import Any, Callable
 
 from archunitpython.common.assertion.violation import Violation
 from archunitpython.common.fluentapi.checkable import CheckOptions, RuleRationaleMixin
+from archunitpython.common.fluentapi.inspection import inspect_check
+from archunitpython.common.logging.inspection import debug, debug_enabled
 from archunitpython.common.pattern_matching import matches_pattern_classname
 from archunitpython.common.regex_factory import RegexFactory
 from archunitpython.common.types import Filter, Pattern
@@ -97,6 +99,20 @@ class MetricsBuilder:
         )
 
 
+def _log_metric_value(
+    metric: Any, subject: str, value: float, threshold: float, comparison: MetricComparison
+) -> None:
+    if not debug_enabled():
+        return
+    try:
+        name = metric.name
+    except Exception:
+        name = type(metric).__name__
+    debug(
+        "Metric %s for %s: value=%s; threshold=%s (%s)", name, subject, value, threshold, comparison
+    )
+
+
 def _get_filtered_classes(project_path: str | None, filters: list[Filter]) -> list[ClassInfo]:
     classes = extract_class_info(project_path)
     if not filters:
@@ -187,12 +203,20 @@ class ClassMetricCondition(RuleRationaleMixin):
         self._threshold = threshold
         self._comparison = comparison
 
+    @inspect_check
     def check(self, options: CheckOptions | None = None) -> list[Violation]:
         classes = _get_filtered_classes(self._project_path, self._filters)
         violations: list[Violation] = []
 
         for cls in classes:
             value = self._metric.calculate(cls)
+            _log_metric_value(
+                self._metric,
+                cls.name,
+                value,
+                self._threshold,
+                self._comparison,
+            )
             if check_threshold(value, self._threshold, self._comparison):
                 violations.append(
                     MetricViolation(
@@ -247,6 +271,7 @@ class FileMetricCondition(RuleRationaleMixin):
         self._threshold = threshold
         self._comparison: MetricComparison = comparison
 
+    @inspect_check
     def check(self, options: CheckOptions | None = None) -> list[Violation]:
         import os
 
@@ -268,6 +293,13 @@ class FileMetricCondition(RuleRationaleMixin):
                 continue
 
             value = self._metric.calculate_from_file(file_path)
+            _log_metric_value(
+                self._metric,
+                file_path,
+                value,
+                self._threshold,
+                self._comparison,
+            )
             if check_threshold(value, self._threshold, self._comparison):
                 violations.append(
                     FileCountViolation(
@@ -381,6 +413,7 @@ class DistanceCondition(RuleRationaleMixin):
         self._threshold = threshold
         self._comparison: MetricComparison = comparison
 
+    @inspect_check
     def check(self, options: CheckOptions | None = None) -> list[Violation]:
         files = extract_enhanced_class_info(self._project_path)
         violations: list[Violation] = []
@@ -388,6 +421,14 @@ class DistanceCondition(RuleRationaleMixin):
         for file_result in files:
             dm = calculate_file_distance_metrics(file_result, files)
             value = getattr(dm, self._metric_attr)
+            debug(
+                "Metric %s for %s: value=%s; threshold=%s (%s)",
+                self._metric_attr,
+                file_result.file_path,
+                value,
+                self._threshold,
+                self._comparison,
+            )
 
             if check_threshold(value, self._threshold, self._comparison):
                 violations.append(
@@ -412,6 +453,7 @@ class ZoneCondition(RuleRationaleMixin):
         self._filters = filters
         self._zone_type = zone_type
 
+    @inspect_check
     def check(self, options: CheckOptions | None = None) -> list[Violation]:
         files = extract_enhanced_class_info(self._project_path)
         violations: list[Violation] = []
@@ -420,6 +462,7 @@ class ZoneCondition(RuleRationaleMixin):
             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
 
+            debug("Zone %s for %s: in_zone=%s", self._zone_type, file_result.file_path, in_zone)
             if in_zone:
                 violations.append(
                     MetricViolation(
@@ -504,12 +547,14 @@ class CustomMetricCondition(RuleRationaleMixin):
         self._threshold = threshold
         self._comparison = comparison
 
+    @inspect_check
     def check(self, options: CheckOptions | None = None) -> list[Violation]:
         classes = _get_filtered_classes(self._project_path, self._filters)
         violations: list[Violation] = []
 
         for cls in classes:
             value = self._calculation(cls)
+            debug("Custom metric %s for %s: value=%s", self._name, cls.name, value)
             if check_threshold(value, self._threshold, self._comparison):
                 violations.append(
                     MetricViolation(
@@ -542,12 +587,14 @@ class CustomAssertionCondition(RuleRationaleMixin):
         self._calculation = calculation
         self._assertion = assertion
 
+    @inspect_check
     def check(self, options: CheckOptions | None = None) -> list[Violation]:
         classes = _get_filtered_classes(self._project_path, self._filters)
         violations: list[Violation] = []
 
         for cls in classes:
             value = self._calculation(cls)
+            debug("Custom metric %s for %s: value=%s", self._name, cls.name, value)
             if not self._assertion(value, cls):
                 violations.append(
                     MetricViolation(

archunitpython/slices/fluentapi/slices.py

@@ -15,6 +15,7 @@ import re
 from archunitpython.common.assertion.violation import Violation
 from archunitpython.common.extraction.extract_graph import extract_graph
 from archunitpython.common.fluentapi.checkable import CheckOptions, RuleRationaleMixin
+from archunitpython.common.fluentapi.inspection import inspect_check
 from archunitpython.common.projection.project_edges import project_edges
 from archunitpython.common.projection.types import MapFunction
 from archunitpython.slices.assertion.admissible_edges import (
@@ -157,6 +158,7 @@ class PositiveSliceCondition(RuleRationaleMixin):
         self._puml_content = puml_content
         self._coherence_options = coherence_options
 
+    @inspect_check
     def check(self, options: CheckOptions | None = None) -> list[Violation]:
         graph = extract_graph(self._project_path, options=options)
         rules, contained_nodes = generate_rule(self._puml_content)
@@ -193,6 +195,7 @@ class NegativeSliceCondition(RuleRationaleMixin):
         self._source = source
         self._target = target
 
+    @inspect_check
     def check(self, options: CheckOptions | None = None) -> list[Violation]:
         graph = extract_graph(self._project_path, options=options)
 

archunitpython/testing/assertion.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from archunitpython.common.assertion.violation import Violation
 from archunitpython.common.fluentapi.checkable import Checkable, CheckOptions
+from archunitpython.testing.common.color_utils import ColorUtils
 from archunitpython.testing.common.violation_factory import ViolationFactory
 
 
@@ -11,26 +12,32 @@ def format_violations(
     violations: list[Violation],
     *,
     because: str | None = None,
+    color: bool | None = None,
 ) -> str:
     """Format violations into a human-readable string.
 
     Args:
         violations: List of violations to format.
+        because: Optional rationale for the rule.
+        color: None detects interactive terminals; False guarantees plain text.
+            True explicitly enables ANSI colors, unless NO_COLOR is set.
 
     Returns:
         Formatted string describing all violations.
     """
     if not violations:
-        return "No violations found."
+        return ColorUtils.style("No violations found.", "32", color)
 
-    lines = [f"Found {len(violations)} architecture violation(s):"]
+    lines = [ColorUtils.style(f"Found {len(violations)} architecture violation(s):", "1;31", color)]
     if because:
-        lines.extend(["", f"Because: {because}"])
+        lines.extend(["", ColorUtils.style(f"Because: {because}", "33", color)])
     lines.append("")
     for i, violation in enumerate(violations, 1):
         tv = ViolationFactory.from_violation(violation)
-        lines.append(f"  {i}. {tv.message}")
-        lines.append(f"     {tv.details}")
+        lines.append(f"  {i}. {ColorUtils.style(tv.message, '1;33', color)}")
+        detail_color = "36" if "value=" in tv.details else "34"
+        for detail in tv.details.split("\n"):
+            lines.append(f"     {ColorUtils.style(detail, detail_color, color)}")
         lines.append("")
 
     return "\n".join(lines)
@@ -39,12 +46,15 @@ def format_violations(
 def assert_passes(
     checkable: Checkable,
     options: CheckOptions | None = None,
+    *,
+    color: bool | None = None,
 ) -> None:
     """Assert that an architecture rule passes (no violations).
 
     Args:
         checkable: Any object with a check() method (implements Checkable).
         options: Optional check options.
+        color: Optional color override for failure output.
 
     Raises:
         AssertionError: If the rule has violations.
@@ -52,4 +62,4 @@ def assert_passes(
     violations = checkable.check(options)
     if violations:
         because = getattr(checkable, "because_reason", None)
-        raise AssertionError(format_violations(violations, because=because))
+        raise AssertionError(format_violations(violations, because=because, color=color))

archunitpython/testing/common/color_utils.py

@@ -8,7 +8,9 @@ import sys
 
 def _supports_color() -> bool:
     """Check if the terminal supports ANSI colors."""
-    if os.environ.get("NO_COLOR"):
+    if "NO_COLOR" in os.environ or os.environ.get("CI", "").lower() == "true":
+        return False
+    if os.environ.get("TERM") == "dumb":
         return False
     if not hasattr(sys.stdout, "isatty"):
         return False
@@ -24,6 +26,15 @@ def _wrap(code: str, text: str) -> str:
 class ColorUtils:
     """ANSI color utilities for terminal output."""
 
+    @staticmethod
+    def style(text: str, code: str, enabled: bool | None = None) -> str:
+        """Style text with automatic detection or an explicit color choice."""
+        if enabled is False or "NO_COLOR" in os.environ:
+            return text
+        if enabled is None and not _supports_color():
+            return text
+        return f"\033[{code}m{text}\033[0m"
+
     @staticmethod
     def red(text: str) -> str:
         return _wrap("31", text)

{archunitpython-1.6.1.dist-info → archunitpython-1.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: archunitpython
-Version: 1.6.1
+Version: 1.8.0
 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
@@ -377,6 +377,12 @@ ArchUnitPython detects string-based dynamic imports such as `importlib.import_mo
 from my_app.adapters.sql import Repository  # archunit: ignore
 ```
 
+### Namespace Packages
+
+ArchUnitPython resolves imports from namespace packages that do not contain
+`__init__.py` files. For example, `from my_app.domain import model` is resolved
+to `my_app/domain/model.py` when `my_app/domain/` is a namespace package.
+
 ### Conditional Imports
 
 Imports inside `try` blocks that handle `ImportError` or
@@ -920,6 +926,10 @@ The most important differences:
 
 When tests fail, you get helpful output with file paths and violation details:
 
+Interactive terminals also highlight the failure summary, numbered headings,
+paths, metric values, and rule rationale. Output stays plain when redirected,
+when `CI=true`, or when `NO_COLOR` is set (even to an empty value).
+
 ```
 Found 2 architecture violation(s):
 
@@ -932,25 +942,91 @@ Found 2 architecture violation(s):
 
 ## 📝 Debug Logging & Configuration
 
-We support logging to help you understand what files are being analyzed and troubleshoot test failures. Logging is disabled by default to keep test output clean.
+Logging is disabled by default. Enable it per check to inspect file discovery,
+graph extraction and cache use, selector decisions, edge projections, class
+analysis, metric values, and the resulting violations. File, layer, slice,
+count/LCOM/distance, and custom metric checks use the same logging options.
+
+| Level | What you see |
+| --- | --- |
+| `error` | Analysis exceptions (the original exception is still raised). |
+| `warn` | Failed check summaries and every violation, plus errors. |
+| `info` | Check start, completion, duration, and violations, plus errors. |
+| `debug` | All of the above, plus rule configuration, discovered files, dependencies, cache decisions, selector matches, projected/omitted edges, classes, and measured values. |
 
 ### Enabling Debug Logging
 
 ```python
-from archunitpython import CheckOptions
-from archunitpython.common.logging.types import LoggingOptions
+from archunitpython import CheckOptions, LoggingOptions, project_files
+
+rule = project_files("src/").should().have_no_cycles()
 
 options = CheckOptions(
     logging=LoggingOptions(
         enabled=True,
         level="debug",       # "error" | "warn" | "info" | "debug"
-        log_file=True,       # Creates logs/archunit-YYYY-MM-DD_HH-MM-SS.log
+        log_file=True,       # Creates a unique timestamped file in logs/
     ),
 )
 
 violations = rule.check(options)
 ```
 
+For example, a debug trace includes entries like these (paths and timings depend
+on your project):
+
+```text
+[INFO] Starting check: CycleFreeFileCondition
+[DEBUG] Graph cache miss
+[DEBUG] Discovered file: /project/src/api.py
+[DEBUG] Processing file: /project/src/api.py
+[DEBUG] Dependency: /project/src/api.py -> /project/src/storage.py; external=False; kinds=[]
+[DEBUG] Projection: /project/src/api.py -> /project/src/storage.py becomes /project/src/api.py -> /project/src/storage.py
+[INFO] Finished check: CycleFreeFileCondition - 0 violation(s) (0.002s)
+```
+
+Console diagnostics use the standard `archunitpython` logger when handlers are
+configured, respecting their levels and formatting; otherwise they go to stderr.
+For pytest live logs, use `pytest --log-cli-level=DEBUG`. You can also configure
+Python's standard `logging` module in your application.
+
+### Save detailed inspection without console noise
+
+```python
+options = CheckOptions(logging=LoggingOptions(
+    enabled=True,
+    level="debug",
+    console=False,
+    log_file=True,
+    log_path="logs/architecture.log",
+    append_to_log_file=True,
+))
+violations = rule.check(options)
+```
+
+File logs are UTF-8, timestamped, and contain no added ANSI colors. Automatic
+paths are unique per check; an explicit `log_path` replaces that path.
+`append_to_log_file=False` overwrites an explicit file at the start of each check.
+Each check closes its own output file and isolates its diagnostics from nested
+and concurrent checks. Use separate paths when concurrent checks write to files.
+Diagnostic output is best effort: an unavailable file or failing logging handler
+does not change rule results or hide analysis exceptions. Debug inspection does
+not re-run custom predicates or metric calculations.
+
+### Format results independently of logging
+
+```python
+from archunitpython import assert_passes, format_violations
+
+print(format_violations(violations))               # Detect terminal colors
+text = format_violations(violations, color=False)  # Stable plain text for artifacts
+assert_passes(rule, options, color=False)         # Plain assertion failure
+```
+
+Pass `color=True` to explicitly request ANSI styling; `NO_COLOR` always wins.
+The numbered report, rationale, and details remain available at every log level,
+including when logging is disabled. Existing plain-text report wording is retained.
+
 ### CI Pipeline Integration
 
 ```yaml

{archunitpython-1.6.1.dist-info → archunitpython-1.8.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
-archunitpython/__init__.py,sha256=V9u2N2MxgEJPGdWPrfPe6ejfnMW98_aCaXZXki9xa4k,1282
+archunitpython/__init__.py,sha256=JaKTTUg_yKFG5p-rh1VNOua4-aFpo7CBaYiAGvzn708,1324
 archunitpython/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 archunitpython/common/__init__.py,sha256=TKL39Z0kBpWqMH99jU4LsDSUZ5lQ_rcAJfLnmUTDTOI,656
-archunitpython/common/pattern_matching.py,sha256=HMAfo8GsooHvA4d2IxCi3btrYTdwfOQXw4bDNr117P0,2669
+archunitpython/common/pattern_matching.py,sha256=WLURKcd9tWXG8MPPNWGh8craK-UP37oW_k39g04THQE,2974
 archunitpython/common/regex_factory.py,sha256=UtlElM0Uty3SuD7tPZeoDnpbFipFUuYDpWfuV-Xq4c4,2459
 archunitpython/common/types.py,sha256=aA6hxCvmOy7_q74pE0sDRILNB8KxmHx9G4j5ql87mWs,755
 archunitpython/common/assertion/__init__.py,sha256=qpFkUrRoJWbwL7KPWaVTqlx70fhUJtwjyY0elsm8tv0,131
@@ -9,16 +9,18 @@ archunitpython/common/assertion/violation.py,sha256=TnMOykN3kPoGrSf1KcxBXYRfaxfX
 archunitpython/common/error/__init__.py,sha256=UWcdIKpGAJvo4WEGOVSaUjQQnKoPi8R496uDGXBWKsE,116
 archunitpython/common/error/errors.py,sha256=y7mcXoZPyK7uD2dMMO1qBt1y7KcIeGlRYiVeI6bjms4,249
 archunitpython/common/extraction/__init__.py,sha256=RkJOcxJoLYQxEagh3uWhjsUCprK3Nr3Bn3o7nmzk4_Q,284
-archunitpython/common/extraction/extract_graph.py,sha256=SZ3-ZYI1RlIIF3saDoduXXzEHMwmflmhN60oWISeFOM,21608
+archunitpython/common/extraction/extract_graph.py,sha256=GGXyoxHGyvWF4iyqIueuj89ObvRUuK3RsuxALJIvByk,24308
 archunitpython/common/extraction/graph.py,sha256=s4QW0WYfwjqXteBNygaNBdTgSC1XKil8cBFLtxl5rJE,1124
 archunitpython/common/fluentapi/__init__.py,sha256=LeS7qS2p9-FqqBhDL8xRPex__W5Qk0UWfcpl7nVVLfI,178
 archunitpython/common/fluentapi/checkable.py,sha256=BJFYibVhHLMFlnWdISPCIL3DYI1_3JN2-1jEQOaVaGE,1547
+archunitpython/common/fluentapi/inspection.py,sha256=VnrQIHH0tKW-QeexG7HiMU-DyvxjNcpAWsuEdhfRyR8,2991
 archunitpython/common/logging/__init__.py,sha256=u3-2_jYmiyoQ-C534SmQXvR1L9h3lbJqA9Yt1Nmv9HA,115
-archunitpython/common/logging/types.py,sha256=wUriZeaUawA3JoBfJVLC6lIMglbLG955nXWdJGwxW4I,425
+archunitpython/common/logging/inspection.py,sha256=7akoJaRsS9vVz8joiMIcTh8LD1ocKjUiURDFsmhGN2k,3291
+archunitpython/common/logging/types.py,sha256=WOWi1UECxSlABGkYn7JcxooqVrC4ZOXSUBbOQjkdnKc,482
 archunitpython/common/projection/__init__.py,sha256=-Sx-b80b2N3ap3ahAcLUCXqYYK3ccgTDpV-K1jSOSYQ,797
 archunitpython/common/projection/edge_projections.py,sha256=Mud8DL6Y8H66CObqyikKYAxdXMRENuAFRtwhCxpwxoU,1524
 archunitpython/common/projection/project_cycles.py,sha256=TQ4Ok1hT4T_znqFbwV4VTj-BXmlFr1O7TtZdVOd5oPg,3081
-archunitpython/common/projection/project_edges.py,sha256=v7hDMSeghiLz0xHbG4BNF7jNQphcWobU7rgoiuw3fh4,1268
+archunitpython/common/projection/project_edges.py,sha256=Rul-BpDT549ZqSlnG6qOriO0bREA-cJqg4TatOKL8fA,1720
 archunitpython/common/projection/project_nodes.py,sha256=U6sLYvJd6NBgg39V0Ry7r_-57gdXaaXsbH-D12nipCg,1497
 archunitpython/common/projection/types.py,sha256=EP5yJd-uXYdACFdFzeID8bUVsg_vdhgiOzshrC-CC8Y,937
 archunitpython/common/projection/cycles/__init__.py,sha256=giGUcwpEMr91XST-biyCmLUjP5okhwTA4CcCaxjZdmg,217
@@ -40,14 +42,14 @@ archunitpython/files/assertion/depend_on_external_modules.py,sha256=BXGpN-301YOc
 archunitpython/files/assertion/depend_on_files.py,sha256=9lBj4YNe1jjKJV3r0ntsXfPHoKc_IbwgHhLgMYOs9Ok,2024
 archunitpython/files/assertion/matching_files.py,sha256=1RyYqFA-IzzAXlgqRfiL18jk9xEJzEBY2fp_A3fxjdE,2015
 archunitpython/files/fluentapi/__init__.py,sha256=wgl8IOqTeQGpNISu-Q8b_j6rTn8aEgoz6t1S5j8z13g,108
-archunitpython/files/fluentapi/files.py,sha256=oZG0lWV6p0AiGANdoZfYd51H8zY-J4eTSPRTRPBYhs0,17152
+archunitpython/files/fluentapi/files.py,sha256=qJW7n6uX4-pfIGox-BdVHK_PVu9ZN_lxpKSXidp8_4s,17316
 archunitpython/graph/__init__.py,sha256=vm1jMOoN35IIU7YDs59qPtf_F82YV-QrEGfXhozAOek,756
 archunitpython/graph/graph_reporter.py,sha256=D_KH01CM7TzeMFB6o5NIQfLVJq0rvKZn9l7WumXV6lo,25598
 archunitpython/layers/__init__.py,sha256=DCRxqLhluTxTaT9ZM2MbfAdJVgqcOO9jtkZHzBbeLOw,164
 archunitpython/layers/assertion/__init__.py,sha256=_VRKjO86psSnmX29EfikDe3RIpJMczTyn6nkSM7xQwc,226
 archunitpython/layers/assertion/layer_dependencies.py,sha256=I8Y3DJnWhCsJfhgQB4lTHBobFG3_bB9a_ljqCNcYeBM,2646
 archunitpython/layers/fluentapi/__init__.py,sha256=psKFB-5IXS1SJ8g62HthExKYJio3bgdVzIleOSiF1gA,125
-archunitpython/layers/fluentapi/layers.py,sha256=Wl926_aWpNrlbWatDi3QDR-8geDflbYFEivWJv-X9dI,4438
+archunitpython/layers/fluentapi/layers.py,sha256=iPI4XxP8iqvRfoJWJE9hrjYDeeQq0fbP6KQG8hIJKT0,4526
 archunitpython/metrics/__init__.py,sha256=HD72MWF0hCh2LzKfyk3mMJp2tf7TJebpwTtZ_kppjso,84
 archunitpython/metrics/assertion/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 archunitpython/metrics/assertion/metric_thresholds.py,sha256=kwX1iRFnF7oLaLMlQsYrDsNRrivDE8pI6nrrZYAafvg,1262
@@ -58,28 +60,28 @@ archunitpython/metrics/calculation/lcom.py,sha256=LK_kNT-BM6yuR5TUOLWQLkVvMpqR6q
 archunitpython/metrics/common/__init__.py,sha256=xtEyAhS4X0UbJXHxnpdiXljVZmKIKKekZAZ1zflSPFE,335
 archunitpython/metrics/common/types.py,sha256=w1BUlw6p_3K8qZDoQXv50P_CcKixGYiyS_YBGYILySA,1601
 archunitpython/metrics/extraction/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-archunitpython/metrics/extraction/extract_class_info.py,sha256=u-i_AkRRdIbOVXhH7LVCCVIxRrz4IX6nOqukPxbB5Iw,7747
+archunitpython/metrics/extraction/extract_class_info.py,sha256=iQuug7gRAdnegOVWCKGJo4YrdVaPC7nkMlrQ940Vi8Q,8381
 archunitpython/metrics/fluentapi/__init__.py,sha256=HD72MWF0hCh2LzKfyk3mMJp2tf7TJebpwTtZ_kppjso,84
 archunitpython/metrics/fluentapi/export_utils.py,sha256=1r-zTQAUqn_agp4_lhbcffdzfdASNY3LebYvKAG9kcQ,2333
-archunitpython/metrics/fluentapi/metrics.py,sha256=8OBOL3jVKbM9v_CjNNM9FMfV1JBfl5UEd1-PPOEScRs,19371
+archunitpython/metrics/fluentapi/metrics.py,sha256=bFGO7DJiRrtDSxcwF9u0OMSpj9OZKBj9Pw0kxEHoVTU,20922
 archunitpython/metrics/projection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 archunitpython/slices/__init__.py,sha256=tb8MoZiEqIdmWy7uyhmEtMNm5Fxjuw6atSvDsD131DE,96
 archunitpython/slices/assertion/__init__.py,sha256=MRwV3d69ljAJ7hFYdxI6UDNC8U4Dm1ImeuLUVKEC9To,280
 archunitpython/slices/assertion/admissible_edges.py,sha256=NNn1PGsK0LS_Msa3g1cAMQwLzxbot4rQNVRAHzW11pk,3124
 archunitpython/slices/fluentapi/__init__.py,sha256=tb8MoZiEqIdmWy7uyhmEtMNm5Fxjuw6atSvDsD131DE,96
-archunitpython/slices/fluentapi/slices.py,sha256=vNoyqmleTDTjnf2i35i2nte-Ycjm-oapfgaf3AhN0QI,7163
+archunitpython/slices/fluentapi/slices.py,sha256=NVH7hm2ywwEi4vJPYe098-_Au4sPfu3pTnGW2zlK_qw,7270
 archunitpython/slices/projection/__init__.py,sha256=tVgcK4gw-bqhUq98vU7_iPE0NEhOPUr7vr1-p7JI1A4,237
 archunitpython/slices/projection/slicing_projections.py,sha256=BHBkuVG80mqzT7N4FlCCfY5U_NvlXmAgTmHf_SPTXVM,4215
 archunitpython/slices/uml/__init__.py,sha256=GQFA5WBKfi_YElWiNWNm9c9IM-VaW83_Cg6kpwkzxkw,196
 archunitpython/slices/uml/export_diagram.py,sha256=FeBRV8Vt8LuhLqEbg5JzZOmEk2i49JPkozMcI5r335g,818
 archunitpython/slices/uml/generate_rules.py,sha256=D9vvqDzHAM0F80z4u5yBalEqIiNfJJ5HGXP0fVlSzHw,2136
 archunitpython/testing/__init__.py,sha256=MJm6CHGhBGFg1um2L20-GD2DEHKqg8SiUoI-sRsoXQk,128
-archunitpython/testing/assertion.py,sha256=7cXlNwBklIGAyUJlPGFGAw97xZ9UgpkZvoO_QBdqm1c,1637
+archunitpython/testing/assertion.py,sha256=sqZHVq1GTuKzil7FgXwuslcs8qtvIejQqblKeCh3eeU,2323
 archunitpython/testing/common/__init__.py,sha256=Wc4bC-N4t6giChKjj6wuTGKkb39thcYS_xKWG9paYeY,220
-archunitpython/testing/common/color_utils.py,sha256=2I8Z1SZfWhhgudMgmXY6PPydGxGl35cK_To-GXnSyJg,1226
+archunitpython/testing/common/color_utils.py,sha256=Bqmx7l8Aw3s3brblyqhWdVRFn0WQiQWiR9y9kz072Wg,1706
 archunitpython/testing/common/violation_factory.py,sha256=yWlvv2U7u-7KoTMfp1QCeJXxTLpPEagKqDHZmPSyrlk,4677
 archunitpython/testing/pytest_plugin/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-archunitpython-1.6.1.dist-info/METADATA,sha256=Pk3XGlaDYzHbLO8D_V1G-OQKssjrhd_-I2c3hIPgMwU,34913
-archunitpython-1.6.1.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
-archunitpython-1.6.1.dist-info/licenses/LICENSE,sha256=kaQWfzfHk45CNIx4sIW7Uf1sNW5rmo6BpZ-R8GruuK0,1102
-archunitpython-1.6.1.dist-info/RECORD,,
+archunitpython-1.8.0.dist-info/METADATA,sha256=6RS5qNk1Aj81iipmKRzmVLr1CcFZUzCO9OF86sSc2bU,38359
+archunitpython-1.8.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+archunitpython-1.8.0.dist-info/licenses/LICENSE,sha256=kaQWfzfHk45CNIx4sIW7Uf1sNW5rmo6BpZ-R8GruuK0,1102
+archunitpython-1.8.0.dist-info/RECORD,,

{archunitpython-1.6.1.dist-info → archunitpython-1.8.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.32.0
+Generator: hatchling 1.32.4
 Root-Is-Purelib: true
 Tag: py3-none-any