PyPI - archunitpython - Versions diffs - 1.0.0__py3-none-any.whl - Mend

archunitpython 1.0.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (75) hide show

archunitpython/__init__.py +45 -0
archunitpython/common/__init__.py +18 -0
archunitpython/common/assertion/__init__.py +3 -0
archunitpython/common/assertion/violation.py +21 -0
archunitpython/common/error/__init__.py +3 -0
archunitpython/common/error/errors.py +13 -0
archunitpython/common/extraction/__init__.py +13 -0
archunitpython/common/extraction/extract_graph.py +345 -0
archunitpython/common/extraction/graph.py +39 -0
archunitpython/common/fluentapi/__init__.py +3 -0
archunitpython/common/fluentapi/checkable.py +28 -0
archunitpython/common/logging/__init__.py +3 -0
archunitpython/common/logging/types.py +18 -0
archunitpython/common/pattern_matching.py +80 -0
archunitpython/common/projection/__init__.py +30 -0
archunitpython/common/projection/cycles/__init__.py +4 -0
archunitpython/common/projection/cycles/cycle_utils.py +49 -0
archunitpython/common/projection/cycles/cycles.py +26 -0
archunitpython/common/projection/cycles/johnsons_apsp.py +110 -0
archunitpython/common/projection/cycles/model.py +22 -0
archunitpython/common/projection/cycles/tarjan_scc.py +86 -0
archunitpython/common/projection/edge_projections.py +36 -0
archunitpython/common/projection/project_cycles.py +85 -0
archunitpython/common/projection/project_edges.py +43 -0
archunitpython/common/projection/project_nodes.py +49 -0
archunitpython/common/projection/types.py +40 -0
archunitpython/common/regex_factory.py +76 -0
archunitpython/common/types.py +29 -0
archunitpython/common/util/__init__.py +3 -0
archunitpython/common/util/declaration_detector.py +115 -0
archunitpython/common/util/logger.py +100 -0
archunitpython/files/__init__.py +3 -0
archunitpython/files/assertion/__init__.py +28 -0
archunitpython/files/assertion/custom_file_logic.py +107 -0
archunitpython/files/assertion/cycle_free.py +29 -0
archunitpython/files/assertion/depend_on_files.py +67 -0
archunitpython/files/assertion/matching_files.py +64 -0
archunitpython/files/fluentapi/__init__.py +3 -0
archunitpython/files/fluentapi/files.py +403 -0
archunitpython/metrics/__init__.py +3 -0
archunitpython/metrics/assertion/__init__.py +0 -0
archunitpython/metrics/assertion/metric_thresholds.py +51 -0
archunitpython/metrics/calculation/__init__.py +0 -0
archunitpython/metrics/calculation/count.py +148 -0
archunitpython/metrics/calculation/distance.py +110 -0
archunitpython/metrics/calculation/lcom.py +177 -0
archunitpython/metrics/common/__init__.py +19 -0
archunitpython/metrics/common/types.py +67 -0
archunitpython/metrics/extraction/__init__.py +0 -0
archunitpython/metrics/extraction/extract_class_info.py +246 -0
archunitpython/metrics/fluentapi/__init__.py +3 -0
archunitpython/metrics/fluentapi/export_utils.py +89 -0
archunitpython/metrics/fluentapi/metrics.py +589 -0
archunitpython/metrics/projection/__init__.py +0 -0
archunitpython/py.typed +0 -0
archunitpython/slices/__init__.py +3 -0
archunitpython/slices/assertion/__init__.py +13 -0
archunitpython/slices/assertion/admissible_edges.py +108 -0
archunitpython/slices/fluentapi/__init__.py +3 -0
archunitpython/slices/fluentapi/slices.py +220 -0
archunitpython/slices/projection/__init__.py +8 -0
archunitpython/slices/projection/slicing_projections.py +128 -0
archunitpython/slices/uml/__init__.py +4 -0
archunitpython/slices/uml/export_diagram.py +31 -0
archunitpython/slices/uml/generate_rules.py +71 -0
archunitpython/testing/__init__.py +3 -0
archunitpython/testing/assertion.py +47 -0
archunitpython/testing/common/__init__.py +4 -0
archunitpython/testing/common/color_utils.py +57 -0
archunitpython/testing/common/violation_factory.py +97 -0
archunitpython/testing/pytest_plugin/__init__.py +0 -0
archunitpython-1.0.0.dist-info/METADATA +660 -0
archunitpython-1.0.0.dist-info/RECORD +75 -0
archunitpython-1.0.0.dist-info/WHEEL +4 -0
archunitpython-1.0.0.dist-info/licenses/LICENSE +7 -0

archunitpython/metrics/fluentapi/export_utils.py ADDED Viewed

@@ -0,0 +1,89 @@
+"""HTML report export for metrics results."""
+from __future__ import annotations
+import os
+from dataclasses import dataclass
+from datetime import datetime
+@dataclass
+class ExportOptions:
+    """Options for metrics export."""
+    output_path: str | None = None
+    title: str = "ArchUnitPython Metrics Report"
+    include_timestamp: bool = True
+    custom_css: str | None = None
+class MetricsExporter:
+    """Export metrics results as HTML reports."""
+    @staticmethod
+    def export_as_html(
+        data: dict[str, object],
+        options: ExportOptions | None = None,
+    ) -> str:
+        """Export metric data as an HTML report.
+        Args:
+            data: Dictionary of metric results to include.
+            options: Export options.
+        Returns:
+            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 ""
+        )
+        css = opts.custom_css or _DEFAULT_CSS
+        rows = ""
+        for key, value in data.items():
+            rows += f"      <tr><td>{key}</td><td>{value}</td></tr>\n"
+        html = f"""<!DOCTYPE html>
+<html>
+<head>
+  <title>{opts.title}</title>
+  <style>{css}</style>
+</head>
+<body>
+  <h1>{opts.title}</h1>
+  {f'<p class="timestamp">Generated: {timestamp}</p>' if timestamp else ''}
+  <table>
+    <thead>
+      <tr><th>Metric</th><th>Value</th></tr>
+    </thead>
+    <tbody>
+{rows}    </tbody>
+  </table>
+</body>
+</html>"""
+        if opts.output_path:
+            path = opts.output_path
+            if not path.endswith(".html"):
+                path += ".html"
+            os.makedirs(os.path.dirname(path) or ".", exist_ok=True)
+            with open(path, "w", encoding="utf-8") as f:
+                f.write(html)
+        return html
+_DEFAULT_CSS = """
+body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+       max-width: 900px; margin: 0 auto; padding: 20px; }
+h1 { color: #333; }
+.timestamp { color: #666; font-size: 0.9em; }
+table { border-collapse: collapse; width: 100%; margin-top: 20px; }
+th, td { border: 1px solid #ddd; padding: 8px 12px; text-align: left; }
+th { background-color: #f5f5f5; font-weight: 600; }
+tr:nth-child(even) { background-color: #fafafa; }
+"""

archunitpython/metrics/fluentapi/metrics.py ADDED Viewed

@@ -0,0 +1,589 @@
+"""Fluent API builders for metrics rules.
+Usage:
+    metrics('src/').count().lines_of_code().should_be_below(500).check()
+    metrics('src/').lcom().lcom96b().should_be_below(0.5).check()
+    metrics('src/').distance().abstractness().should_be_below(0.8).check()
+"""
+from __future__ import annotations
+from typing import Any, Callable
+from archunitpython.common.assertion.violation import Violation
+from archunitpython.common.fluentapi.checkable import CheckOptions
+from archunitpython.common.pattern_matching import matches_pattern_classname
+from archunitpython.common.regex_factory import RegexFactory
+from archunitpython.common.types import Filter, Pattern
+from archunitpython.metrics.assertion.metric_thresholds import (
+    FileCountViolation,
+    MetricViolation,
+    check_threshold,
+)
+from archunitpython.metrics.calculation.count import (
+    ClassCountMetric,
+    FieldCountMetric,
+    FunctionCountMetric,
+    ImportCountMetric,
+    LinesOfCodeMetric,
+    MethodCountMetric,
+    StatementCountMetric,
+)
+from archunitpython.metrics.calculation.distance import (
+    calculate_file_distance_metrics,
+)
+from archunitpython.metrics.calculation.lcom import (
+    LCOM1,
+    LCOM2,
+    LCOM3,
+    LCOM4,
+    LCOM5,
+    LCOM96a,
+    LCOM96b,
+    LCOMStar,
+)
+from archunitpython.metrics.common.types import ClassInfo, MetricComparison
+from archunitpython.metrics.extraction.extract_class_info import (
+    extract_class_info,
+    extract_enhanced_class_info,
+)
+def metrics(project_path: str | None = None) -> "MetricsBuilder":
+    """Entry point for metrics rules."""
+    return MetricsBuilder(project_path)
+class MetricsBuilder:
+    """Top-level metrics builder with filter methods."""
+    def __init__(self, project_path: str | None = None) -> None:
+        self._project_path = project_path
+        self._filters: list[Filter] = []
+    def with_name(self, name: Pattern) -> "MetricsBuilder":
+        self._filters.append(RegexFactory.filename_matcher(name))
+        return self
+    def in_folder(self, folder: Pattern) -> "MetricsBuilder":
+        self._filters.append(RegexFactory.folder_matcher(folder))
+        return self
+    def in_path(self, path: Pattern) -> "MetricsBuilder":
+        self._filters.append(RegexFactory.path_matcher(path))
+        return self
+    def for_classes_matching(self, pattern: Pattern) -> "MetricsBuilder":
+        self._filters.append(RegexFactory.classname_matcher(pattern))
+        return self
+    def count(self) -> "CountMetricsBuilder":
+        return CountMetricsBuilder(self._project_path, list(self._filters))
+    def lcom(self) -> "LCOMMetricsBuilder":
+        return LCOMMetricsBuilder(self._project_path, list(self._filters))
+    def distance(self) -> "DistanceMetricsBuilder":
+        return DistanceMetricsBuilder(self._project_path, list(self._filters))
+    def custom_metric(
+        self,
+        name: str,
+        description: str,
+        calculation: Callable[[ClassInfo], float],
+    ) -> "CustomMetricsBuilder":
+        return CustomMetricsBuilder(
+            self._project_path, list(self._filters), name, description, calculation
+        )
+def _get_filtered_classes(
+    project_path: str | None, filters: list[Filter]
+) -> list[ClassInfo]:
+    classes = extract_class_info(project_path)
+    if not filters:
+        return classes
+    return [
+        c
+        for c in classes
+        if all(matches_pattern_classname(c.name, c.file_path, f) for f in filters)
+    ]
+# --- Count Metrics ---
+class CountMetricsBuilder:
+    def __init__(self, project_path: str | None, filters: list[Filter]) -> None:
+        self._project_path = project_path
+        self._filters = filters
+    def method_count(self) -> "ClassMetricThresholdBuilder":
+        return ClassMetricThresholdBuilder(
+            self._project_path, self._filters, MethodCountMetric()
+        )
+    def field_count(self) -> "ClassMetricThresholdBuilder":
+        return ClassMetricThresholdBuilder(
+            self._project_path, self._filters, FieldCountMetric()
+        )
+    def lines_of_code(self) -> "FileMetricThresholdBuilder":
+        return FileMetricThresholdBuilder(
+            self._project_path, self._filters, LinesOfCodeMetric()
+        )
+    def statements(self) -> "FileMetricThresholdBuilder":
+        return FileMetricThresholdBuilder(
+            self._project_path, self._filters, StatementCountMetric()
+        )
+    def imports(self) -> "FileMetricThresholdBuilder":
+        return FileMetricThresholdBuilder(
+            self._project_path, self._filters, ImportCountMetric()
+        )
+    def classes(self) -> "FileMetricThresholdBuilder":
+        return FileMetricThresholdBuilder(
+            self._project_path, self._filters, ClassCountMetric()
+        )
+    def functions(self) -> "FileMetricThresholdBuilder":
+        return FileMetricThresholdBuilder(
+            self._project_path, self._filters, FunctionCountMetric()
+        )
+class ClassMetricThresholdBuilder:
+    def __init__(self, project_path: str | None, filters: list[Filter], metric: Any) -> None:
+        self._project_path = project_path
+        self._filters = filters
+        self._metric = metric
+    def should_be_below(self, threshold: float) -> "ClassMetricCondition":
+        return ClassMetricCondition(
+            self._project_path, self._filters, self._metric, threshold, "below"
+        )
+    def should_be_above(self, threshold: float) -> "ClassMetricCondition":
+        return ClassMetricCondition(
+            self._project_path, self._filters, self._metric, threshold, "above"
+        )
+    def should_be(self, threshold: float) -> "ClassMetricCondition":
+        return ClassMetricCondition(
+            self._project_path, self._filters, self._metric, threshold, "equal"
+        )
+    def should_be_below_or_equal(self, threshold: float) -> "ClassMetricCondition":
+        return ClassMetricCondition(
+            self._project_path, self._filters, self._metric, threshold, "below_equal"
+        )
+    def should_be_above_or_equal(self, threshold: float) -> "ClassMetricCondition":
+        return ClassMetricCondition(
+            self._project_path, self._filters, self._metric, threshold, "above_equal"
+        )
+class ClassMetricCondition:
+    """Checkable that verifies a class-level metric threshold."""
+    def __init__(
+        self,
+        project_path: str | None,
+        filters: list[Filter],
+        metric: Any,
+        threshold: float,
+        comparison: MetricComparison,
+    ) -> None:
+        self._project_path = project_path
+        self._filters = filters
+        self._metric = metric
+        self._threshold = threshold
+        self._comparison = comparison
+    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)
+            if check_threshold(value, self._threshold, self._comparison):
+                violations.append(
+                    MetricViolation(
+                        class_name=cls.name,
+                        file_path=cls.file_path,
+                        metric_name=self._metric.name,
+                        metric_value=value,
+                        threshold=self._threshold,
+                        comparison=self._comparison,
+                    )
+                )
+        return violations
+class FileMetricThresholdBuilder:
+    def __init__(self, project_path: str | None, filters: list[Filter], metric: Any) -> None:
+        self._project_path = project_path
+        self._filters = filters
+        self._metric = metric
+    def should_be_below(self, threshold: float) -> "FileMetricCondition":
+        return FileMetricCondition(
+            self._project_path, self._filters, self._metric, threshold, "below"
+        )
+    def should_be_above(self, threshold: float) -> "FileMetricCondition":
+        return FileMetricCondition(
+            self._project_path, self._filters, self._metric, threshold, "above"
+        )
+    def should_be_below_or_equal(self, threshold: float) -> "FileMetricCondition":
+        return FileMetricCondition(
+            self._project_path, self._filters, self._metric, threshold, "below_equal"
+        )
+class FileMetricCondition:
+    """Checkable that verifies a file-level metric threshold."""
+    def __init__(
+        self,
+        project_path: str | None,
+        filters: list[Filter],
+        metric: Any,
+        threshold: float,
+        comparison: MetricComparison,
+    ) -> None:
+        self._project_path = project_path
+        self._filters = filters
+        self._metric = metric
+        self._threshold = threshold
+        self._comparison: MetricComparison = comparison
+    def check(self, options: CheckOptions | None = None) -> list[Violation]:
+        import os
+        from archunitpython.common.extraction.extract_graph import (
+            _DEFAULT_EXCLUDE,
+            _find_python_files,
+        )
+        project = self._project_path or os.getcwd()
+        project = os.path.abspath(project)
+        files = _find_python_files(project, _DEFAULT_EXCLUDE)
+        violations: list[Violation] = []
+        for file_path in files:
+            norm = file_path.replace("\\", "/")
+            if self._filters and not all(
+                matches_pattern_classname("", norm, f) for f in self._filters
+            ):
+                continue
+            value = self._metric.calculate_from_file(file_path)
+            if check_threshold(value, self._threshold, self._comparison):
+                violations.append(
+                    FileCountViolation(
+                        file_path=norm,
+                        metric_name=self._metric.name,
+                        metric_value=value,
+                        threshold=self._threshold,
+                        comparison=self._comparison,
+                    )
+                )
+        return violations
+# --- LCOM Metrics ---
+class LCOMMetricsBuilder:
+    def __init__(self, project_path: str | None, filters: list[Filter]) -> None:
+        self._project_path = project_path
+        self._filters = filters
+    def lcom96a(self) -> "ClassMetricThresholdBuilder":
+        return ClassMetricThresholdBuilder(self._project_path, self._filters, LCOM96a())
+    def lcom96b(self) -> "ClassMetricThresholdBuilder":
+        return ClassMetricThresholdBuilder(self._project_path, self._filters, LCOM96b())
+    def lcom1(self) -> "ClassMetricThresholdBuilder":
+        return ClassMetricThresholdBuilder(self._project_path, self._filters, LCOM1())
+    def lcom2(self) -> "ClassMetricThresholdBuilder":
+        return ClassMetricThresholdBuilder(self._project_path, self._filters, LCOM2())
+    def lcom3(self) -> "ClassMetricThresholdBuilder":
+        return ClassMetricThresholdBuilder(self._project_path, self._filters, LCOM3())
+    def lcom4(self) -> "ClassMetricThresholdBuilder":
+        return ClassMetricThresholdBuilder(self._project_path, self._filters, LCOM4())
+    def lcom5(self) -> "ClassMetricThresholdBuilder":
+        return ClassMetricThresholdBuilder(self._project_path, self._filters, LCOM5())
+    def lcomstar(self) -> "ClassMetricThresholdBuilder":
+        return ClassMetricThresholdBuilder(self._project_path, self._filters, LCOMStar())
+# --- Distance Metrics ---
+class DistanceMetricsBuilder:
+    def __init__(self, project_path: str | None, filters: list[Filter]) -> None:
+        self._project_path = project_path
+        self._filters = filters
+    def abstractness(self) -> "DistanceThresholdBuilder":
+        return DistanceThresholdBuilder(
+            self._project_path, self._filters, "abstractness"
+        )
+    def instability(self) -> "DistanceThresholdBuilder":
+        return DistanceThresholdBuilder(
+            self._project_path, self._filters, "instability"
+        )
+    def distance_from_main_sequence(self) -> "DistanceThresholdBuilder":
+        return DistanceThresholdBuilder(
+            self._project_path, self._filters, "distance"
+        )
+    def not_in_zone_of_pain(self) -> "ZoneCondition":
+        return ZoneCondition(self._project_path, self._filters, "pain")
+    def not_in_zone_of_uselessness(self) -> "ZoneCondition":
+        return ZoneCondition(self._project_path, self._filters, "uselessness")
+class DistanceThresholdBuilder:
+    def __init__(self, project_path: str | None, filters: list[Filter], metric_attr: str) -> None:
+        self._project_path = project_path
+        self._filters = filters
+        self._metric_attr = metric_attr
+    def should_be_below(self, threshold: float) -> "DistanceCondition":
+        return DistanceCondition(
+            self._project_path,
+            self._filters,
+            self._metric_attr,
+            threshold,
+            "below",
+        )
+    def should_be_above(self, threshold: float) -> "DistanceCondition":
+        return DistanceCondition(
+            self._project_path,
+            self._filters,
+            self._metric_attr,
+            threshold,
+            "above",
+        )
+class DistanceCondition:
+    """Checkable for distance metric thresholds."""
+    def __init__(
+        self,
+        project_path: str | None,
+        filters: list[Filter],
+        metric_attr: str,
+        threshold: float,
+        comparison: MetricComparison,
+    ) -> None:
+        self._project_path = project_path
+        self._filters = filters
+        self._metric_attr = metric_attr
+        self._threshold = threshold
+        self._comparison: MetricComparison = comparison
+    def check(self, options: CheckOptions | None = None) -> list[Violation]:
+        files = extract_enhanced_class_info(self._project_path)
+        violations: list[Violation] = []
+        for file_result in files:
+            dm = calculate_file_distance_metrics(file_result, files)
+            value = getattr(dm, self._metric_attr)
+            if check_threshold(value, self._threshold, self._comparison):
+                violations.append(
+                    MetricViolation(
+                        class_name="",
+                        file_path=file_result.file_path,
+                        metric_name=self._metric_attr,
+                        metric_value=value,
+                        threshold=self._threshold,
+                        comparison=self._comparison,
+                    )
+                )
+        return violations
+class ZoneCondition:
+    """Checkable for zone detection (pain/uselessness)."""
+    def __init__(self, project_path: str | None, filters: list[Filter], zone_type: str) -> None:
+        self._project_path = project_path
+        self._filters = filters
+        self._zone_type = zone_type
+    def check(self, options: CheckOptions | None = None) -> list[Violation]:
+        files = extract_enhanced_class_info(self._project_path)
+        violations: list[Violation] = []
+        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
+            )
+            if in_zone:
+                violations.append(
+                    MetricViolation(
+                        class_name="",
+                        file_path=file_result.file_path,
+                        metric_name=f"zone_of_{self._zone_type}",
+                        metric_value=1.0,
+                        threshold=0.0,
+                        comparison="equal",
+                    )
+                )
+        return violations
+# --- Custom Metrics ---
+class CustomMetricsBuilder:
+    def __init__(
+        self,
+        project_path: str | None,
+        filters: list[Filter],
+        name: str,
+        description: str,
+        calculation: Callable[[ClassInfo], float],
+    ) -> None:
+        self._project_path = project_path
+        self._filters = filters
+        self._name = name
+        self._description = description
+        self._calculation = calculation
+    def should_be_below(self, threshold: float) -> "CustomMetricCondition":
+        return CustomMetricCondition(
+            self._project_path,
+            self._filters,
+            self._name,
+            self._calculation,
+            threshold,
+            "below",
+        )
+    def should_be_above(self, threshold: float) -> "CustomMetricCondition":
+        return CustomMetricCondition(
+            self._project_path,
+            self._filters,
+            self._name,
+            self._calculation,
+            threshold,
+            "above",
+        )
+    def should_satisfy(
+        self, assertion: Callable[[float, ClassInfo], bool]
+    ) -> "CustomAssertionCondition":
+        return CustomAssertionCondition(
+            self._project_path,
+            self._filters,
+            self._name,
+            self._calculation,
+            assertion,
+        )
+class CustomMetricCondition:
+    """Checkable for custom metric thresholds."""
+    def __init__(
+        self,
+        project_path: str | None,
+        filters: list[Filter],
+        name: str,
+        calculation: Callable[[ClassInfo], float],
+        threshold: float,
+        comparison: MetricComparison,
+    ) -> None:
+        self._project_path = project_path
+        self._filters = filters
+        self._name = name
+        self._calculation = calculation
+        self._threshold = threshold
+        self._comparison = comparison
+    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)
+            if check_threshold(value, self._threshold, self._comparison):
+                violations.append(
+                    MetricViolation(
+                        class_name=cls.name,
+                        file_path=cls.file_path,
+                        metric_name=self._name,
+                        metric_value=value,
+                        threshold=self._threshold,
+                        comparison=self._comparison,
+                    )
+                )
+        return violations
+class CustomAssertionCondition:
+    """Checkable for custom metric assertions."""
+    def __init__(
+        self,
+        project_path: str | None,
+        filters: list[Filter],
+        name: str,
+        calculation: Callable[[ClassInfo], float],
+        assertion: Callable[[float, ClassInfo], bool],
+    ) -> None:
+        self._project_path = project_path
+        self._filters = filters
+        self._name = name
+        self._calculation = calculation
+        self._assertion = assertion
+    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)
+            if not self._assertion(value, cls):
+                violations.append(
+                    MetricViolation(
+                        class_name=cls.name,
+                        file_path=cls.file_path,
+                        metric_name=self._name,
+                        metric_value=value,
+                        threshold=0,
+                        comparison="equal",
+                    )
+                )
+        return violations

archunitpython/metrics/projection/__init__.py ADDED Viewed

File without changes

archunitpython/py.typed ADDED Viewed

File without changes

archunitpython/slices/__init__.py ADDED Viewed

@@ -0,0 +1,3 @@
+from archunitpython.slices.fluentapi.slices import project_slices
+__all__ = ["project_slices"]

archunitpython/slices/assertion/__init__.py ADDED Viewed

@@ -0,0 +1,13 @@
+from archunitpython.slices.assertion.admissible_edges import (
+    CoherenceOptions,
+    ViolatingEdge,
+    gather_positive_violations,
+    gather_violations,
+)
+__all__ = [
+    "CoherenceOptions",
+    "ViolatingEdge",
+    "gather_positive_violations",
+    "gather_violations",
+]