Remove references to responses API as we don't use that anymore; update unit test accordingly

Author: nonprofittechy

formfyxer/passive_voice_detection.py

@@ -1,4 +1,4 @@
-"""Passive voice detection utilities backed by OpenAI's Responses API."""
+"""Passive voice detection utilities backed by OpenAI's ChatCompletion API."""
 
 from __future__ import annotations
 
@@ -160,11 +160,7 @@ def _normalize_input(text: Union[str, Sequence[str]]) -> List[str]:
 
 
 def _extract_text_from_response(response) -> str:
-    """Extract text content from OpenAI Responses API response object.
-    
-    This function handles different response formats from the OpenAI Responses API,
-    trying multiple approaches to extract the text content. It checks for various
-    attributes and nested structures that may contain the response text.
+    """Extract text content from OpenAI ChatCompletion API response object.
     
     Args:
         response: OpenAI API response object with potentially nested content
@@ -234,7 +230,7 @@ def detect_passive_voice_segments(
 
     Note:
         This implementation uses a single prompt per sentence to classify rather
-        than the responses API after testing and finding better performance with this
+        than the ChatCompletion API after testing and finding better performance with this
         simple approach.
     """
 

formfyxer/tests/test_passive_voice_detection.py

@@ -1,6 +1,5 @@
 """Unit tests for passive voice detection with mocked OpenAI responses."""
 
-import json
 import unittest
 from unittest.mock import Mock, patch, MagicMock
 from pathlib import Path
@@ -15,30 +14,29 @@ def setUp(self):
         """Set up test fixtures."""
         self.mock_client = Mock()
 
-    def _create_mock_response(self, results_data):
-        """Create a mock OpenAI response with the given results data.
+    def _create_mock_chat_response(self, content):
+        """Create a mock OpenAI chat completion response.
         
         Args:
-            results_data: List of dicts with 'sentence' and 'fragments' keys
+            content: The content string ("passive" or "active")
             
         Returns:
-            Mock response object that mimics OpenAI's response structure
+            Mock response object that mimics OpenAI's chat completion structure
         """
         mock_response = Mock()
-        mock_response.output_text = json.dumps({"results": results_data})
+        mock_choice = Mock()
+        mock_message = Mock()
+        mock_message.content = content
+        mock_choice.message = mock_message
+        mock_response.choices = [mock_choice]
         return mock_response
 
     def test_detect_passive_voice_basic_passive(self):
         """Test detection of basic passive voice constructions."""
         # Mock response for passive voice sentence
-        mock_response = self._create_mock_response([
-            {
-                "sentence": "The ball was thrown by John.",
-                "fragments": ["was thrown"]
-            }
-        ])
+        mock_response = self._create_mock_chat_response("passive")
 
-        self.mock_client.responses.create.return_value = mock_response
+        self.mock_client.chat.completions.create.return_value = mock_response
 
         result = detect_passive_voice_segments(
             "The ball was thrown by John.",
@@ -48,24 +46,19 @@ def test_detect_passive_voice_basic_passive(self):
         self.assertEqual(len(result), 1)
         sentence, fragments = result[0]
         self.assertEqual(sentence, "The ball was thrown by John.")
-        self.assertEqual(fragments, ["was thrown"])
+        self.assertEqual(fragments, ["The ball was thrown by John."])  # Now returns full sentence
 
         # Verify the API was called correctly
-        self.mock_client.responses.create.assert_called_once()
-        call_args = self.mock_client.responses.create.call_args
+        self.mock_client.chat.completions.create.assert_called_once()
+        call_args = self.mock_client.chat.completions.create.call_args
         self.assertEqual(call_args[1]['model'], 'gpt-5-nano')
 
     def test_detect_passive_voice_active_sentence(self):
         """Test that active voice sentences return empty fragments."""
         # Mock response for active voice sentence
-        mock_response = self._create_mock_response([
-            {
-                "sentence": "John threw the ball.",
-                "fragments": []
-            }
-        ])
+        mock_response = self._create_mock_chat_response("active")
 
-        self.mock_client.responses.create.return_value = mock_response
+        self.mock_client.chat.completions.create.return_value = mock_response
 
         result = detect_passive_voice_segments(
             "John threw the ball.",
@@ -79,23 +72,14 @@ def test_detect_passive_voice_active_sentence(self):
 
     def test_detect_passive_voice_multiple_sentences(self):
         """Test detection with multiple sentences."""
-        # Mock response for multiple sentences
-        mock_response = self._create_mock_response([
-            {
-                "sentence": "The report was completed yesterday.",
-                "fragments": ["was completed"]
-            },
-            {
-                "sentence": "The team finished the project.",
-                "fragments": []
-            },
-            {
-                "sentence": "The documents were reviewed by the manager.",
-                "fragments": ["were reviewed"]
-            }
-        ])
-        
-        self.mock_client.responses.create.return_value = mock_response
+        # Mock responses for each sentence call
+        responses = [
+            self._create_mock_chat_response("passive"),    # "The report was completed yesterday."
+            self._create_mock_chat_response("active"),     # "The team finished the project."
+            self._create_mock_chat_response("passive")     # "The documents were reviewed by the manager."
+        ]
+        
+        self.mock_client.chat.completions.create.side_effect = responses
 
         text = "The report was completed yesterday. The team finished the project. The documents were reviewed by the manager."
         result = detect_passive_voice_segments(text, openai_client=self.mock_client)
@@ -105,7 +89,7 @@ def test_detect_passive_voice_multiple_sentences(self):
         # Check first sentence (passive)
         sentence1, fragments1 = result[0]
         self.assertEqual(sentence1, "The report was completed yesterday.")
-        self.assertEqual(fragments1, ["was completed"])
+        self.assertEqual(fragments1, ["The report was completed yesterday."])
 
         # Check second sentence (active)
         sentence2, fragments2 = result[1]
@@ -115,27 +99,18 @@ def test_detect_passive_voice_multiple_sentences(self):
         # Check third sentence (passive)
         sentence3, fragments3 = result[2]
         self.assertEqual(sentence3, "The documents were reviewed by the manager.")
-        self.assertEqual(fragments3, ["were reviewed"])
+        self.assertEqual(fragments3, ["The documents were reviewed by the manager."])
 
     def test_detect_passive_voice_edge_cases(self):
         """Test edge cases that should not be flagged as passive."""
-        # Mock response for edge cases that are not passive
-        mock_response = self._create_mock_response([
-            {
-                "sentence": "Business is very well known career field.",
-                "fragments": []
-            },
-            {
-                "sentence": "I am immersing myself in my culture.",
-                "fragments": []
-            },
-            {
-                "sentence": "The president was satisfied with the results.",
-                "fragments": []
-            }
-        ])
-        
-        self.mock_client.responses.create.return_value = mock_response
+        # Mock responses for edge cases that are not passive
+        responses = [
+            self._create_mock_chat_response("active"),
+            self._create_mock_chat_response("active"),
+            self._create_mock_chat_response("active")
+        ]
+        
+        self.mock_client.chat.completions.create.side_effect = responses
 
         sentences = [
             "Business is very well known career field.",
@@ -156,39 +131,32 @@ def test_detect_passive_voice_sequence_input(self):
             "She baked the cake this morning."
         ]
 
-        mock_response = self._create_mock_response([
-            {
-                "sentence": "The cake was baked this morning.",
-                "fragments": ["was baked"]
-            },
-            {
-                "sentence": "She baked the cake this morning.",
-                "fragments": []
-            }
-        ])
+        responses = [
+            self._create_mock_chat_response("passive"),
+            self._create_mock_chat_response("active")
+        ]
 
-        self.mock_client.responses.create.return_value = mock_response
+        self.mock_client.chat.completions.create.side_effect = responses
 
         result = detect_passive_voice_segments(sentences, openai_client=self.mock_client)
 
         self.assertEqual(len(result), 2)
-        self.assertEqual(result[0][1], ["was baked"])  # First should have fragments
+        self.assertEqual(result[0][1], ["The cake was baked this morning."])  # First should have full sentence
         self.assertEqual(result[1][1], [])  # Second should have no fragments
 
-    def test_detect_passive_voice_invalid_json_response(self):
-        """Test handling of invalid JSON responses."""
-        # Mock response with invalid JSON
-        mock_response = Mock()
-        mock_response.output_text = "Invalid JSON response"
+    def test_detect_passive_voice_invalid_response(self):
+        """Test handling of invalid responses."""
+        # Mock response with unrecognized classification
+        mock_response = self._create_mock_chat_response("invalid_classification")
 
-        self.mock_client.responses.create.return_value = mock_response
+        self.mock_client.chat.completions.create.return_value = mock_response
 
         result = detect_passive_voice_segments(
             "The ball was thrown.",
             openai_client=self.mock_client
         )
 
-        # Should return empty fragments for all sentences when JSON is invalid
+        # Should return empty fragments for all sentences when response is invalid
         self.assertEqual(len(result), 1)
         sentence, fragments = result[0]
         self.assertEqual(sentence, "The ball was thrown.")
@@ -197,12 +165,9 @@ def test_detect_passive_voice_invalid_json_response(self):
     def test_detect_passive_voice_empty_response(self):
         """Test handling of empty responses."""
         # Mock response with empty content
-        mock_response = Mock()
-        mock_response.output_text = ""
-        mock_response.output = []
-        mock_response.data = []
+        mock_response = self._create_mock_chat_response("")
 
-        self.mock_client.responses.create.return_value = mock_response
+        self.mock_client.chat.completions.create.return_value = mock_response
 
         result = detect_passive_voice_segments(
             "The ball was thrown.",
@@ -215,23 +180,41 @@ def test_detect_passive_voice_empty_response(self):
         self.assertEqual(sentence, "The ball was thrown.")
         self.assertEqual(fragments, [])
 
-    def test_detect_passive_voice_partial_json_response(self):
-        """Test handling of partial JSON in response with extra text."""
-        # Mock response with JSON embedded in extra text
-        mock_response = Mock()
-        mock_response.output_text = 'Here is the analysis: {"results": [{"sentence": "The door was opened.", "fragments": ["was opened"]}]} Hope this helps!'
+    def test_detect_passive_voice_response_with_extra_text(self):
+        """Test handling of response with extra text around the classification."""
+        # Mock response with extra text around the main classification
+        mock_response = self._create_mock_chat_response("The sentence is: passive")
+        
+        self.mock_client.chat.completions.create.return_value = mock_response
+        
+        result = detect_passive_voice_segments(
+            "The door was opened.",
+            openai_client=self.mock_client
+        )
+        
+        # Current implementation requires exact match, so extra text causes it to be treated as active
+        self.assertEqual(len(result), 1)
+        sentence, fragments = result[0]
+        self.assertEqual(sentence, "The door was opened.")
+        self.assertEqual(fragments, [])  # Should be empty due to inexact match
 
-        self.mock_client.responses.create.return_value = mock_response
+    def test_detect_passive_voice_exact_passive_response(self):
+        """Test that exact 'passive' responses are handled correctly."""
+        # Mock response with exact "passive" classification
+        mock_response = self._create_mock_chat_response("passive")
+        
+        self.mock_client.chat.completions.create.return_value = mock_response
 
         result = detect_passive_voice_segments(
             "The door was opened.",
             openai_client=self.mock_client
         )
 
+        # Should return full sentence as fragment for exact "passive" match
         self.assertEqual(len(result), 1)
         sentence, fragments = result[0]
         self.assertEqual(sentence, "The door was opened.")
-        self.assertEqual(fragments, ["was opened"])
+        self.assertEqual(fragments, ["The door was opened."])
 
     def test_detect_passive_voice_short_sentences_filtered(self):
         """Test that sentences with 2 or fewer words are filtered out."""
@@ -242,11 +225,9 @@ def test_detect_passive_voice_short_sentences_filtered(self):
 
     def test_detect_passive_voice_custom_model(self):
         """Test that custom model parameter is passed correctly."""
-        mock_response = self._create_mock_response([
-            {"sentence": "Test sentence here.", "fragments": []}
-        ])
+        mock_response = self._create_mock_chat_response("active")
 
-        self.mock_client.responses.create.return_value = mock_response
+        self.mock_client.chat.completions.create.return_value = mock_response
 
         detect_passive_voice_segments(
             "Test sentence here.",
@@ -255,19 +236,17 @@ def test_detect_passive_voice_custom_model(self):
         )
 
         # Verify the custom model was used
-        call_args = self.mock_client.responses.create.call_args
+        call_args = self.mock_client.chat.completions.create.call_args
         self.assertEqual(call_args[1]['model'], 'gpt-4')
 
     @patch('formfyxer.passive_voice_detection._load_prompt')
     def test_prompt_loading(self, mock_load_prompt):
         """Test that the prompt is loaded correctly."""
         mock_load_prompt.return_value = "Test prompt content"
 
-        mock_response = self._create_mock_response([
-            {"sentence": "Test sentence with more words.", "fragments": []}
-        ])
+        mock_response = self._create_mock_chat_response("active")
 
-        self.mock_client.responses.create.return_value = mock_response
+        self.mock_client.chat.completions.create.return_value = mock_response
 
         detect_passive_voice_segments(
             "Test sentence with more words.",
@@ -278,20 +257,20 @@ def test_prompt_loading(self, mock_load_prompt):
         mock_load_prompt.assert_called_once()
 
         # Verify the loaded prompt was used in the API call
-        call_args = self.mock_client.responses.create.call_args
-        input_items = call_args[1]['input']
-        system_message = input_items[0]
-        self.assertEqual(system_message['content'][0]['text'], "Test prompt content")
+        call_args = self.mock_client.chat.completions.create.call_args
+        messages = call_args[1]['messages']
+        self.assertEqual(len(messages), 1)
+        self.assertIn("Test prompt content", messages[0]['content'])
 
     def test_sentence_splitting(self):
         """Test that text is properly split into sentences."""
-        mock_response = self._create_mock_response([
-            {"sentence": "First sentence here.", "fragments": []},
-            {"sentence": "Second sentence here.", "fragments": []},
-            {"sentence": "Third sentence here!", "fragments": []}
-        ])
+        responses = [
+            self._create_mock_chat_response("active"),
+            self._create_mock_chat_response("active"),
+            self._create_mock_chat_response("active")
+        ]
 
-        self.mock_client.responses.create.return_value = mock_response
+        self.mock_client.chat.completions.create.side_effect = responses
 
         text = "First sentence here. Second sentence here. Third sentence here!"
         result = detect_passive_voice_segments(text, openai_client=self.mock_client)