aws-cost-calculator-cli 1.5.1__py3-none-any.whl → 1.6.3__py3-none-any.whl

{aws_cost_calculator_cli-1.5.1.dist-info → aws_cost_calculator_cli-1.6.3.dist-info}/METADATA

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: aws-cost-calculator-cli
-Version: 1.5.1
+Version: 1.6.3
 Summary: AWS Cost Calculator CLI - Calculate daily and annual AWS costs across multiple accounts
-Home-page: https://github.com/yourusername/cost-calculator
+Home-page: https://github.com/trilogy-group/aws-cost-calculator
 Author: Cost Optimization Team
 Author-email: 
-Project-URL: Documentation, https://github.com/yourusername/cost-calculator/blob/main/README.md
+Project-URL: Documentation, https://github.com/trilogy-group/aws-cost-calculator/blob/main/README.md
 Keywords: aws cost calculator billing optimization cloud
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
@@ -43,66 +43,200 @@ A CLI tool to quickly calculate AWS costs across multiple accounts.
 ## Installation
 
 ```bash
-cd ~/cost-calculator
-pip install -e .
+pip install aws-cost-calculator-cli
+```
+
+Or upgrade to the latest version:
+```bash
+pip install --upgrade aws-cost-calculator-cli
 ```
 
 ## Quick Start
 
-### 1. Login to AWS SSO
+### Authentication Methods
+
+The CLI supports three authentication methods:
 
+#### 1. SSO (Recommended)
 ```bash
-aws sso login --profile my_aws_profile
+# The CLI will automatically trigger SSO login if needed
+cc calculate --profile myprofile --sso my_sso_profile
 ```
 
-**Note:** You need to do this before running cost calculations. The SSO session typically lasts 8-12 hours.
-
-### 2. Initialize a profile
+#### 2. Static Credentials
+```bash
+cc calculate --profile myprofile \
+  --access-key-id ASIA... \
+  --secret-access-key ... \
+  --session-token ...
+```
 
+#### 3. Environment Variables
 ```bash
-cc init --profile myprofile \
-  --aws-profile my_aws_profile \
-  --accounts "123456789012,234567890123,345678901234"
+# For SSO
+export AWS_PROFILE=my_sso_profile
+cc calculate --profile myprofile
+
+# For static credentials
+export AWS_ACCESS_KEY_ID=ASIA...
+export AWS_SECRET_ACCESS_KEY=...
+export AWS_SESSION_TOKEN=...
+cc calculate --profile myprofile
 ```
 
-### 3. Calculate costs
+### Basic Usage
 
 ```bash
 # Default: Today minus 2 days, going back 30 days
-cc calculate --profile myprofile
+cc calculate --profile myprofile --sso my_sso_profile
 
 # Specific start date
-cc calculate --profile myprofile --start-date 2025-11-04
+cc calculate --profile myprofile --sso my_sso_profile --start-date 2025-11-04
 
 # Custom offset and window
-cc calculate --profile myprofile --offset 2 --window 30
+cc calculate --profile myprofile --sso my_sso_profile --offset 2 --window 30
 
 # JSON output
-cc calculate --profile myprofile --json-output
+cc calculate --profile myprofile --sso my_sso_profile --json-output
 ```
 
 ### 4. Analyze cost trends
 
+All commands support the same authentication options:
+
 ```bash
-# Analyze last 3 weeks (default)
+# With SSO
+cc trends --profile myprofile --sso my_sso_profile
+
+# With static credentials
+cc trends --profile myprofile --access-key-id ASIA... --secret-access-key ... --session-token ...
+
+# With environment variables
+export AWS_PROFILE=my_sso_profile
 cc trends --profile myprofile
 
 # Analyze more weeks
-cc trends --profile myprofile --weeks 5
+cc trends --profile myprofile --sso my_sso_profile --weeks 5
 
 # Custom output file
-cc trends --profile myprofile --output weekly_trends.md
+cc trends --profile myprofile --sso my_sso_profile --output weekly_trends.md
 
 # JSON output
-cc trends --profile myprofile --json-output
+cc trends --profile myprofile --sso my_sso_profile --json-output
 ```
 
-### 5. List profiles
+### 5. Monthly and drill-down analysis
+
+```bash
+# Monthly trends
+cc monthly --profile myprofile --sso my_sso_profile
+
+# Drill down by service
+cc drill --profile myprofile --sso my_sso_profile --service "EC2 - Other"
+
+# Drill down by account
+cc drill --profile myprofile --sso my_sso_profile --account 123456789012
+```
+
+### 6. List profiles
 
 ```bash
 cc list-profiles
 ```
 
+## Authentication
+
+### Overview
+
+The CLI supports three authentication methods, all of which work with every command (`calculate`, `trends`, `monthly`, `drill`):
+
+### Method 1: SSO (Recommended)
+
+The CLI automatically handles SSO login if your session has expired:
+
+```bash
+cc calculate --profile myprofile --sso my_sso_profile
+```
+
+**How it works:**
+1. CLI checks if SSO session is valid using `aws sts get-caller-identity`
+2. If expired, automatically runs `aws sso login --profile my_sso_profile`
+3. Opens browser for authentication
+4. Proceeds with cost calculation once authenticated
+
+**Benefits:**
+- No manual SSO login required
+- Automatic session refresh
+- Most secure method
+- Works with AWS IAM Identity Center
+
+### Method 2: Static Credentials
+
+Pass temporary credentials directly via CLI flags:
+
+```bash
+cc calculate --profile myprofile \
+  --access-key-id ASIA... \
+  --secret-access-key ... \
+  --session-token ...
+```
+
+**Use cases:**
+- CI/CD pipelines
+- Temporary credentials from STS
+- Automated scripts
+- When SSO is not available
+
+### Method 3: Environment Variables
+
+Set credentials in your shell environment:
+
+```bash
+# For SSO
+export AWS_PROFILE=my_sso_profile
+cc calculate --profile myprofile
+
+# For static credentials
+export AWS_ACCESS_KEY_ID=ASIA...
+export AWS_SECRET_ACCESS_KEY=...
+export AWS_SESSION_TOKEN=...
+cc calculate --profile myprofile
+```
+
+**Benefits:**
+- No need to pass credentials with each command
+- Works with existing AWS CLI configuration
+- Can be set in shell profile (~/.zshrc, ~/.bashrc)
+
+### Profile Configuration
+
+Profiles can be stored locally or fetched from a backend API:
+
+**Local storage:** `~/.config/cost-calculator/profiles.json`
+```json
+{
+  "myprofile": {
+    "accounts": ["123456789012", "234567890123", ...]
+  }
+}
+```
+
+**Backend API:** Set `COST_API_SECRET` environment variable
+
+Quick setup (saves to shell profile):
+```bash
+cc setup-api
+# Enter your API secret when prompted (input will be hidden)
+```
+
+Or set manually:
+```bash
+export COST_API_SECRET="your-api-secret"
+cc calculate --profile myprofile --sso my_sso_profile
+```
+
+The CLI will automatically fetch profile configuration from the backend if `COST_API_SECRET` is set.
+
 ## How It Works
 
 ### Date Calculation
@@ -262,7 +396,7 @@ cc drill --profile myprofile --service "EC2 - Other"
 Showing top accounts:
 Week of Oct 19 → Week of Oct 26
   Increases: 3, Decreases: 2
-  Top: 887649220066 (+$450.23)
+  Top: 123456789012 (+$450.23)
 ```
 
 The report is saved to `drill_down.md` by default.

aws_cost_calculator_cli-1.6.3.dist-info/RECORD

@@ -0,0 +1,25 @@
+aws_cost_calculator_cli-1.6.3.dist-info/licenses/LICENSE,sha256=cYtmQZHNGGTXOtg3T7LHDRneleaH0dHXHfxFV3WR50Y,1079
+backend/__init__.py,sha256=PnH3-V1bIUu7nKDGdfPykzx0sz3x4lsLP0OheoAqY4U,18
+backend/algorithms/__init__.py,sha256=QWrMPtDO_nVOFzKm8yI6_RXdSE0n25RQAFnpS1GsGZs,21
+backend/algorithms/analyze.py,sha256=LvYuY83vIW162km3MvxrL1xsdFdpBqSUOWm7YZ-Tdyc,8922
+backend/algorithms/drill.py,sha256=hGi-prLgZDvNMMICQc4fl3LenM7YaZ3To_Ei4LKwrdc,10543
+backend/algorithms/monthly.py,sha256=6k9F8S7djhX1wGV3-T1MZP7CvWbbfhSTEaddwCfVu5M,7932
+backend/algorithms/trends.py,sha256=k_s4ylBX50sqoiM_fwepi58HW01zz767FMJhQUPDznk,12246
+backend/handlers/__init__.py,sha256=YGc9-XVhFcT5NOvnu0Vg5qaGy0Md0J_PNj8dJIM5PhE,19
+backend/handlers/analyze.py,sha256=ULeYYMpD5VS4qBd-WvPP_OjgbSLm9VzT6BZYHrt47eE,3546
+backend/handlers/drill.py,sha256=WQbqM5RvOcJHsUpBOR6PS-BtKHqszeCZ7xZu3499jPo,3847
+backend/handlers/monthly.py,sha256=A4B-BLrWHsR9OnhsTEvbYHIATbM5fBRIf_h-liczfE0,3415
+backend/handlers/profiles.py,sha256=tSnHxvGvwH4ynR0R-WrsPgz_VMgxaWHu-SnuhmGPxcs,5107
+backend/handlers/trends.py,sha256=loNvfoc1B-nAb-dTJVLf4TnRZ-UZd_AilyA2l4YahK8,3404
+cost_calculator/__init__.py,sha256=PJeIqvWh5AYJVrJxPPkI4pJnAt37rIjasrNS0I87kaM,52
+cost_calculator/api_client.py,sha256=LUzQmveDF0X9MqAyThp9mbSzJzkOO73Pk4F7IEJjASU,2353
+cost_calculator/cli.py,sha256=zGxFsErjmZAy9v7fqGQDS8qZf4lXoir8Fel0Ka7lw3Y,42235
+cost_calculator/drill.py,sha256=hGi-prLgZDvNMMICQc4fl3LenM7YaZ3To_Ei4LKwrdc,10543
+cost_calculator/executor.py,sha256=tVyyBtXIj9OPyG-xQj8CUmyFjDhb9IVK639360dUZDc,8076
+cost_calculator/monthly.py,sha256=6k9F8S7djhX1wGV3-T1MZP7CvWbbfhSTEaddwCfVu5M,7932
+cost_calculator/trends.py,sha256=k_s4ylBX50sqoiM_fwepi58HW01zz767FMJhQUPDznk,12246
+aws_cost_calculator_cli-1.6.3.dist-info/METADATA,sha256=VNV5xwWJraHcgf44FpX1TZEGpfkSkXB98BLnkGIo8n0,11506
+aws_cost_calculator_cli-1.6.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aws_cost_calculator_cli-1.6.3.dist-info/entry_points.txt,sha256=_5Qy4EcHbYVYrdgOu1E48faMHb9fLUl5VJ3djDHuJBo,47
+aws_cost_calculator_cli-1.6.3.dist-info/top_level.txt,sha256=YV8sPp9unLPDmK3ixw8-yoyVEKU3O4kskxvZAxFgIK0,24
+aws_cost_calculator_cli-1.6.3.dist-info/RECORD,,

{aws_cost_calculator_cli-1.5.1.dist-info → aws_cost_calculator_cli-1.6.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.7.1)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{aws_cost_calculator_cli-1.5.1.dist-info → aws_cost_calculator_cli-1.6.3.dist-info}/top_level.txt

@@ -1 +1,2 @@
+backend
 cost_calculator

backend/__init__.py

@@ -0,0 +1 @@
+# Backend package

backend/algorithms/__init__.py

@@ -0,0 +1 @@
+# Algorithms package

backend/algorithms/analyze.py

@@ -0,0 +1,272 @@
+"""
+Analysis algorithm using pandas for aggregations.
+Reuses existing algorithms and adds pandas-based analytics.
+"""
+import pandas as pd
+import numpy as np
+from datetime import datetime, timedelta
+from algorithms.trends import analyze_trends
+from algorithms.drill import analyze_drill_down
+
+
+def analyze_aggregated(ce_client, accounts, weeks=12, analysis_type='summary'):
+    """
+    Perform pandas-based analysis on cost data.
+    
+    Args:
+        ce_client: boto3 Cost Explorer client
+        accounts: List of account IDs
+        weeks: Number of weeks to analyze
+        analysis_type: 'summary', 'volatility', 'trends', 'multi_group'
+    
+    Returns:
+        dict with analysis results
+    """
+    # Get raw data from trends
+    trends_data = analyze_trends(ce_client, accounts, weeks)
+    
+    # Convert to pandas DataFrame
+    rows = []
+    for comp in trends_data['wow_comparisons']:
+        week_label = comp['curr_week']['label']
+        for item in comp['increases'] + comp['decreases']:
+            rows.append({
+                'week': week_label,
+                'service': item['service'],
+                'prev_cost': item['prev_cost'],
+                'curr_cost': item['curr_cost'],
+                'change': item['change'],
+                'pct_change': item['pct_change']
+            })
+    
+    df = pd.DataFrame(rows)
+    
+    if df.empty:
+        return {'error': 'No data available'}
+    
+    # Perform requested analysis
+    if analysis_type == 'summary':
+        return _analyze_summary(df, weeks)
+    elif analysis_type == 'volatility':
+        return _analyze_volatility(df)
+    elif analysis_type == 'trends':
+        return _detect_trends(df)
+    elif analysis_type == 'multi_group':
+        return _multi_group_analysis(ce_client, accounts, weeks)
+    else:
+        return {'error': f'Unknown analysis type: {analysis_type}'}
+
+
+def _analyze_summary(df, weeks):
+    """Aggregate summary statistics across all weeks."""
+    # Group by service and aggregate
+    summary = df.groupby('service').agg({
+        'change': ['sum', 'mean', 'std', 'min', 'max', 'count'],
+        'curr_cost': ['sum', 'mean']
+    }).round(2)
+    
+    # Flatten column names
+    summary.columns = ['_'.join(col).strip() for col in summary.columns.values]
+    summary = summary.reset_index()
+    
+    # Calculate coefficient of variation
+    summary['volatility'] = (summary['change_std'] / summary['change_mean'].abs()).fillna(0).round(3)
+    
+    # Sort by total change
+    summary = summary.sort_values('change_sum', ascending=False)
+    
+    # Convert to dict
+    results = summary.to_dict('records')
+    
+    # Add percentiles
+    percentiles = df.groupby('service')['change'].sum().quantile([0.5, 0.9, 0.99]).to_dict()
+    
+    return {
+        'analysis_type': 'summary',
+        'weeks_analyzed': weeks,
+        'total_services': len(results),
+        'services': results[:50],  # Top 50
+        'percentiles': {
+            'p50': round(percentiles.get(0.5, 0), 2),
+            'p90': round(percentiles.get(0.9, 0), 2),
+            'p99': round(percentiles.get(0.99, 0), 2)
+        }
+    }
+
+
+def _analyze_volatility(df):
+    """Identify services with high cost volatility."""
+    # Calculate volatility metrics
+    volatility = df.groupby('service').agg({
+        'change': ['mean', 'std', 'count']
+    })
+    
+    volatility.columns = ['mean_change', 'std_change', 'weeks']
+    volatility['coefficient_of_variation'] = (volatility['std_change'] / volatility['mean_change'].abs()).fillna(0)
+    
+    # Only services that appear in at least 3 weeks
+    volatility = volatility[volatility['weeks'] >= 3]
+    
+    # Sort by CV
+    volatility = volatility.sort_values('coefficient_of_variation', ascending=False)
+    volatility = volatility.reset_index()
+    
+    # Identify outliers (z-score > 2)
+    df['z_score'] = df.groupby('service')['change'].transform(
+        lambda x: (x - x.mean()) / x.std() if x.std() > 0 else 0
+    )
+    outliers = df[df['z_score'].abs() > 2][['week', 'service', 'change', 'z_score']].to_dict('records')
+    
+    return {
+        'analysis_type': 'volatility',
+        'high_volatility_services': volatility.head(20).to_dict('records'),
+        'outliers': outliers[:20]
+    }
+
+
+def _detect_trends(df):
+    """Detect services with consistent increasing/decreasing trends."""
+    # Calculate trend for each service
+    trends = []
+    
+    for service in df['service'].unique():
+        service_df = df[df['service'] == service].sort_values('week')
+        
+        if len(service_df) < 3:
+            continue
+        
+        # Calculate linear regression slope
+        x = np.arange(len(service_df))
+        y = service_df['change'].values
+        
+        if len(x) > 1:
+            slope = np.polyfit(x, y, 1)[0]
+            avg_change = service_df['change'].mean()
+            
+            # Classify trend
+            if slope > avg_change * 0.1:  # Increasing by >10% on average
+                trend_type = 'increasing'
+            elif slope < -avg_change * 0.1:  # Decreasing by >10%
+                trend_type = 'decreasing'
+            else:
+                trend_type = 'stable'
+            
+            trends.append({
+                'service': service,
+                'trend': trend_type,
+                'slope': round(slope, 2),
+                'avg_change': round(avg_change, 2),
+                'weeks_analyzed': len(service_df)
+            })
+    
+    # Separate by trend type
+    increasing = [t for t in trends if t['trend'] == 'increasing']
+    decreasing = [t for t in trends if t['trend'] == 'decreasing']
+    stable = [t for t in trends if t['trend'] == 'stable']
+    
+    # Sort by slope magnitude
+    increasing.sort(key=lambda x: x['slope'], reverse=True)
+    decreasing.sort(key=lambda x: x['slope'])
+    
+    return {
+        'analysis_type': 'trend_detection',
+        'increasing_trends': increasing[:20],
+        'decreasing_trends': decreasing[:20],
+        'stable_services': len(stable)
+    }
+
+
+def _multi_group_analysis(ce_client, accounts, weeks):
+    """Multi-dimensional grouping (service + account)."""
+    # Get drill-down data for all services
+    drill_data = analyze_drill_down(ce_client, accounts, weeks)
+    
+    # Convert to DataFrame
+    rows = []
+    for comp in drill_data['comparisons']:
+        week = comp['curr_week']['label']
+        for item in comp['increases'] + comp['decreases']:
+            rows.append({
+                'week': week,
+                'dimension': item['dimension'],  # This is account when drilling by service
+                'change': item['change'],
+                'curr_cost': item['curr_cost']
+            })
+    
+    df = pd.DataFrame(rows)
+    
+    if df.empty:
+        return {'error': 'No drill-down data available'}
+    
+    # Group by dimension (account) and aggregate
+    grouped = df.groupby('dimension').agg({
+        'change': ['sum', 'mean', 'count'],
+        'curr_cost': 'sum'
+    }).round(2)
+    
+    grouped.columns = ['total_change', 'avg_change', 'weeks_appeared', 'total_cost']
+    grouped = grouped.sort_values('total_change', ascending=False).reset_index()
+    
+    return {
+        'analysis_type': 'multi_group',
+        'group_by': drill_data.get('group_by', 'account'),
+        'groups': grouped.head(50).to_dict('records')
+    }
+
+
+def search_services(ce_client, accounts, weeks, pattern=None, min_cost=None):
+    """
+    Search and filter services.
+    
+    Args:
+        ce_client: boto3 Cost Explorer client
+        accounts: List of account IDs
+        weeks: Number of weeks
+        pattern: Service name pattern (e.g., "EC2*", "*Compute*")
+        min_cost: Minimum total cost threshold
+    
+    Returns:
+        dict with matching services
+    """
+    # Get trends data
+    trends_data = analyze_trends(ce_client, accounts, weeks)
+    
+    # Convert to DataFrame
+    rows = []
+    for comp in trends_data['wow_comparisons']:
+        for item in comp['increases'] + comp['decreases']:
+            rows.append({
+                'service': item['service'],
+                'change': item['change'],
+                'curr_cost': item['curr_cost']
+            })
+    
+    df = pd.DataFrame(rows)
+    
+    if df.empty:
+        return {'matches': []}
+    
+    # Aggregate by service
+    summary = df.groupby('service').agg({
+        'change': 'sum',
+        'curr_cost': 'sum'
+    }).reset_index()
+    
+    # Apply filters
+    if pattern:
+        # Convert glob pattern to regex
+        import re
+        regex_pattern = pattern.replace('*', '.*').replace('?', '.')
+        summary = summary[summary['service'].str.contains(regex_pattern, case=False, regex=True)]
+    
+    if min_cost:
+        summary = summary[summary['curr_cost'] >= min_cost]
+    
+    # Sort by total cost
+    summary = summary.sort_values('curr_cost', ascending=False)
+    
+    return {
+        'pattern': pattern,
+        'min_cost': min_cost,
+        'matches': summary.to_dict('records')
+    }