InfoTracker 0.1.0__py3-none-any.whl → 0.2.3__py3-none-any.whl

infotracker/adapters.py

@@ -16,9 +16,15 @@ class MssqlAdapter:
     name = "mssql"
     dialect = "tsql"
 
-    def __init__(self):
+    def __init__(self, config=None):
         self.parser = SqlParser(dialect=self.dialect)
-        self.lineage_generator = OpenLineageGenerator()
+        # Use namespace from config if available
+        namespace = "mssql://localhost/InfoTrackerDW"  # default
+        if config and hasattr(config, 'openlineage'):
+            namespace = f"{config.openlineage.namespace}://localhost/InfoTrackerDW"
+        if config and hasattr(config, 'default_database'):
+            self.parser.set_default_database(config.default_database)
+        self.lineage_generator = OpenLineageGenerator(namespace=namespace)
 
     def extract_lineage(self, sql: str, object_hint: Optional[str] = None) -> str:
         """Extract lineage from SQL and return OpenLineage JSON as string."""
@@ -54,12 +60,13 @@ class MssqlAdapter:
             }
             return json.dumps(error_payload, indent=2, ensure_ascii=False)
         
-_ADAPTERS: Dict[str, Adapter] = {
-    "mssql": MssqlAdapter(),
-}
+_ADAPTERS: Dict[str, Adapter] = {}
 
 
-def get_adapter(name: str) -> Adapter:
+def get_adapter(name: str, config=None) -> Adapter:
     if name not in _ADAPTERS:
-        raise KeyError(f"Unknown adapter '{name}'. Available: {', '.join(_ADAPTERS)}")
+        if name == "mssql":
+            _ADAPTERS[name] = MssqlAdapter(config)
+        else:
+            raise KeyError(f"Unknown adapter '{name}'. Available: mssql")
     return _ADAPTERS[name]

infotracker/cli.py

@@ -93,23 +93,20 @@ def impact(
 @app.command()
 def diff(
     ctx: typer.Context,
-    base: str = typer.Option(..., help="git ref name for base"),
-    head: str = typer.Option(..., help="git ref name for head"),
-    sql_dir: Optional[Path] = typer.Option(None, exists=True, file_okay=False),
-    adapter: Optional[str] = typer.Option(None),
-    severity_threshold: str = typer.Option("BREAKING"),
+    base: Optional[Path] = typer.Option(None, "--base", help="Directory containing base OpenLineage artifacts"),
+    head: Optional[Path] = typer.Option(None, "--head", help="Directory containing head OpenLineage artifacts"),
+    format: str = typer.Option("text", "--format", help="Output format: text|json"),
 ):
+    """Compare two sets of OpenLineage artifacts for breaking changes."""
     cfg: RuntimeConfig = ctx.obj["cfg"]
     engine = Engine(cfg)
-    req = DiffRequest(
-        base=base,
-        head=head,
-        sql_dir=sql_dir or Path(cfg.sql_dir),
-        adapter=adapter or cfg.default_adapter,
-        severity_threshold=severity_threshold,
-    )
-    result = engine.run_diff(req)
-    _emit(result, cfg.output_format)
+    
+    if not base or not head:
+        console.print("[red]ERROR: Both --base and --head directories are required[/red]")
+        raise typer.Exit(1)
+    
+    result = engine.run_diff(base, head, format)
+    _emit(result, format)
     raise typer.Exit(code=result.get("exit_code", 0))
 
 
@@ -121,23 +118,42 @@ def _emit(payload: dict, fmt: str, out_path: Optional[Path] = None) -> None:
     console = Console()
 
     if fmt == "json":
-        console.print_json(json.dumps(payload, ensure_ascii=False))
-        return
-
-    # fmt == "text"
-    table = Table(show_header=True, header_style="bold")
-    cols = payload.get("columns", [])
-    for k in cols:
-        table.add_column(str(k))
-
-    for r in payload.get("rows", []):
-        if isinstance(r, dict):
-            table.add_row(*[str(r.get(c, "")) for c in cols])
+        content = json.dumps(payload, ensure_ascii=False, indent=2)
+    else:
+        # fmt == "text" - we'll capture the table as a string
+        table = Table(show_header=True, header_style="bold")
+        cols = payload.get("columns", [])
+        for k in cols:
+            table.add_column(str(k))
+
+        for r in payload.get("rows", []):
+            if isinstance(r, dict):
+                table.add_row(*[str(r.get(c, "")) for c in cols])
+            else:
+                # lista / krotka — dopasuj po pozycji
+                table.add_row(*[str(x) for x in (list(r) + [""] * max(0, len(cols) - len(r)))][:len(cols)])
+
+        if out_path:
+            # Capture table as string for file output
+            from io import StringIO
+            string_io = StringIO()
+            temp_console = Console(file=string_io, width=120)
+            temp_console.print(table)
+            content = string_io.getvalue()
         else:
-            # lista / krotka — dopasuj po pozycji
-            table.add_row(*[str(x) for x in (list(r) + [""] * max(0, len(cols) - len(r)))][:len(cols)])
-
-    console.print(table)
+            # Print to stdout
+            console.print(table)
+            return
+
+    # Write to file if out_path is specified
+    if out_path:
+        out_path.parent.mkdir(parents=True, exist_ok=True)
+        out_path.write_text(content, encoding='utf-8')
+        console.print(f"[green]Output written to {out_path}[/green]")
+    else:
+        # Print to stdout for JSON format
+        if fmt == "json":
+            console.print_json(content)
 
 
 

infotracker/config.py

@@ -7,6 +7,11 @@ from typing import List, Optional
 import yaml
 
 
+@dataclass
+class OpenLineageCfg:
+    namespace: str = "mssql"
+
+
 @dataclass
 class RuntimeConfig:
     default_adapter: str = "mssql"
@@ -20,6 +25,7 @@ class RuntimeConfig:
     catalog: Optional[str] = None
     log_level: str = "info"
     output_format: str = "text"
+    openlineage: OpenLineageCfg = field(default_factory=OpenLineageCfg)
 
 
 def load_config(path: Optional[Path]) -> RuntimeConfig:

infotracker/diff.py

@@ -3,7 +3,7 @@ Breaking change detection for InfoTracker.
 """
 from __future__ import annotations
 
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from enum import Enum
 from typing import Dict, List, Optional, Set, Any
 
@@ -44,12 +44,57 @@ class Change:
     impact_count: int = 0  # Number of downstream columns affected
 
 
+@dataclass
+class DiffReport:
+    """Report containing detected changes and metadata."""
+    changes: List[Change] = field(default_factory=list)
+    
+    @property
+    def has_breaking(self) -> bool:
+        """Check if there are any breaking changes."""
+        return any(c.severity == Severity.BREAKING for c in self.changes)
+    
+    @property
+    def rows(self) -> List[List[str]]:
+        """Get rows for table display."""
+        return [
+            [c.object_name, c.change_type.value, c.severity.value, c.description]
+            for c in self.changes
+        ]
+    
+    @property
+    def columns(self) -> List[str]:
+        """Get column headers for table display."""
+        return ["object", "change_type", "severity", "description"]
+
+
+@dataclass
+class DiffResult:
+    """Result of diff operation."""
+    report: DiffReport
+    exit_code: int
+    
+    @property
+    def rows(self) -> List[List[str]]:
+        return self.report.rows
+    
+    @property
+    def columns(self) -> List[str]:
+        return self.report.columns
+
+
 class BreakingChangeDetector:
     """Detects breaking changes between two sets of object information."""
     
     def __init__(self):
         self.changes: List[Change] = []
     
+    def compare(self, base_objects: List[ObjectInfo], head_objects: List[ObjectInfo]) -> DiffReport:
+        """Compare base and head objects and return a diff report."""
+        self.changes = []
+        self.detect_changes(base_objects, head_objects)
+        return DiffReport(changes=self.changes.copy())
+    
     def detect_changes(self, base_objects: List[ObjectInfo], head_objects: List[ObjectInfo]) -> List[Change]:
         """Detect changes between base and head object lists."""
         self.changes = []
@@ -117,8 +162,18 @@ class BreakingChangeDetector:
         base_names = set(base_columns.keys())
         head_names = set(head_columns.keys())
         
-        # Column additions
-        for added_name in head_names - base_names:
+        # Detect column renames before processing additions/removals
+        removed = base_names - head_names
+        added = head_names - base_names
+        renamed_pairs = self._detect_column_renames(base_columns, head_columns, removed, added, base_obj, head_obj)
+        
+        # Remove renamed columns from added/removed sets
+        for old_name, new_name in renamed_pairs:
+            removed.discard(old_name)
+            added.discard(new_name)
+        
+        # Column additions (after removing renames)
+        for added_name in added:
             col = head_columns[added_name]
             severity = Severity.POTENTIALLY_BREAKING  # Could affect SELECT *
             self.changes.append(Change(
@@ -130,8 +185,8 @@ class BreakingChangeDetector:
                 description=f"Added column '{col.name}' ({col.data_type})"
             ))
         
-        # Column removals
-        for removed_name in base_names - head_names:
+        # Column removals (after removing renames)
+        for removed_name in removed:
             col = base_columns[removed_name]
             self.changes.append(Change(
                 change_type=ChangeType.COLUMN_REMOVED,
@@ -142,48 +197,58 @@ class BreakingChangeDetector:
                 description=f"Removed column '{col.name}'"
             ))
         
-        # Column changes for existing columns
-        for common_name in base_names & head_names:
-            base_col = base_columns[common_name]
-            head_col = head_columns[common_name]
-            
-            # Type changes
-            if base_col.data_type != head_col.data_type:
-                severity = self._classify_type_change_severity(base_col.data_type, head_col.data_type)
-                self.changes.append(Change(
-                    change_type=ChangeType.COLUMN_TYPE_CHANGED,
-                    severity=severity,
-                    object_name=base_obj.name,
-                    column_name=base_col.name,
-                    old_value=base_col.data_type,
-                    new_value=head_col.data_type,
-                    description=f"Changed column '{base_col.name}' type from {base_col.data_type} to {head_col.data_type}"
-                ))
-            
-            # Nullability changes
-            if base_col.nullable != head_col.nullable:
-                severity = Severity.BREAKING if not head_col.nullable else Severity.POTENTIALLY_BREAKING
-                self.changes.append(Change(
-                    change_type=ChangeType.COLUMN_NULLABILITY_CHANGED,
-                    severity=severity,
-                    object_name=base_obj.name,
-                    column_name=base_col.name,
-                    old_value="NULL" if base_col.nullable else "NOT NULL",
-                    new_value="NULL" if head_col.nullable else "NOT NULL",
-                    description=f"Changed column '{base_col.name}' nullability"
-                ))
-            
-            # Ordinal changes (column order)
-            if base_col.ordinal != head_col.ordinal:
-                self.changes.append(Change(
-                    change_type=ChangeType.COLUMN_ORDER_CHANGED,
-                    severity=Severity.POTENTIALLY_BREAKING,
-                    object_name=base_obj.name,
-                    column_name=base_col.name,
-                    old_value=base_col.ordinal,
-                    new_value=head_col.ordinal,
-                    description=f"Changed column '{base_col.name}' position from {base_col.ordinal} to {head_col.ordinal}"
-                ))
+        # Column changes for existing columns (including renamed ones)
+        for common_name in (base_names & head_names) | {new_name for _, new_name in renamed_pairs}:
+            # For renamed columns, use the new name to find the head column
+            if common_name in head_columns:
+                head_col = head_columns[common_name]
+                # Find corresponding base column (could be renamed)
+                base_col = None
+                for old_name, new_name in renamed_pairs:
+                    if new_name == common_name:
+                        base_col = base_columns[old_name]
+                        break
+                if not base_col and common_name in base_columns:
+                    base_col = base_columns[common_name]
+                
+                if base_col:
+                    # Type changes
+                    if base_col.data_type != head_col.data_type:
+                        severity = self._classify_type_change_severity(base_col.data_type, head_col.data_type)
+                        self.changes.append(Change(
+                            change_type=ChangeType.COLUMN_TYPE_CHANGED,
+                            severity=severity,
+                            object_name=base_obj.name,
+                            column_name=head_col.name,  # Use new name for renamed columns
+                            old_value=base_col.data_type,
+                            new_value=head_col.data_type,
+                            description=f"Changed column '{head_col.name}' type from {base_col.data_type} to {head_col.data_type}"
+                        ))
+                    
+                    # Nullability changes
+                    if base_col.nullable != head_col.nullable:
+                        severity = Severity.BREAKING if not head_col.nullable else Severity.POTENTIALLY_BREAKING
+                        self.changes.append(Change(
+                            change_type=ChangeType.COLUMN_NULLABILITY_CHANGED,
+                            severity=severity,
+                            object_name=base_obj.name,
+                            column_name=head_col.name,  # Use new name for renamed columns
+                            old_value="NULL" if base_col.nullable else "NOT NULL",
+                            new_value="NULL" if head_col.nullable else "NOT NULL",
+                            description=f"Changed column '{head_col.name}' nullability"
+                        ))
+                    
+                    # Ordinal changes (column order)
+                    if base_col.ordinal != head_col.ordinal:
+                        self.changes.append(Change(
+                            change_type=ChangeType.COLUMN_ORDER_CHANGED,
+                            severity=Severity.POTENTIALLY_BREAKING,
+                            object_name=base_obj.name,
+                            column_name=head_col.name,  # Use new name for renamed columns
+                            old_value=base_col.ordinal,
+                            new_value=head_col.ordinal,
+                            description=f"Changed column '{head_col.name}' position from {base_col.ordinal} to {head_col.ordinal}"
+                        ))
     
     def _detect_lineage_changes(self, base_obj: ObjectInfo, head_obj: ObjectInfo) -> None:
         """Detect lineage changes for columns."""
@@ -222,6 +287,102 @@ class BreakingChangeDetector:
                     description=f"Changed input dependencies for '{base_lin.output_column}'"
                 ))
     
+    def _detect_column_renames(self, base_columns: Dict[str, ColumnSchema], head_columns: Dict[str, ColumnSchema], 
+                               removed: Set[str], added: Set[str], base_obj: ObjectInfo, head_obj: ObjectInfo) -> List[tuple[str, str]]:
+        """
+        Detect column renames using scoring algorithm.
+        Returns list of (old_name, new_name) tuples.
+        """
+        if not removed or not added:
+            return []
+        
+        # Build lineage lookup for both objects
+        base_lineage = {lin.output_column.lower(): lin for lin in base_obj.lineage}
+        head_lineage = {lin.output_column.lower(): lin for lin in head_obj.lineage}
+        
+        renamed_pairs = []
+        
+        for old_name in list(removed):
+            best_score = 0
+            best_candidate = None
+            candidates_with_score = []
+            
+            old_col = base_columns[old_name]
+            old_lineage = base_lineage.get(old_name)
+            
+            for new_name in added:
+                new_col = head_columns[new_name]
+                score = 0
+                
+                # +2 for matching data type (case-insensitive)
+                if self._normalize_data_type(old_col.data_type) == self._normalize_data_type(new_col.data_type):
+                    score += 2
+                
+                # +2 for matching nullability
+                if old_col.nullable == new_col.nullable:
+                    score += 2
+                
+                # +3 for identical lineage input_fields or +1 for similar ordinal if no lineage
+                if old_lineage:
+                    new_lineage = head_lineage.get(new_name)
+                    if new_lineage and self._compare_lineage_input_fields(old_lineage, new_lineage):
+                        score += 3
+                else:
+                    # If no lineage, use ordinal proximity
+                    if abs(old_col.ordinal - new_col.ordinal) <= 1:
+                        score += 1
+                
+                # +1 for matching length/precision (if extractable from type)
+                if self._compare_type_precision(old_col.data_type, new_col.data_type):
+                    score += 1
+                
+                candidates_with_score.append((new_name, score))
+                
+                if score > best_score:
+                    best_score = score
+                    best_candidate = new_name
+            
+            # Check if best candidate has score >= 4 and is unambiguous
+            if best_score >= 4:
+                # Check for ties
+                tied_candidates = [name for name, score in candidates_with_score if score == best_score]
+                if len(tied_candidates) == 1:
+                    renamed_pairs.append((old_name, best_candidate))
+                    
+                    # Register the rename change
+                    self.changes.append(Change(
+                        change_type=ChangeType.COLUMN_RENAMED,
+                        severity=Severity.POTENTIALLY_BREAKING,
+                        object_name=base_obj.name,
+                        column_name=f"{old_col.name}→{head_columns[best_candidate].name}",
+                        description=f"Column renamed from '{old_col.name}' to '{head_columns[best_candidate].name}' with matching type/nullability/lineage"
+                    ))
+        
+        return renamed_pairs
+    
+    def _normalize_data_type(self, data_type: str) -> str:
+        """Normalize data type for comparison (case-insensitive)."""
+        return data_type.upper().strip()
+    
+    def _compare_lineage_input_fields(self, lineage1: ColumnLineage, lineage2: ColumnLineage) -> bool:
+        """Compare if two lineages have identical input fields."""
+        fields1 = {(ref.table_name, ref.column_name) for ref in lineage1.input_fields}
+        fields2 = {(ref.table_name, ref.column_name) for ref in lineage2.input_fields}
+        return fields1 == fields2
+    
+    def _compare_type_precision(self, type1: str, type2: str) -> bool:
+        """Compare if types have matching length/precision."""
+        import re
+        
+        # Extract precision info from types like VARCHAR(100), DECIMAL(10,2)
+        def extract_precision(type_str: str) -> tuple:
+            match = re.search(r'\(([^)]+)\)', type_str)
+            if match:
+                return tuple(match.group(1).split(','))
+            return ()
+        
+        return extract_precision(type1) == extract_precision(type2)
+
     def _classify_type_change_severity(self, old_type: str, new_type: str) -> Severity:
         """Classify the severity of a type change."""
         old_type = old_type.upper()