deply 0.1.0__py3-none-any.whl

deply/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.0"

deply/code_analyzer.py

@@ -0,0 +1,78 @@
+import ast
+from typing import Dict, Set, Tuple
+
+from .models.code_element import CodeElement
+
+
+class CodeAnalyzer:
+    def __init__(self, code_elements: Set[CodeElement]):
+        self.code_elements = code_elements
+        self.dependencies = {}  # Dict[CodeElement, Set[Tuple[CodeElement, int]]]
+
+    def analyze(self):
+        name_to_element = self._build_name_to_element_map()
+        for code_element in self.code_elements:
+            dependencies = self._extract_dependencies(code_element, name_to_element)
+            self.dependencies[code_element] = dependencies
+
+    def _build_name_to_element_map(self) -> Dict[str, Set[CodeElement]]:
+        name_to_element = {}
+        for elem in self.code_elements:
+            name_to_element.setdefault(elem.name, set()).add(elem)
+        return name_to_element
+
+    def _extract_dependencies(self, code_element: CodeElement, name_to_element: Dict[str, Set[CodeElement]]) -> Set[
+        Tuple[CodeElement, int]]:
+        dependencies = set()
+        with open(code_element.file, 'r', encoding='utf-8') as f:
+            try:
+                tree = ast.parse(f.read(), filename=str(code_element.file))
+            except SyntaxError:
+                return dependencies  # Skip files with syntax errors
+
+        class DependencyVisitor(ast.NodeVisitor):
+            def __init__(self, dependencies):
+                self.dependencies = dependencies
+
+            def visit_Import(self, node):
+                for alias in node.names:
+                    name = alias.asname or alias.name.split('.')[0]
+                    dep_elements = name_to_element.get(name, set())
+                    for dep_element in dep_elements:
+                        self.dependencies.add((dep_element, node.lineno))
+
+            def visit_ImportFrom(self, node):
+                module = node.module
+                for alias in node.names:
+                    name = alias.asname or alias.name
+                    full_name = f"{module}.{name}" if module else name
+                    dep_elements = name_to_element.get(name, set())
+                    for dep_element in dep_elements:
+                        self.dependencies.add((dep_element, node.lineno))
+
+            def visit_Call(self, node):
+                if isinstance(node.func, ast.Name):
+                    name = node.func.id
+                    dep_elements = name_to_element.get(name, set())
+                    for dep_element in dep_elements:
+                        self.dependencies.add((dep_element, node.lineno))
+                self.generic_visit(node)
+
+            def visit_Attribute(self, node):
+                if isinstance(node.value, ast.Name):
+                    name = f"{node.value.id}.{node.attr}"
+                    dep_elements = name_to_element.get(name, set())
+                    for dep_element in dep_elements:
+                        self.dependencies.add((dep_element, node.lineno))
+                self.generic_visit(node)
+
+            def visit_Name(self, node):
+                if isinstance(node.ctx, ast.Load):
+                    name = node.id
+                    dep_elements = name_to_element.get(name, set())
+                    for dep_element in dep_elements:
+                        self.dependencies.add((dep_element, node.lineno))
+
+        visitor = DependencyVisitor(dependencies)
+        visitor.visit(tree)
+        return dependencies

deply/collectors/__init__.py

@@ -0,0 +1,3 @@
+from .base_collector import BaseCollector
+from .file_regex_collector import FileRegexCollector
+from .class_inherits_collector import ClassInheritsCollector

deply/collectors/base_collector.py

@@ -0,0 +1,8 @@
+from abc import ABC, abstractmethod
+from ..models.code_element import CodeElement
+
+
+class BaseCollector(ABC):
+    @abstractmethod
+    def collect(self) -> set[CodeElement]:
+        pass

deply/collectors/class_inherits_collector.py

@@ -0,0 +1,44 @@
+import ast
+from pathlib import Path
+from typing import Set
+from .base_collector import BaseCollector
+from ..models.code_element import CodeElement
+from ..utils.ast_utils import get_import_aliases, get_base_name
+
+
+class ClassInheritsCollector(BaseCollector):
+    def __init__(self, config: dict, project_root: Path):
+        self.base_class = config.get("base_class", "")
+        self.project_root = project_root
+
+    def collect(self) -> Set[CodeElement]:
+        collected_elements = set()
+        for file_path in self.project_root.rglob("*.py"):
+            tree = self.parse_file(file_path)
+            classes = self.get_classes_inheriting(tree, file_path)
+            collected_elements.update(classes)
+
+        return collected_elements
+
+    def parse_file(self, file_path: Path):
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                return ast.parse(f.read(), filename=str(file_path))
+        except SyntaxError:
+            return None
+
+    def get_classes_inheriting(self, tree, file_path: Path) -> set[CodeElement]:
+        import_aliases = get_import_aliases(tree)
+        classes = set()
+        for node in ast.walk(tree):
+            if isinstance(node, ast.ClassDef):
+                for base in node.bases:
+                    base_name = get_base_name(base, import_aliases)
+                    if base_name == self.base_class:
+                        code_element = CodeElement(
+                            file=file_path,
+                            name=node.name,
+                            element_type='class'
+                        )
+                        classes.add(code_element)
+        return classes

deply/collectors/collector_factory.py

@@ -0,0 +1,17 @@
+from typing import Dict, Any
+from pathlib import Path
+from .base_collector import BaseCollector
+from .file_regex_collector import FileRegexCollector
+from .class_inherits_collector import ClassInheritsCollector
+
+
+class CollectorFactory:
+    @staticmethod
+    def create(config: Dict[str, Any], project_root: Path) -> BaseCollector:
+        collector_type = config.get("type")
+        if collector_type == "file_regex":
+            return FileRegexCollector(config, project_root)
+        elif collector_type == "class_inherits":
+            return ClassInheritsCollector(config, project_root)
+        else:
+            raise ValueError(f"Unknown collector type: {collector_type}")

deply/collectors/file_regex_collector.py

@@ -0,0 +1,86 @@
+import re
+import ast
+from pathlib import Path
+from typing import Set
+from .base_collector import BaseCollector
+from ..models.code_element import CodeElement
+
+
+class FileRegexCollector(BaseCollector):
+    def __init__(self, config: dict, project_root: Path):
+        self.regex_pattern = config.get("regex", "")
+        self.element_type = config.get("element_type", "")  # 'class', 'function', 'variable'
+        self.regex = re.compile(self.regex_pattern)
+        self.project_root = project_root
+
+    def collect(self) -> Set[CodeElement]:
+        all_files = self.get_all_files()
+        collected_elements = set()
+        for file_path in all_files:
+            relative_path = str(file_path.relative_to(self.project_root))
+            if self.regex.match(relative_path):
+                elements = self.get_elements_in_file(file_path)
+                collected_elements.update(elements)
+        return collected_elements
+
+    def get_all_files(self):
+        return [f for f in self.project_root.rglob('*.py') if f.is_file()]
+
+    def get_elements_in_file(self, file_path: Path) -> Set[CodeElement]:
+        elements = set()
+        tree = self.parse_file(file_path)
+        if tree is None:
+            return elements
+
+        if not self.element_type or self.element_type == 'class':
+            elements.update(self.get_class_names(tree, file_path))
+        if not self.element_type or self.element_type == 'function':
+            elements.update(self.get_function_names(tree, file_path))
+        if not self.element_type or self.element_type == 'variable':
+            elements.update(self.get_variable_names(tree, file_path))
+        return elements
+
+    def parse_file(self, file_path: Path):
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                return ast.parse(f.read(), filename=str(file_path))
+        except SyntaxError:
+            return None
+
+    def get_class_names(self, tree, file_path: Path) -> Set[CodeElement]:
+        classes = set()
+        for node in ast.walk(tree):
+            if isinstance(node, ast.ClassDef):
+                code_element = CodeElement(
+                    file=file_path,
+                    name=node.name,
+                    element_type='class'
+                )
+                classes.add(code_element)
+        return classes
+
+    def get_function_names(self, tree, file_path: Path) -> Set[CodeElement]:
+        functions = set()
+        for node in ast.walk(tree):
+            if isinstance(node, ast.FunctionDef):
+                code_element = CodeElement(
+                    file=file_path,
+                    name=node.name,
+                    element_type='function'
+                )
+                functions.add(code_element)
+        return functions
+
+    def get_variable_names(self, tree, file_path: Path) -> Set[CodeElement]:
+        variables = set()
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Assign):
+                for target in node.targets:
+                    if isinstance(target, ast.Name):
+                        code_element = CodeElement(
+                            file=file_path,
+                            name=target.id,
+                            element_type='variable'
+                        )
+                        variables.add(code_element)
+        return variables

deply/config_parser.py

@@ -0,0 +1,13 @@
+from pathlib import Path
+from typing import Any, Dict
+import yaml
+
+
+class ConfigParser:
+    def __init__(self, config_path: Path):
+        self.config_path = config_path
+
+    def parse(self) -> Dict[str, Any]:
+        with self.config_path.open("r") as f:
+            config = yaml.safe_load(f)
+        return config

deply/file_regex_collector.py

@@ -0,0 +1,16 @@
+import re
+from pathlib import Path
+from typing import Set
+from .base_collector import BaseCollector
+from ..utils.file_utils import get_python_files
+
+
+class FileRegexCollector(BaseCollector):
+    def __init__(self, config: dict, project_root: Path):
+        self.regex = re.compile(config.get("regex", ""))
+        self.project_root = project_root
+
+    def collect(self) -> Set[Path]:
+        files = get_python_files(self.project_root)
+        matched_files = {f for f in files if self.regex.match(str(f.relative_to(self.project_root)))}
+        return matched_files

deply/main.py

@@ -0,0 +1,69 @@
+import argparse
+from pathlib import Path
+from .config_parser import ConfigParser
+from .collectors.collector_factory import CollectorFactory
+from .code_analyzer import CodeAnalyzer
+from .rules.dependency_rule import DependencyRule
+from .reports.report_generator import ReportGenerator
+
+
+def main():
+    # Parse command-line arguments
+    parser = argparse.ArgumentParser(prog="deply", description='Deply')
+    parser.add_argument("--config", required=True, type=str, help="Path to the configuration YAML file")
+    parser.add_argument("--project_root", required=True, type=str, help="Root directory of the project to analyze")
+    parser.add_argument("--report-format", type=str, choices=["text", "json", "html"], default="text",
+                        help="Format of the output report")
+    parser.add_argument("--output", type=str, help="Output file for the report")
+    args = parser.parse_args()
+
+    config_path = Path(args.config)
+    project_root = Path(args.project_root)
+
+    # Parse configuration
+    config = ConfigParser(config_path).parse()
+
+    # Collect code elements
+    code_elements = set()
+    code_element_to_layer = {}
+    for layer in config['layers']:
+        layer_name = layer['name']
+        for collector_config in layer['collectors']:
+            collector = CollectorFactory.create(collector_config, project_root)
+            collected = collector.collect()
+            code_elements.update(collected)
+            for element in collected:
+                code_element_to_layer[element] = layer_name
+
+    # Analyze code to find dependencies
+    analyzer = CodeAnalyzer(code_elements)
+    analyzer.analyze()
+    code_element_dependencies = analyzer.dependencies
+
+    # Apply rules
+    rule = DependencyRule(config['ruleset'])
+    violations = rule.check(
+        code_element_to_layer=code_element_to_layer,
+        code_element_dependencies=code_element_dependencies
+    )
+
+    # Generate report
+    report_generator = ReportGenerator(violations)
+    report = report_generator.generate(format=args.report_format)
+
+    # Output the report
+    if args.output:
+        output_path = Path(args.output)
+        output_path.write_text(report)
+    else:
+        print(report)
+
+    # Exit with appropriate status
+    if violations:
+        exit(1)
+    else:
+        exit(0)
+
+
+if __name__ == "__main__":
+    main()

deply/rules/__init__.py

@@ -0,0 +1,3 @@
+from .base_rule import BaseRule
+from .dependency_rule import DependencyRule
+from .rule_factory import RuleFactory

deply/rules/base_rule.py

@@ -0,0 +1,11 @@
+from ..models.code_element import CodeElement
+from ..models.violation import Violation
+
+
+class BaseRule:
+    def check(
+            self,
+            code_element_to_layer: dict[CodeElement, str],
+            code_element_dependencies: dict[CodeElement, set[tuple[CodeElement, int]]],
+    ) -> list[Violation]:
+        raise NotImplementedError

deply/rules/dependency_rule.py

@@ -0,0 +1,50 @@
+# rules/dependency_rule.py
+
+from .base_rule import BaseRule
+from ..models.code_element import CodeElement
+from ..models.violation import Violation
+
+
+class DependencyRule(BaseRule):
+    def __init__(self, ruleset: dict[str, dict[str, list[str]]]):
+        self.ruleset = ruleset
+
+    def check(
+            self,
+            code_element_to_layer: dict[CodeElement, str],
+            code_element_dependencies: dict[CodeElement, set[tuple[CodeElement, int]]],
+    ) -> list[Violation]:
+        violations = []
+        for code_element, layer_name in code_element_to_layer.items():
+            layer_rules = self.ruleset.get(layer_name, {})
+            allowed_layers = set(layer_rules.get("allow", []))
+            disallowed_layers = set(layer_rules.get("disallow", []))
+            dependencies = code_element_dependencies.get(code_element, set())
+            for dep_element, line_number in dependencies:
+                dep_layer = code_element_to_layer.get(dep_element)
+
+                if dep_layer and dep_layer != layer_name:
+                    if dep_layer in disallowed_layers:
+
+                        message = f"Layer '{layer_name}' is not allowed to depend on layer '{dep_layer}'"
+                        violations.append(
+                            Violation(
+                                file=code_element.file,
+                                element_name=code_element.name,
+                                element_type=code_element.element_type,
+                                line=line_number,
+                                message=message,
+                            )
+                        )
+                    elif allowed_layers and dep_layer not in allowed_layers:
+                        message = f"Layer '{layer_name}' depends on unallowed layer '{dep_layer}'"
+                        violations.append(
+                            Violation(
+                                file=code_element.file,
+                                element_name=code_element.name,
+                                element_type=code_element.element_type,
+                                line=line_number,
+                                message=message,
+                            )
+                        )
+        return violations

deply/rules/rule_factory.py

@@ -0,0 +1,9 @@
+from typing import Dict, Any, List
+from .base_rule import BaseRule
+from .dependency_rule import DependencyRule
+
+
+class RuleFactory:
+    @staticmethod
+    def create_rules(ruleset: Dict[str, Any]) -> List[BaseRule]:
+        return [DependencyRule(ruleset)]

deply-0.1.0.dist-info/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2024, Archil
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

deply-0.1.0.dist-info/METADATA

@@ -0,0 +1,106 @@
+Metadata-Version: 2.1
+Name: deply
+Version: 0.1.0
+Summary: A tool to enforce architectural patterns in python projects
+Home-page: https://github.com/vashkatsi/deply
+Author: Archil Abuladze
+Author-email: armiworker@gmail.com
+License: UNKNOWN
+Project-URL: Bug Tracker, https://github.com/vashkatsi/deply/issues
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyYAML (>=5.1)
+
+# Deply
+
+**Deply** is a standalone Python tool for enforcing architectural patterns and dependencies in large
+python projects. By analyzing code structure and dependencies, this tool ensures that architectural rules are followed,
+promoting cleaner, more maintainable, and modular codebases.
+
+Inspired by https://github.com/qossmic/deptrac
+
+## Features
+
+- **Layer-Based Analysis**: Define project layers and restrict their dependencies to enforce modularity.
+- **Dynamic Layer Configuration**: Easily configure collectors for each layer using file patterns and class inheritance.
+- **Cross-Layer Dependency Rules** (TODO): Specify rules to disallow certain layers from accessing others.
+- **Extensible and Configurable**: Customize layers and rules for any python project setup.
+
+## Installation
+
+To install **Deply**, use `pip`:
+
+```bash
+pip install deply
+```
+
+## Configuration
+
+Before running the tool, create a configuration file (`config.yaml` or similar) that specifies the rules and target
+files to enforce.
+
+### Example Configuration (`config.example.yaml`)
+
+```yaml
+layers:
+  - name: models
+    collectors:
+      - type: class_inherits
+        base_class: "django.db.models.Model"
+
+  - name: services
+    collectors:
+      - type: file_regex
+        regex: "^.*/providers.py$"
+
+  - name: views
+    collectors:
+      - type: file_regex
+        regex: ".*/views_api.py"
+
+ruleset:
+  views:
+    disallow:
+      - models  # Disallows direct access to models in views
+
+```
+
+## Usage
+
+Run the tool from the command line by specifying the project root directory and configuration file:
+
+```bash
+python deply.py --project_root='/path/to/your_project' --config=config.example.yaml
+```
+
+### Arguments
+
+- `--project_root`: The path to the root of the project where apps are located.
+- `--config`: Path to the configuration file that defines the rules and target files.
+
+## Sample Output
+
+If violations are found, the tool will output a summary of architectural violations grouped by app, along with details
+of each violation, such as the file, line number, and violation message.
+
+```plaintext
+/path/to/your_project/your_project/app1/views_api.py:74 - Layer 'views' is not allowed to depend on layer 'models'
+```
+
+## Running Tests
+
+To test the tool, use `unittest`:
+
+```bash
+python -m unittest discover tests
+```
+
+## License
+
+See the [LICENSE](LICENSE) file for details.
+
+

deply-0.1.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+deply/__init__.py,sha256=Zn1KFblwuFHiDRdRAiRnDBRkbPttWh44jKa5zG2ov0E,22
+deply/code_analyzer.py,sha256=bppc8CPanzF_apI0CYO8y-q4tUbprz5r0mX4lLTHK2s,3384
+deply/config_parser.py,sha256=Y3lL4VjE9W9IuFIak0SfzGrxCGz2Yqw2ulsOo1qHMEo,317
+deply/file_regex_collector.py,sha256=oEBEbEMhgjtmhmPkshTl4m0ebZVLnKxm55hvc71bVkw,567
+deply/main.py,sha256=DWOUhKXu05sSw6mBbOJm0p5Yem7Ozf-OJM20XYoH5Tg,2336
+deply/collectors/__init__.py,sha256=AjpFzRM4zyz9avFdnRsYDZd00nYY19gEf91aWr5pQzc,156
+deply/collectors/base_collector.py,sha256=b_RKmnJVKR4detYVWr93yC6izj-MoMPCeCRZLt06IbE,186
+deply/collectors/class_inherits_collector.py,sha256=P_54mhw5xU8SiFYCVOgDF0xc5uufhobFHeIqmPC-3nM,1671
+deply/collectors/collector_factory.py,sha256=ykPYQfDs-HZsr2mI1SWXPotf5Qy9wQoevxsW1L-mlGs,679
+deply/collectors/file_regex_collector.py,sha256=zAKhwctKeSZbKYzoTI0BFSDujh4ih4vEs99lTE8wgeA,3336
+deply/rules/__init__.py,sha256=fuowBlrNBki39MUvD-T11ATZng-8cz_yOzhXQKFUuIo,114
+deply/rules/base_rule.py,sha256=zAjWRTcx_jPMxaTFskNFt9NVaELQfY-CKBy5dBhdrow,345
+deply/rules/dependency_rule.py,sha256=vlKjJlBI_1jgGgDXS-7JmDaJocYooYSfkFOBMX_VycA,2255
+deply/rules/rule_factory.py,sha256=pejJQNoivlP53XXZpK1hR2bxzJOPvYnMB5URbiW_szs,256
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/test.py,sha256=wEjN3qQdmuIH-jmVG6d4dX0SnD0pFSbDHhm3v1INyCM,3106
+deply-0.1.0.dist-info/LICENSE,sha256=bVLuZzbcVnSRRlbO6G8kmv7sN4vLJPrhVvTHSc4LUYI,1493
+deply-0.1.0.dist-info/METADATA,sha256=4WpxYbeXY3Gw4mwnnY1E30jes1j-wJ0t7NFmWckIVyk,2905
+deply-0.1.0.dist-info/WHEEL,sha256=ewwEueio1C2XeHTvT17n8dZUJgOvyCWCt0WVNLClP9o,92
+deply-0.1.0.dist-info/entry_points.txt,sha256=8m_ILhOfLloKfK4IPzRBDw-4ha1oAVLptjLLqPUZswI,43
+deply-0.1.0.dist-info/top_level.txt,sha256=dzbGa4EPLXcGenGwT9w1tLl_DXjbi73jl6suLa4ViXA,12
+deply-0.1.0.dist-info/RECORD,,

deply-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

deply-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+deply = deply.main:main
+

deply-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+deply
+tests

tests/test.py

@@ -0,0 +1,110 @@
+import unittest
+import os
+import shutil
+from deply.main import main
+from unittest.mock import patch
+from io import StringIO
+import sys
+
+
+class TestArchCheck(unittest.TestCase):
+
+    def setUp(self):
+        # Set up a simulated project structure
+        self.test_project_root = os.path.abspath('tests/test_project')
+        self.app_path = os.path.join(self.test_project_root, 'app')
+        os.makedirs(self.app_path, exist_ok=True)
+
+        # create __init__.py in the test_project_root directory
+        with open(os.path.join(self.test_project_root, '__init__.py'), 'w') as f:
+            f.write("")
+
+        # Create config.yaml for the test
+        self.config_path = os.path.join(self.test_project_root, 'config.yaml')
+        with open(self.config_path, 'w') as f:
+            f.write("""
+layers:
+  - name: models
+    collectors:
+      - type: class_inherits
+        base_class: "BaseModel"
+
+  - name: views
+    collectors:
+      - type: file_regex
+        regex: ".*/views.py"
+
+ruleset:
+  views:
+    disallow:
+      - models
+""")
+
+        # create __init__.py in the app directory
+        with open(os.path.join(self.app_path, '__init__.py'), 'w') as f:
+            f.write("")
+
+        # Create models.py with a class
+        with open(os.path.join(self.app_path, 'models.py'), 'w') as f:
+            f.write("""
+class BaseModel:
+    pass
+    
+    
+class MyModel(BaseModel):
+    pass
+""")
+
+    def tearDown(self):
+        # Clean up the test project directory after each test
+        shutil.rmtree(self.test_project_root)
+
+    def test_class_dependency_violation(self):
+        # Create views.py that imports MyModel from models
+        with open(os.path.join(self.app_path, 'views.py'), 'w') as f:
+            f.write("""
+from .models import MyModel
+
+def view_function():
+    instance = MyModel()
+""")
+        # Capture the output
+        with patch.object(sys, 'argv', [
+            'archcheck',
+            '--project_root', self.test_project_root,
+            '--config', self.config_path
+        ]):
+            with patch('sys.stdout', new=StringIO()) as fake_out, patch('sys.stderr', new=StringIO()):
+                try:
+                    main()
+                except SystemExit:
+                    pass
+                output = fake_out.getvalue()
+
+                self.assertIn('views.py:2', output)
+
+    def test_no_violation(self):
+        # Create views.py that does not import from models
+        with open(os.path.join(self.app_path, 'views.py'), 'w') as f:
+            f.write("""
+def view_function():
+    pass
+""")
+        # Capture the output
+        with patch.object(sys, 'argv', [
+            'archcheck',
+            '--project_root', self.test_project_root,
+            '--config', self.config_path
+        ]):
+            with patch('sys.stdout', new=StringIO()) as fake_out, patch('sys.stderr', new=StringIO()):
+                try:
+                    main()
+                except SystemExit:
+                    pass
+                output = fake_out.getvalue()
+
+                self.assertNotIn('views', output)
+
+
+if __name__ == '__main__':
+    unittest.main()