analyze_marketplace.py

#!/usr/bin/env python3
"""
Run marketplace simulation analysis

This script provides a command-line interface for running the marketplace analysis pipeline.
"""

import argparse
import json
import logging
from typing import Dict, Any
from src.analysis import MarketplaceAnalysis

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)


def parse_arguments():
    """Parse command-line arguments."""
    parser = argparse.ArgumentParser(description="Run marketplace simulation analysis")
    parser.add_argument(
        "--simulation-file",
        type=str,
        default="results/simuleval/true_gpt_simulation_20250814_111659.json",
        help="Path to simulation results JSON file"
    )
    parser.add_argument(
        "--output-dir",
        type=str,
        default="results",
        help="Directory to save analysis results"
    )
    parser.add_argument(
        "--skip-visualizations",
        action="store_true",
        help="Skip generating visualizations"
    )
    parser.add_argument(
        "--skip-reports",
        action="store_true",
        help="Skip generating reports"
    )
    parser.add_argument(
        "--generate-trend-plots",
        action="store_true",
        help="Generate historical market trend plots"
    )
    return parser.parse_args()


def run_analysis(analyzer: MarketplaceAnalysis) -> Dict[str, Any]:
    """Run core analysis and return results."""
    market_metrics = analyzer.analyze_market_metrics()
    return {
        'simulation_overview': market_metrics.get('simulation_overview', {}),
        'market_metrics': market_metrics,
        'bidding_behavior': analyzer.analyze_bidding_behavior(),
        'agent_learning': analyzer.analyze_agent_learning(),
        'reputation_analysis': analyzer.analyze_reputation_dynamics()
    }


def generate_visualizations(analyzer: MarketplaceAnalysis, args) -> None:
    """Generate visualizations if not skipped."""
    if args.skip_visualizations:
        return
    
    analyzer.generate_visualizations(f"{args.output_dir}/figures")


def generate_trend_plots(args) -> None:
    """Generate trend plots if requested."""
    if not args.generate_trend_plots:
        return
    
    from src.analysis.visualization.market_trend_plots import plot_market_trends_from_file
    print("\nGenerating historical trend plots...")
    plot_market_trends_from_file(args.simulation_file, f"{args.output_dir}/figures")
    print("✅ Trend plots saved to results/figures/")


def generate_reports(analyzer: MarketplaceAnalysis, args, results: Dict[str, Any]) -> None:
    """Generate reports if not skipped."""
    if args.skip_reports:
        return
    
    reports = analyzer.generate_reports(args.output_dir)
    results['reports'] = reports


def generate_paper_figures(args, results: Dict[str, Any]) -> None:
    """Generate paper figures and merge saved results."""
    if args.skip_visualizations:
        return
    
    from src.analysis.paper_figures import generate_paper_figures
    generate_paper_figures(
        simulation_file=args.simulation_file,
        analysis_file=f"{args.output_dir}/analysis_results.json",
        output_dir=f"{args.output_dir}/figures"
    )
    
    # Read the saved analysis results to get complete data
    try:
        with open(f"{args.output_dir}/analysis_results.json", "r") as f:
            saved_results = json.load(f)
            results.update(saved_results)
    except FileNotFoundError:
        pass


def print_market_performance(metrics: Dict[str, Any]) -> None:
    """Print market performance statistics."""
    if 'unfilled_jobs' not in metrics:
        return
    
    stats = metrics['unfilled_jobs']['overall_stats']
    print("\nMarket Performance:")
    print(f"- Fill rate: {stats['fill_rate']*100:.1f}%")
    print(f"- Total jobs: {stats['total_jobs']}")
    print(f"- Unfilled jobs: {stats['unfilled_jobs']}")


def print_market_health(saturation: Dict[str, Any]) -> None:
    """Print market health score and trends."""
    if 'market_health_score' not in saturation:
        return
    
    health = saturation['market_health_score']
    if 'health_grade' not in health:
        return
    
    grade = health.get('health_grade', 'unknown')
    score = health.get('overall_health_score', 0)
    trend = health.get('health_trend', 'unknown')
    print(f"- Market health: {grade} ({score:.2f})")
    if trend != 'unknown':
        print(f"  • Health trend: {trend}")


def print_bid_volume_analysis(saturation: Dict[str, Any]) -> None:
    """Print bid volume and competitiveness analysis."""
    if 'bid_volume_analysis' not in saturation:
        return
    
    bid_vol = saturation['bid_volume_analysis']
    if 'average_bids_per_job' not in bid_vol:
        return
    
    avg_bids = bid_vol['average_bids_per_job']
    risk = bid_vol.get('saturation_risk_level', 'unknown')
    competitiveness = bid_vol.get('current_competitiveness', 'unknown')
    comp_trend = bid_vol.get('competition_trend', 'unknown')
    
    print(f"- Avg bids per job: {avg_bids:.1f}")
    print(f"- Saturation risk: {risk}")
    print(f"- Market competitiveness: {competitiveness}")
    if comp_trend != 'unknown':
        print(f"  • Competition trend: {comp_trend}")


def print_bid_rejection_analysis(saturation: Dict[str, Any]) -> None:
    """Print bid rejection analysis."""
    if 'bid_rejection_analysis' not in saturation:
        return
    
    rejection = saturation['bid_rejection_analysis']
    if 'average_rejection_rate' not in rejection:
        return
    
    rate = rejection['average_rejection_rate']
    trend = rejection.get('trend_direction', 'unknown')
    print(f"- Avg bid rejection rate: {rate*100:.1f}%")
    if trend != 'unknown':
        print(f"  • Rejection rate trend: {trend}")


def print_outcome_diversity(saturation: Dict[str, Any]) -> None:
    """Print freelancer outcome diversity analysis."""
    if 'freelancer_outcome_diversity' not in saturation:
        return
    
    diversity = saturation['freelancer_outcome_diversity']
    if 'current_gini_coefficient' not in diversity:
        return
    
    gini = diversity['current_gini_coefficient']
    level = diversity.get('diversity_level', 'unknown')
    freelancers_with_work = diversity.get('freelancers_with_work', 0)
    total_freelancers = diversity.get('total_freelancers', 0)
    gini_trend = diversity.get('gini_trend', 'unknown')
    
    print(f"- Outcome diversity: {level} ({gini:.2f})")
    print(f"- Freelancers with work: {freelancers_with_work}/{total_freelancers}")
    if gini_trend != 'unknown':
        print(f"  • Diversity trend: {gini_trend}")


def print_fatigue_indicators(saturation: Dict[str, Any]) -> None:
    """Print freelancer fatigue indicators."""
    if 'freelancer_fatigue_indicators' not in saturation:
        return
    
    fatigue = saturation['freelancer_fatigue_indicators']
    if 'overall_fatigue_level' not in fatigue:
        return
    
    level = fatigue['overall_fatigue_level']
    trend = fatigue.get('fatigue_trend', 'unknown')
    print(f"- Freelancer fatigue: {level}")
    if trend != 'unknown':
        print(f"  • Fatigue trend: {trend}")


def print_client_activity(saturation: Dict[str, Any]) -> None:
    """Print client activity patterns."""
    if 'client_activity_patterns' not in saturation:
        return
    
    activity = saturation['client_activity_patterns']
    if 'engagement_assessment' not in activity:
        return
    
    assessment = activity['engagement_assessment']
    rate = activity.get('average_activity_rate', 0)
    trend = activity.get('engagement_trend', 'unknown')
    print(f"- Client engagement: {assessment} ({rate*100:.1f}% activity rate)")
    if trend != 'unknown':
        print(f"  • Client engagement trend: {trend}")


def print_saturation_analysis(metrics: Dict[str, Any]) -> None:
    """Print complete saturation analysis."""
    if 'saturation_analysis' not in metrics:
        return
    
    saturation = metrics['saturation_analysis']
    print("\nMarket Saturation Analysis:")
    
    print_market_health(saturation)
    print_bid_volume_analysis(saturation)
    print_bid_rejection_analysis(saturation)
    print_outcome_diversity(saturation)
    print_fatigue_indicators(saturation)
    print_client_activity(saturation)


def print_bidding_behavior(behavior: Dict[str, Any]) -> None:
    """Print bidding behavior analysis."""
    if 'decision_patterns' not in behavior:
        return
    
    patterns = behavior['decision_patterns']
    print("\nBidding Behavior:")
    print(f"- Total decisions: {patterns.get('total_decisions', 0)}")
    print(f"- Bid rate: {patterns.get('bid_rate', 0)*100:.1f}%")


def print_reputation_progression(reputation: Dict[str, Any]) -> None:
    """Print reputation progression analysis."""
    if 'reputation_progression' not in reputation:
        return
    
    progression = reputation['reputation_progression']
    
    # Freelancer progression
    if 'freelancers' in progression:
        fl_prog = progression['freelancers']
        print(f"- Freelancer Learning: {fl_prog.get('agents_tracked', 0)} agents tracked")
        print(f"  • Tier Mobility: {fl_prog.get('tier_mobility_rate', 0)*100:.1f}% promoted ({fl_prog.get('agents_promoted', 0)} agents)")
        print(f"  • Learning Trajectory: {fl_prog.get('learning_trajectory', 'unknown')}")
        print(f"  • Avg Score Improvement: {fl_prog.get('average_score_improvement', 0):.3f}")
    
    # Client progression
    if 'clients' in progression:
        cl_prog = progression['clients']
        print(f"- Client Learning: {cl_prog.get('agents_tracked', 0)} agents tracked")
        print(f"  • Tier Mobility: {cl_prog.get('tier_mobility_rate', 0)*100:.1f}% promoted ({cl_prog.get('agents_promoted', 0)} agents)")
        print(f"  • Learning Trajectory: {cl_prog.get('learning_trajectory', 'unknown')}")


def print_reputation_distribution(reputation: Dict[str, Any]) -> None:
    """Print current reputation distribution."""
    if 'current_reputation_distribution' not in reputation:
        return
    
    current = reputation['current_reputation_distribution']
    
    # Freelancer current state
    if 'freelancers' in current:
        freelancer_rep = current['freelancers']
        if 'tier_distribution' in freelancer_rep:
            tier_dist = freelancer_rep['tier_distribution']
            print(f"- Current Freelancer Tiers: New={tier_dist.get('New', 0)}, Established={tier_dist.get('Established', 0)}, Expert={tier_dist.get('Expert', 0)}, Elite={tier_dist.get('Elite', 0)}")
        
        if 'average_completion_rate' in freelancer_rep:
            print(f"- Avg Completion Rate: {freelancer_rep['average_completion_rate']*100:.1f}%")
    
    # Client current state  
    if 'clients' in current:
        client_rep = current['clients']
        if 'tier_distribution' in client_rep:
            tier_dist = client_rep['tier_distribution']
            print(f"- Current Client Tiers: New={tier_dist.get('New', 0)}, Established={tier_dist.get('Established', 0)}, Expert={tier_dist.get('Expert', 0)}, Elite={tier_dist.get('Elite', 0)}")
        
        if 'average_hire_success_rate' in client_rep:
            print(f"- Avg Client Hire Success: {client_rep['average_hire_success_rate']*100:.1f}%")


def print_reputation_impact(reputation: Dict[str, Any]) -> None:
    """Print reputation impact metrics."""
    if 'reputation_impact' not in reputation:
        return
    
    impact = reputation['reputation_impact']
    if 'tier_hiring_advantage' in impact:
        advantage = impact['tier_hiring_advantage']
        print(f"- Elite vs New Hire Rate: {advantage.get('elite_vs_new_ratio', 1.0):.1f}x advantage")
    
    if 'reputation_mobility' in impact:
        mobility = impact['reputation_mobility']
        print(f"- Market Mobility: {mobility.get('freelancers_promoted', 0)} freelancers, {mobility.get('clients_promoted', 0)} clients advanced")


def print_reputation_analysis(reputation: Dict[str, Any]) -> None:
    """Print complete reputation analysis."""
    print("\nReputation Dynamics:")
    print_reputation_progression(reputation)
    print_reputation_distribution(reputation)
    print_reputation_impact(reputation)
    print(f"- Historical Data Points: {reputation.get('historical_data_points', 0)} rounds")


def print_agent_statistics(results: Dict[str, Any]) -> None:
    """Print agent statistics."""
    print("\nAgent Statistics:")
    
    # Get actual number of unique freelancers from simulation overview
    total_freelancers = results.get('simulation_overview', {}).get('total_freelancers', 0)
    total_bids = results.get('simulation_overview', {}).get('total_bids', 0)
    if total_freelancers > 0:
        print(f"- Total freelancers: {total_freelancers}")
        print(f"- Total bids made: {total_bids}")
        print(f"- Avg bids per freelancer: {total_bids/total_freelancers:.1f}")
    
    # Show categories with bidding activity
    if 'market_metrics' in results:
        metrics = results['market_metrics']
        if 'skill_distribution' in metrics and 'category_coverage' in metrics['skill_distribution']:
            active_categories = sum(1 for cat in metrics['skill_distribution']['category_coverage'].values() 
                               if cat.get('avg_bids_per_job', 0) > 0)
            total_categories = len(metrics['skill_distribution']['category_coverage'])
            print(f"- Active categories: {active_categories}/{total_categories}")


def print_analysis_summary(results: Dict[str, Any]) -> None:
    """Print comprehensive analysis summary."""
    print("\n=== Analysis Results Summary ===")
    
    if 'market_metrics' in results:
        metrics = results['market_metrics']
        print_market_performance(metrics)
        print_saturation_analysis(metrics)
    
    if 'bidding_behavior' in results:
        print_bidding_behavior(results['bidding_behavior'])
    
    if 'reputation_analysis' in results:
        print_reputation_analysis(results['reputation_analysis'])
    
    print_agent_statistics(results)
    
    if 'reports' in results:
        print("\nReports generated:")
        for report_type, path in results['reports'].items():
            print(f"- {report_type}: {path}")
    
    print("\nAnalysis completed successfully!")


def main():
    """Run analysis pipeline."""
    args = parse_arguments()
    
    try:
        # Initialize analyzer
        analyzer = MarketplaceAnalysis(args.simulation_file)
        
        # Run analysis
        results = run_analysis(analyzer)
        
        # Generate outputs
        generate_visualizations(analyzer, args)
        generate_trend_plots(args)
        generate_reports(analyzer, args, results)
        generate_paper_figures(args, results)
        
        # Print summary
        print_analysis_summary(results)
        
    except Exception as e:
        logger.exception(f"Error during analysis: {e}")
        return 1
    
    return 0

if __name__ == "__main__":
    import sys
    sys.exit(main())