runbooks 1.1.3__py3-none-any.whl → 1.1.5__py3-none-any.whl

runbooks/finops/workspaces_analyzer.py

@@ -1,5 +1,5 @@
 """
-WorkSpaces Cost Optimization Analysis - Enterprise Framework: 
+WorkSpaces Cost Optimization Analysis - Enterprise Framework:
 
 This module provides business-focused WorkSpaces analysis with enterprise patterns:
 - Real AWS API integration (no hardcoded values)
@@ -17,19 +17,27 @@ Strategic Alignment:
 import asyncio
 import json
 import logging
+from dataclasses import asdict, dataclass
 from datetime import datetime, timedelta, timezone
-from typing import Dict, List, Optional, Tuple, Any
-from dataclasses import dataclass, asdict
+from typing import Any, Dict, List, Optional, Tuple
 
 import boto3
 from botocore.exceptions import ClientError
 
+from ..common.profile_utils import get_profile_for_operation
 from ..common.rich_utils import (
-    console, print_header, print_success, print_error, print_warning, print_info,
-    create_table, create_progress_bar, format_cost, create_panel
+    console,
+    create_panel,
+    create_progress_bar,
+    create_table,
+    format_cost,
+    print_error,
+    print_header,
+    print_info,
+    print_success,
+    print_warning,
 )
-from ..common.profile_utils import get_profile_for_operation
-from ..remediation.workspaces_list import get_workspaces, calculate_workspace_monthly_cost
+from ..remediation.workspaces_list import calculate_workspace_monthly_cost, get_workspaces
 
 logger = logging.getLogger(__name__)
 
@@ -37,6 +45,7 @@ logger = logging.getLogger(__name__)
 @dataclass
 class WorkSpaceAnalysisResult:
     """WorkSpace analysis result with cost optimization data."""
+
     workspace_id: str
     username: str
     state: str
@@ -49,7 +58,7 @@ class WorkSpaceAnalysisResult:
     is_unused: bool
     usage_hours: float
     connection_state: str
-    
+
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dictionary for JSON serialization."""
         return asdict(self)
@@ -58,6 +67,7 @@ class WorkSpaceAnalysisResult:
 @dataclass
 class WorkSpacesCostSummary:
     """Summary of WorkSpaces cost analysis."""
+
     total_workspaces: int
     unused_workspaces: int
     total_monthly_cost: float
@@ -65,7 +75,7 @@ class WorkSpacesCostSummary:
     potential_annual_savings: float
     target_achievement_rate: float
     analysis_timestamp: str
-    
+
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dictionary for JSON serialization."""
         return asdict(self)
@@ -74,97 +84,95 @@ class WorkSpacesCostSummary:
 class WorkSpacesCostAnalyzer:
     """
     WorkSpaces cost optimization analyzer following enterprise patterns.
-    
+
     Implements WorkSpaces optimization requirements with proven profile management and Rich CLI standards.
     """
-    
+
     def __init__(self, profile: Optional[str] = None):
         """Initialize analyzer with enterprise profile management."""
         # Apply proven profile management pattern from dashboard_runner.py
         self.profile = get_profile_for_operation("operational", profile)
         self.session = boto3.Session(profile_name=self.profile)
-        
+
         # WorkSpaces optimization business targets
         self.target_annual_savings = 12518.0
         self.unused_threshold_days = 90
         self.analysis_period_days = 30
-        
+
         logger.info(f"WorkSpaces analyzer initialized with profile: {self.profile}")
-    
+
     def analyze_workspaces(
-        self, 
-        unused_days: int = 90,
-        analysis_days: int = 30,
-        dry_run: bool = True
+        self, unused_days: int = 90, analysis_days: int = 30, dry_run: bool = True
     ) -> Tuple[List[WorkSpaceAnalysisResult], WorkSpacesCostSummary]:
         """
         Analyze WorkSpaces for cost optimization opportunities.
-        
+
         Args:
             unused_days: Days threshold for unused WorkSpaces detection
             analysis_days: Period for usage analysis
             dry_run: Safety flag for preview mode
-            
+
         Returns:
             Tuple of analysis results and summary
         """
         print_header("WorkSpaces Cost Optimization Analysis", f"Profile: {self.profile}")
-        
+
         if dry_run:
             print_info("🔍 Running in DRY-RUN mode (safe preview)")
-        
+
         try:
             # Get WorkSpaces client
-            ws_client = self.session.client('workspaces')
-            
+            ws_client = self.session.client("workspaces")
+
             # Calculate time ranges
             end_time = datetime.now(tz=timezone.utc)
             start_time = end_time - timedelta(days=analysis_days)
             unused_threshold = end_time - timedelta(days=unused_days)
-            
-            console.print(f"[dim]Analysis period: {start_time.strftime('%Y-%m-%d')} to {end_time.strftime('%Y-%m-%d')}[/dim]")
+
+            console.print(
+                f"[dim]Analysis period: {start_time.strftime('%Y-%m-%d')} to {end_time.strftime('%Y-%m-%d')}[/dim]"
+            )
             console.print(f"[dim]Unused threshold: {unused_days} days ({unused_threshold.strftime('%Y-%m-%d')})[/dim]")
-            
+
             # Get all WorkSpaces with progress tracking
             print_info("Collecting WorkSpaces inventory...")
             paginator = ws_client.get_paginator("describe_workspaces")
             all_workspaces = []
-            
+
             for page in paginator.paginate():
                 workspaces = page.get("Workspaces", [])
                 all_workspaces.extend(workspaces)
-            
+
             console.print(f"[green]✅ Found {len(all_workspaces)} WorkSpaces[/green]")
-            
+
             # Analyze each WorkSpace with progress bar
             analysis_results = []
             total_cost = 0.0
             unused_cost = 0.0
-            
+
             with create_progress_bar() as progress:
-                task_id = progress.add_task(
-                    f"Analyzing WorkSpaces cost optimization...",
-                    total=len(all_workspaces)
-                )
-                
+                task_id = progress.add_task(f"Analyzing WorkSpaces cost optimization...", total=len(all_workspaces))
+
                 for workspace in all_workspaces:
                     result = self._analyze_single_workspace(
                         workspace, ws_client, start_time, end_time, unused_threshold
                     )
-                    
+
                     analysis_results.append(result)
                     total_cost += result.monthly_cost
-                    
+
                     if result.is_unused:
                         unused_cost += result.monthly_cost
-                    
+
                     progress.advance(task_id)
-            
+
             # Create summary
             unused_count = len([r for r in analysis_results if r.is_unused])
             potential_annual_savings = unused_cost * 12
-            achievement_rate = (potential_annual_savings / self.target_annual_savings * 100) if self.target_annual_savings > 0 else 0
-            
+            achievement_rate = (
+                (potential_annual_savings / self.target_annual_savings * 100) if self.target_annual_savings > 0 else 0
+            )
+
             summary = WorkSpacesCostSummary(
                 total_workspaces=len(analysis_results),
                 unused_workspaces=unused_count,
@@ -172,11 +180,11 @@ class WorkSpacesCostAnalyzer:
                 unused_monthly_cost=unused_cost,
                 potential_annual_savings=potential_annual_savings,
                 target_achievement_rate=achievement_rate,
-                analysis_timestamp=datetime.now().isoformat()
+                analysis_timestamp=datetime.now().isoformat(),
             )
-            
+
             return analysis_results, summary
-            
+
         except ClientError as e:
             print_error(f"AWS API error: {e}")
             if "AccessDenied" in str(e):
@@ -186,14 +194,9 @@ class WorkSpacesCostAnalyzer:
         except Exception as e:
             print_error(f"Analysis failed: {e}")
             raise
-    
+
     def _analyze_single_workspace(
-        self,
-        workspace: Dict[str, Any],
-        ws_client,
-        start_time: datetime,
-        end_time: datetime,
-        unused_threshold: datetime
+        self, workspace: Dict[str, Any], ws_client, start_time: datetime, end_time: datetime, unused_threshold: datetime
     ) -> WorkSpaceAnalysisResult:
         """Analyze a single WorkSpace for cost optimization."""
         workspace_id = workspace["WorkspaceId"]
@@ -201,23 +204,21 @@ class WorkSpacesCostAnalyzer:
         state = workspace["State"]
         bundle_id = workspace["BundleId"]
         running_mode = workspace["WorkspaceProperties"]["RunningMode"]
-        
+
         # Get connection status
         last_connection = None
         connection_state = "UNKNOWN"
-        
+
         try:
-            connection_response = ws_client.describe_workspaces_connection_status(
-                WorkspaceIds=[workspace_id]
-            )
-            
+            connection_response = ws_client.describe_workspaces_connection_status(WorkspaceIds=[workspace_id])
+
             connection_status_list = connection_response.get("WorkspacesConnectionStatus", [])
             if connection_status_list:
                 last_connection = connection_status_list[0].get("LastKnownUserConnectionTimestamp")
                 connection_state = connection_status_list[0].get("ConnectionState", "UNKNOWN")
         except ClientError as e:
             logger.warning(f"Could not get connection status for {workspace_id}: {e}")
-        
+
         # Format connection info
         if last_connection:
             last_connection_str = last_connection.strftime("%Y-%m-%d %H:%M:%S")
@@ -225,17 +226,17 @@ class WorkSpacesCostAnalyzer:
         else:
             last_connection_str = None
             days_since_connection = 999
-        
+
         # Get usage metrics
         usage_hours = self._get_workspace_usage(workspace_id, start_time, end_time)
-        
+
         # Calculate costs
         monthly_cost = calculate_workspace_monthly_cost(bundle_id, running_mode)
         annual_cost = monthly_cost * 12
-        
+
         # Determine if unused
         is_unused = last_connection is None or last_connection < unused_threshold
-        
+
         return WorkSpaceAnalysisResult(
             workspace_id=workspace_id,
             username=username,
@@ -248,16 +249,14 @@ class WorkSpacesCostAnalyzer:
             days_since_connection=days_since_connection,
             is_unused=is_unused,
             usage_hours=usage_hours,
-            connection_state=connection_state
+            connection_state=connection_state,
         )
-    
-    def _get_workspace_usage(
-        self, workspace_id: str, start_time: datetime, end_time: datetime
-    ) -> float:
+
+    def _get_workspace_usage(self, workspace_id: str, start_time: datetime, end_time: datetime) -> float:
         """Get WorkSpace usage hours from CloudWatch metrics."""
         try:
             cloudwatch = self.session.client("cloudwatch")
-            
+
             response = cloudwatch.get_metric_statistics(
                 Namespace="AWS/WorkSpaces",
                 MetricName="UserConnected",
@@ -267,68 +266,68 @@ class WorkSpacesCostAnalyzer:
                 Period=3600,  # 1 hour intervals
                 Statistics=["Sum"],
             )
-            
+
             usage_hours = sum(datapoint["Sum"] for datapoint in response.get("Datapoints", []))
             return round(usage_hours, 2)
-            
+
         except ClientError as e:
             logger.warning(f"Could not get usage metrics for {workspace_id}: {e}")
             return 0.0
-    
-    def display_analysis_results(
-        self, 
-        results: List[WorkSpaceAnalysisResult], 
-        summary: WorkSpacesCostSummary
-    ) -> None:
+
+    def display_analysis_results(self, results: List[WorkSpaceAnalysisResult], summary: WorkSpacesCostSummary) -> None:
         """Display analysis results using Rich CLI formatting."""
-        
+
         # Summary table
         print_header("WorkSpaces Cost Analysis Summary")
-        
+
         summary_table = create_table(
             title="WorkSpaces Optimization Summary",
             columns=[
                 {"header": "Metric", "style": "cyan"},
                 {"header": "Count", "style": "green bold"},
                 {"header": "Monthly Cost", "style": "red"},
-                {"header": "Annual Cost", "style": "red bold"}
-            ]
+                {"header": "Annual Cost", "style": "red bold"},
+            ],
         )
-        
+
         summary_table.add_row(
             "Total WorkSpaces",
             str(summary.total_workspaces),
             format_cost(summary.total_monthly_cost),
-            format_cost(summary.total_monthly_cost * 12)
+            format_cost(summary.total_monthly_cost * 12),
         )
-        
+
         summary_table.add_row(
             f"Unused WorkSpaces (>{self.unused_threshold_days} days)",
             str(summary.unused_workspaces),
             format_cost(summary.unused_monthly_cost),
-            format_cost(summary.potential_annual_savings)
+            format_cost(summary.potential_annual_savings),
         )
-        
+
         summary_table.add_row(
             "🎯 Potential Savings",
             f"{summary.unused_workspaces} WorkSpaces",
             format_cost(summary.unused_monthly_cost),
-            format_cost(summary.potential_annual_savings)
+            format_cost(summary.potential_annual_savings),
         )
-        
+
         console.print(summary_table)
-        
+
         # Achievement analysis
         if summary.target_achievement_rate >= 80:
-            print_success(f"🎯 Target Achievement: {summary.target_achievement_rate:.1f}% of ${self.target_annual_savings:,.0f} annual savings target")
+            print_success(
+                f"🎯 Target Achievement: {summary.target_achievement_rate:.1f}% of ${self.target_annual_savings:,.0f} annual savings target"
+            )
         else:
-            print_warning(f"📊 Analysis: {summary.target_achievement_rate:.1f}% of ${self.target_annual_savings:,.0f} annual savings target")
-        
+            print_warning(
+                f"📊 Analysis: {summary.target_achievement_rate:.1f}% of ${self.target_annual_savings:,.0f} annual savings target"
+            )
+
         # Detailed unused WorkSpaces
         unused_results = [r for r in results if r.is_unused]
         if unused_results:
             print_warning(f"⚠ Found {len(unused_results)} unused WorkSpaces:")
-            
+
             unused_table = create_table(
                 title="Unused WorkSpaces Details",
                 columns=[
@@ -337,10 +336,10 @@ class WorkSpacesCostAnalyzer:
                     {"header": "Days Unused", "style": "yellow"},
                     {"header": "Running Mode", "style": "green"},
                     {"header": "Monthly Cost", "style": "red"},
-                    {"header": "State", "style": "magenta"}
-                ]
+                    {"header": "State", "style": "magenta"},
+                ],
             )
-            
+
             # Show first 10 for readability
             for ws in unused_results[:10]:
                 unused_table.add_row(
@@ -349,27 +348,27 @@ class WorkSpacesCostAnalyzer:
                     str(ws.days_since_connection),
                     ws.running_mode,
                     format_cost(ws.monthly_cost),
-                    ws.state
+                    ws.state,
                 )
-            
+
             console.print(unused_table)
-            
+
             if len(unused_results) > 10:
                 console.print(f"[dim]... and {len(unused_results) - 10} more unused WorkSpaces[/dim]")
-    
+
     def export_results(
         self,
         results: List[WorkSpaceAnalysisResult],
         summary: WorkSpacesCostSummary,
         output_format: str = "json",
-        output_file: Optional[str] = None
+        output_file: Optional[str] = None,
     ) -> str:
         """Export analysis results in specified format."""
-        
+
         if not output_file:
             timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
             output_file = f"./tmp/workspaces_analysis_{timestamp}.{output_format}"
-        
+
         export_data = {
             "summary": summary.to_dict(),
             "workspaces": [result.to_dict() for result in results],
@@ -377,58 +376,57 @@ class WorkSpacesCostAnalyzer:
                 "analysis_timestamp": summary.analysis_timestamp,
                 "profile": self.profile,
                 "target_savings": self.target_annual_savings,
-                "version": "0.9.1"
-            }
+                "version": "latest version",
+            },
         }
-        
+
         if output_format.lower() == "json":
-            with open(output_file, 'w') as f:
+            with open(output_file, "w") as f:
                 json.dump(export_data, f, indent=2, default=str)
         elif output_format.lower() == "csv":
             import csv
-            with open(output_file, 'w', newline='') as f:
+
+            with open(output_file, "w", newline="") as f:
                 if results:
                     writer = csv.DictWriter(f, fieldnames=results[0].to_dict().keys())
                     writer.writeheader()
                     for result in results:
                         writer.writerow(result.to_dict())
-        
+
         print_success(f"Analysis results exported to: {output_file}")
         return output_file
-    
+
     def cleanup_unused_workspaces(
-        self, 
-        unused_results: List[WorkSpaceAnalysisResult],
-        dry_run: bool = True,
-        confirm: bool = False
+        self, unused_results: List[WorkSpaceAnalysisResult], dry_run: bool = True, confirm: bool = False
     ) -> Dict[str, Any]:
         """
         Cleanup unused WorkSpaces with enterprise safety controls.
-        
+
         Args:
             unused_results: List of unused WorkSpaces to cleanup
             dry_run: Safety flag for preview mode
             confirm: Skip confirmation prompts
-            
+
         Returns:
             Cleanup operation results
         """
         print_header("WorkSpaces Cleanup Operation", "🚨 HIGH-RISK OPERATION")
-        
+
         if not unused_results:
             print_info("✅ No unused WorkSpaces found for cleanup")
             return {"status": "no_action", "deleted": 0, "message": "No unused WorkSpaces"}
-        
+
         # Safety validation
         cleanup_candidates = [
-            ws for ws in unused_results 
+            ws
+            for ws in unused_results
             if ws.state in ["AVAILABLE", "STOPPED"] and ws.days_since_connection >= self.unused_threshold_days
         ]
-        
+
         if not cleanup_candidates:
             print_warning("⚠ No WorkSpaces meet the safety criteria for cleanup")
             return {"status": "no_candidates", "deleted": 0, "message": "No cleanup candidates"}
-        
+
         # Display cleanup preview
         cleanup_table = create_table(
             title=f"Cleanup Candidates ({len(cleanup_candidates)} WorkSpaces)",
@@ -437,98 +435,93 @@ class WorkSpacesCostAnalyzer:
                 {"header": "Username", "style": "blue"},
                 {"header": "Days Unused", "style": "yellow"},
                 {"header": "Monthly Cost", "style": "red"},
-                {"header": "State", "style": "magenta"}
-            ]
+                {"header": "State", "style": "magenta"},
+            ],
         )
-        
+
         total_cleanup_savings = 0.0
         for ws in cleanup_candidates:
             cleanup_table.add_row(
-                ws.workspace_id,
-                ws.username,
-                str(ws.days_since_connection),
-                format_cost(ws.monthly_cost),
-                ws.state
+                ws.workspace_id, ws.username, str(ws.days_since_connection), format_cost(ws.monthly_cost), ws.state
             )
             total_cleanup_savings += ws.monthly_cost
-        
+
         console.print(cleanup_table)
-        
+
         annual_cleanup_savings = total_cleanup_savings * 12
-        print_info(f"💰 Cleanup savings: {format_cost(total_cleanup_savings)}/month, {format_cost(annual_cleanup_savings)}/year")
-        
+        print_info(
+            f"💰 Cleanup savings: {format_cost(total_cleanup_savings)}/month, {format_cost(annual_cleanup_savings)}/year"
+        )
+
         if dry_run:
             print_info("🔍 DRY-RUN: Preview mode - no WorkSpaces will be deleted")
             return {
                 "status": "dry_run",
                 "candidates": len(cleanup_candidates),
                 "monthly_savings": total_cleanup_savings,
-                "annual_savings": annual_cleanup_savings
+                "annual_savings": annual_cleanup_savings,
             }
-        
+
         # Confirmation required for actual cleanup
         if not confirm:
             print_warning("🚨 DANGER: This will permanently delete WorkSpaces and all user data")
             print_warning(f"About to delete {len(cleanup_candidates)} WorkSpaces")
-            
+
             if not console.input("Type 'DELETE' to confirm: ") == "DELETE":
                 print_error("Cleanup cancelled - confirmation failed")
                 return {"status": "cancelled", "deleted": 0}
-        
+
         # Perform cleanup
         print_warning("🗑 Starting WorkSpaces cleanup...")
         ws_client = self.session.client("workspaces")
-        
+
         deleted_count = 0
         failed_count = 0
         cleanup_results = []
-        
+
         for ws in cleanup_candidates:
             try:
                 print_info(f"Deleting: {ws.workspace_id} ({ws.username})")
-                
-                ws_client.terminate_workspaces(
-                    TerminateWorkspaceRequests=[{"WorkspaceId": ws.workspace_id}]
-                )
-                
+
+                ws_client.terminate_workspaces(TerminateWorkspaceRequests=[{"WorkspaceId": ws.workspace_id}])
+
                 deleted_count += 1
-                cleanup_results.append({
-                    "workspace_id": ws.workspace_id,
-                    "username": ws.username,
-                    "status": "deleted",
-                    "monthly_saving": ws.monthly_cost
-                })
-                
+                cleanup_results.append(
+                    {
+                        "workspace_id": ws.workspace_id,
+                        "username": ws.username,
+                        "status": "deleted",
+                        "monthly_saving": ws.monthly_cost,
+                    }
+                )
+
                 print_success(f"✅ Deleted: {ws.workspace_id}")
-                
+
             except ClientError as e:
                 failed_count += 1
-                cleanup_results.append({
-                    "workspace_id": ws.workspace_id,
-                    "username": ws.username,
-                    "status": "failed",
-                    "error": str(e)
-                })
+                cleanup_results.append(
+                    {"workspace_id": ws.workspace_id, "username": ws.username, "status": "failed", "error": str(e)}
+                )
                 print_error(f"❌ Failed: {ws.workspace_id} - {e}")
-        
+
         # Summary
         actual_monthly_savings = sum(
-            result.get("monthly_saving", 0) 
-            for result in cleanup_results 
-            if result["status"] == "deleted"
+            result.get("monthly_saving", 0) for result in cleanup_results if result["status"] == "deleted"
         )
         actual_annual_savings = actual_monthly_savings * 12
-        
+
         print_success(f"🔄 Cleanup complete: {deleted_count} deleted, {failed_count} failed")
-        print_success(f"💰 Realized savings: {format_cost(actual_monthly_savings)}/month, {format_cost(actual_annual_savings)}/year")
-        
+        print_success(
+            f"💰 Realized savings: {format_cost(actual_monthly_savings)}/month, {format_cost(actual_annual_savings)}/year"
+        )
+
         return {
             "status": "completed",
             "deleted": deleted_count,
             "failed": failed_count,
             "monthly_savings": actual_monthly_savings,
             "annual_savings": actual_annual_savings,
-            "details": cleanup_results
+            "details": cleanup_results,
         }
 
 
@@ -538,11 +531,11 @@ def analyze_workspaces(
     analysis_days: int = 30,
     output_format: str = "json",
     output_file: Optional[str] = None,
-    dry_run: bool = True
+    dry_run: bool = True,
 ) -> Dict[str, Any]:
     """
     WorkSpaces analysis wrapper for CLI and notebook integration.
-    
+
     Args:
         profile: AWS profile to use
         unused_days: Days threshold for unused detection
@@ -550,7 +543,7 @@ def analyze_workspaces(
         output_format: Export format (json, csv)
         output_file: Optional output file path
         dry_run: Safety flag for preview mode
-        
+
     Returns:
         Analysis results with cost optimization recommendations
     """
@@ -562,21 +555,17 @@ def analyze_workspaces(
 
         analyzer = WorkSpacesCostAnalyzer(profile=profile)
         results, summary = analyzer.analyze_workspaces(
-            unused_days=unused_days,
-            analysis_days=analysis_days,
-            dry_run=dry_run
+            unused_days=unused_days, analysis_days=analysis_days, dry_run=dry_run
         )
-        
+
         # Display results
         analyzer.display_analysis_results(results, summary)
-        
+
         # Export if requested
         export_file = None
         if output_file or output_format:
-            export_file = analyzer.export_results(
-                results, summary, output_format, output_file
-            )
-        
+            export_file = analyzer.export_results(results, summary, output_format, output_file)
+
         # Return comprehensive results
         if summary is not None:
             return {
@@ -584,7 +573,7 @@ def analyze_workspaces(
                 "workspaces": [result.to_dict() for result in results],
                 "export_file": export_file,
                 "achievement_rate": summary.target_achievement_rate,
-                "status": "success"
+                "status": "success",
             }
         else:
             return {
@@ -592,7 +581,7 @@ def analyze_workspaces(
                 "workspaces": [],
                 "export_file": None,
                 "achievement_rate": 0,
-                "status": "partial_failure"
+                "status": "partial_failure",
             }
 
     except Exception as e:
@@ -603,11 +592,11 @@ def analyze_workspaces(
             "summary": {"error": str(e)},
             "workspaces": [],
             "export_file": None,
-            "achievement_rate": 0
+            "achievement_rate": 0,
         }
 
 
 # Legacy alias for backward compatibility
 def analyze_workspaces_finops_24(*args, **kwargs):
     """Legacy alias for analyze_workspaces - deprecated, use analyze_workspaces instead."""
-    return analyze_workspaces(*args, **kwargs)
+    return analyze_workspaces(*args, **kwargs)