aws-cost-calculator-cli 1.7.0__tar.gz → 1.8.3__tar.gz

{aws_cost_calculator_cli-1.7.0 → aws_cost_calculator_cli-1.8.3}/CHANGES.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## Version 1.8.0 (2025-11-07)
+
+### Added
+- **New `cc investigate` command** - Multi-stage cost investigation tool
+  - Combines cost analysis, resource inventory, and CloudTrail events
+  - Automatically finds SSO profiles for accounts
+  - Generates comprehensive markdown reports
+  - Supports `--no-cloudtrail` flag for faster execution
+  - Example: `cc investigate --profile myprofile --account 123456789012`
+
+### Changed
+- **Package cleanup** - Excluded backend, tests, and notebooks from PyPI distribution
+  - Backend code is only for Lambda deployment, not needed in CLI package
+  - Reduces package size and eliminates unnecessary files
+
+### Security
+- Verified no sensitive data (company names, account IDs) in PyPI package
+- All example data uses generic placeholders
+
 ## Version 1.7.0 (2025-11-06)
 
 ### Added

{aws_cost_calculator_cli-1.7.0/aws_cost_calculator_cli.egg-info → aws_cost_calculator_cli-1.8.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aws-cost-calculator-cli
-Version: 1.7.0
+Version: 1.8.3
 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-1.7.0 → aws_cost_calculator_cli-1.8.3/aws_cost_calculator_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aws-cost-calculator-cli
-Version: 1.7.0
+Version: 1.8.3
 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-1.7.0 → aws_cost_calculator_cli-1.8.3}/aws_cost_calculator_cli.egg-info/SOURCES.txt

@@ -9,24 +9,12 @@ aws_cost_calculator_cli.egg-info/dependency_links.txt
 aws_cost_calculator_cli.egg-info/entry_points.txt
 aws_cost_calculator_cli.egg-info/requires.txt
 aws_cost_calculator_cli.egg-info/top_level.txt
-backend/__init__.py
-backend/algorithms/__init__.py
-backend/algorithms/analyze.py
-backend/algorithms/cur.py
-backend/algorithms/drill.py
-backend/algorithms/monthly.py
-backend/algorithms/trends.py
-backend/handlers/__init__.py
-backend/handlers/analyze.py
-backend/handlers/drill.py
-backend/handlers/monthly.py
-backend/handlers/profiles.py
-backend/handlers/trends.py
 cost_calculator/__init__.py
 cost_calculator/api_client.py
 cost_calculator/cli.py
 cost_calculator/cur.py
 cost_calculator/drill.py
 cost_calculator/executor.py
+cost_calculator/forensics.py
 cost_calculator/monthly.py
 cost_calculator/trends.py

{aws_cost_calculator_cli-1.7.0 → aws_cost_calculator_cli-1.8.3}/aws_cost_calculator_cli.egg-info/top_level.txt

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

{aws_cost_calculator_cli-1.7.0 → aws_cost_calculator_cli-1.8.3}/cost_calculator/api_client.py

@@ -50,7 +50,8 @@ def call_lambda_api(endpoint, credentials, accounts, **kwargs):
         'monthly': 'https://6aueebodw6q4zdeu3aaexb6tle0fqhhr.lambda-url.us-east-1.on.aws/',
         'drill': 'https://3ncm2gzxrsyptrhud3ua3x5lju0akvsr.lambda-url.us-east-1.on.aws/',
         'analyze': 'https://y6npmidtxwzg62nrqzkbacfs5q0edwgs.lambda-url.us-east-1.on.aws/',
-        'profiles': 'https://64g7jq7sjygec2zmll5lsghrpi0txrzo.lambda-url.us-east-1.on.aws/'
+        'profiles': 'https://64g7jq7sjygec2zmll5lsghrpi0txrzo.lambda-url.us-east-1.on.aws/',
+        'forensics': 'https://gaekfzz7sc2hwn4mjyk64sieke0vadfo.lambda-url.us-east-1.on.aws/'  # Will be populated after deployment
     }
     
     url = endpoint_urls.get(endpoint)

{aws_cost_calculator_cli-1.7.0 → aws_cost_calculator_cli-1.8.3}/cost_calculator/cli.py

@@ -325,7 +325,8 @@ def calculate_costs(profile_config, accounts, start_date, offset, window):
     # Calculate days in the month that the support covers
     # Support on Nov 1 covers October (31 days)
     support_month = support_month_date - timedelta(days=1)  # Go back to previous month
-    days_in_support_month = support_month.day  # This gives us the last day of the month
+    import calendar
+    days_in_support_month = calendar.monthrange(support_month.year, support_month.month)[1]
     
     # Support allocation: divide by 2 (50% allocation), then by days in month
     support_per_day = (support_cost / 2) / days_in_support_month
@@ -1135,5 +1136,209 @@ def profile(operation, name, accounts, description):
         click.echo(result.get('message', 'Operation completed'))
 
 
+@cli.command()
+@click.option('--profile', required=True, help='Profile name')
+@click.option('--sso', help='AWS SSO profile to use')
+@click.option('--weeks', default=8, help='Number of weeks to analyze')
+@click.option('--account', help='Focus on specific account ID')
+@click.option('--service', help='Focus on specific service')
+@click.option('--no-cloudtrail', is_flag=True, help='Skip CloudTrail analysis (faster)')
+@click.option('--output', default='investigation_report.md', help='Output file path')
+def investigate(profile, sso, weeks, account, service, no_cloudtrail, output):
+    """
+    Multi-stage cost investigation:
+    1. Analyze cost trends and drill-downs
+    2. Inventory actual resources in problem accounts
+    3. Analyze CloudTrail events (optional)
+    4. Generate comprehensive report
+    """
+    from cost_calculator.executor import execute_trends, execute_drill, get_credentials_dict
+    from cost_calculator.api_client import call_lambda_api, is_api_configured
+    from cost_calculator.forensics import format_investigation_report
+    from datetime import datetime, timedelta
+    
+    click.echo("=" * 80)
+    click.echo("COST INVESTIGATION")
+    click.echo("=" * 80)
+    click.echo(f"Profile: {profile}")
+    click.echo(f"Weeks: {weeks}")
+    if account:
+        click.echo(f"Account: {account}")
+    if service:
+        click.echo(f"Service: {service}")
+    click.echo("")
+    
+    # Load profile
+    config = load_profile(profile)
+    
+    # Override with SSO if provided
+    if sso:
+        config['aws_profile'] = sso
+    
+    # Step 1: Cost Analysis
+    click.echo("Step 1/3: Analyzing cost trends...")
+    try:
+        trends_data = execute_trends(config, weeks)
+        click.echo(f"✓ Found cost data for {weeks} weeks")
+    except Exception as e:
+        click.echo(f"✗ Error analyzing trends: {str(e)}")
+        trends_data = None
+    
+    # Step 2: Drill-down
+    click.echo("\nStep 2/3: Drilling down into costs...")
+    drill_data = None
+    if service or account:
+        try:
+            drill_data = execute_drill(config, weeks, service, account, None, False)
+            click.echo(f"✓ Drill-down complete")
+        except Exception as e:
+            click.echo(f"✗ Error in drill-down: {str(e)}")
+    
+    # Step 3: Resource Inventory
+    click.echo("\nStep 3/3: Inventorying resources...")
+    inventories = []
+    cloudtrail_analyses = []
+    
+    # Determine which accounts to investigate
+    accounts_to_investigate = []
+    if account:
+        accounts_to_investigate = [account]
+    else:
+        # Extract top cost accounts from trends/drill data
+        # For now, we'll need the user to specify
+        click.echo("⚠️  No account specified. Use --account to inventory resources.")
+    
+    # For each account, do inventory and CloudTrail via backend API
+    for acc_id in accounts_to_investigate:
+        click.echo(f"\n  Investigating account {acc_id}...")
+        
+        # Get credentials (SSO or static)
+        account_creds = get_credentials_dict(config)
+        if not account_creds:
+            click.echo(f"    ⚠️  No credentials available for account")
+            continue
+        
+        # Inventory resources via backend API
+        try:
+            regions = ['us-west-2', 'us-east-1', 'eu-west-1']
+            for region in regions:
+                try:
+                    if is_api_configured():
+                        inv = call_lambda_api(
+                            'forensics',
+                            account_creds,
+                            [],  # accounts not needed for forensics
+                            operation='inventory',
+                            account_id=acc_id,
+                            region=region
+                        )
+                    else:
+                        # Fallback to local execution
+                        from cost_calculator.forensics import inventory_resources
+                        acc_profile = find_account_profile(acc_id)
+                        if not acc_profile:
+                            raise Exception("No SSO profile found and API not configured")
+                        inv = inventory_resources(acc_id, acc_profile, region)
+                    
+                    if not inv.get('error'):
+                        inventories.append(inv)
+                        click.echo(f"    ✓ Inventory complete for {region}")
+                        click.echo(f"      - EC2: {len(inv['ec2_instances'])} instances")
+                        click.echo(f"      - EFS: {len(inv['efs_file_systems'])} file systems ({inv.get('total_efs_size_gb', 0):,.0f} GB)")
+                        click.echo(f"      - ELB: {len(inv['load_balancers'])} load balancers")
+                        break
+                except Exception as e:
+                    continue
+        except Exception as e:
+            click.echo(f"    ✗ Inventory error: {str(e)}")
+        
+        # CloudTrail analysis via backend API
+        if not no_cloudtrail:
+            try:
+                start_date = (datetime.now() - timedelta(days=weeks * 7)).isoformat() + 'Z'
+                end_date = datetime.now().isoformat() + 'Z'
+                
+                if is_api_configured():
+                    ct_analysis = call_lambda_api(
+                        'forensics',
+                        account_creds,
+                        [],
+                        operation='cloudtrail',
+                        account_id=acc_id,
+                        start_date=start_date,
+                        end_date=end_date,
+                        region='us-west-2'
+                    )
+                else:
+                    # Fallback to local execution
+                    from cost_calculator.forensics import analyze_cloudtrail
+                    acc_profile = find_account_profile(acc_id)
+                    if not acc_profile:
+                        raise Exception("No SSO profile found and API not configured")
+                    start_dt = datetime.now() - timedelta(days=weeks * 7)
+                    end_dt = datetime.now()
+                    ct_analysis = analyze_cloudtrail(acc_id, acc_profile, start_dt, end_dt)
+                
+                cloudtrail_analyses.append(ct_analysis)
+                
+                if ct_analysis.get('error'):
+                    click.echo(f"    ⚠️  CloudTrail: {ct_analysis['error']}")
+                else:
+                    click.echo(f"    ✓ CloudTrail analysis complete")
+                    click.echo(f"      - {len(ct_analysis['event_summary'])} event types")
+                    click.echo(f"      - {len(ct_analysis['write_events'])} resource changes")
+            except Exception as e:
+                click.echo(f"    ✗ CloudTrail error: {str(e)}")
+    
+    # Generate report
+    click.echo(f"\nGenerating report...")
+    report = format_investigation_report(trends_data, inventories, cloudtrail_analyses if not no_cloudtrail else None)
+    
+    # Write to file
+    with open(output, 'w') as f:
+        f.write(report)
+    
+    click.echo(f"\n✓ Investigation complete!")
+    click.echo(f"✓ Report saved to: {output}")
+    click.echo("")
+
+
+def find_account_profile(account_id):
+    """
+    Find the SSO profile name for a given account ID
+    Returns profile name or None
+    """
+    import subprocess
+    
+    try:
+        # Get list of profiles
+        result = subprocess.run(
+            ['aws', 'configure', 'list-profiles'],
+            capture_output=True,
+            text=True
+        )
+        
+        profiles = result.stdout.strip().split('\n')
+        
+        # Check each profile
+        for profile in profiles:
+            try:
+                result = subprocess.run(
+                    ['aws', 'sts', 'get-caller-identity', '--profile', profile],
+                    capture_output=True,
+                    text=True,
+                    timeout=5
+                )
+                
+                if account_id in result.stdout:
+                    return profile
+            except:
+                continue
+        
+        return None
+    except:
+        return None
+
+
 if __name__ == '__main__':
     cli()

aws_cost_calculator_cli-1.8.3/cost_calculator/forensics.py

@@ -0,0 +1,322 @@
+"""
+Cost forensics module - Resource inventory and CloudTrail analysis
+"""
+import boto3
+from datetime import datetime, timedelta
+from collections import defaultdict
+import json
+
+
+def inventory_resources(account_id, profile, region='us-west-2'):
+    """
+    Inventory AWS resources in an account
+    
+    Args:
+        account_id: AWS account ID
+        profile: AWS profile name (SSO)
+        region: AWS region
+        
+    Returns:
+        dict with resource inventory
+    """
+    session = boto3.Session(profile_name=profile)
+    inventory = {
+        'account_id': account_id,
+        'profile': profile,
+        'region': region,
+        'timestamp': datetime.utcnow().isoformat(),
+        'ec2_instances': [],
+        'efs_file_systems': [],
+        'load_balancers': [],
+        'dynamodb_tables': []
+    }
+    
+    try:
+        # EC2 Instances
+        ec2_client = session.client('ec2', region_name=region)
+        instances_response = ec2_client.describe_instances()
+        
+        for reservation in instances_response['Reservations']:
+            for instance in reservation['Instances']:
+                if instance['State']['Name'] == 'running':
+                    name = 'N/A'
+                    for tag in instance.get('Tags', []):
+                        if tag['Key'] == 'Name':
+                            name = tag['Value']
+                            break
+                    
+                    inventory['ec2_instances'].append({
+                        'instance_id': instance['InstanceId'],
+                        'instance_type': instance['InstanceType'],
+                        'name': name,
+                        'state': instance['State']['Name'],
+                        'launch_time': instance['LaunchTime'].isoformat(),
+                        'availability_zone': instance['Placement']['AvailabilityZone']
+                    })
+        
+        # EFS File Systems
+        efs_client = session.client('efs', region_name=region)
+        efs_response = efs_client.describe_file_systems()
+        
+        total_efs_size = 0
+        for fs in efs_response['FileSystems']:
+            size_bytes = fs['SizeInBytes']['Value']
+            size_gb = size_bytes / (1024**3)
+            total_efs_size += size_gb
+            
+            inventory['efs_file_systems'].append({
+                'file_system_id': fs['FileSystemId'],
+                'name': fs.get('Name', 'N/A'),
+                'size_gb': round(size_gb, 2),
+                'creation_time': fs['CreationTime'].isoformat(),
+                'number_of_mount_targets': fs['NumberOfMountTargets']
+            })
+        
+        inventory['total_efs_size_gb'] = round(total_efs_size, 2)
+        
+        # Load Balancers
+        elbv2_client = session.client('elbv2', region_name=region)
+        elb_response = elbv2_client.describe_load_balancers()
+        
+        for lb in elb_response['LoadBalancers']:
+            inventory['load_balancers'].append({
+                'name': lb['LoadBalancerName'],
+                'type': lb['Type'],
+                'dns_name': lb['DNSName'],
+                'scheme': lb['Scheme'],
+                'created_time': lb['CreatedTime'].isoformat(),
+                'availability_zones': [az['ZoneName'] for az in lb['AvailabilityZones']]
+            })
+        
+        # DynamoDB Tables (only if region supports it)
+        try:
+            ddb_client = session.client('dynamodb', region_name=region)
+            tables_response = ddb_client.list_tables()
+            
+            for table_name in tables_response['TableNames'][:20]:  # Limit to 20 tables
+                table_desc = ddb_client.describe_table(TableName=table_name)
+                table_info = table_desc['Table']
+                
+                # Get backup settings
+                try:
+                    backup_desc = ddb_client.describe_continuous_backups(TableName=table_name)
+                    pitr_status = backup_desc['ContinuousBackupsDescription']['PointInTimeRecoveryDescription']['PointInTimeRecoveryStatus']
+                except:
+                    pitr_status = 'UNKNOWN'
+                
+                size_gb = table_info.get('TableSizeBytes', 0) / (1024**3)
+                
+                inventory['dynamodb_tables'].append({
+                    'table_name': table_name,
+                    'size_gb': round(size_gb, 2),
+                    'item_count': table_info.get('ItemCount', 0),
+                    'pitr_status': pitr_status,
+                    'created_time': table_info['CreationDateTime'].isoformat()
+                })
+        except Exception as e:
+            # DynamoDB might not be available in all regions
+            pass
+            
+    except Exception as e:
+        inventory['error'] = str(e)
+    
+    return inventory
+
+
+def analyze_cloudtrail(account_id, profile, start_date, end_date, region='us-west-2'):
+    """
+    Analyze CloudTrail events for an account
+    
+    Args:
+        account_id: AWS account ID
+        profile: AWS profile name (SSO)
+        start_date: Start datetime
+        end_date: End datetime
+        region: AWS region
+        
+    Returns:
+        dict with CloudTrail event summary
+    """
+    session = boto3.Session(profile_name=profile)
+    ct_client = session.client('cloudtrail', region_name=region)
+    
+    analysis = {
+        'account_id': account_id,
+        'profile': profile,
+        'region': region,
+        'start_date': start_date.isoformat(),
+        'end_date': end_date.isoformat(),
+        'event_summary': {},
+        'write_events': [],
+        'error': None
+    }
+    
+    # Events that indicate resource creation/modification
+    write_event_names = [
+        'RunInstances', 'CreateVolume', 'AttachVolume',
+        'CreateFileSystem', 'ModifyFileSystem',
+        'CreateLoadBalancer', 'ModifyLoadBalancerAttributes',
+        'CreateTable', 'UpdateTable', 'UpdateContinuousBackups',
+        'CreateBackupVault', 'StartBackupJob'
+    ]
+    
+    try:
+        event_counts = defaultdict(int)
+        
+        # Query CloudTrail
+        paginator = ct_client.get_paginator('lookup_events')
+        
+        for page in paginator.paginate(
+            StartTime=start_date,
+            EndTime=end_date,
+            MaxResults=50,
+            PaginationConfig={'MaxItems': 200}
+        ):
+            for event in page.get('Events', []):
+                event_name = event.get('EventName', '')
+                event_counts[event_name] += 1
+                
+                # Capture write events
+                if event_name in write_event_names:
+                    event_detail = json.loads(event['CloudTrailEvent'])
+                    
+                    analysis['write_events'].append({
+                        'time': event.get('EventTime').isoformat(),
+                        'event_name': event_name,
+                        'username': event.get('Username', 'N/A'),
+                        'resources': [
+                            {
+                                'type': r.get('ResourceType', 'N/A'),
+                                'name': r.get('ResourceName', 'N/A')
+                            }
+                            for r in event.get('Resources', [])[:3]
+                        ]
+                    })
+        
+        # Convert to regular dict and sort
+        analysis['event_summary'] = dict(sorted(
+            event_counts.items(),
+            key=lambda x: x[1],
+            reverse=True
+        ))
+        
+    except Exception as e:
+        analysis['error'] = str(e)
+    
+    return analysis
+
+
+def format_investigation_report(cost_data, inventories, cloudtrail_data=None):
+    """
+    Format investigation data into markdown report
+    
+    Args:
+        cost_data: Cost analysis results from trends/drill
+        inventories: List of resource inventories
+        cloudtrail_data: List of CloudTrail analyses (optional)
+        
+    Returns:
+        str: Markdown formatted report
+    """
+    report = []
+    report.append("# Cost Investigation Report")
+    report.append(f"**Generated:** {datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S UTC')}")
+    report.append("")
+    
+    # Cost Analysis Section
+    if cost_data:
+        report.append("## Cost Analysis")
+        report.append("")
+        # Add cost data formatting here
+        # This will be populated from trends/drill results
+    
+    # Resource Inventory Section
+    if inventories:
+        report.append("## Resource Inventory")
+        report.append("")
+        
+        for inv in inventories:
+            profile_name = inv.get('profile', inv['account_id'])
+            report.append(f"### Account {inv['account_id']} ({profile_name})")
+            report.append(f"**Region:** {inv['region']}")
+            report.append("")
+            
+            # EC2 Instances
+            if inv['ec2_instances']:
+                report.append(f"**EC2 Instances:** {len(inv['ec2_instances'])} running")
+                for instance in inv['ec2_instances'][:10]:  # Show first 10
+                    report.append(f"- `{instance['instance_id']}`: {instance['instance_type']} ({instance['name']})")
+                    report.append(f"  - Launched: {instance['launch_time'][:10]}, AZ: {instance['availability_zone']}")
+                if len(inv['ec2_instances']) > 10:
+                    report.append(f"  ... and {len(inv['ec2_instances']) - 10} more")
+                report.append("")
+            
+            # EFS File Systems
+            if inv['efs_file_systems']:
+                total_size = inv.get('total_efs_size_gb', 0)
+                report.append(f"**EFS File Systems:** {len(inv['efs_file_systems'])} total, {total_size:,.0f} GB")
+                for fs in inv['efs_file_systems']:
+                    report.append(f"- `{fs['file_system_id']}` ({fs['name']}): {fs['size_gb']:,.2f} GB")
+                    report.append(f"  - Created: {fs['creation_time'][:10]}")
+                report.append("")
+            
+            # Load Balancers
+            if inv['load_balancers']:
+                report.append(f"**Load Balancers:** {len(inv['load_balancers'])}")
+                for lb in inv['load_balancers'][:10]:  # Show first 10
+                    report.append(f"- `{lb['name']}`: {lb['type']}")
+                    report.append(f"  - Created: {lb['created_time'][:10]}, Scheme: {lb['scheme']}")
+                if len(inv['load_balancers']) > 10:
+                    report.append(f"  ... and {len(inv['load_balancers']) - 10} more")
+                report.append("")
+            
+            # DynamoDB Tables
+            if inv['dynamodb_tables']:
+                report.append(f"**DynamoDB Tables:** {len(inv['dynamodb_tables'])}")
+                for table in inv['dynamodb_tables'][:10]:
+                    report.append(f"- `{table['table_name']}`: {table['size_gb']:.2f} GB, {table['item_count']:,} items")
+                    report.append(f"  - PITR: {table['pitr_status']}, Created: {table['created_time'][:10]}")
+                if len(inv['dynamodb_tables']) > 10:
+                    report.append(f"  ... and {len(inv['dynamodb_tables']) - 10} more")
+                report.append("")
+            
+            report.append("---")
+            report.append("")
+    
+    # CloudTrail Section
+    if cloudtrail_data:
+        report.append("## CloudTrail Events")
+        report.append("")
+        
+        for ct in cloudtrail_data:
+            report.append(f"### Account {ct['account_id']} ({ct['profile']})")
+            report.append(f"**Period:** {ct['start_date'][:10]} to {ct['end_date'][:10]}")
+            report.append("")
+            
+            if ct.get('error'):
+                report.append(f"⚠️ Error: {ct['error']}")
+                report.append("")
+                continue
+            
+            # Write events (resource changes)
+            if ct['write_events']:
+                report.append(f"**Resource Changes:** {len(ct['write_events'])} events")
+                for evt in ct['write_events'][:10]:
+                    report.append(f"- `{evt['time'][:19]}` - **{evt['event_name']}**")
+                    report.append(f"  - User: {evt['username']}")
+                    if evt['resources']:
+                        for res in evt['resources']:
+                            report.append(f"  - Resource: {res['type']} - {res['name']}")
+                report.append("")
+            
+            # Event summary
+            if ct['event_summary']:
+                report.append("**Top Events:**")
+                for event_name, count in list(ct['event_summary'].items())[:15]:
+                    report.append(f"- {event_name}: {count}")
+                report.append("")
+            
+            report.append("---")
+            report.append("")
+    
+    return "\n".join(report)

{aws_cost_calculator_cli-1.7.0 → aws_cost_calculator_cli-1.8.3}/setup.py

@@ -5,8 +5,8 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name='aws-cost-calculator-cli',
-    version='1.7.0',
-    packages=find_packages(),
+    version='1.8.3',
+    packages=['cost_calculator'],
     install_requires=[
         'click>=8.0.0',
         'boto3>=1.26.0',

aws_cost_calculator_cli-1.7.0/backend/__init__.py

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

aws_cost_calculator_cli-1.7.0/backend/algorithms/__init__.py

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