Python Text Extraction Benchmarks 2025¶

# Best Speed calculation
best_speed_fw = min(frameworks, key=lambda fw:
    sum(result.extraction_time for result in fw_results) / len(fw_results))

# Best Memory calculation
best_memory_fw = min(frameworks, key=lambda fw:
    sum(result.peak_memory_mb for result in fw_results) / len(fw_results))

# Best Quality calculation
best_quality_fw = max(frameworks, key=lambda fw:
    sum(result.quality_score or 0 for result in fw_results) / len(fw_results))

# Average time across all frameworks
avg_time = sum(all_extraction_times) / total_test_count

# Average speed (throughput) calculation
def calc_avg_speed(results):
    total_files = len(results)
    total_time = sum(result.extraction_time for result in results)
    return total_files / total_time  # files per second

# Average memory calculation
def calc_avg_memory(results):
    return sum(result.peak_memory_mb for result in results) / len(results) if results else 0

# Success rate calculation
def calc_success_rate(results):
    successful = sum(1 for result in results if result.status == ExtractionStatus.SUCCESS)
    return (successful / len(results) if results else 0) * 100

# Best framework calculation
def find_best_framework(frameworks_results):
    scores = {}
    for framework, results in frameworks_results.items():
        success_rate = calc_success_rate(results) / 100  # normalize to 0-1
        throughput = calc_avg_speed(results)
        scores[framework] = success_rate * throughput  # combined score
    return max(scores.items(), key=lambda x: x[1])[0]  # framework with max score

def score_to_grade(score):
    '''Convert 0-100 score to letter grade'''
    if score >= 95: return "A+"
    elif score >= 90: return "A"
    elif score >= 85: return "B+"
    elif score >= 80: return "B"
    elif score >= 75: return "C+"
    elif score >= 70: return "C"
    elif score >= 60: return "D"
    else: return "F"

def calculate_overall_score(framework_results):
    # Speed: files per second (normalized to 0-100)
    speed = len(results) / sum(r.extraction_time for r in results)
    speed_score = min(speed * 10, 100)  # cap at 100

    # Memory: lower is better (inverted score)
    avg_memory = sum(r.peak_memory_mb for r in results) / len(results) if results else 0
    memory_score = max(0, 100 - min(avg_memory, 100))

    # Quality: direct average of quality scores
    quality_score = sum(r.quality_score or 0 for r in results) / len(results) if results else 0

    # Success rate: percentage successful
    success_rate = (sum(1 for r in results if r.status == ExtractionStatus.SUCCESS) / len(results) * 100) if results else 0

    # Weighted composite score (0-5 scale)
    overall = (
        speed_score * 0.3 +
        memory_score * 0.2 +
        quality_score * 0.3 +
        success_rate * 0.2
    ) / 100 * 5  # convert to 0-5 scale

    return {
        "speed_grade": score_to_grade(speed_score),
        "memory_grade": score_to_grade(memory_score),
        "quality_grade": score_to_grade(quality_score),
        "success_rate": success_rate,
        "overall_score": overall
    }