gitflow-analytics 1.0.3__py3-none-any.whl → 1.3.11__py3-none-any.whl

gitflow_analytics/tui/screens/results_screen.py

@@ -3,37 +3,34 @@
 import json
 from datetime import datetime
 from pathlib import Path
-from typing import Optional, Dict, Any, List
+from typing import Any, Optional
 
-from textual.widgets import (
-    Header, Footer, Label, Static, Button, 
-    TabbedContent, TabPane, Rule
-)
-from textual.containers import Container, Vertical, Horizontal, ScrollableContainer
-from textual.screen import Screen
-from textual.binding import Binding
 from rich.table import Table
-from rich.text import Text
+from textual.binding import Binding
+from textual.containers import Container, Horizontal, ScrollableContainer, Vertical
+from textual.screen import Screen
+from textual.widgets import Button, Footer, Header, Label, Rule, Static, TabbedContent, TabPane
+
+from gitflow_analytics.config import Config
 
 from ..widgets.data_table import EnhancedDataTable
 from ..widgets.export_modal import ExportModal
-from gitflow_analytics.config import Config
 
 
 class ResultsScreen(Screen):
     """
     Screen displaying comprehensive analysis results with interactive exploration.
-    
-    WHY: Analysis results are complex and multi-dimensional, requiring an 
+
+    WHY: Analysis results are complex and multi-dimensional, requiring an
     interactive interface that allows users to explore different aspects of
     the data. Tabbed layout organizes information logically while providing
     powerful data exploration capabilities.
-    
+
     DESIGN DECISION: Uses tabbed interface to separate different result categories
     while providing consistent export functionality across all views. Interactive
     tables allow users to sort, filter, and drill down into specific data points.
     """
-    
+
     BINDINGS = [
         Binding("escape", "back", "Back to Main"),
         Binding("ctrl+s", "export", "Export Results"),
@@ -41,16 +38,16 @@ class ResultsScreen(Screen):
         Binding("r", "refresh", "Refresh View"),
         Binding("ctrl+e", "export_current", "Export Current View"),
     ]
-    
+
     def __init__(
         self,
-        commits: List[Dict],
-        prs: List[Dict],
-        developers: List[Dict],
+        commits: list[dict],
+        prs: list[dict],
+        developers: list[dict],
         config: Config,
         *,
         name: Optional[str] = None,
-        id: Optional[str] = None
+        id: Optional[str] = None,
     ) -> None:
         super().__init__(name=name, id=id)
         self.commits = commits
@@ -58,414 +55,443 @@ class ResultsScreen(Screen):
         self.developers = developers
         self.config = config
         self.current_tab = "summary"
-        
+
     def compose(self):
         """Compose the results screen."""
         yield Header()
-        
+
         with Container(id="results-container"):
             yield Label("GitFlow Analytics - Results", classes="screen-title")
-            
+
             with TabbedContent(initial="summary"):
                 # Summary Tab
                 with TabPane("Summary", id="summary"):
                     yield self._create_summary_panel()
-                
+
                 # Developers Tab
                 with TabPane("Developers", id="developers"):
                     yield self._create_developers_panel()
-                
+
                 # Commits Tab
                 with TabPane("Commits", id="commits"):
                     yield self._create_commits_panel()
-                
+
                 # Pull Requests Tab (if available)
                 if self.prs:
                     with TabPane("Pull Requests", id="pull-requests"):
                         yield self._create_prs_panel()
-                
+
                 # Qualitative Insights Tab (if available)
                 if self._has_qualitative_data():
                     with TabPane("Qualitative Insights", id="qualitative"):
                         yield self._create_qualitative_panel()
-                
+
                 # Export Tab
                 with TabPane("Export", id="export"):
                     yield self._create_export_panel()
-        
+
         yield Footer()
-    
+
     def _create_summary_panel(self) -> ScrollableContainer:
         """
         Create comprehensive summary statistics panel.
-        
+
         WHY: Provides high-level overview of all analysis results in a single view,
         allowing users to quickly understand the overall scope and key metrics
         without diving into detailed data tables.
         """
         container = ScrollableContainer()
-        
+
         # Key metrics section
         container.mount(Label("Analysis Summary", classes="section-title"))
-        
+
         # Create summary table
         summary_table = Table(show_header=False, show_edge=False, pad_edge=False)
         summary_table.add_column("Metric", style="bold cyan", width=25)
         summary_table.add_column("Value", style="green", width=15)
         summary_table.add_column("Details", style="dim", width=40)
-        
+
         # Calculate key metrics
         total_commits = len(self.commits)
         total_prs = len(self.prs)
         total_developers = len(self.developers)
-        
+
         # Time range
         if self.commits:
-            dates = [c.get('timestamp') for c in self.commits if c.get('timestamp')]
+            dates = [c.get("timestamp") for c in self.commits if c.get("timestamp")]
             if dates:
-                min_date = min(dates).strftime('%Y-%m-%d')
-                max_date = max(dates).strftime('%Y-%m-%d')
+                min_date = min(dates).strftime("%Y-%m-%d")
+                max_date = max(dates).strftime("%Y-%m-%d")
                 date_range = f"{min_date} to {max_date}"
             else:
                 date_range = "Unknown"
         else:
             date_range = "No data"
-        
+
         # Story points
-        total_story_points = sum(c.get('story_points', 0) or 0 for c in self.commits)
-        
+        total_story_points = sum(c.get("story_points", 0) or 0 for c in self.commits)
+
         # Ticket coverage
-        commits_with_tickets = sum(1 for c in self.commits if c.get('ticket_references'))
+        commits_with_tickets = sum(1 for c in self.commits if c.get("ticket_references"))
         ticket_coverage = (commits_with_tickets / total_commits * 100) if total_commits > 0 else 0
-        
+
         # Add metrics to table
-        summary_table.add_row("Total Commits", f"{total_commits:,}", "All commits in analysis period")
+        summary_table.add_row(
+            "Total Commits", f"{total_commits:,}", "All commits in analysis period"
+        )
         summary_table.add_row("Total Pull Requests", f"{total_prs:,}", "Detected pull requests")
-        summary_table.add_row("Active Developers", f"{total_developers:,}", "Unique developer identities")
+        summary_table.add_row(
+            "Active Developers", f"{total_developers:,}", "Unique developer identities"
+        )
         summary_table.add_row("Analysis Period", date_range, "Date range of analyzed commits")
-        summary_table.add_row("Story Points", f"{total_story_points:,}", "Total story points completed")
-        summary_table.add_row("Ticket Coverage", f"{ticket_coverage:.1f}%", "Commits with ticket references")
-        
+        summary_table.add_row(
+            "Story Points", f"{total_story_points:,}", "Total story points completed"
+        )
+        summary_table.add_row(
+            "Ticket Coverage", f"{ticket_coverage:.1f}%", "Commits with ticket references"
+        )
+
         from rich.console import Console
         from rich.panel import Panel
-        console = Console()
-        
+
+        Console()
+
         container.mount(Static(Panel(summary_table, title="Key Metrics", border_style="blue")))
-        
+
         # Top contributors section
         container.mount(Rule())
         container.mount(Label("Top Contributors", classes="section-title"))
-        
+
         if self.developers:
-            top_devs = sorted(self.developers, key=lambda d: d.get('total_commits', 0), reverse=True)[:10]
-            
+            top_devs = sorted(
+                self.developers, key=lambda d: d.get("total_commits", 0), reverse=True
+            )[:10]
+
             contrib_table = Table(show_header=True, header_style="bold magenta")
             contrib_table.add_column("Developer", width=25)
             contrib_table.add_column("Commits", justify="right", width=10)
             contrib_table.add_column("Story Points", justify="right", width=12)
             contrib_table.add_column("Avg Points/Commit", justify="right", width=15)
-            
+
             for dev in top_devs:
-                commits = dev.get('total_commits', 0)
-                points = dev.get('total_story_points', 0)
+                commits = dev.get("total_commits", 0)
+                points = dev.get("total_story_points", 0)
                 avg_points = points / commits if commits > 0 else 0
-                
+
                 contrib_table.add_row(
-                    dev.get('primary_name', 'Unknown')[:23],
+                    dev.get("primary_name", "Unknown")[:23],
                     f"{commits:,}",
                     f"{points:,}",
-                    f"{avg_points:.1f}"
+                    f"{avg_points:.1f}",
                 )
-            
-            container.mount(Static(Panel(contrib_table, title="Developer Activity", border_style="green")))
-        
+
+            container.mount(
+                Static(Panel(contrib_table, title="Developer Activity", border_style="green"))
+            )
+
         # Qualitative insights summary (if available)
         if self._has_qualitative_data():
             container.mount(Rule())
             container.mount(Label("Qualitative Analysis Summary", classes="section-title"))
             container.mount(Static(self._create_qualitative_summary()))
-        
+
         return container
-    
+
     def _create_developers_panel(self) -> Container:
         """Create interactive developers data panel."""
         container = Container()
-        
+
         container.mount(Label("Developer Statistics", classes="section-title"))
-        container.mount(Static(
-            f"Showing {len(self.developers)} unique developers. Click column headers to sort.",
-            classes="help-text"
-        ))
-        
-        # Create enhanced data table
-        developers_table = EnhancedDataTable(
-            data=self.developers,
-            id="developers-table"
+        container.mount(
+            Static(
+                f"Showing {len(self.developers)} unique developers. Click column headers to sort.",
+                classes="help-text",
+            )
         )
-        
+
+        # Create enhanced data table
+        developers_table = EnhancedDataTable(data=self.developers, id="developers-table")
+
         container.mount(developers_table)
-        
+
         # Action buttons
         with container.mount(Horizontal(classes="action-bar")):
             yield Button("Export Developers", id="export-developers")
             yield Button("Show Identity Details", id="show-identities")
-        
+
         return container
-    
+
     def _create_commits_panel(self) -> Container:
         """Create interactive commits data panel."""
         container = Container()
-        
+
         container.mount(Label("Commit Analysis", classes="section-title"))
-        container.mount(Static(
-            f"Showing {len(self.commits)} commits. Use filters to explore specific data.",
-            classes="help-text"
-        ))
-        
+        container.mount(
+            Static(
+                f"Showing {len(self.commits)} commits. Use filters to explore specific data.",
+                classes="help-text",
+            )
+        )
+
         # Prepare commits data for table display
         commits_data = []
         for commit in self.commits[:1000]:  # Limit to 1000 for performance
             commit_row = {
-                'date': commit.get('timestamp', '').strftime('%Y-%m-%d') if commit.get('timestamp') else '',
-                'author': commit.get('author_name', ''),
-                'message': commit.get('message', '')[:80] + '...' if len(commit.get('message', '')) > 80 else commit.get('message', ''),
-                'files_changed': commit.get('files_changed_count', 0),
-                'insertions': commit.get('insertions', 0),
-                'deletions': commit.get('deletions', 0),
-                'story_points': commit.get('story_points', 0),
-                'project_key': commit.get('project_key', ''),
-                'change_type': commit.get('change_type', 'unknown'),
-                'risk_level': commit.get('risk_level', 'unknown')
+                "date": (
+                    commit.get("timestamp", "").strftime("%Y-%m-%d")
+                    if commit.get("timestamp")
+                    else ""
+                ),
+                "author": commit.get("author_name", ""),
+                "message": (
+                    commit.get("message", "")[:80] + "..."
+                    if len(commit.get("message", "")) > 80
+                    else commit.get("message", "")
+                ),
+                "files_changed": commit.get("files_changed_count", 0),
+                "insertions": commit.get("insertions", 0),
+                "deletions": commit.get("deletions", 0),
+                "story_points": commit.get("story_points", 0),
+                "project_key": commit.get("project_key", ""),
+                "change_type": commit.get("change_type", "unknown"),
+                "risk_level": commit.get("risk_level", "unknown"),
             }
             commits_data.append(commit_row)
-        
-        commits_table = EnhancedDataTable(
-            data=commits_data,
-            id="commits-table"
-        )
-        
+
+        commits_table = EnhancedDataTable(data=commits_data, id="commits-table")
+
         container.mount(commits_table)
-        
+
         # Action buttons
         with container.mount(Horizontal(classes="action-bar")):
             yield Button("Export Commits", id="export-commits")
             yield Button("Filter by Author", id="filter-author")
             yield Button("Filter by Project", id="filter-project")
-        
+
         return container
-    
+
     def _create_prs_panel(self) -> Container:
         """Create pull requests analysis panel."""
         container = Container()
-        
+
         container.mount(Label("Pull Request Analysis", classes="section-title"))
-        container.mount(Static(
-            f"Showing {len(self.prs)} pull requests with metrics and timing data.",
-            classes="help-text"
-        ))
-        
+        container.mount(
+            Static(
+                f"Showing {len(self.prs)} pull requests with metrics and timing data.",
+                classes="help-text",
+            )
+        )
+
         # Prepare PR data for table
         prs_data = []
         for pr in self.prs:
             pr_row = {
-                'title': pr.get('title', '')[:60] + '...' if len(pr.get('title', '')) > 60 else pr.get('title', ''),
-                'author': pr.get('author', ''),
-                'state': pr.get('state', ''),
-                'created_date': pr.get('created_at', '').strftime('%Y-%m-%d') if pr.get('created_at') else '',
-                'merged_date': pr.get('merged_at', '').strftime('%Y-%m-%d') if pr.get('merged_at') else '',
-                'commits': pr.get('commits_count', 0),
-                'changed_files': pr.get('changed_files', 0),
-                'additions': pr.get('additions', 0),
-                'deletions': pr.get('deletions', 0),
+                "title": (
+                    pr.get("title", "")[:60] + "..."
+                    if len(pr.get("title", "")) > 60
+                    else pr.get("title", "")
+                ),
+                "author": pr.get("author", ""),
+                "state": pr.get("state", ""),
+                "created_date": (
+                    pr.get("created_at", "").strftime("%Y-%m-%d") if pr.get("created_at") else ""
+                ),
+                "merged_date": (
+                    pr.get("merged_at", "").strftime("%Y-%m-%d") if pr.get("merged_at") else ""
+                ),
+                "commits": pr.get("commits_count", 0),
+                "changed_files": pr.get("changed_files", 0),
+                "additions": pr.get("additions", 0),
+                "deletions": pr.get("deletions", 0),
             }
             prs_data.append(pr_row)
-        
-        prs_table = EnhancedDataTable(
-            data=prs_data,
-            id="prs-table"
-        )
-        
+
+        prs_table = EnhancedDataTable(data=prs_data, id="prs-table")
+
         container.mount(prs_table)
-        
+
         # Action buttons
         with container.mount(Horizontal(classes="action-bar")):
             yield Button("Export PRs", id="export-prs")
             yield Button("Show PR Metrics", id="show-pr-metrics")
-        
+
         return container
-    
+
     def _create_qualitative_panel(self) -> ScrollableContainer:
         """Create qualitative insights panel."""
         container = ScrollableContainer()
-        
+
         container.mount(Label("Qualitative Analysis Results", classes="section-title"))
-        
+
         if not self._has_qualitative_data():
-            container.mount(Static("No qualitative analysis data available.", classes="info-message"))
-            container.mount(Static("Run analysis with qualitative processing enabled to see insights here."))
+            container.mount(
+                Static("No qualitative analysis data available.", classes="info-message")
+            )
+            container.mount(
+                Static("Run analysis with qualitative processing enabled to see insights here.")
+            )
             return container
-        
+
         # Analyze qualitative data distributions
         change_types = {}
         risk_levels = {}
         domains = {}
         confidence_scores = []
-        
+
         for commit in self.commits:
-            if 'change_type' in commit:
-                change_type = commit.get('change_type', 'unknown')
+            if "change_type" in commit:
+                change_type = commit.get("change_type", "unknown")
                 change_types[change_type] = change_types.get(change_type, 0) + 1
-                
-                risk_level = commit.get('risk_level', 'unknown')
+
+                risk_level = commit.get("risk_level", "unknown")
                 risk_levels[risk_level] = risk_levels.get(risk_level, 0) + 1
-                
-                domain = commit.get('business_domain', 'unknown')
+
+                domain = commit.get("business_domain", "unknown")
                 domains[domain] = domains.get(domain, 0) + 1
-                
-                if 'confidence_score' in commit:
-                    confidence_scores.append(commit['confidence_score'])
-        
+
+                if "confidence_score" in commit:
+                    confidence_scores.append(commit["confidence_score"])
+
         # Change types distribution
         container.mount(Label("Change Type Distribution", classes="subsection-title"))
-        
+
         change_table = Table(show_header=True, header_style="bold cyan")
         change_table.add_column("Change Type", width=20)
         change_table.add_column("Count", justify="right", width=10)
         change_table.add_column("Percentage", justify="right", width=12)
-        
+
         total_commits = len(self.commits)
         for change_type, count in sorted(change_types.items(), key=lambda x: x[1], reverse=True):
             pct = (count / total_commits) * 100
-            change_table.add_row(
-                change_type.title(),
-                f"{count:,}",
-                f"{pct:.1f}%"
-            )
-        
+            change_table.add_row(change_type.title(), f"{count:,}", f"{pct:.1f}%")
+
         from rich.panel import Panel
+
         container.mount(Static(Panel(change_table, title="Change Types", border_style="cyan")))
-        
+
         # Risk levels distribution
         container.mount(Rule())
         container.mount(Label("Risk Level Distribution", classes="subsection-title"))
-        
+
         risk_table = Table(show_header=True, header_style="bold red")
         risk_table.add_column("Risk Level", width=20)
         risk_table.add_column("Count", justify="right", width=10)
         risk_table.add_column("Percentage", justify="right", width=12)
-        
+
         for risk_level, count in sorted(risk_levels.items(), key=lambda x: x[1], reverse=True):
             pct = (count / total_commits) * 100
-            risk_table.add_row(
-                risk_level.title(),
-                f"{count:,}",
-                f"{pct:.1f}%"
-            )
-        
+            risk_table.add_row(risk_level.title(), f"{count:,}", f"{pct:.1f}%")
+
         container.mount(Static(Panel(risk_table, title="Risk Levels", border_style="red")))
-        
+
         # Business domains
         container.mount(Rule())
         container.mount(Label("Business Domain Activity", classes="subsection-title"))
-        
+
         domain_table = Table(show_header=True, header_style="bold green")
         domain_table.add_column("Business Domain", width=25)
         domain_table.add_column("Count", justify="right", width=10)
         domain_table.add_column("Percentage", justify="right", width=12)
-        
+
         for domain, count in sorted(domains.items(), key=lambda x: x[1], reverse=True):
             pct = (count / total_commits) * 100
-            domain_table.add_row(
-                domain.title(),
-                f"{count:,}",
-                f"{pct:.1f}%"
-            )
-        
+            domain_table.add_row(domain.title(), f"{count:,}", f"{pct:.1f}%")
+
         container.mount(Static(Panel(domain_table, title="Business Domains", border_style="green")))
-        
+
         # Confidence score statistics
         if confidence_scores:
             container.mount(Rule())
             container.mount(Label("Analysis Confidence", classes="subsection-title"))
-            
+
             avg_confidence = sum(confidence_scores) / len(confidence_scores)
             min_confidence = min(confidence_scores)
             max_confidence = max(confidence_scores)
-            
+
             confidence_text = f"""Average Confidence: {avg_confidence:.2f}
 Minimum Confidence: {min_confidence:.2f}
 Maximum Confidence: {max_confidence:.2f}
 Total Analyzed: {len(confidence_scores):,} commits"""
-            
-            container.mount(Static(Panel(confidence_text, title="Confidence Statistics", border_style="yellow")))
-        
+
+            container.mount(
+                Static(Panel(confidence_text, title="Confidence Statistics", border_style="yellow"))
+            )
+
         return container
-    
+
     def _create_export_panel(self) -> Container:
         """Create export options panel."""
         container = Container()
-        
+
         container.mount(Label("Export Analysis Results", classes="section-title"))
-        container.mount(Static(
-            "Export your analysis results in various formats for further analysis or reporting.",
-            classes="help-text"
-        ))
-        
+        container.mount(
+            Static(
+                "Export your analysis results in various formats for further analysis or reporting.",
+                classes="help-text",
+            )
+        )
+
         # Export options
         with container.mount(Vertical(id="export-options")):
-            yield Button("📄 Export Summary Report (CSV)", variant="primary", id="export-summary-csv")
+            yield Button(
+                "📄 Export Summary Report (CSV)", variant="primary", id="export-summary-csv"
+            )
             yield Button("👥 Export Developer Statistics (CSV)", id="export-developers-csv")
             yield Button("📝 Export Commit Details (CSV)", id="export-commits-csv")
-            
+
             if self.prs:
                 yield Button("🔀 Export Pull Requests (CSV)", id="export-prs-csv")
-            
+
             if self._has_qualitative_data():
                 yield Button("🧠 Export Qualitative Insights (CSV)", id="export-qualitative-csv")
-            
+
             yield Rule()
             yield Button("📊 Export Complete Dataset (JSON)", id="export-json")
             yield Button("📋 Generate Markdown Report", id="export-markdown")
-        
+
         # Export status
         container.mount(Rule())
         container.mount(Static("", id="export-status"))
-        
+
         return container
-    
+
     def _has_qualitative_data(self) -> bool:
         """Check if qualitative analysis data is available."""
-        return any('change_type' in commit for commit in self.commits)
-    
+        return any("change_type" in commit for commit in self.commits)
+
     def _create_qualitative_summary(self) -> str:
         """Create a text summary of qualitative insights."""
         if not self._has_qualitative_data():
             return "No qualitative data available"
-        
+
         # Count change types and risk levels
         change_types = {}
         risk_levels = {}
-        
+
         for commit in self.commits:
-            if 'change_type' in commit:
-                change_type = commit.get('change_type', 'unknown')
+            if "change_type" in commit:
+                change_type = commit.get("change_type", "unknown")
                 change_types[change_type] = change_types.get(change_type, 0) + 1
-                
-                risk_level = commit.get('risk_level', 'unknown')
+
+                risk_level = commit.get("risk_level", "unknown")
                 risk_levels[risk_level] = risk_levels.get(risk_level, 0) + 1
-        
+
         # Find most common values
-        top_change_type = max(change_types.items(), key=lambda x: x[1]) if change_types else ('unknown', 0)
-        top_risk_level = max(risk_levels.items(), key=lambda x: x[1]) if risk_levels else ('unknown', 0)
-        
+        top_change_type = (
+            max(change_types.items(), key=lambda x: x[1]) if change_types else ("unknown", 0)
+        )
+        top_risk_level = (
+            max(risk_levels.items(), key=lambda x: x[1]) if risk_levels else ("unknown", 0)
+        )
+
         total_analyzed = sum(change_types.values())
-        
+
         return f"""Qualitative Analysis Summary:
 • Total commits analyzed: {total_analyzed:,}
 • Most common change type: {top_change_type[0]} ({top_change_type[1]} commits)
 • Most common risk level: {top_risk_level[0]} ({top_risk_level[1]} commits)
 • Coverage: {(total_analyzed/len(self.commits)*100):.1f}% of all commits"""
-    
+
     def on_button_pressed(self, event: Button.Pressed) -> None:
         """Handle button press events."""
         export_actions = {
@@ -477,7 +503,7 @@ Total Analyzed: {len(confidence_scores):,} commits"""
             "export-json": lambda: self._export_data("complete", "json"),
             "export-markdown": lambda: self._export_data("report", "markdown"),
         }
-        
+
         action = export_actions.get(event.button.id)
         if action:
             action()
@@ -487,165 +513,163 @@ Total Analyzed: {len(confidence_scores):,} commits"""
                 self._show_identity_details()
             elif event.button.id == "show-pr-metrics":
                 self._show_pr_metrics()
-    
+
     def _export_data(self, data_type: str, format_type: str) -> None:
         """
         Export specific data type in specified format.
-        
+
         WHY: Provides flexible export functionality that allows users to
         export exactly the data they need in their preferred format.
         """
         try:
             # Determine data and filename based on type
             timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-            
+
             if data_type == "summary":
                 data = self._prepare_summary_data()
-                filename = f"gitflow_summary_{timestamp}.csv"
             elif data_type == "developers":
                 data = self.developers
-                filename = f"gitflow_developers_{timestamp}.csv"
             elif data_type == "commits":
                 data = self.commits
-                filename = f"gitflow_commits_{timestamp}.csv"
             elif data_type == "prs":
                 data = self.prs
-                filename = f"gitflow_prs_{timestamp}.csv"
             elif data_type == "qualitative":
                 data = self._prepare_qualitative_data()
-                filename = f"gitflow_qualitative_{timestamp}.csv"
             elif data_type == "complete":
                 data = {
-                    'commits': self.commits,
-                    'prs': self.prs,
-                    'developers': self.developers,
-                    'config': self.config.__dict__ if hasattr(self.config, '__dict__') else {}
+                    "commits": self.commits,
+                    "prs": self.prs,
+                    "developers": self.developers,
+                    "config": self.config.__dict__ if hasattr(self.config, "__dict__") else {},
                 }
-                filename = f"gitflow_complete_{timestamp}.json"
             else:
                 self.notify("Unknown export type", severity="error")
                 return
-            
+
             # Show export modal
             export_modal = ExportModal(
                 available_formats=[format_type.upper()],
                 default_path=Path("./reports"),
                 data_info={
-                    'type': data_type,
-                    'row_count': len(data) if isinstance(data, list) else 'N/A',
-                    'timestamp': timestamp
-                }
+                    "type": data_type,
+                    "row_count": len(data) if isinstance(data, list) else "N/A",
+                    "timestamp": timestamp,
+                },
             )
-            
+
             def handle_export(config):
                 if config:
                     self._perform_export(data, config, format_type)
-            
+
             self.app.push_screen(export_modal, handle_export)
-            
+
         except Exception as e:
             self.notify(f"Export preparation failed: {e}", severity="error")
-    
-    def _perform_export(self, data: Any, export_config: Dict[str, Any], format_type: str) -> None:
+
+    def _perform_export(self, data: Any, export_config: dict[str, Any], format_type: str) -> None:
         """Perform the actual export operation."""
         try:
-            export_path = export_config['path']
-            
+            export_path = export_config["path"]
+
             if format_type == "csv":
                 self._export_to_csv(data, export_path, export_config)
             elif format_type == "json":
                 self._export_to_json(data, export_path, export_config)
             elif format_type == "markdown":
                 self._export_to_markdown(data, export_path, export_config)
-            
+
             self.notify(f"Successfully exported to {export_path}", severity="success")
-            
+
         except Exception as e:
             self.notify(f"Export failed: {e}", severity="error")
-    
-    def _export_to_csv(self, data: List[Dict], path: Path, config: Dict[str, Any]) -> None:
+
+    def _export_to_csv(self, data: list[dict], path: Path, config: dict[str, Any]) -> None:
         """Export data to CSV format."""
         import csv
-        
+
         if not data:
             return
-        
+
         # Ensure parent directory exists
         path.parent.mkdir(parents=True, exist_ok=True)
-        
-        with open(path, 'w', newline='', encoding='utf-8') as csvfile:
+
+        with open(path, "w", newline="", encoding="utf-8") as csvfile:
             fieldnames = list(data[0].keys())
             writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
-            
-            if config.get('include_headers', True):
+
+            if config.get("include_headers", True):
                 writer.writeheader()
-            
+
             for row in data:
                 # Anonymize if requested
-                if config.get('anonymize', False):
+                if config.get("anonymize", False):
                     row = self._anonymize_row(row)
                 writer.writerow(row)
-    
-    def _export_to_json(self, data: Any, path: Path, config: Dict[str, Any]) -> None:
+
+    def _export_to_json(self, data: Any, path: Path, config: dict[str, Any]) -> None:
         """Export data to JSON format."""
         # Ensure parent directory exists
         path.parent.mkdir(parents=True, exist_ok=True)
-        
+
         # Anonymize if requested
-        if config.get('anonymize', False):
+        if config.get("anonymize", False):
             data = self._anonymize_data(data)
-        
-        with open(path, 'w', encoding='utf-8') as jsonfile:
+
+        with open(path, "w", encoding="utf-8") as jsonfile:
             json.dump(data, jsonfile, indent=2, default=str)
-    
-    def _export_to_markdown(self, data: Any, path: Path, config: Dict[str, Any]) -> None:
+
+    def _export_to_markdown(self, data: Any, path: Path, config: dict[str, Any]) -> None:
         """Export data as markdown report."""
         self.notify("Markdown export not yet implemented", severity="info")
         # TODO: Implement markdown report generation
-    
-    def _prepare_summary_data(self) -> List[Dict]:
+
+    def _prepare_summary_data(self) -> list[dict]:
         """Prepare summary statistics for export."""
         return [
-            {'metric': 'Total Commits', 'value': len(self.commits)},
-            {'metric': 'Total PRs', 'value': len(self.prs)},
-            {'metric': 'Active Developers', 'value': len(self.developers)},
-            {'metric': 'Total Story Points', 'value': sum(c.get('story_points', 0) or 0 for c in self.commits)},
+            {"metric": "Total Commits", "value": len(self.commits)},
+            {"metric": "Total PRs", "value": len(self.prs)},
+            {"metric": "Active Developers", "value": len(self.developers)},
+            {
+                "metric": "Total Story Points",
+                "value": sum(c.get("story_points", 0) or 0 for c in self.commits),
+            },
         ]
-    
-    def _prepare_qualitative_data(self) -> List[Dict]:
+
+    def _prepare_qualitative_data(self) -> list[dict]:
         """Prepare qualitative analysis data for export."""
         qualitative_commits = []
         for commit in self.commits:
-            if 'change_type' in commit:
+            if "change_type" in commit:
                 qual_commit = {
-                    'commit_hash': commit.get('hash'),
-                    'author': commit.get('author_name'),
-                    'message': commit.get('message'),
-                    'change_type': commit.get('change_type'),
-                    'business_domain': commit.get('business_domain'),
-                    'risk_level': commit.get('risk_level'),
-                    'confidence_score': commit.get('confidence_score')
+                    "commit_hash": commit.get("hash"),
+                    "author": commit.get("author_name"),
+                    "message": commit.get("message"),
+                    "change_type": commit.get("change_type"),
+                    "business_domain": commit.get("business_domain"),
+                    "risk_level": commit.get("risk_level"),
+                    "confidence_score": commit.get("confidence_score"),
                 }
                 qualitative_commits.append(qual_commit)
         return qualitative_commits
-    
-    def _anonymize_row(self, row: Dict) -> Dict:
+
+    def _anonymize_row(self, row: dict) -> dict:
         """Anonymize sensitive data in a row."""
         # Simple anonymization - replace names with hashed versions
         anonymized = row.copy()
-        
+
         # Fields to anonymize
-        sensitive_fields = ['author_name', 'author_email', 'primary_name', 'primary_email']
-        
+        sensitive_fields = ["author_name", "author_email", "primary_name", "primary_email"]
+
         for field in sensitive_fields:
             if field in anonymized and anonymized[field]:
                 # Simple hash-based anonymization
                 import hashlib
+
                 hash_value = hashlib.md5(str(anonymized[field]).encode()).hexdigest()[:8]
                 anonymized[field] = f"User_{hash_value}"
-        
+
         return anonymized
-    
+
     def _anonymize_data(self, data: Any) -> Any:
         """Anonymize data structure recursively."""
         if isinstance(data, list):
@@ -654,38 +678,38 @@ Total Analyzed: {len(confidence_scores):,} commits"""
             return {key: self._anonymize_data(value) for key, value in data.items()}
         else:
             return data
-    
+
     def _show_identity_details(self) -> None:
         """Show detailed developer identity information."""
         self.notify("Identity details view not yet implemented", severity="info")
-    
+
     def _show_pr_metrics(self) -> None:
         """Show detailed pull request metrics."""
         self.notify("PR metrics view not yet implemented", severity="info")
-    
+
     def action_back(self) -> None:
         """Go back to main screen."""
         self.app.pop_screen()
-    
+
     def action_export(self) -> None:
         """Show export options."""
         # Switch to export tab
         tabbed_content = self.query_one(TabbedContent)
         tabbed_content.active = "export"
-    
+
     def action_filter(self) -> None:
         """Show filter options for current tab."""
         self.notify("Filtering functionality not yet implemented", severity="info")
-    
+
     def action_refresh(self) -> None:
         """Refresh current view."""
         self.refresh()
-    
+
     def action_export_current(self) -> None:
         """Export data from currently active tab."""
         tabbed_content = self.query_one(TabbedContent)
         current_tab = tabbed_content.active
-        
+
         if current_tab == "developers":
             self._export_data("developers", "csv")
         elif current_tab == "commits":
@@ -695,4 +719,4 @@ Total Analyzed: {len(confidence_scores):,} commits"""
         elif current_tab == "qualitative":
             self._export_data("qualitative", "csv")
         else:
-            self._export_data("summary", "csv")
+            self._export_data("summary", "csv")