# Create a virtual environment
python -m venv venv

# Activate environment (Windows)
venv\Scripts\activate
# Activate environment (Mac/Linux)
source venv/bin/activate

# Install necessary libraries
pip install openai python-dotenv

# Initialize project
npm init -y

# Install dependencies
npm install openai dotenv

# If using TypeScript, install dev dependencies
npm install --save-dev typescript @types/node ts-node

import os
import json
from typing import Dict, Any
from dotenv import load_dotenv
from openai import OpenAI

# Load environment variables from .env file
load_dotenv()

class PolicyAnalyzer:
    def __init__(self):
        # Initialize client with API key from environment
        self.client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
        self.model = "gpt-4o"

    def analyze_speech(self, text: str) -> Dict[str, Any]:
        """
        Analyzes diplomatic text to extract regulatory sentiment and stakeholders.
        """
        prompt = f"""
        Analyze the following geopolitical statement. 
        Return ONLY a JSON object with these keys:
        - 'sentiment': (string: 'cooperative', 'confrontational', or 'neutral')
        - 'key_stakeholders': (list of strings)
        - 'regulatory_urgency': (integer 1-10)
        - 'summary': (short 1-sentence summary)

        Statement: "{text}"
        """

        try:
            response = self.client.chat.completions.create(
                model=self.model,
                messages=[
                    {"role": "system", "content": "You are a geopolitical policy analyst specializing in AI regulation."},
                    {"role": "user", "content": prompt}
                ],
                response_format={"type": "json_object"} # Ensures valid JSON output
            )
            
            # Parse the string response into a Python Dictionary
            return json.loads(response.choices[0].message.content)

        except Exception as e:
            return {"error": f"Failed to analyze text: {str(e)}"}

# --- EXECUTION EXAMPLE ---
if __name__ == "__main__":
    # The context provided in the ICARAX news report
    macron_statement = (
        "President Macron urges the US to share cutting-edge AI technology "
        "and calls for democracies to cooperate on global AI regulation."
    )

    analyzer = PolicyAnalyzer()
    result = analyzer.analyze_speech(macron_statement)

    print(json.dumps(result, indent=4))

import 'dotenv/config';
import OpenAI from 'openai';

// Define the structure of our analysis for type safety
interface PolicyAnalysis {
  sentiment: 'cooperative' | 'confrontational' | 'neutral';
  key_stakeholders: string[];
  regulatory_urgency: number;
  summary: string;
}

class PolicyAnalyzer {
  private openai: OpenAI;

  constructor() {
    this.openai = new OpenAI({
      apiKey: process.env.OPENAI_API_KEY,
    });
  }

  async analyzeSpeech(text: string): Promise<PolicyAnalysis | { error: string }> {
    const prompt = `
      Analyze the following geopolitical statement. 
      Return ONLY a JSON object with these keys:
      - 'sentiment': (string: 'cooperative', 'confrontational', or 'neutral')
      - 'key_stakeholders': (array of strings)
      - 'regulatory_urgency': (number 1-10)
      - 'summary': (short 1-sentence summary)

      Statement: "${text}"
    `;

    try {
      const response = await this.openai.chat.completions.create({
        model: "gpt-4o",
        messages: [
          { role: "system", content: "You are a geopolitical policy analyst." },
          { role: "user", content: prompt }
        ],
        response_format: { type: "json_object" },
      });

      const content = response.choices[0].message.content;
      return JSON.parse(content || '{}') as PolicyAnalysis;
    } catch (error: any) {
      return { error: `Analysis failed: ${error.message}` };
    }
  }
}

// --- EXECUTION EXAMPLE ---
async function run() {
  const analyzer = new PolicyAnalyzer();
  const statement = "President Macron urges the US to share cutting-edge AI technology and calls for democracies to cooperate on global AI regulation.";
  
  const result = await analyzer.analyzeSpeech(statement);
  console.log(JSON.stringify(result, null, 2));
}

run();

# .env file
OPENAI_API_KEY=sk-your-actual-api-key-here
NODE_ENV=development