aws-cost-calculator-cli 1.11.0__py3-none-any.whl → 2.0.1__py3-none-any.whl

{aws_cost_calculator_cli-1.11.0.dist-info → aws_cost_calculator_cli-2.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aws-cost-calculator-cli
-Version: 1.11.0
+Version: 2.0.1
 Summary: AWS Cost Calculator CLI - Calculate daily and annual AWS costs across multiple accounts
 Home-page: https://github.com/trilogy-group/aws-cost-calculator
 Author: Cost Optimization Team

aws_cost_calculator_cli-2.0.1.dist-info/RECORD

@@ -0,0 +1,15 @@
+aws_cost_calculator_cli-2.0.1.dist-info/licenses/LICENSE,sha256=cYtmQZHNGGTXOtg3T7LHDRneleaH0dHXHfxFV3WR50Y,1079
+cost_calculator/__init__.py,sha256=PJeIqvWh5AYJVrJxPPkI4pJnAt37rIjasrNS0I87kaM,52
+cost_calculator/api_client.py,sha256=4ZI2XcGIN3FBeQqb7xOxQ91kCoeM43-rExiOELXoKBQ,2485
+cost_calculator/cli.py,sha256=7j_jK2PKOchF9oereH6GtDtTjDnlhiTaVuS5FFdeL6U,76371
+cost_calculator/cur.py,sha256=QaZ_nyDSw5_cti-h5Ho6eYLbqzY5TWoub24DpyzIiSs,9502
+cost_calculator/drill.py,sha256=hGi-prLgZDvNMMICQc4fl3LenM7YaZ3To_Ei4LKwrdc,10543
+cost_calculator/executor.py,sha256=yZTCUgJc1OpB892O3mq9ZA0Yekc7N-HvaW8xLFyrXjo,8681
+cost_calculator/forensics.py,sha256=uhRo3I_zOeMEaBENHfgq65URga31W0Z4vzS2UN6VmTY,12819
+cost_calculator/monthly.py,sha256=6k9F8S7djhX1wGV3-T1MZP7CvWbbfhSTEaddwCfVu5M,7932
+cost_calculator/trends.py,sha256=k_s4ylBX50sqoiM_fwepi58HW01zz767FMJhQUPDznk,12246
+aws_cost_calculator_cli-2.0.1.dist-info/METADATA,sha256=vC_DLqKCR82e1D9uideemfOE6AihjB57fR4wS1F-WWc,11978
+aws_cost_calculator_cli-2.0.1.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+aws_cost_calculator_cli-2.0.1.dist-info/entry_points.txt,sha256=_5Qy4EcHbYVYrdgOu1E48faMHb9fLUl5VJ3djDHuJBo,47
+aws_cost_calculator_cli-2.0.1.dist-info/top_level.txt,sha256=PRwGPPlNqASfyhGHDjSfyl4SXeE7GF3OVTu1tY1Uqyc,16
+aws_cost_calculator_cli-2.0.1.dist-info/RECORD,,

cost_calculator/cli.py

@@ -67,127 +67,107 @@ def apply_auth_options(config, sso=None, access_key_id=None, secret_access_key=N
     return config
 
 
-def load_profile(profile_name):
-    """Load profile configuration from DynamoDB API or local file as fallback"""
+def get_api_secret():
+    """Get API secret from config file or environment variable"""
     import os
-    import requests
     
-    config_dir = Path.home() / '.config' / 'cost-calculator'
-    config_file = config_dir / 'profiles.json'
-    creds_file = config_dir / 'credentials.json'
-    
-    # Try DynamoDB API first if COST_API_SECRET is set
+    # Check environment variable first
     api_secret = os.environ.get('COST_API_SECRET')
     if api_secret:
-        try:
-            response = requests.post(
-                'https://64g7jq7sjygec2zmll5lsghrpi0txrzo.lambda-url.us-east-1.on.aws/',
-                headers={'X-API-Secret': api_secret, 'Content-Type': 'application/json'},
-                json={'operation': 'get', 'profile_name': profile_name},
-                timeout=10
-            )
-            
-            if response.status_code == 200:
-                response_data = response.json()
-                # API returns {"profile": {...}} wrapper
-                profile_data = response_data.get('profile', response_data)
-                profile = {'accounts': profile_data['accounts']}
-                
-                # If profile has aws_profile field, use it
-                if 'aws_profile' in profile_data:
-                    profile['aws_profile'] = profile_data['aws_profile']
-                # Check for AWS_PROFILE environment variable (SSO support)
-                elif os.environ.get('AWS_PROFILE'):
-                    profile['aws_profile'] = os.environ['AWS_PROFILE']
-                # Use environment credentials
-                elif os.environ.get('AWS_ACCESS_KEY_ID'):
-                    profile['credentials'] = {
-                        'aws_access_key_id': os.environ['AWS_ACCESS_KEY_ID'],
-                        'aws_secret_access_key': os.environ['AWS_SECRET_ACCESS_KEY'],
-                        'aws_session_token': os.environ.get('AWS_SESSION_TOKEN')
-                    }
-                else:
-                    # Try to find a matching AWS profile by name
-                    # This allows "khoros" profile to work with "khoros_umbrella" AWS profile
-                    import subprocess
-                    try:
-                        result = subprocess.run(
-                            ['aws', 'configure', 'list-profiles'],
-                            capture_output=True,
-                            text=True,
-                            timeout=5
-                        )
-                        if result.returncode == 0:
-                            available_profiles = result.stdout.strip().split('\n')
-                            # Try exact match first
-                            if profile_name in available_profiles:
-                                profile['aws_profile'] = profile_name
-                            # Try with common suffixes
-                            elif f"{profile_name}_umbrella" in available_profiles:
-                                profile['aws_profile'] = f"{profile_name}_umbrella"
-                            elif f"{profile_name}-umbrella" in available_profiles:
-                                profile['aws_profile'] = f"{profile_name}-umbrella"
-                            elif f"{profile_name}_prod" in available_profiles:
-                                profile['aws_profile'] = f"{profile_name}_prod"
-                            # If no match found, leave it unset - user must provide --sso
-                    except:
-                        # If we can't list profiles, leave it unset - user must provide --sso
-                        pass
-                
-                return profile
-            else:
-                raise click.ClickException(
-                    f"Profile '{profile_name}' not found in DynamoDB.\n"
-                    f"Run: cc profile create --name {profile_name} --accounts \"...\""
-                )
-        except requests.exceptions.RequestException as e:
-            raise click.ClickException(
-                f"Failed to fetch profile from API: {e}\n"
-            )
+        return api_secret
+    
+    # Check config file
+    config_dir = Path.home() / '.config' / 'cost-calculator'
+    config_file = config_dir / 'config.json'
     
-    # Fallback to local file if no API secret
     if config_file.exists():
         with open(config_file) as f:
-            profiles = json.load(f)
+            config = json.load(f)
+            return config.get('api_secret')
+    
+    return None
+
+
+def load_profile(profile_name):
+    """Load profile configuration from DynamoDB API (API-only, no local files)"""
+    import requests
+    
+    # Get API secret
+    api_secret = get_api_secret()
+    
+    if not api_secret:
+        raise click.ClickException(
+            "No API secret configured.\n"
+            "Run: cc configure --api-secret YOUR_SECRET\n"
+            "Or set environment variable: export COST_API_SECRET=YOUR_SECRET"
+        )
+    
+    try:
+        response = requests.post(
+            'https://64g7jq7sjygec2zmll5lsghrpi0txrzo.lambda-url.us-east-1.on.aws/',
+            headers={'X-API-Secret': api_secret, 'Content-Type': 'application/json'},
+            json={'operation': 'get', 'profile_name': profile_name},
+            timeout=10
+        )
         
-        if profile_name in profiles:
-            profile = profiles[profile_name]
+        if response.status_code == 200:
+            response_data = response.json()
+            # API returns {"profile": {...}} wrapper
+            profile_data = response_data.get('profile', response_data)
+            profile = {'accounts': profile_data['accounts']}
             
-            # Load credentials if using static credentials (not SSO)
-            if 'aws_profile' not in profile:
-                if not creds_file.exists():
-                    # Try environment variables
-                    if os.environ.get('AWS_ACCESS_KEY_ID'):
-                        profile['credentials'] = {
-                            'aws_access_key_id': os.environ['AWS_ACCESS_KEY_ID'],
-                            'aws_secret_access_key': os.environ['AWS_SECRET_ACCESS_KEY'],
-                            'aws_session_token': os.environ.get('AWS_SESSION_TOKEN')
-                        }
-                        return profile
-                    
-                    raise click.ClickException(
-                        f"No credentials found for profile '{profile_name}'.\n"
-                        f"Run: cc configure --profile {profile_name}"
-                    )
-                
-                with open(creds_file) as f:
-                    creds = json.load(f)
-                
-                if profile_name not in creds:
-                    raise click.ClickException(
-                        f"No credentials found for profile '{profile_name}'.\n"
-                        f"Run: cc configure --profile {profile_name}"
+            # If profile has aws_profile field, use it
+            if 'aws_profile' in profile_data:
+                profile['aws_profile'] = profile_data['aws_profile']
+            # Check for AWS_PROFILE environment variable (SSO support)
+            elif os.environ.get('AWS_PROFILE'):
+                profile['aws_profile'] = os.environ['AWS_PROFILE']
+            # Use environment credentials
+            elif os.environ.get('AWS_ACCESS_KEY_ID'):
+                profile['credentials'] = {
+                    'aws_access_key_id': os.environ['AWS_ACCESS_KEY_ID'],
+                    'aws_secret_access_key': os.environ['AWS_SECRET_ACCESS_KEY'],
+                    'aws_session_token': os.environ.get('AWS_SESSION_TOKEN')
+                }
+            else:
+                # Try to find a matching AWS profile by name
+                # This allows "khoros" profile to work with "khoros_umbrella" AWS profile
+                import subprocess
+                try:
+                    result = subprocess.run(
+                        ['aws', 'configure', 'list-profiles'],
+                        capture_output=True,
+                        text=True,
+                        timeout=5
                     )
-                
-                profile['credentials'] = creds[profile_name]
+                    if result.returncode == 0:
+                        available_profiles = result.stdout.strip().split('\n')
+                        # Try exact match first
+                        if profile_name in available_profiles:
+                            profile['aws_profile'] = profile_name
+                        # Try with common suffixes
+                        elif f"{profile_name}_umbrella" in available_profiles:
+                            profile['aws_profile'] = f"{profile_name}_umbrella"
+                        elif f"{profile_name}-umbrella" in available_profiles:
+                            profile['aws_profile'] = f"{profile_name}-umbrella"
+                        elif f"{profile_name}_prod" in available_profiles:
+                            profile['aws_profile'] = f"{profile_name}_prod"
+                        # If no match found, leave it unset - user must provide --sso
+                except:
+                    # If we can't list profiles, leave it unset - user must provide --sso
+                    pass
             
             return profile
-    
-    # Profile not found anywhere
-    raise click.ClickException(
-        f"Profile '{profile_name}' not found.\n"
-        f"Run: cc profile create --name {profile_name} --accounts \"...\""
-    )
+        else:
+            raise click.ClickException(
+                f"Profile '{profile_name}' not found in DynamoDB.\n"
+                f"Run: cc profile create --name {profile_name} --accounts \"...\""
+            )
+    except requests.exceptions.RequestException as e:
+        raise click.ClickException(
+            f"Failed to fetch profile from API: {e}\n"
+            "Check your API secret and network connection."
+        )
 
 
 def calculate_costs(profile_config, accounts, start_date, offset, window):
@@ -737,77 +717,81 @@ def setup():
 
 
 @cli.command()
-@click.option('--profile', required=True, help='Profile name to configure')
-@click.option('--access-key-id', prompt=True, hide_input=False, help='AWS Access Key ID')
-@click.option('--secret-access-key', prompt=True, hide_input=True, help='AWS Secret Access Key')
-@click.option('--session-token', default='', help='AWS Session Token (optional, for temporary credentials)')
-@click.option('--region', default='us-east-1', help='AWS Region (default: us-east-1)')
-def configure(profile, access_key_id, secret_access_key, session_token, region):
-    """Configure AWS credentials for a profile (alternative to SSO)"""
+@click.option('--api-secret', help='API secret for DynamoDB profile access')
+@click.option('--show', is_flag=True, help='Show current configuration')
+def configure(api_secret, show):
+    """
+    Configure Cost Calculator CLI settings.
     
-    config_dir = Path.home() / '.config' / 'cost-calculator'
-    config_file = config_dir / 'profiles.json'
-    creds_file = config_dir / 'credentials.json'
+    This tool requires an API secret to access profiles stored in DynamoDB.
+    The secret can be configured here or set via COST_API_SECRET environment variable.
     
-    # Create config directory if it doesn't exist
+    Examples:
+        # Configure API secret
+        cc configure --api-secret YOUR_SECRET_KEY
+        
+        # Show current configuration
+        cc configure --show
+        
+        # Use environment variable instead (no configuration needed)
+        export COST_API_SECRET=YOUR_SECRET_KEY
+    """
+    import os
+    
+    config_dir = Path.home() / '.config' / 'cost-calculator'
     config_dir.mkdir(parents=True, exist_ok=True)
+    config_file = config_dir / 'config.json'
     
-    # Load existing profiles
-    if config_file.exists() and config_file.stat().st_size > 0:
-        try:
+    if show:
+        # Show current configuration
+        if config_file.exists():
             with open(config_file) as f:
-                profiles = json.load(f)
-        except json.JSONDecodeError:
-            profiles = {}
-    else:
-        profiles = {}
-    
-    # Check if profile exists
-    if profile not in profiles:
-        click.echo(f"Error: Profile '{profile}' not found. Create it first with: cc init --profile {profile}")
+                config = json.load(f)
+                if 'api_secret' in config:
+                    masked_secret = config['api_secret'][:8] + '...' + config['api_secret'][-4:]
+                    click.echo(f"API Secret: {masked_secret} (configured)")
+                else:
+                    click.echo("API Secret: Not configured")
+        else:
+            click.echo("No configuration file found")
+        
+        # Check environment variable
+        import os
+        if os.environ.get('COST_API_SECRET'):
+            click.echo("Environment: COST_API_SECRET is set")
+        else:
+            click.echo("Environment: COST_API_SECRET is not set")
+        
         return
     
-    # Remove aws_profile if it exists (switching from SSO to static creds)
-    if 'aws_profile' in profiles[profile]:
-        del profiles[profile]['aws_profile']
-    
-    # Save updated profile
-    with open(config_file, 'w') as f:
-        json.dump(profiles, f, indent=2)
-    
-    # Load or create credentials file
-    if creds_file.exists() and creds_file.stat().st_size > 0:
-        try:
-            with open(creds_file) as f:
-                creds = json.load(f)
-        except json.JSONDecodeError:
-            creds = {}
-    else:
-        creds = {}
+    if not api_secret:
+        raise click.ClickException(
+            "Please provide --api-secret or use --show to view current configuration\n"
+            "Example: cc configure --api-secret YOUR_SECRET_KEY"
+        )
     
-    # Store credentials (encrypted would be better, but for now just file permissions)
-    creds[profile] = {
-        'aws_access_key_id': access_key_id,
-        'aws_secret_access_key': secret_access_key,
-        'region': region
-    }
+    # Load existing config
+    config = {}
+    if config_file.exists():
+        with open(config_file) as f:
+            config = json.load(f)
     
-    if session_token:
-        creds[profile]['aws_session_token'] = session_token
+    # Update API secret
+    config['api_secret'] = api_secret
     
-    # Save credentials with restricted permissions
-    with open(creds_file, 'w') as f:
-        json.dump(creds, f, indent=2)
+    # Save config
+    with open(config_file, 'w') as f:
+        json.dump(config, f, indent=2)
     
-    # Set file permissions to 600 (owner read/write only)
-    creds_file.chmod(0o600)
+    # Set restrictive permissions (Unix/Mac only - Windows uses different permission model)
+    import platform
+    if platform.system() != 'Windows':
+        os.chmod(config_file, 0o600)
     
-    click.echo(f"✓ AWS credentials configured for profile '{profile}'")
-    click.echo(f"✓ Credentials saved to {creds_file} (permissions: 600)")
-    click.echo(f"\nUsage: cc calculate --profile {profile}")
-    click.echo("\nNote: Credentials are stored locally. For temporary credentials,")
-    click.echo("      you'll need to reconfigure when they expire.")
-
+    masked_secret = api_secret[:8] + '...' + api_secret[-4:]
+    click.echo(f"✓ API secret configured: {masked_secret}")
+    click.echo(f"\nYou can now run: cc calculate --profile PROFILE_NAME")
+    click.echo(f"\nNote: Profiles are stored in DynamoDB and accessed via the API.")
 
 @cli.command()
 @click.option('--profile', required=True, help='Profile name')
@@ -1391,10 +1375,22 @@ def find_account_profile(account_id):
 @click.option('--json', 'output_json', is_flag=True, help='Output as JSON')
 def daily(profile, start_date, end_date, days, service, account, sso, output_json):
     """
-    Get daily cost breakdown with granular detail
+    Get daily cost breakdown with granular detail.
     
-    Example:
+    Shows day-by-day costs for specific services and accounts, useful for:
+    - Identifying cost spikes on specific dates
+    - Validating daily cost patterns
+    - Calculating precise daily averages
+    
+    Examples:
+        # Last 10 days of CloudWatch costs for specific account
         cc daily --profile khoros --days 10 --service AmazonCloudWatch --account 820054669588
+        
+        # Custom date range with JSON output for automation
+        cc daily --profile khoros --start-date 2025-10-28 --end-date 2025-11-06 --json
+        
+        # Find high-cost days using jq
+        cc daily --profile khoros --days 30 --json | jq '.daily_costs | map(select(.cost > 1000))'
     """
     # Load profile
     config = load_profile(profile)
@@ -1545,11 +1541,25 @@ def daily(profile, start_date, end_date, days, service, account, sso, output_jso
 @click.option('--json', 'output_json', is_flag=True, help='Output as JSON')
 def compare(profile, account, service, before, after, expected_reduction, sso, output_json):
     """
-    Compare costs between two periods
+    Compare costs between two periods for validation and analysis.
     
-    Example:
+    Perfect for:
+    - Validating cost optimization savings
+    - Before/after migration analysis
+    - Measuring impact of infrastructure changes
+    - Automated savings validation in CI/CD
+    
+    Examples:
+        # Validate Datadog migration savings (expect 50% reduction)
         cc compare --profile khoros --account 180770971501 --service AmazonCloudWatch \
           --before "2025-10-28:2025-11-06" --after "2025-11-17:2025-11-26" --expected-reduction 50
+        
+        # Compare total costs across all accounts
+        cc compare --profile khoros --before "2025-10-01:2025-10-31" --after "2025-11-01:2025-11-30"
+        
+        # JSON output for automated validation
+        cc compare --profile khoros --service EC2 --before "2025-10-01:2025-10-07" \
+          --after "2025-11-08:2025-11-14" --json | jq '.comparison.met_expectation'
     """
     # Load profile
     config = load_profile(profile)
@@ -1731,11 +1741,27 @@ def compare(profile, account, service, before, after, expected_reduction, sso, o
 @click.option('--json', 'output_json', is_flag=True, help='Output as JSON')
 def tags(profile, tag_key, tag_value, start_date, end_date, days, sso, output_json):
     """
-    Analyze costs by resource tags
+    Analyze costs grouped by resource tags for cost attribution.
     
-    Example:
-        cc tags --profile khoros --tag-key "datadog:org" --days 30
-        cc tags --profile khoros --tag-key "Environment" --tag-value "Production"
+    Useful for:
+    - Cost allocation by team, project, or environment
+    - Identifying untagged resources (cost attribution gaps)
+    - Tracking costs by cost center or department
+    - Validating tagging compliance
+    
+    Examples:
+        # See all costs by Environment tag
+        cc tags --profile khoros --tag-key "Environment" --days 30
+        
+        # Filter to specific tag value
+        cc tags --profile khoros --tag-key "Team" --tag-value "Platform" --days 30
+        
+        # Find top cost centers with JSON output
+        cc tags --profile khoros --tag-key "CostCenter" --days 30 --json | \
+          jq '.tag_costs | sort_by(-.cost) | .[:5]'
+        
+        # Identify untagged resources (look for empty tag values)
+        cc tags --profile khoros --tag-key "Owner" --days 7
     """
     # Load profile
     config = load_profile(profile)

aws_cost_calculator_cli-1.11.0.dist-info/RECORD

@@ -1,15 +0,0 @@
-aws_cost_calculator_cli-1.11.0.dist-info/licenses/LICENSE,sha256=cYtmQZHNGGTXOtg3T7LHDRneleaH0dHXHfxFV3WR50Y,1079
-cost_calculator/__init__.py,sha256=PJeIqvWh5AYJVrJxPPkI4pJnAt37rIjasrNS0I87kaM,52
-cost_calculator/api_client.py,sha256=4ZI2XcGIN3FBeQqb7xOxQ91kCoeM43-rExiOELXoKBQ,2485
-cost_calculator/cli.py,sha256=UclTm6G5kZyk0Dw2Ot7IkVhKIJK96VSvKe8D4oCSk1Q,76053
-cost_calculator/cur.py,sha256=QaZ_nyDSw5_cti-h5Ho6eYLbqzY5TWoub24DpyzIiSs,9502
-cost_calculator/drill.py,sha256=hGi-prLgZDvNMMICQc4fl3LenM7YaZ3To_Ei4LKwrdc,10543
-cost_calculator/executor.py,sha256=yZTCUgJc1OpB892O3mq9ZA0Yekc7N-HvaW8xLFyrXjo,8681
-cost_calculator/forensics.py,sha256=uhRo3I_zOeMEaBENHfgq65URga31W0Z4vzS2UN6VmTY,12819
-cost_calculator/monthly.py,sha256=6k9F8S7djhX1wGV3-T1MZP7CvWbbfhSTEaddwCfVu5M,7932
-cost_calculator/trends.py,sha256=k_s4ylBX50sqoiM_fwepi58HW01zz767FMJhQUPDznk,12246
-aws_cost_calculator_cli-1.11.0.dist-info/METADATA,sha256=M_I1zl12wIBb6fdmzxeAa7CNBc3gWOggYdzqpYLZNTw,11979
-aws_cost_calculator_cli-1.11.0.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-aws_cost_calculator_cli-1.11.0.dist-info/entry_points.txt,sha256=_5Qy4EcHbYVYrdgOu1E48faMHb9fLUl5VJ3djDHuJBo,47
-aws_cost_calculator_cli-1.11.0.dist-info/top_level.txt,sha256=PRwGPPlNqASfyhGHDjSfyl4SXeE7GF3OVTu1tY1Uqyc,16
-aws_cost_calculator_cli-1.11.0.dist-info/RECORD,,