Usage Tracking

def analyze_cost_optimization_opportunities():
    """Identify opportunities to reduce costs"""
    response = requests.get(
        "https://api.tensorone.ai/v2/billing/usage/optimization",
        headers={"Authorization": "Bearer YOUR_API_KEY"},
        params={
            "timeRange": "last_month",
            "includeRecommendations": True,
            "analysisDepth": "detailed"
        }
    )
    
    return response.json()

def generate_cost_report():
    """Generate comprehensive cost analysis report"""
    optimization_data = analyze_cost_optimization_opportunities()
    
    print("💡 Cost Optimization Report")
    print("=" * 35)
    
    # Potential savings
    if 'potentialSavings' in optimization_data:
        savings = optimization_data['potentialSavings']
        total_savings = savings['totalMonthly']
        print(f"Potential Monthly Savings: ${total_savings:,.2f}")
        print()
        
        # Savings by category
        for category in savings['byCategory']:
            print(f"📊 {category['name']}:")
            print(f"   Current Cost: ${category['currentCost']:,.2f}")
            print(f"   Potential Savings: ${category['savings']:,.2f} ({category['percentage']:.1f}%)")
            print(f"   Recommendation: {category['recommendation']}")
            print()
    
    # Optimization recommendations
    if 'recommendations' in optimization_data:
        print("🎯 Optimization Recommendations:")
        print("-" * 35)
        
        for i, rec in enumerate(optimization_data['recommendations'][:5], 1):
            impact_icon = {"high": "🔴", "medium": "🟡", "low": "🟢"}.get(rec['impact'], "⚪")
            
            print(f"{i}. {impact_icon} {rec['title']}")
            print(f"   Impact: {rec['impact']} - ${rec['potentialSavings']:,.2f}/month")
            print(f"   Description: {rec['description']}")
            print(f"   Effort: {rec['implementationEffort']}")
            print()
    
    # Waste identification
    if 'wasteAnalysis' in optimization_data:
        waste = optimization_data['wasteAnalysis']
        print(f"🗑️  Identified Waste: ${waste['totalWaste']:,.2f}/month")
        
        for waste_item in waste['items']:
            print(f"   • {waste_item['description']}: ${waste_item['amount']:,.2f}")

# Run cost optimization analysis
generate_cost_report()

def get_usage_forecast(forecast_period="3_months"):
    """Get usage and cost forecasts"""
    response = requests.get(
        "https://api.tensorone.ai/v2/billing/usage/forecast",
        headers={"Authorization": "Bearer YOUR_API_KEY"},
        params={
            "forecastPeriod": forecast_period,
            "includeScenarios": True,
            "confidenceInterval": 0.95
        }
    )
    
    return response.json()

def analyze_usage_trends():
    """Analyze usage trends and forecasts"""
    forecast_data = get_usage_forecast("6_months")
    
    print("🔮 Usage Forecast Analysis")
    print("=" * 30)
    
    baseline = forecast_data['baseline']
    print(f"Current Monthly Average: ${baseline['avgMonthlyCost']:,.2f}")
    print(f"Growth Rate: {baseline['growthRate']:+.1f}% per month")
    print()
    
    # Monthly projections
    print("📅 Monthly Projections:")
    for month in forecast_data['monthlyProjections']:
        month_name = month['month']
        projected_cost = month['projectedCost']
        confidence = month['confidence']
        
        print(f"  {month_name}: ${projected_cost:,.2f} (confidence: {confidence:.0%})")
    
    # Scenario analysis
    if 'scenarios' in forecast_data:
        print(f"\n📊 Scenario Analysis:")
        scenarios = forecast_data['scenarios']
        
        for scenario_name, scenario_data in scenarios.items():
            print(f"  {scenario_name.title()} Case:")
            print(f"    6-month total: ${scenario_data['sixMonthTotal']:,.2f}")
            print(f"    Peak month: ${scenario_data['peakMonth']:,.2f}")
            print(f"    Probability: {scenario_data['probability']:.0%}")
            print()
    
    # Growth drivers
    if 'growthDrivers' in forecast_data:
        print("📈 Key Growth Drivers:")
        for driver in forecast_data['growthDrivers']:
            print(f"  • {driver['factor']}: +{driver['impact']:,.2f}/month")
            print(f"    {driver['description']}")

analyze_usage_trends()

def get_team_usage_breakdown():
    """Get usage breakdown by team/project"""
    response = requests.get(
        "https://api.tensorone.ai/v2/billing/usage",
        headers={"Authorization": "Bearer YOUR_API_KEY"},
        params={
            "timeRange": "current_month",
            "groupBy": ["project", "user"],
            "includeTeamMetrics": True
        }
    )
    
    return response.json()

def generate_team_usage_report():
    """Generate team usage accountability report"""
    team_data = get_team_usage_breakdown()
    
    print("👥 Team Usage Report")
    print("=" * 25)
    
    if 'teamBreakdown' in team_data:
        teams = team_data['teamBreakdown']
        
        # Sort teams by cost
        teams_sorted = sorted(teams, key=lambda x: x['totalCost'], reverse=True)
        
        print("Top Teams by Cost:")
        print("-" * 20)
        
        for i, team in enumerate(teams_sorted[:10], 1):
            team_name = team['teamName']
            team_cost = team['totalCost']
            team_percentage = team['percentage']
            member_count = team['memberCount']
            avg_per_member = team_cost / member_count if member_count > 0 else 0
            
            print(f"{i:2d}. {team_name}")
            print(f"    Total: ${team_cost:,.2f} ({team_percentage:.1f}%)")
            print(f"    Members: {member_count}")
            print(f"    Avg/Member: ${avg_per_member:,.2f}")
            print()
        
        # Resource utilization by team
        print("Resource Utilization by Team:")
        print("-" * 32)
        
        for team in teams_sorted[:5]:
            print(f"\n🏢 {team['teamName']}:")
            
            resources = team.get('resourceUsage', {})
            for resource, usage in resources.items():
                print(f"  {resource.title()}: {usage['quantity']:,.1f} {usage['unit']} (${usage['cost']:,.2f})")
    
    # Individual user breakdown
    if 'userBreakdown' in team_data:
        users = team_data['userBreakdown']
        top_users = sorted(users, key=lambda x: x['totalCost'], reverse=True)[:10]
        
        print(f"\n👤 Top Users by Cost:")
        print("-" * 20)
        
        for i, user in enumerate(top_users, 1):
            user_name = user['userName']
            user_cost = user['totalCost']
            user_team = user.get('team', 'N/A')
            
            print(f"{i:2d}. {user_name} ({user_team}): ${user_cost:,.2f}")

generate_team_usage_report()

def set_usage_budget(budget_amount, alert_thresholds, resource_types=None):
    """Set monthly usage budget with alerts"""
    budget_config = {
        "monthlyBudget": budget_amount,
        "currency": "USD",
        "alertThresholds": alert_thresholds,  # e.g., [50, 75, 90, 100]
        "resourceTypes": resource_types or ["all"],
        "notificationChannels": ["email", "webhook"],
        "actions": {
            "at_90_percent": "send_warning",
            "at_100_percent": ["send_alert", "notify_admin"],
            "at_110_percent": ["send_critical", "auto_limit"]
        }
    }
    
    response = requests.post(
        "https://api.tensorone.ai/v2/billing/budgets",
        headers={
            "Authorization": "Bearer YOUR_API_KEY",
            "Content-Type": "application/json"
        },
        json=budget_config
    )
    
    return response.json()

def monitor_budget_status():
    """Monitor current budget status"""
    response = requests.get(
        "https://api.tensorone.ai/v2/billing/budgets/status",
        headers={"Authorization": "Bearer YOUR_API_KEY"}
    )
    
    budget_status = response.json()
    
    print("💰 Budget Status Monitor")
    print("=" * 25)
    
    for budget in budget_status['budgets']:
        budget_name = budget.get('name', 'Default Budget')
        budget_amount = budget['monthlyBudget']
        spent_amount = budget['currentSpent']
        percentage_used = (spent_amount / budget_amount) * 100
        remaining = budget_amount - spent_amount
        days_left = budget['daysRemainingInPeriod']
        
        status_icon = "🔴" if percentage_used >= 100 else "🟡" if percentage_used >= 75 else "🟢"
        
        print(f"{status_icon} {budget_name}")
        print(f"  Budget: ${budget_amount:,.2f}")
        print(f"  Spent: ${spent_amount:,.2f} ({percentage_used:.1f}%)")
        print(f"  Remaining: ${remaining:,.2f}")
        print(f"  Days Left: {days_left}")
        
        if percentage_used > 0 and days_left > 0:
            daily_burn_rate = spent_amount / (30 - days_left) if days_left < 30 else 0
            projected_total = spent_amount + (daily_burn_rate * days_left)
            print(f"  Projected Total: ${projected_total:,.2f}")
        
        print()

# Set up budget alerts
budget_result = set_usage_budget(
    budget_amount=2000.00,
    alert_thresholds=[50, 75, 90, 100],
    resource_types=["clusters", "ai-services"]
)

print(f"Budget created: {budget_result.get('budgetId', 'N/A')}")

# Monitor budget status
monitor_budget_status()