Analyzing Results

import requests
import os
 
def analyze_goals(recording_id):
    API_KEY = os.environ.get("IDENTITYCALL_API_KEY")
 
    response = requests.get(
        f"https://api.identitycall.com/api/v1/public/recordings/{recording_id}/results",
        headers={"Authorization": f"Bearer {API_KEY}"}
    )
 
    results = response.json()["data"]
 
    # Calculate overall achievement
    goals = results["goals"]
    total_score = sum(g["score"] for g in goals)
    avg_score = total_score / len(goals) if goals else 0
    met_count = sum(1 for g in goals if g["met"])
 
    print(f"Goal Achievement: {met_count}/{len(goals)} ({avg_score:.0%})")
    print()
 
    # Group by achievement
    achieved = [g for g in goals if g["met"]]
    not_achieved = [g for g in goals if not g["met"]]
 
    if achieved:
        print("✓ Achieved Goals:")
        for goal in achieved:
            print(f"  - {goal['goal_name']} (score: {goal['score']:.2f})")
            print(f"    {goal['explanation']}")
 
    if not_achieved:
        print("\n✗ Not Achieved:")
        for goal in not_achieved:
            print(f"  - {goal['goal_name']} (score: {goal['score']:.2f})")
            print(f"    {goal['explanation']}")
 
    return results

async function analyzeGoals(recordingId) {
  const API_KEY = process.env.IDENTITYCALL_API_KEY;
 
  const response = await fetch(
    `https://api.identitycall.com/api/v1/public/recordings/${recordingId}/results`,
    { headers: { 'Authorization': `Bearer ${API_KEY}` } }
  );
 
  const { data: results } = await response.json();
 
  // Calculate overall achievement
  const goals = results.goals;
  const totalScore = goals.reduce((sum, g) => sum + g.score, 0);
  const avgScore = goals.length ? totalScore / goals.length : 0;
  const metCount = goals.filter(g => g.met).length;
 
  console.log(`Goal Achievement: ${metCount}/${goals.length} (${(avgScore * 100).toFixed(0)}%)`);
  console.log();
 
  // Group by achievement
  const achieved = goals.filter(g => g.met);
  const notAchieved = goals.filter(g => !g.met);
 
  if (achieved.length) {
    console.log('✓ Achieved Goals:');
    achieved.forEach(goal => {
      console.log(`  - ${goal.goal_name} (score: ${goal.score.toFixed(2)})`);
      console.log(`    ${goal.explanation}`);
    });
  }
 
  if (notAchieved.length) {
    console.log('\n✗ Not Achieved:');
    notAchieved.forEach(goal => {
      console.log(`  - ${goal.goal_name} (score: ${goal.score.toFixed(2)})`);
      console.log(`    ${goal.explanation}`);
    });
  }
 
  return results;
}

def analyze_keywords(results):
    keywords = results["keywords"]
 
    # Group by sentiment
    positive = [k for k in keywords if k["sentiment"] == "positive"]
    negative = [k for k in keywords if k["sentiment"] == "negative"]
    neutral = [k for k in keywords if k["sentiment"] == "neutral"]
 
    print("Keyword Analysis:")
 
    if positive:
        total_positive = sum(k["count"] for k in positive)
        print(f"\n  Positive mentions: {total_positive}")
        for k in positive:
            print(f"    - '{k['keyword_name']}': {k['count']} times")
 
    if negative:
        total_negative = sum(k["count"] for k in negative)
        print(f"\n  Negative mentions: {total_negative}")
        for k in negative:
            print(f"    - '{k['keyword_name']}': {k['count']} times")
            print(f"      at: {k['timestamps_ms']}")
 
    # Calculate sentiment ratio
    pos_count = sum(k["count"] for k in positive)
    neg_count = sum(k["count"] for k in negative)
    total = pos_count + neg_count
 
    if total > 0:
        sentiment_score = pos_count / total
        print(f"\n  Sentiment ratio: {sentiment_score:.0%} positive")

function analyzeKeywords(results) {
  const keywords = results.keywords;
 
  // Group by sentiment
  const positive = keywords.filter(k => k.sentiment === 'positive');
  const negative = keywords.filter(k => k.sentiment === 'negative');
  const neutral = keywords.filter(k => k.sentiment === 'neutral');
 
  console.log('Keyword Analysis:');
 
  if (positive.length) {
    const totalPositive = positive.reduce((sum, k) => sum + k.count, 0);
    console.log(`\n  Positive mentions: ${totalPositive}`);
    positive.forEach(k => {
      console.log(`    - '${k.keyword_name}': ${k.count} times`);
    });
  }
 
  if (negative.length) {
    const totalNegative = negative.reduce((sum, k) => sum + k.count, 0);
    console.log(`\n  Negative mentions: ${totalNegative}`);
    negative.forEach(k => {
      console.log(`    - '${k.keyword_name}': ${k.count} times`);
      console.log(`      at: ${k.timestamps_ms.join(', ')}ms`);
    });
  }
 
  // Calculate sentiment ratio
  const posCount = positive.reduce((sum, k) => sum + k.count, 0);
  const negCount = negative.reduce((sum, k) => sum + k.count, 0);
  const total = posCount + negCount;
 
  if (total > 0) {
    const sentimentScore = posCount / total;
    console.log(`\n  Sentiment ratio: ${(sentimentScore * 100).toFixed(0)}% positive`);
  }
}