Fix issues in test_create_profile and changelog

.github/workflows/push.yml

@@ -68,8 +68,13 @@ jobs:
           credentials_json: "${{ secrets.GCP_SA_KEY }}"
       - name: Set up GCloud
         uses: "google-github-actions/setup-gcloud@v2"
-      - name: Deploy
-        run: make deploy
+      - name: Deploy with retries
+        uses: nick-fields/retry@v2
+        with:
+          timeout_minutes: 10
+          max_attempts: 10
+          retry_on: error
+          command: make deploy
         env:
           POLICYENGINE_DB_PASSWORD: ${{ secrets.POLICYENGINE_DB_PASSWORD }}
           GOOGLE_APPLICATION_CREDENTIALS: ${{ secrets.GCP_SA_KEY }}
@@ -92,4 +97,4 @@ jobs:
       - name: Build container
         run: docker build -t ghcr.io/policyengine/policyengine docker
       - name: Push container
-        run: docker push ghcr.io/policyengine/policyengine
+        run: docker push ghcr.io/policyengine/policyengine

Makefile

@@ -12,7 +12,11 @@ test:
 	coverage xml -i
 
 debug-test:
-	MAX_HOUSEHOLDS=1000 FLASK_DEBUG=1 pytest -vv --durations=0 tests
+	MAX_HOUSEHOLDS=1000 FLASK_DEBUG=1 pytest -vv --durations=0 $(TEST_PATH)
+
+# Usage: make debug-test-file TEST_FILE=tests/unit/services/test_create_profile.py
+debug-test-file:
+	MAX_HOUSEHOLDS=1000 FLASK_DEBUG=1 pytest -vv --durations=0 $(TEST_FILE)
 
 format:
 	black . -l 79

policyengine_api/constants.py

@@ -6,7 +6,11 @@
 POST = "POST"
 UPDATE = "UPDATE"
 LIST = "LIST"
+<<<<<<< HEAD
 VERSION = "3.15.7"
+=======
+VERSION = "3.12.9"
+>>>>>>> parent of affae549 (Bump version to 3.12.10)
 COUNTRIES = ("uk", "us", "ca", "ng", "il")
 COUNTRY_PACKAGE_NAMES = (
     "policyengine_uk",

policyengine_api/services/ai_analysis_service.py

@@ -1,9 +1,14 @@
 import anthropic
 import os
 import json
-from typing import Generator, Optional, Literal
+from typing import Generator, Optional
 from policyengine_api.data import local_database
 from pydantic import BaseModel
+import openai
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
 
 
 class StreamEvent(BaseModel):
@@ -42,40 +47,110 @@ def get_existing_analysis(self, prompt: str) -> Optional[str]:
 
         return json.dumps(analysis["analysis"])
 
-    def trigger_ai_analysis(self, prompt: str) -> Generator[str, None, None]:
-
+    def _call_claude_api(self, prompt: str) -> Generator[StreamEvent, None, None]:
+        """
+        Make an API call to Anthropic's Claude model and return a generator
+        of stream events
+        """
         # Configure a Claude client
         claude_client = anthropic.Anthropic(
             api_key=os.getenv("ANTHROPIC_API_KEY")
         )
 
-        def generate():
-            response_text = ""
+        response_text = ""
+
+        with claude_client.messages.stream(
+            model="claude-3-5-sonnet-20240620",
+            max_tokens=1500,
+            temperature=0.0,
+            system="Respond with a historical quote",
+            messages=[{"role": "user", "content": prompt}],
+        ) as stream:
+            for event in stream:
+                # Docs on structure of Anthropic error events at https://docs.anthropic.com/en/api/messages-streaming#error-events
+                if event.type == "error":
+                    error: dict[str, str] = event.error
+                    error_type: str = error["type"]
+                    yield ErrorEvent(error=error_type)
+                    return
+                if event.type == "text":
+                    response_text += event.text
+                    yield TextEvent(stream=event.text)
+
+        # Update the analysis record if no error occurred
+        local_database.query(
+            f"INSERT INTO analysis (prompt, analysis, status) VALUES (?, ?, ?)",
+            (prompt, response_text, "ok"),
+        )
 
-            with claude_client.messages.stream(
-                model="claude-3-5-sonnet-20240620",
-                max_tokens=1500,
-                temperature=0.0,
-                system="Respond with a historical quote",
+    def _call_openai_api(self, prompt: str) -> Generator[StreamEvent, None, None]:
+        """
+        Make an API call to OpenAI's ChatGPT model and return a generator
+        of stream events
+        """
+        # Configure OpenAI client
+        openai_client = openai.Client(
+            api_key=os.getenv("OPENAI_API_KEY")
+        )
+
+        response_text = ""
+
+        try:
+            # Create a streaming response
+            stream = openai_client.chat.completions.create(
+                model="gpt-4o",
                 messages=[{"role": "user", "content": prompt}],
-            ) as stream:
-                for event in stream:
-                    # Docs on structure of Anthropic error events at https://docs.anthropic.com/en/api/messages-streaming#error-events
-                    if event.type == "error":
-                        error: dict[str, str] = event.error
-                        error_type: str = error["type"]
-                        return_event = ErrorEvent(error=error_type)
-                        yield json.dumps(return_event.model_dump()) + "\n"
-                        return
-                    if event.type == "text":
-                        response_text += event.text
-                        return_event = TextEvent(stream=event.text)
-                        yield json.dumps(return_event.model_dump()) + "\n"
-
-            # Update the analysis record and return if no error occurred
+                temperature=0.0,
+                max_tokens=1500,
+                stream=True,
+            )
+
+            # Process the streaming response
+            for chunk in stream:
+                if chunk.choices[0].delta.content is not None:
+                    content = chunk.choices[0].delta.content
+                    response_text += content
+                    yield TextEvent(stream=content)
+
+            # Update the analysis record if no error occurred
             local_database.query(
                 f"INSERT INTO analysis (prompt, analysis, status) VALUES (?, ?, ?)",
                 (prompt, response_text, "ok"),
             )
-
+        except openai.OpenAIError as e:
+            error_message = str(e)
+
+            # Check for quota/billing error
+            if "insufficient_quota" in error_message:
+                error_message = "OpenAI API quota exceeded or billing issue. Please check your OpenAI account."
+
+            yield ErrorEvent(error=error_message)
+        except Exception as e:
+            yield ErrorEvent(error=str(e))
+
+    def trigger_ai_analysis(self, prompt: str, provider: str = "claude") -> Generator[str, None, None]:
+        """
+        Trigger AI analysis with the specified provider
+
+        Args:
+            prompt: The prompt to send to the AI model
+            provider: The AI provider to use ('claude' or 'openai')
+
+        Returns:
+            A generator that yields JSON-serialized stream events
+        """
+        def generate():
+            stream_generator = None
+
+            if provider.lower() == "claude":
+                stream_generator = self._call_claude_api(prompt)
+            elif provider.lower() == "openai":
+                stream_generator = self._call_openai_api(prompt)
+            else:
+                yield json.dumps(ErrorEvent(error=f"Unsupported provider: {provider}").model_dump()) + "\n"
+                return
+
+            for event in stream_generator:
+                yield json.dumps(event.model_dump()) + "\n"
+
         return generate()

standalone_ai_test.py

@@ -0,0 +1,139 @@
+import os
+import json
+import anthropic
+import openai
+from dotenv import load_dotenv
+from pydantic import BaseModel
+from typing import Generator
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Stream event classes
+class StreamEvent(BaseModel):
+    type: str
+
+class TextEvent(StreamEvent):
+    type: str = "text"
+    stream: str
+
+class ErrorEvent(StreamEvent):
+    type: str = "error"
+    error: str
+
+
+class AIService:
+    """Simplified AI service for testing purposes"""
+
+    def _call_claude_api(self, prompt: str) -> Generator[StreamEvent, None, None]:
+        """
+        Make an API call to Anthropic's Claude model and return a generator
+        of stream events
+        """
+        try:
+            # Configure a Claude client
+            claude_client = anthropic.Anthropic(
+                api_key=os.getenv("ANTHROPIC_API_KEY")
+            )
+
+            with claude_client.messages.stream(
+                model="claude-3-5-sonnet-20240620",
+                max_tokens=1500,
+                temperature=0.0,
+                system="Respond with a historical quote",
+                messages=[{"role": "user", "content": prompt}],
+            ) as stream:
+                for event in stream:
+                    if event.type == "error":
+                        error: dict[str, str] = event.error
+                        error_type: str = error["type"]
+                        yield ErrorEvent(error=error_type)
+                        return
+                    if event.type == "text":
+                        yield TextEvent(stream=event.text)
+        except Exception as e:
+            yield ErrorEvent(error=str(e))
+
+    def _call_openai_api(self, prompt: str) -> Generator[StreamEvent, None, None]:
+        try:
+            openai_client = openai.Client(
+                api_key=os.getenv("OPENAI_API_KEY")
+            )
+
+            stream = openai_client.chat.completions.create(
+                model="gpt-4o",
+                messages=[{"role": "user", "content": prompt}],
+                temperature=0.0,
+                max_tokens=1500,
+                stream=True,
+            )
+
+            for chunk in stream:
+                if chunk.choices[0].delta.content is not None:
+                    content = chunk.choices[0].delta.content
+                    yield TextEvent(stream=content)
+
+        except openai.OpenAIError as e:
+            error_message = str(e)
+            yield ErrorEvent(error=error_message)
+        except Exception as e:
+            yield ErrorEvent(error=str(e))
+
+    def trigger_ai_analysis(self, prompt: str, provider: str = "claude") -> Generator[str, None, None]:
+        """
+        Trigger AI analysis with the specified provider
+
+        Args:
+            prompt: The prompt to send to the AI model
+            provider: The AI provider to use ('claude' or 'openai')
+
+        Returns:
+            A generator that yields JSON-serialized stream events
+        """
+        def generate():
+            stream_generator = None
+
+            if provider.lower() == "claude":
+                stream_generator = self._call_claude_api(prompt)
+            elif provider.lower() == "openai":
+                stream_generator = self._call_openai_api(prompt)
+            else:
+                yield json.dumps(ErrorEvent(error=f"Unsupported provider: {provider}").model_dump()) + "\n"
+                return
+
+            for event in stream_generator:
+                yield json.dumps(event.model_dump()) + "\n"
+
+        return generate()
+
+
+def test_service_provider(provider):
+    print(f"\nTesting AI Service with {provider} provider...")
+    service = AIService()
+    prompt = "What is the capital of France?"
+
+    try:
+        # Collect results
+        results = []
+        for response in service.trigger_ai_analysis(prompt, provider=provider):
+            print(response)
+            results.append(json.loads(response))
+
+        # Check for errors in results
+        errors = [r for r in results if r.get("type") == "error"]
+        if errors:
+            print(f"{provider} test completed with errors: {errors[0].get('error')}")
+        else:
+            print(f"{provider} test completed successfully.")
+
+    except Exception as e:
+        print(f"Error testing {provider}: {str(e)}")
+
+
+if __name__ == "__main__":
+    print("API Key Verification:")
+    print(f"ANTHROPIC_API_KEY: {'Present' if os.getenv('ANTHROPIC_API_KEY') else 'Missing'}")
+    print(f"OPENAI_API_KEY: {'Present' if os.getenv('OPENAI_API_KEY') else 'Missing'}")
+
+    test_service_provider("claude")
+    test_service_provider("openai") 

test_ai_providers.py

@@ -0,0 +1,18 @@
+from policyengine_api.services.ai_analysis_service import AIAnalysisService
+
+def test_ai_provider(provider):
+    print(f"\nTesting {provider} API...")
+    service = AIAnalysisService()
+    prompt = "What is the capital of France?"
+    generator = service.trigger_ai_analysis(prompt, provider=provider)
+
+    try:
+        for response in generator():
+            print(response)
+        print(f"{provider} test completed successfully.")
+    except Exception as e:
+        print(f"Error testing {provider}: {str(e)}")
+
+if __name__ == "__main__":
+    test_ai_provider("claude")
+    test_ai_provider("openai")