deply 0.2.2__tar.gz → 0.2.4__tar.gz

{deply-0.2.2/deply.egg-info → deply-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: deply
-Version: 0.2.2
+Version: 0.2.4
 Summary: A tool to enforce architectural patterns in python projects
 Home-page: https://github.com/vashkatsi/deply
 Author: Archil Abuladze

deply-0.2.4/deply/__init__.py

@@ -0,0 +1 @@
+__version__ = '0.2.4'

{deply-0.2.2 → deply-0.2.4}/deply/main.py

@@ -1,5 +1,6 @@
 import argparse
 import sys
+import logging
 from pathlib import Path
 
 from deply import __version__
@@ -16,13 +17,14 @@ from .rules.dependency_rule import DependencyRule
 def main():
     parser = argparse.ArgumentParser(prog="deply", description='Deply - A dependency analysis tool')
     parser.add_argument('-V', '--version', action='store_true', help='Show the version number and exit')
+    parser.add_argument('-v', '--verbose', action='count', default=1, help='Increase output verbosity')
 
     subparsers = parser.add_subparsers(dest='command', help='Sub-commands')
-    parser_analyse = subparsers.add_parser('analyze', help='Analyze the project dependencies')
-    parser_analyse.add_argument('--config', type=str, default="deply.yaml", help="Path to the configuration YAML file")
-    parser_analyse.add_argument('--report-format', type=str, choices=["text", "json", "html"], default="text",
+    parser_analyze = subparsers.add_parser('analyze', help='Analyze the project dependencies')
+    parser_analyze.add_argument('--config', type=str, default="deply.yaml", help="Path to the configuration YAML file")
+    parser_analyze.add_argument('--report-format', type=str, choices=["text", "json", "html"], default="text",
                                 help="Format of the output report")
-    parser_analyse.add_argument('--output', type=str, help="Output file for the report")
+    parser_analyze.add_argument('--output', type=str, help="Output file for the report")
     args = parser.parse_args()
 
     if args.version:
@@ -30,23 +32,47 @@ def main():
         print(f"deply {version}")
         sys.exit(0)
 
+    # Set up logging
+    log_level = logging.WARNING  # Default log level
+    if args.verbose == 1:
+        log_level = logging.INFO
+    elif args.verbose >= 2:
+        log_level = logging.DEBUG
+
+    logging.basicConfig(
+        level=log_level,
+        format='[%(asctime)s] [%(levelname)s] %(message)s',
+        datefmt='%Y-%m-%d %H:%M:%S'
+    )
+
+    if args.command is None:
+        args = parser.parse_args(['analyze'] + sys.argv[1:])
+
+    logging.info("Starting Deply analysis...")
+
     # Parse configuration
     config_path = Path(args.config)
+    logging.info(f"Using configuration file: {config_path}")
     config = ConfigParser(config_path).parse()
 
     # Collect code elements and organize them by layers
     layers: dict[str, Layer] = {}
     code_element_to_layer: dict[CodeElement, str] = {}
 
+    logging.info("Collecting code elements for each layer...")
     for layer_config in config['layers']:
         layer_name = layer_config['name']
+        logging.debug(f"Processing layer: {layer_name}")
         collectors = layer_config.get('collectors', [])
         collected_elements: set[CodeElement] = set()
 
         for collector_config in collectors:
+            collector_type = collector_config.get('type', 'unknown')
+            logging.debug(f"Using collector: {collector_type} for layer: {layer_name}")
             collector = CollectorFactory.create(collector_config, config['paths'], config['exclude_files'])
             collected = collector.collect()
             collected_elements.update(collected)
+            logging.debug(f"Collected {len(collected)} elements for collector {collector_type}")
 
         # Initialize Layer with collected code elements
         layer = Layer(
@@ -55,26 +81,33 @@ def main():
             dependencies=set()
         )
         layers[layer_name] = layer
+        logging.info(f"Layer '{layer_name}' collected {len(collected_elements)} code elements.")
 
         # Map each code element to its layer
         for element in collected_elements:
             code_element_to_layer[element] = layer_name
 
     # Analyze code to find dependencies
+    logging.info("Analyzing code to find dependencies...")
     analyzer = CodeAnalyzer(set(code_element_to_layer.keys()))
     dependencies: set[Dependency] = analyzer.analyze()
+    logging.info(f"Found {len(dependencies)} dependencies.")
 
     # Assign dependencies to respective layers
+    logging.info("Assigning dependencies to layers...")
     for dependency in dependencies:
         source_layer_name = code_element_to_layer.get(dependency.code_element)
         if source_layer_name and source_layer_name in layers:
             layers[source_layer_name].dependencies.add(dependency)
 
     # Apply rules
+    logging.info("Applying dependency rules...")
     rule = DependencyRule(config['ruleset'])
     violations = rule.check(layers=layers)
+    logging.info(f"Analysis complete. Found {len(violations)} violation(s).")
 
     # Generate report
+    logging.info("Generating report...")
     report_generator = ReportGenerator(violations)
     report = report_generator.generate(format=args.report_format)
 
@@ -82,13 +115,17 @@ def main():
     if args.output:
         output_path = Path(args.output)
         output_path.write_text(report)
+        logging.info(f"Report written to {output_path}")
     else:
+        print("\n")
         print(report)
 
     # Exit with appropriate status
     if violations:
+        print(f"\n\nTotal violation(s): {len(violations)}")
         exit(1)
     else:
+        logging.info("No violations detected.")
         exit(0)
 
 

deply-0.2.4/deply/models/violation.py

@@ -0,0 +1,21 @@
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class Violation:
+    file: Path
+    element_name: str
+    element_type: str  # 'class', 'function', or 'variable'
+    line: int
+    column: int
+    message: str
+
+    def __hash__(self):
+        return hash((self.file, self.line, self.column, self.message))
+
+    def __eq__(self, other):
+        return (
+                (self.file, self.line, self.column, self.message)
+                == (other.file, other.line, other.column, other.message)
+        )

{deply-0.2.2 → deply-0.2.4}/deply/reports/formats/text_report.py

@@ -6,9 +6,13 @@ class TextReport:
         self.violations = violations
 
     def generate(self) -> str:
-        lines = set()
-        for violation in self.violations:
-            lines.add(
+        sorted_violations = sorted(
+            self.violations,
+            key=lambda v: (v.file, v.line, v.column)
+        )
+        lines = []
+        for violation in sorted_violations:
+            lines.append(
                 f"{violation.file}:{violation.line}:{violation.column} - {violation.message}"
                 # + f" ({violation.element_type} '{violation.element_name}')"
             )

{deply-0.2.2 → deply-0.2.4}/deply/rules/dependency_rule.py

@@ -1,5 +1,5 @@
 # rules/dependency_rule.py
-from typing import Dict, List
+from typing import Dict, List, Set
 
 from deply.models.code_element import CodeElement
 from deply.models.layer import Layer
@@ -12,7 +12,7 @@ class DependencyRule(BaseRule):
         self.ruleset = ruleset
 
     def check(self, layers: Dict[str, Layer]) -> List[Violation]:
-        violations: List[Violation] = []
+        violations: Set[Violation] = set()
 
         # Build a mapping from CodeElement to Layer name for quick lookup
         code_element_to_layer: Dict[CodeElement, str] = {}
@@ -51,7 +51,7 @@ class DependencyRule(BaseRule):
                         column=dependency.column,
                         message=message,
                     )
-                    violations.append(violation)
+                    violations.add(violation)
 
                 # Check against allowed layers if "allow" is specified
                 if allowed_layers and target_layer not in allowed_layers:
@@ -67,6 +67,6 @@ class DependencyRule(BaseRule):
                         column=dependency.column,
                         message=message,
                     )
-                    violations.append(violation)
+                    violations.add(violation)
 
-        return violations
+        return list(violations)

{deply-0.2.2 → deply-0.2.4/deply.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: deply
-Version: 0.2.2
+Version: 0.2.4
 Summary: A tool to enforce architectural patterns in python projects
 Home-page: https://github.com/vashkatsi/deply
 Author: Archil Abuladze

deply-0.2.2/deply/__init__.py

@@ -1 +0,0 @@
-__version__ = '0.2.2'

deply-0.2.2/deply/models/violation.py

@@ -1,12 +0,0 @@
-from dataclasses import dataclass
-from pathlib import Path
-
-
-@dataclass(frozen=True)
-class Violation:
-    file: Path
-    element_name: str
-    element_type: str  # 'class', 'function', or 'variable'
-    line: int
-    column: int
-    message: str