Datasets:

danielrosehill
/

Open-Router-API-Pricing-Analysis

#!/usr/bin/env python3
"""
OpenRouter API Pricing Analysis
Analyzes context windows, token pricing, and output/input ratios
"""

import json
import numpy as np
from pathlib import Path
from typing import Dict, List, Any
import statistics

def load_data(file_path: str) -> List[Dict[str, Any]]:
    """Load the models data from JSON file"""
    with open(file_path, 'r') as f:
        return json.load(f)

def calculate_distribution_stats(values: List[float], name: str) -> Dict[str, Any]:
    """Calculate comprehensive distribution statistics"""
    if not values:
        return {"error": "No data"}

    values = sorted(values)
    n = len(values)

    stats = {
        "name": name,
        "count": n,
        "min": min(values),
        "max": max(values),
        "mean": statistics.mean(values),
        "median": statistics.median(values),
        "std_dev": statistics.stdev(values) if n > 1 else 0,
    }

    # Quartiles
    stats["q1"] = np.percentile(values, 25)
    stats["q3"] = np.percentile(values, 75)
    stats["iqr"] = stats["q3"] - stats["q1"]

    # Additional percentiles
    stats["p10"] = np.percentile(values, 10)
    stats["p90"] = np.percentile(values, 90)
    stats["p95"] = np.percentile(values, 95)
    stats["p99"] = np.percentile(values, 99)

    return stats

def calculate_stratification(values: List[float], name: str) -> Dict[str, Any]:
    """Calculate stratification by creating bins/ranges"""
    if not values:
        return {"error": "No data"}

    values_array = np.array(values)

    # Determine appropriate bins based on data range
    min_val = values_array.min()
    max_val = values_array.max()

    # Create stratification bins
    if max_val - min_val < 1:
        # For very small ranges (like some pricing)
        bins = np.linspace(min_val, max_val, 11)
    else:
        # Use log scale for wide ranges
        if min_val > 0:
            bins = np.logspace(np.log10(max(min_val, 0.0001)), np.log10(max_val), 11)
        else:
            bins = np.linspace(min_val, max_val, 11)

    hist, bin_edges = np.histogram(values_array, bins=bins)

    stratification = {
        "name": name,
        "bins": []
    }

    for i in range(len(hist)):
        stratification["bins"].append({
            "range": f"{bin_edges[i]:.6f} - {bin_edges[i+1]:.6f}",
            "count": int(hist[i]),
            "percentage": float(hist[i] / len(values) * 100)
        })

    return stratification

def analyze_context_windows(models: List[Dict[str, Any]]) -> tuple:
    """Analyze context window distribution"""
    context_lengths = [
        m['context_length']
        for m in models
        if m.get('context_length') and m['context_length'] > 0
    ]

    distribution = calculate_distribution_stats(context_lengths, "Context Windows")
    stratification = calculate_stratification(context_lengths, "Context Windows")

    return distribution, stratification

def analyze_input_pricing(models: List[Dict[str, Any]]) -> tuple:
    """Analyze input token pricing distribution"""
    input_prices = [
        m['prompt_price_per_1m_tokens']
        for m in models
        if m.get('prompt_price_per_1m_tokens') is not None and m['prompt_price_per_1m_tokens'] > 0
    ]

    distribution = calculate_distribution_stats(input_prices, "Input Token Pricing (per 1M tokens)")
    stratification = calculate_stratification(input_prices, "Input Token Pricing")

    return distribution, stratification

def analyze_output_pricing(models: List[Dict[str, Any]]) -> tuple:
    """Analyze output token pricing distribution"""
    output_prices = [
        m['completion_price_per_1m_tokens']
        for m in models
        if m.get('completion_price_per_1m_tokens') is not None and m['completion_price_per_1m_tokens'] > 0
    ]

    distribution = calculate_distribution_stats(output_prices, "Output Token Pricing (per 1M tokens)")
    stratification = calculate_stratification(output_prices, "Output Token Pricing")

    return distribution, stratification

def analyze_output_input_ratio(models: List[Dict[str, Any]]) -> tuple:
    """Analyze output/input token price ratio"""
    ratios = []

    for m in models:
        input_price = m.get('prompt_price_per_1m_tokens', 0)
        output_price = m.get('completion_price_per_1m_tokens', 0)

        # Calculate ratio only for non-free models
        if input_price > 0 and output_price > 0:
            ratio = output_price / input_price
            ratios.append(ratio)

    distribution = calculate_distribution_stats(ratios, "Output/Input Price Ratio")
    stratification = calculate_stratification(ratios, "Output/Input Price Ratio")

    return distribution, stratification

def format_distribution_report(dist: Dict[str, Any]) -> str:
    """Format distribution statistics as readable text"""
    if "error" in dist:
        return f"Error: {dist['error']}"

    report = f"""
{dist['name']}
{'=' * len(dist['name'])}
Sample Size: {dist['count']:,}
Central Tendency:
  Mean:   {dist['mean']:.6f}
  Median: {dist['median']:.6f}
Spread:
  Min:     {dist['min']:.6f}
  Max:     {dist['max']:.6f}
  Std Dev: {dist['std_dev']:.6f}
  IQR:     {dist['iqr']:.6f}
Quartiles:
  Q1 (25th percentile): {dist['q1']:.6f}
  Q2 (50th percentile): {dist['median']:.6f}
  Q3 (75th percentile): {dist['q3']:.6f}
Additional Percentiles:
  10th: {dist['p10']:.6f}
  90th: {dist['p90']:.6f}
  95th: {dist['p95']:.6f}
  99th: {dist['p99']:.6f}
"""
    return report

def format_stratification_report(strat: Dict[str, Any]) -> str:
    """Format stratification as readable text"""
    if "error" in strat:
        return f"Error: {strat['error']}"

    report = f"""
{strat['name']} - Stratification
{'=' * (len(strat['name']) + 18)}
Range Distribution:
"""

    for bin_data in strat['bins']:
        report += f"  {bin_data['range']:>40s}: {bin_data['count']:>6,} models ({bin_data['percentage']:>5.1f}%)\n"

    return report

def main():
    # Load data
    data_file = Path(__file__).parent.parent / 'raw' / 'models.json'
    models = load_data(data_file)

    print(f"Loaded {len(models)} models\n")

    # Create output directory
    output_dir = Path(__file__).parent
    output_dir.mkdir(exist_ok=True)

    # Analyze each metric
    analyses = {
        'context_windows': analyze_context_windows(models),
        'input_pricing': analyze_input_pricing(models),
        'output_pricing': analyze_output_pricing(models),
        'output_input_ratio': analyze_output_input_ratio(models)
    }

    # Generate reports for each analysis
    for metric_name, (distribution, stratification) in analyses.items():
        # Create individual report files
        dist_report = format_distribution_report(distribution)
        strat_report = format_stratification_report(stratification)

        # Write distribution report
        dist_file = output_dir / f"{metric_name}_distribution.txt"
        with open(dist_file, 'w') as f:
            f.write(dist_report)
        print(f"Created: {dist_file}")

        # Write stratification report
        strat_file = output_dir / f"{metric_name}_stratification.txt"
        with open(strat_file, 'w') as f:
            f.write(strat_report)
        print(f"Created: {strat_file}")

        # Also save as JSON for programmatic access
        json_file = output_dir / f"{metric_name}_stats.json"
        with open(json_file, 'w') as f:
            json.dump({
                'distribution': distribution,
                'stratification': stratification
            }, f, indent=2)
        print(f"Created: {json_file}")

    # Create comprehensive summary report
    summary_file = output_dir / "summary_report.txt"
    with open(summary_file, 'w') as f:
        f.write("OpenRouter API Pricing Analysis - Summary Report\n")
        f.write("=" * 60 + "\n\n")
        f.write(f"Dataset: {len(models)} models analyzed\n\n")

        for metric_name, (distribution, stratification) in analyses.items():
            f.write("\n" + "=" * 60 + "\n")
            f.write(format_distribution_report(distribution))
            f.write("\n")
            f.write(format_stratification_report(stratification))
            f.write("\n")

    print(f"\nCreated: {summary_file}")
    print("\nAnalysis complete!")

if __name__ == "__main__":
    main()

	#!/usr/bin/env python3
	"""
	OpenRouter API Pricing Analysis
	Analyzes context windows, token pricing, and output/input ratios
	"""

	import json
	import numpy as np
	from pathlib import Path
	from typing import Dict, List, Any
	import statistics

	def load_data(file_path: str) -> List[Dict[str, Any]]:
	"""Load the models data from JSON file"""
	with open(file_path, 'r') as f:
	return json.load(f)

	def calculate_distribution_stats(values: List[float], name: str) -> Dict[str, Any]:
	"""Calculate comprehensive distribution statistics"""
	if not values:
	return {"error": "No data"}

	values = sorted(values)
	n = len(values)

	stats = {
	"name": name,
	"count": n,
	"min": min(values),
	"max": max(values),
	"mean": statistics.mean(values),
	"median": statistics.median(values),
	"std_dev": statistics.stdev(values) if n > 1 else 0,
	}

	# Quartiles
	stats["q1"] = np.percentile(values, 25)
	stats["q3"] = np.percentile(values, 75)
	stats["iqr"] = stats["q3"] - stats["q1"]

	# Additional percentiles
	stats["p10"] = np.percentile(values, 10)
	stats["p90"] = np.percentile(values, 90)
	stats["p95"] = np.percentile(values, 95)
	stats["p99"] = np.percentile(values, 99)

	return stats

	def calculate_stratification(values: List[float], name: str) -> Dict[str, Any]:
	"""Calculate stratification by creating bins/ranges"""
	if not values:
	return {"error": "No data"}

	values_array = np.array(values)

	# Determine appropriate bins based on data range
	min_val = values_array.min()
	max_val = values_array.max()

	# Create stratification bins
	if max_val - min_val < 1:
	# For very small ranges (like some pricing)
	bins = np.linspace(min_val, max_val, 11)
	else:
	# Use log scale for wide ranges
	if min_val > 0:
	bins = np.logspace(np.log10(max(min_val, 0.0001)), np.log10(max_val), 11)
	else:
	bins = np.linspace(min_val, max_val, 11)

	hist, bin_edges = np.histogram(values_array, bins=bins)

	stratification = {
	"name": name,
	"bins": []
	}

	for i in range(len(hist)):
	stratification["bins"].append({
	"range": f"{bin_edges[i]:.6f} - {bin_edges[i+1]:.6f}",
	"count": int(hist[i]),
	"percentage": float(hist[i] / len(values) * 100)
	})

	return stratification

	def analyze_context_windows(models: List[Dict[str, Any]]) -> tuple:
	"""Analyze context window distribution"""
	context_lengths = [
	m['context_length']
	for m in models
	if m.get('context_length') and m['context_length'] > 0
	]

	distribution = calculate_distribution_stats(context_lengths, "Context Windows")
	stratification = calculate_stratification(context_lengths, "Context Windows")

	return distribution, stratification

	def analyze_input_pricing(models: List[Dict[str, Any]]) -> tuple:
	"""Analyze input token pricing distribution"""
	input_prices = [
	m['prompt_price_per_1m_tokens']
	for m in models
	if m.get('prompt_price_per_1m_tokens') is not None and m['prompt_price_per_1m_tokens'] > 0
	]

	distribution = calculate_distribution_stats(input_prices, "Input Token Pricing (per 1M tokens)")
	stratification = calculate_stratification(input_prices, "Input Token Pricing")

	return distribution, stratification

	def analyze_output_pricing(models: List[Dict[str, Any]]) -> tuple:
	"""Analyze output token pricing distribution"""
	output_prices = [
	m['completion_price_per_1m_tokens']
	for m in models
	if m.get('completion_price_per_1m_tokens') is not None and m['completion_price_per_1m_tokens'] > 0
	]

	distribution = calculate_distribution_stats(output_prices, "Output Token Pricing (per 1M tokens)")
	stratification = calculate_stratification(output_prices, "Output Token Pricing")

	return distribution, stratification

	def analyze_output_input_ratio(models: List[Dict[str, Any]]) -> tuple:
	"""Analyze output/input token price ratio"""
	ratios = []

	for m in models:
	input_price = m.get('prompt_price_per_1m_tokens', 0)
	output_price = m.get('completion_price_per_1m_tokens', 0)

	# Calculate ratio only for non-free models
	if input_price > 0 and output_price > 0:
	ratio = output_price / input_price
	ratios.append(ratio)

	distribution = calculate_distribution_stats(ratios, "Output/Input Price Ratio")
	stratification = calculate_stratification(ratios, "Output/Input Price Ratio")

	return distribution, stratification

	def format_distribution_report(dist: Dict[str, Any]) -> str:
	"""Format distribution statistics as readable text"""
	if "error" in dist:
	return f"Error: {dist['error']}"

	report = f"""
	{dist['name']}
	{'=' * len(dist['name'])}

	Sample Size: {dist['count']:,}

	Central Tendency:
	Mean: {dist['mean']:.6f}
	Median: {dist['median']:.6f}

	Spread:
	Min: {dist['min']:.6f}
	Max: {dist['max']:.6f}
	Std Dev: {dist['std_dev']:.6f}
	IQR: {dist['iqr']:.6f}

	Quartiles:
	Q1 (25th percentile): {dist['q1']:.6f}
	Q2 (50th percentile): {dist['median']:.6f}
	Q3 (75th percentile): {dist['q3']:.6f}

	Additional Percentiles:
	10th: {dist['p10']:.6f}
	90th: {dist['p90']:.6f}
	95th: {dist['p95']:.6f}
	99th: {dist['p99']:.6f}
	"""
	return report

	def format_stratification_report(strat: Dict[str, Any]) -> str:
	"""Format stratification as readable text"""
	if "error" in strat:
	return f"Error: {strat['error']}"

	report = f"""
	{strat['name']} - Stratification
	{'=' * (len(strat['name']) + 18)}

	Range Distribution:
	"""

	for bin_data in strat['bins']:
	report += f" {bin_data['range']:>40s}: {bin_data['count']:>6,} models ({bin_data['percentage']:>5.1f}%)\n"

	return report

	def main():
	# Load data
	data_file = Path(__file__).parent.parent / 'raw' / 'models.json'
	models = load_data(data_file)

	print(f"Loaded {len(models)} models\n")

	# Create output directory
	output_dir = Path(__file__).parent
	output_dir.mkdir(exist_ok=True)

	# Analyze each metric
	analyses = {
	'context_windows': analyze_context_windows(models),
	'input_pricing': analyze_input_pricing(models),
	'output_pricing': analyze_output_pricing(models),
	'output_input_ratio': analyze_output_input_ratio(models)
	}

	# Generate reports for each analysis
	for metric_name, (distribution, stratification) in analyses.items():
	# Create individual report files
	dist_report = format_distribution_report(distribution)
	strat_report = format_stratification_report(stratification)

	# Write distribution report
	dist_file = output_dir / f"{metric_name}_distribution.txt"
	with open(dist_file, 'w') as f:
	f.write(dist_report)
	print(f"Created: {dist_file}")

	# Write stratification report
	strat_file = output_dir / f"{metric_name}_stratification.txt"
	with open(strat_file, 'w') as f:
	f.write(strat_report)
	print(f"Created: {strat_file}")

	# Also save as JSON for programmatic access
	json_file = output_dir / f"{metric_name}_stats.json"
	with open(json_file, 'w') as f:
	json.dump({
	'distribution': distribution,
	'stratification': stratification
	}, f, indent=2)
	print(f"Created: {json_file}")

	# Create comprehensive summary report
	summary_file = output_dir / "summary_report.txt"
	with open(summary_file, 'w') as f:
	f.write("OpenRouter API Pricing Analysis - Summary Report\n")
	f.write("=" * 60 + "\n\n")
	f.write(f"Dataset: {len(models)} models analyzed\n\n")

	for metric_name, (distribution, stratification) in analyses.items():
	f.write("\n" + "=" * 60 + "\n")
	f.write(format_distribution_report(distribution))
	f.write("\n")
	f.write(format_stratification_report(stratification))
	f.write("\n")

	print(f"\nCreated: {summary_file}")
	print("\nAnalysis complete!")

	if __name__ == "__main__":
	main()