edsl 0.1.59__py3-none-any.whl → 0.1.60__py3-none-any.whl

edsl/__version__.py

@@ -1 +1 @@
-__version__ = "0.1.59"
+__version__ = "0.1.60"

edsl/base/data_transfer_models.py

@@ -17,6 +17,7 @@ class EDSLOutput(NamedTuple):
     answer: Any
     generated_tokens: str
     comment: Optional[str] = None
+    reasoning_summary: Optional[Any] = None
 
 
 class ModelResponse(NamedTuple):
@@ -49,6 +50,7 @@ class EDSLResultObjectInput(NamedTuple):
     cache_key: str
     answer: Any
     comment: str
+    reasoning_summary: Optional[Any] = None
     validated: bool = False
     exception_occurred: Exception = None
     input_tokens: Optional[int] = None
@@ -96,12 +98,15 @@ class Answers(UserDict):
         answer = response.answer
         comment = response.comment
         generated_tokens = response.generated_tokens
+        reasoning_summary = response.reasoning_summary
         # record the answer
         if generated_tokens:
             self[question.question_name + "_generated_tokens"] = generated_tokens
         self[question.question_name] = answer
         if comment:
             self[question.question_name + "_comment"] = comment
+        if reasoning_summary:
+            self[question.question_name + "_reasoning_summary"] = reasoning_summary
 
     def replace_missing_answers_with_none(self, survey: "Survey") -> None:
         """Replace missing answers with None. Answers can be missing if the agent skips a question."""

edsl/base/enums.py

@@ -57,6 +57,7 @@ class InferenceServiceType(EnumWithChecks):
     DEEP_INFRA = "deep_infra"
     REPLICATE = "replicate"
     OPENAI = "openai"
+    OPENAI_V2 = "openai_v2"
     GOOGLE = "google"
     TEST = "test"
     ANTHROPIC = "anthropic"
@@ -77,6 +78,7 @@ InferenceServiceLiteral = Literal[
     "deep_infra",
     "replicate",
     "openai",
+    "openai_v2",
     "google",
     "test",
     "anthropic",
@@ -93,6 +95,7 @@ InferenceServiceLiteral = Literal[
 available_models_urls = {
     "anthropic": "https://docs.anthropic.com/en/docs/about-claude/models",
     "openai": "https://platform.openai.com/docs/models/gp",
+    "openai_v2": "https://platform.openai.com/docs/models/gp",
     "groq": "https://console.groq.com/docs/models",
     "google": "https://cloud.google.com/vertex-ai/generative-ai/docs/learn/models",
 }
@@ -102,6 +105,7 @@ service_to_api_keyname = {
     InferenceServiceType.DEEP_INFRA.value: "DEEP_INFRA_API_KEY",
     InferenceServiceType.REPLICATE.value: "TBD",
     InferenceServiceType.OPENAI.value: "OPENAI_API_KEY",
+    InferenceServiceType.OPENAI_V2.value: "OPENAI_API_KEY",
     InferenceServiceType.GOOGLE.value: "GOOGLE_API_KEY",
     InferenceServiceType.TEST.value: "TBD",
     InferenceServiceType.ANTHROPIC.value: "ANTHROPIC_API_KEY",
@@ -135,7 +139,7 @@ class TokenPricing:
             and self.prompt_token_price == other.prompt_token_price
             and self.completion_token_price == other.completion_token_price
         )
-    
+
     @classmethod
     def example(cls) -> "TokenPricing":
         """Return an example TokenPricing object."""
@@ -145,6 +149,7 @@ class TokenPricing:
             completion_token_price_per_k=0.03,
         )
 
+
 pricing = {
     "dbrx-instruct": TokenPricing(
         model_name="dbrx-instruct",
@@ -212,4 +217,4 @@ def get_token_pricing(model_name):
             model_name=model_name,
             prompt_token_price_per_k=0.0,
             completion_token_price_per_k=0.0,
-        )
+        )

edsl/dataset/dataset_operations_mixin.py

@@ -357,7 +357,7 @@ class DataOperationsBase:
             4
             >>> engine = Results.example()._db(shape = "long")
             >>> len(engine.execute(text("SELECT * FROM self")).fetchall())
-            204
+            212
         """
         # Import needed for database connection
         from sqlalchemy import create_engine
@@ -442,7 +442,7 @@ class DataOperationsBase:
 
             # Using long format
             >>> len(r.sql("SELECT * FROM self", shape="long"))
-            204
+            212
         """
         import pandas as pd
 

edsl/inference_services/services/__init__.py

@@ -8,6 +8,7 @@ from .groq_service import GroqService
 from .mistral_ai_service import MistralAIService
 from .ollama_service import OllamaService
 from .open_ai_service import OpenAIService
+from .open_ai_service_v2 import OpenAIServiceV2
 from .perplexity_service import PerplexityService
 from .test_service import TestService
 from .together_ai_service import TogetherAIService
@@ -24,8 +25,9 @@ __all__ = [
     "MistralAIService",
     "OllamaService",
     "OpenAIService",
+    "OpenAIServiceV2",
     "PerplexityService",
     "TestService",
     "TogetherAIService",
     "XAIService",
-] 
+]

edsl/inference_services/services/open_ai_service_v2.py

@@ -0,0 +1,243 @@
+from __future__ import annotations
+from typing import Any, List, Optional, Dict, NewType, TYPE_CHECKING
+import os
+
+import openai
+
+from ..inference_service_abc import InferenceServiceABC
+
+# Use TYPE_CHECKING to avoid circular imports at runtime
+if TYPE_CHECKING:
+    from ...language_models import LanguageModel
+from ..rate_limits_cache import rate_limits
+
+# Default to completions API but can use responses API with parameter
+
+if TYPE_CHECKING:
+    from ....scenarios.file_store import FileStore as Files
+    from ....invigilators.invigilator_base import InvigilatorBase as InvigilatorAI
+
+
+APIToken = NewType("APIToken", str)
+
+
+class OpenAIServiceV2(InferenceServiceABC):
+    """OpenAI service class using the Responses API."""
+
+    _inference_service_ = "openai_v2"
+    _env_key_name_ = "OPENAI_API_KEY"
+    _base_url_ = None
+
+    _sync_client_ = openai.OpenAI
+    _async_client_ = openai.AsyncOpenAI
+
+    _sync_client_instances: Dict[APIToken, openai.OpenAI] = {}
+    _async_client_instances: Dict[APIToken, openai.AsyncOpenAI] = {}
+
+    # sequence to extract text from response.output
+    key_sequence = ["output", 1, "content", 0, "text"]
+    usage_sequence = ["usage"]
+    # sequence to extract reasoning summary from response.output
+    reasoning_sequence = ["output", 0, "summary"]
+    input_token_name = "prompt_tokens"
+    output_token_name = "completion_tokens"
+
+    available_models_url = "https://platform.openai.com/docs/models/gp"
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        cls._sync_client_instances = {}
+        cls._async_client_instances = {}
+
+    @classmethod
+    def sync_client(cls, api_key: str) -> openai.OpenAI:
+        if api_key not in cls._sync_client_instances:
+            client = cls._sync_client_(
+                api_key=api_key,
+                base_url=cls._base_url_,
+            )
+            cls._sync_client_instances[api_key] = client
+        return cls._sync_client_instances[api_key]
+
+    @classmethod
+    def async_client(cls, api_key: str) -> openai.AsyncOpenAI:
+        if api_key not in cls._async_client_instances:
+            client = cls._async_client_(
+                api_key=api_key,
+                base_url=cls._base_url_,
+            )
+            cls._async_client_instances[api_key] = client
+        return cls._async_client_instances[api_key]
+
+    model_exclude_list = [
+        "whisper-1",
+        "davinci-002",
+        "dall-e-2",
+        "tts-1-hd-1106",
+        "tts-1-hd",
+        "dall-e-3",
+        "tts-1",
+        "babbage-002",
+        "tts-1-1106",
+        "text-embedding-3-large",
+        "text-embedding-3-small",
+        "text-embedding-ada-002",
+        "ft:davinci-002:mit-horton-lab::8OfuHgoo",
+        "gpt-3.5-turbo-instruct-0914",
+        "gpt-3.5-turbo-instruct",
+    ]
+    _models_list_cache: List[str] = []
+
+    @classmethod
+    def get_model_list(cls, api_key: str | None = None) -> List[str]:
+        if api_key is None:
+            api_key = os.getenv(cls._env_key_name_)
+        raw = cls.sync_client(api_key).models.list()
+        return raw.data if hasattr(raw, "data") else raw
+
+    @classmethod
+    def available(cls, api_token: str | None = None) -> List[str]:
+        if api_token is None:
+            api_token = os.getenv(cls._env_key_name_)
+        if not cls._models_list_cache:
+            data = cls.get_model_list(api_key=api_token)
+            cls._models_list_cache = [
+                m.id for m in data if m.id not in cls.model_exclude_list
+            ]
+        return cls._models_list_cache
+
+    @classmethod
+    def create_model(
+        cls,
+        model_name: str,
+        model_class_name: str | None = None,
+    ) -> LanguageModel:
+        if model_class_name is None:
+            model_class_name = cls.to_class_name(model_name)
+
+        from ...language_models import LanguageModel
+
+        class LLM(LanguageModel):
+            """Child class for OpenAI Responses API"""
+
+            key_sequence = cls.key_sequence
+            usage_sequence = cls.usage_sequence
+            reasoning_sequence = cls.reasoning_sequence
+            input_token_name = cls.input_token_name
+            output_token_name = cls.output_token_name
+            _inference_service_ = cls._inference_service_
+            _model_ = model_name
+            _parameters_ = {
+                "temperature": 0.5,
+                "max_tokens": 2000,
+                "top_p": 1,
+                "frequency_penalty": 0,
+                "presence_penalty": 0,
+                "logprobs": False,
+                "top_logprobs": 3,
+            }
+
+            def sync_client(self) -> openai.OpenAI:
+                return cls.sync_client(api_key=self.api_token)
+
+            def async_client(self) -> openai.AsyncOpenAI:
+                return cls.async_client(api_key=self.api_token)
+
+            @classmethod
+            def available(cls) -> list[str]:
+                return cls.sync_client().models.list().data
+
+            def get_headers(self) -> dict[str, Any]:
+                client = self.sync_client()
+                response = client.responses.with_raw_response.create(
+                    model=self.model,
+                    input=[{"role": "user", "content": "Say this is a test"}],
+                    store=False,
+                )
+                return dict(response.headers)
+
+            def get_rate_limits(self) -> dict[str, Any]:
+                try:
+                    headers = rate_limits.get("openai", self.get_headers())
+                except Exception:
+                    return {"rpm": 10000, "tpm": 2000000}
+                return {
+                    "rpm": int(headers["x-ratelimit-limit-requests"]),
+                    "tpm": int(headers["x-ratelimit-limit-tokens"]),
+                }
+
+            async def async_execute_model_call(
+                self,
+                user_prompt: str,
+                system_prompt: str = "",
+                files_list: Optional[List[Files]] = None,
+                invigilator: Optional[InvigilatorAI] = None,
+            ) -> dict[str, Any]:
+                content = user_prompt
+                if files_list:
+                    # embed files as separate inputs
+                    content = [{"type": "text", "text": user_prompt}]
+                    for f in files_list:
+                        content.append(
+                            {
+                                "type": "image_url",
+                                "image_url": {
+                                    "url": f"data:{f.mime_type};base64,{f.base64_string}"
+                                },
+                            }
+                        )
+                # build input sequence
+                messages: Any
+                if system_prompt and not self.omit_system_prompt_if_empty:
+                    messages = [
+                        {"role": "system", "content": system_prompt},
+                        {"role": "user", "content": content},
+                    ]
+                else:
+                    messages = [{"role": "user", "content": content}]
+
+                # All OpenAI models with the responses API use these base parameters
+                params = {
+                    "model": self.model,
+                    "input": messages,
+                    "temperature": self.temperature,
+                    "top_p": self.top_p,
+                    "store": False,
+                }
+                
+                # Check if this is a reasoning model (o-series models)
+                is_reasoning_model = any(tag in self.model for tag in ["o1", "o1-mini", "o3", "o3-mini", "o1-pro", "o4-mini"])
+                
+                # Only add reasoning parameter for reasoning models
+                if is_reasoning_model:
+                    params["reasoning"] = {"summary": "auto"}
+                
+                # For all models using the responses API, use max_output_tokens
+                # instead of max_tokens (which is for the completions API)
+                params["max_output_tokens"] = self.max_tokens
+                
+                # Specifically for o-series, we also set temperature to 1
+                if is_reasoning_model:
+                    params["temperature"] = 1
+
+                client = self.async_client()
+                try:
+                    response = await client.responses.create(**params)
+
+                except Exception as e:
+                    return {"message": str(e)}
+
+                # convert to dict
+                response_dict = response.model_dump()
+                return response_dict
+
+        LLM.__name__ = model_class_name
+        return LLM
+
+    @staticmethod
+    def _create_reasoning_sequence():
+        """Create the reasoning sequence for extracting reasoning summaries from model responses."""
+        # For OpenAI responses, the reasoning summary is typically found at:
+        # ["output", 0, "summary"]
+        # This is the path to the 'summary' field in the first item of the 'output' array
+        return ["output", 0, "summary"]

edsl/jobs/data_structures.py

@@ -213,6 +213,9 @@ class Answers(UserDict):
         if comment:
             self[question.question_name + "_comment"] = comment
 
+        if getattr(response, "reasoning_summary", None):
+            self[question.question_name + "_reasoning_summary"] = response.reasoning_summary
+
     def replace_missing_answers_with_none(self, survey: "Survey") -> None:
         """
         Replace missing answers with None for all questions in the survey.

edsl/key_management/key_lookup_builder.py

@@ -363,13 +363,35 @@ class KeyLookupBuilder:
         >>> builder._add_api_key("OPENAI_API_KEY", "sk-1234", "env")
         >>> 'sk-1234' == builder.key_data["openai"][-1].value
         True
+        >>> 'sk-1234' == builder.key_data["openai_v2"][-1].value
+        True
         """
         service = api_keyname_to_service[key]
         new_entry = APIKeyEntry(service=service, name=key, value=value, source=source)
-        if service not in self.key_data:
-            self.key_data[service] = [new_entry]
+        
+        # Special case for OPENAI_API_KEY - add to both openai and openai_v2
+        if key == "OPENAI_API_KEY":
+            # Add to openai service
+            openai_service = "openai"
+            openai_entry = APIKeyEntry(service=openai_service, name=key, value=value, source=source)
+            if openai_service not in self.key_data:
+                self.key_data[openai_service] = [openai_entry]
+            else:
+                self.key_data[openai_service].append(openai_entry)
+                
+            # Add to openai_v2 service
+            openai_v2_service = "openai_v2"
+            openai_v2_entry = APIKeyEntry(service=openai_v2_service, name=key, value=value, source=source)
+            if openai_v2_service not in self.key_data:
+                self.key_data[openai_v2_service] = [openai_v2_entry]
+            else:
+                self.key_data[openai_v2_service].append(openai_v2_entry)
         else:
-            self.key_data[service].append(new_entry)
+            # Normal case for all other API keys
+            if service not in self.key_data:
+                self.key_data[service] = [new_entry]
+            else:
+                self.key_data[service].append(new_entry)
 
     def update_from_dict(self, d: dict) -> None:
         """

edsl/language_models/language_model.py

@@ -174,7 +174,8 @@ class LanguageModel(
         """
         key_sequence = cls.key_sequence
         usage_sequence = cls.usage_sequence if hasattr(cls, "usage_sequence") else None
-        return RawResponseHandler(key_sequence, usage_sequence)
+        reasoning_sequence = cls.reasoning_sequence if hasattr(cls, "reasoning_sequence") else None
+        return RawResponseHandler(key_sequence, usage_sequence, reasoning_sequence)
 
     def __init__(
         self,

edsl/language_models/raw_response_handler.py

@@ -1,5 +1,5 @@
 import json
-from typing import Optional, Any
+from typing import Optional, Any, List
 from .exceptions import (
     LanguageModelBadResponseError,
     LanguageModelTypeError,
@@ -41,10 +41,13 @@ def _extract_item_from_raw_response(data, sequence):
             current_data = current_data[key]
         except Exception as e:
             path = " -> ".join(map(str, sequence[: i + 1]))
-            if "error" in data:
-                msg = data["error"]
+            
+            # Create a safe error message that won't be None
+            if "error" in data and data["error"] is not None:
+                msg = str(data["error"])
             else:
                 msg = f"Error accessing path: {path}. {str(e)}. Full response is: '{data}'"
+                
             raise LanguageModelBadResponseError(message=msg, response_json=data)
     if isinstance(current_data, str):
         return current_data.strip()
@@ -55,17 +58,127 @@ def _extract_item_from_raw_response(data, sequence):
 class RawResponseHandler:
     """Class to handle raw responses from language models."""
 
-    def __init__(self, key_sequence: list, usage_sequence: Optional[list] = None):
+    def __init__(self, key_sequence: list, usage_sequence: Optional[list] = None, reasoning_sequence: Optional[list] = None):
         self.key_sequence = key_sequence
         self.usage_sequence = usage_sequence
+        self.reasoning_sequence = reasoning_sequence
 
     def get_generated_token_string(self, raw_response):
-        return _extract_item_from_raw_response(raw_response, self.key_sequence)
+        try:
+            return _extract_item_from_raw_response(raw_response, self.key_sequence)
+        except (LanguageModelKeyError, LanguageModelIndexError, LanguageModelTypeError, LanguageModelBadResponseError) as e:
+            # For non-reasoning models or reasoning models with different response formats,
+            # try to extract text directly from common response formats
+            if isinstance(raw_response, dict):
+                # Responses API format for non-reasoning models
+                if 'output' in raw_response and isinstance(raw_response['output'], list):
+                    # Try to get first message content
+                    if len(raw_response['output']) > 0:
+                        item = raw_response['output'][0]
+                        if isinstance(item, dict) and 'content' in item:
+                            if isinstance(item['content'], list) and len(item['content']) > 0:
+                                first_content = item['content'][0]
+                                if isinstance(first_content, dict) and 'text' in first_content:
+                                    return first_content['text']
+                            elif isinstance(item['content'], str):
+                                return item['content']
+                
+                # OpenAI completions format
+                if 'choices' in raw_response and isinstance(raw_response['choices'], list) and len(raw_response['choices']) > 0:
+                    choice = raw_response['choices'][0]
+                    if isinstance(choice, dict):
+                        if 'text' in choice:
+                            return choice['text']
+                        elif 'message' in choice and isinstance(choice['message'], dict) and 'content' in choice['message']:
+                            return choice['message']['content']
+                
+                # Text directly in response
+                if 'text' in raw_response:
+                    return raw_response['text']
+                elif 'content' in raw_response:
+                    return raw_response['content']
+                
+                # Error message - try to return a coherent error for debugging
+                if 'message' in raw_response:
+                    return f"[ERROR: {raw_response['message']}]"
+            
+            # If we get a string directly, return it
+            if isinstance(raw_response, str):
+                return raw_response
+            
+            # As a last resort, convert the whole response to string
+            try:
+                return f"[ERROR: Could not extract text. Raw response: {str(raw_response)}]"
+            except:
+                return "[ERROR: Could not extract text from response]"
 
     def get_usage_dict(self, raw_response):
         if self.usage_sequence is None:
             return {}
-        return _extract_item_from_raw_response(raw_response, self.usage_sequence)
+        try:
+            return _extract_item_from_raw_response(raw_response, self.usage_sequence)
+        except (LanguageModelKeyError, LanguageModelIndexError, LanguageModelTypeError, LanguageModelBadResponseError):
+            # For non-reasoning models, try to extract usage from common response formats
+            if isinstance(raw_response, dict):
+                # Standard OpenAI usage format
+                if 'usage' in raw_response:
+                    return raw_response['usage']
+                
+                # Look for nested usage info
+                if 'choices' in raw_response and len(raw_response['choices']) > 0:
+                    choice = raw_response['choices'][0]
+                    if isinstance(choice, dict) and 'usage' in choice:
+                        return choice['usage']
+            
+            # If no usage info found, return empty dict
+            return {}
+
+    def get_reasoning_summary(self, raw_response):
+        """
+        Extract reasoning summary from the model response.
+        
+        Handles various response structures:
+        1. Standard path extraction using self.reasoning_sequence
+        2. Direct access to output[0]['summary'] for OpenAI responses
+        3. List responses where the first item contains the output structure
+        """
+        if self.reasoning_sequence is None:
+            return None
+            
+        try:
+            # First try the standard extraction path
+            summary_data = _extract_item_from_raw_response(raw_response, self.reasoning_sequence)
+            
+            # If summary_data is a list of dictionaries with 'text' and 'type' fields
+            # (as in OpenAI's response format), combine them into a single string
+            if isinstance(summary_data, list) and all(isinstance(item, dict) and 'text' in item for item in summary_data):
+                return '\n\n'.join(item['text'] for item in summary_data)
+            
+            return summary_data
+        except Exception:
+            # Fallback approaches for different response structures
+            try:
+                # Case 1: Direct dict with 'output' field (common OpenAI format)
+                if isinstance(raw_response, dict) and 'output' in raw_response:
+                    output = raw_response['output']
+                    if isinstance(output, list) and len(output) > 0 and 'summary' in output[0]:
+                        summary_data = output[0]['summary']
+                        if isinstance(summary_data, list) and all(isinstance(item, dict) and 'text' in item for item in summary_data):
+                            return '\n\n'.join(item['text'] for item in summary_data)
+                
+                # Case 2: List where the first item is a dict with 'output' field
+                if isinstance(raw_response, list) and len(raw_response) > 0:
+                    first_item = raw_response[0]
+                    if isinstance(first_item, dict) and 'output' in first_item:
+                        output = first_item['output']
+                        if isinstance(output, list) and len(output) > 0 and 'summary' in output[0]:
+                            summary_data = output[0]['summary']
+                            if isinstance(summary_data, list) and all(isinstance(item, dict) and 'text' in item for item in summary_data):
+                                return '\n\n'.join(item['text'] for item in summary_data)
+            except Exception:
+                pass
+            
+            return None
 
     def parse_response(self, raw_response: dict[str, Any]) -> Any:
         """Parses the API response and returns the response text."""
@@ -73,7 +186,11 @@ class RawResponseHandler:
         from edsl.data_transfer_models import EDSLOutput
 
         generated_token_string = self.get_generated_token_string(raw_response)
+        # Ensure generated_token_string is a string before using string methods
+        if not isinstance(generated_token_string, str):
+            generated_token_string = str(generated_token_string)
         last_newline = generated_token_string.rfind("\n")
+        reasoning_summary = self.get_reasoning_summary(raw_response)
 
         if last_newline == -1:
             # There is no comment
@@ -81,12 +198,14 @@ class RawResponseHandler:
                 "answer": self.convert_answer(generated_token_string),
                 "generated_tokens": generated_token_string,
                 "comment": None,
+                "reasoning_summary": reasoning_summary,
             }
         else:
             edsl_dict = {
                 "answer": self.convert_answer(generated_token_string[:last_newline]),
-                "comment": generated_token_string[last_newline + 1 :].strip(),
+                "comment": generated_token_string[last_newline + 1:].strip(),
                 "generated_tokens": generated_token_string,
+                "reasoning_summary": reasoning_summary,
             }
         return EDSLOutput(**edsl_dict)
 

edsl/results/result.py

@@ -95,6 +95,7 @@ class Result(Base, UserDict):
         question_to_attributes: Optional[dict[QuestionName, Any]] = None,
         generated_tokens: Optional[dict] = None,
         comments_dict: Optional[dict] = None,
+        reasoning_summaries_dict: Optional[dict] = None,
         cache_used_dict: Optional[dict[QuestionName, bool]] = None,
         indices: Optional[dict] = None,
         cache_keys: Optional[dict[QuestionName, str]] = None,
@@ -112,6 +113,7 @@ class Result(Base, UserDict):
         :param question_to_attributes: A dictionary of question attributes.
         :param generated_tokens: A dictionary of generated tokens.
         :param comments_dict: A dictionary of comments.
+        :param reasoning_summaries_dict: A dictionary of reasoning summaries.
         :param cache_used_dict: A dictionary of cache usage.
         :param indices: A dictionary of indices.
 
@@ -130,6 +132,7 @@ class Result(Base, UserDict):
             "question_to_attributes": self.question_to_attributes,
             "generated_tokens": generated_tokens or {},
             "comments_dict": comments_dict or {},
+            "reasoning_summaries_dict": reasoning_summaries_dict or {},
             "cache_used_dict": cache_used_dict or {},
             "cache_keys": cache_keys or {},
         }
@@ -236,6 +239,7 @@ class Result(Base, UserDict):
             "answer": self.data["answer"],
             "prompt": self.data["prompt"],
             "comment": self.data["comments_dict"],
+            "reasoning_summary": self.data["reasoning_summaries_dict"],
             "generated_tokens": self.data["generated_tokens"],
             "raw_model_response": self.data["raw_model_response"],
             "question_text": sub_dicts_needing_new_keys["question_text"],
@@ -497,6 +501,7 @@ class Result(Base, UserDict):
             question_to_attributes=json_dict.get("question_to_attributes", None),
             generated_tokens=json_dict.get("generated_tokens", {}),
             comments_dict=json_dict.get("comments_dict", {}),
+            reasoning_summaries_dict=json_dict.get("reasoning_summaries_dict", {}),
             cache_used_dict=json_dict.get("cache_used_dict", {}),
             cache_keys=json_dict.get("cache_keys", {}),
             indices=json_dict.get("indices", None),
@@ -631,6 +636,36 @@ class Result(Base, UserDict):
             }
             return comments_dict
 
+        def get_reasoning_summaries_dict(answer_key_names) -> dict[str, Any]:
+            reasoning_summaries_dict = {}
+            for k in answer_key_names:
+                reasoning_summary = question_results[k].reasoning_summary
+                
+                # If reasoning summary is None but we have a raw model response, try to extract it
+                if reasoning_summary is None and hasattr(question_results[k], 'raw_model_response'):
+                    try:
+                        # Get the model class to access the reasoning_sequence
+                        model_class = interview.model.__class__ if hasattr(interview, 'model') else None
+                        
+                        if model_class and hasattr(model_class, 'reasoning_sequence'):
+                            from ..language_models.raw_response_handler import RawResponseHandler
+                            
+                            # Create a handler with the model's reasoning sequence
+                            handler = RawResponseHandler(
+                                key_sequence=model_class.key_sequence if hasattr(model_class, 'key_sequence') else None,
+                                usage_sequence=model_class.usage_sequence if hasattr(model_class, 'usage_sequence') else None, 
+                                reasoning_sequence=model_class.reasoning_sequence
+                            )
+                            
+                            # Try to extract the reasoning summary
+                            reasoning_summary = handler.get_reasoning_summary(question_results[k].raw_model_response)
+                    except Exception:
+                        # If extraction fails, keep it as None
+                        pass
+                        
+                reasoning_summaries_dict[k + "_reasoning_summary"] = reasoning_summary
+            return reasoning_summaries_dict
+
         def get_question_name_to_prompts(
             model_response_objects,
         ) -> dict[str, dict[str, str]]:
@@ -705,6 +740,7 @@ class Result(Base, UserDict):
         answer_key_names = list(question_results.keys())
         generated_tokens_dict = get_generated_tokens_dict(answer_key_names) if answer_key_names else {}
         comments_dict = get_comments_dict(answer_key_names) if answer_key_names else {}
+        reasoning_summaries_dict = get_reasoning_summaries_dict(answer_key_names) if answer_key_names else {}
         
         # Get answers that are in the question results
         answer_dict = {}
@@ -735,6 +771,7 @@ class Result(Base, UserDict):
             survey=survey_copy,
             generated_tokens=generated_tokens_dict,
             comments_dict=comments_dict,
+            reasoning_summaries_dict=reasoning_summaries_dict,
             cache_used_dict=cache_used_dictionary,
             indices=indices_copy,
             cache_keys=cache_keys,

edsl/results/results.py

@@ -273,6 +273,7 @@ class Results(MutableSequence, ResultsOperationsMixin, Base):
         "generated_tokens",
         "cache_used",
         "cache_keys",
+        "reasoning_summary",
     ]
 
     @classmethod

{edsl-0.1.59.dist-info → edsl-0.1.60.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: edsl
-Version: 0.1.59
+Version: 0.1.60
 Summary: Create and analyze LLM-based surveys
 Home-page: https://www.expectedparrot.com/
 License: MIT
@@ -43,7 +43,7 @@ Requires-Dist: pydot (>=2.0.0,<3.0.0)
 Requires-Dist: pygments (>=2.17.2,<3.0.0)
 Requires-Dist: pymupdf (>=1.25.5,<2.0.0)
 Requires-Dist: pypdf2 (>=3.0.1,<4.0.0)
-Requires-Dist: pyreadstat (>=1.2.7,<2.0.0)
+Requires-Dist: pyreadstat (==1.2.8)
 Requires-Dist: python-docx (>=1.1.0,<2.0.0)
 Requires-Dist: python-dotenv (>=1.0.0,<2.0.0)
 Requires-Dist: python-pptx (>=1.0.2,<2.0.0)

{edsl-0.1.59.dist-info → edsl-0.1.60.dist-info}/RECORD

@@ -1,6 +1,6 @@
 edsl/__init__.py,sha256=EkpMsEKqKRbN9Qqcn_y8CjX8OjlWFyhxslLrt3SJY0Q,4827
 edsl/__init__original.py,sha256=PzMzANf98PrSleSThXT4anNkeVqZMdw0tfFonzsoiGk,4446
-edsl/__version__.py,sha256=6ejKyHgulDwYDrT6JBlbHrh83UmxgavrhSuOolniIfI,23
+edsl/__version__.py,sha256=SH6dBtwKkjChke7DXHi0Y5HbtzV16-5wAfhv91d_D0A,23
 edsl/agents/__init__.py,sha256=AyhfXjygRHT1Pd9w16lcu5Bu0jnBmMPz86aKP1uRL3Y,93
 edsl/agents/agent.py,sha256=omq3lnEujOObKuDyr0seaTiRL7SbJxMjF6bZXqiTt7c,56296
 edsl/agents/agent_list.py,sha256=k29SMOP2trdYWJs5-tPIfpme97fcnanL1lDhhJK3zfg,24249
@@ -9,8 +9,8 @@ edsl/agents/exceptions.py,sha256=7KMAtAHKqlkVkd_iVZC_mWXQnzDPV0V_n2iXaGAQgzc,566
 edsl/base/__init__.py,sha256=h119NxrAJOV92jnX7ussXNjKFXqzySVGOjMG3G7Zkzc,992
 edsl/base/base_class.py,sha256=bpuKCf6OOl71OlhrInDLC4b8LxFfDnuMVaaEaSp7ECY,48158
 edsl/base/base_exception.py,sha256=gwk4mNoS3TBe6446NiQeSrUrjUqjlB3_fcDFgV90Dms,7644
-edsl/base/data_transfer_models.py,sha256=j_7qQIlP73WxFEPvU6lL4RSN_CV8xihpYAl0OM62dW4,3677
-edsl/base/enums.py,sha256=njo1lEsjB4Xf0loTerks8eWMTP0JResqzd5kZuclS-w,6447
+edsl/base/data_transfer_models.py,sha256=JpEnlgdQ5_URixzZUr7MJuAY4U6obPo0rWfzDl39WNg,3934
+edsl/base/enums.py,sha256=46mqtWjeiL6NTsN8j-zGfY8QNOVXO4sVb1p1MjmD1N4,6613
 edsl/base/exceptions.py,sha256=hEMu40lW1IsuarZiOJAL2sAUwuxsubxfR41J6BK5Ri8,3493
 edsl/base.py,sha256=9Jx5zXfWLtKAm0L7LD_kTF3rSIR-tlEuCEuXDbeqHxI,221
 edsl/buckets/__init__.py,sha256=g3VzxuhrC4wO1i6sljXAcJ_k6MNAu_OH-wAmSfzxBjI,1536
@@ -52,7 +52,7 @@ edsl/coop/utils.py,sha256=DON2ns5nWlUqqvlNVUsdgiPlz-6oEqFVOmjhnOwHQBs,8174
 edsl/data_transfer_models.py,sha256=pPaKsbo9pgNcBB9kX-U2O_dUtNkd0Xm4JNmv26jrbhI,265
 edsl/dataset/__init__.py,sha256=RIzfFIytKJfniKZ0VThMk8Z2fjejx91t9PZBct78xXw,422
 edsl/dataset/dataset.py,sha256=o1icaFSE2ipCj7FDqhXkPb-E42wBzn74hLD7QXg0qaE,42277
-edsl/dataset/dataset_operations_mixin.py,sha256=SDGqQRg0Zdy-VMHDF1z4bChCkZ6t5iT-tP2zydAdyYs,59344
+edsl/dataset/dataset_operations_mixin.py,sha256=k0t4MF_nOIf7McLV6JNLUkGmQNoeDvP5kN0Z_aK9JHA,59344
 edsl/dataset/dataset_tree.py,sha256=mKLQhwo-gxDyJCwCH3gj6Os0Jk2JqfWd_PvUyuWqM6s,14268
 edsl/dataset/display/CSSParameterizer.py,sha256=vI3VTgTihJeCYGfmGp7fOhTitHZ17jrDGbq46Sa2rd8,3677
 edsl/dataset/display/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -81,7 +81,7 @@ edsl/inference_services/models_available_cache.py,sha256=bOvevfRn2HlmBcHalaDkjFL
 edsl/inference_services/rate_limits_cache.py,sha256=HYslviz7mxF9U4CUTPAkoyBsiXjSju-YCp4HHir6e34,1398
 edsl/inference_services/registry.py,sha256=KIs1GpGSrczqukm6QsKe9pPn9LnfSrpT_wVAthU3-HM,307
 edsl/inference_services/service_availability.py,sha256=z4rkonyD51Y-flKoxrpxBZIfOqjNrOXCxWCmA0mlUDU,4176
-edsl/inference_services/services/__init__.py,sha256=y28_A9Sbza0-kWC041ocLTBXsWvPObEFHTIbjFl2nBE,939
+edsl/inference_services/services/__init__.py,sha256=_6F-qINiAj9spBmCRKgQR9tYDEek3x1uzX9CKX-3DLw,1010
 edsl/inference_services/services/anthropic_service.py,sha256=yeSdXbqZ0RxXd2NKOrgXM4V5K2ioV_W1h-qujsPQpRU,4212
 edsl/inference_services/services/aws_bedrock.py,sha256=tijqEp4IgKWeJiqR90T3zkeXaqA0Qat9h5eyhG1qY3M,4285
 edsl/inference_services/services/azure_ai.py,sha256=7tZzyOhvT0eRooO2hccTZNghykth1e05MWlUKZNovpo,9436
@@ -92,6 +92,7 @@ edsl/inference_services/services/groq_service.py,sha256=eSxVbQXzrc6rtgVyMgDOsdG0
 edsl/inference_services/services/mistral_ai_service.py,sha256=tvwIeqhwzT6kPjrUo_lO3QCSBYUGD7jHG010FPp72Z4,3925
 edsl/inference_services/services/ollama_service.py,sha256=quSKlgD0bHG9mO_s9verGePfqQi_rZWovHEQ6dy-Fe0,303
 edsl/inference_services/services/open_ai_service.py,sha256=WFcl9g7Y28hckdiD_bPxRL_yJqz9ukERL3h_znh6b80,8682
+edsl/inference_services/services/open_ai_service_v2.py,sha256=KywwuZKeJA3zmnVU8EQC32xt0ICVPDp2suKpeAPxWAg,9027
 edsl/inference_services/services/perplexity_service.py,sha256=7bt5Mb6Dxkb7UOljNdTBpZuT_8ri4i6Sk_h5g8paKu4,5994
 edsl/inference_services/services/test_service.py,sha256=JUK2bch1uu5XefMhNnuAXCbTqgiMqQRAIN8xYCMNe1E,7394
 edsl/inference_services/services/together_ai_service.py,sha256=biUYs07jsrIHp19O81o0nJCwYdSWudMEXdGtmA1-y60,6151
@@ -127,7 +128,7 @@ edsl/invigilators/question_template_replacements_builder.py,sha256=a_-n0TWE4PLK_
 edsl/jobs/__init__.py,sha256=gBGDlPZiaTkKENGdGYaMKzk0BFf5R1Cv9yk2YMPvIqI,1183
 edsl/jobs/async_interview_runner.py,sha256=rj07EKRu4fjbBkTADn8RAxbMF6m3vZFOG1qtnn0g12U,9532
 edsl/jobs/check_survey_scenario_compatibility.py,sha256=9qD9qi6qjvC-4M3Mq2bSF8F5HMIbWilSVPSJ3wlFqmM,4022
-edsl/jobs/data_structures.py,sha256=i-XXq2zul1K1aOZDZXbPIO8l-0bJLqDL2t7pxITXbks,9869
+edsl/jobs/data_structures.py,sha256=jQPl4KIv4WZ7rJ9bQD2_S14T_oyG7mN9nPiA2eqrYMo,10020
 edsl/jobs/decorators.py,sha256=0Eot9pFPsWmQIJAafNd0f5hdb9RUAFp_hGMmSUTJ_C8,3272
 edsl/jobs/exceptions.py,sha256=5lktTya2VgiBR5Bd977tG2xHdrMjDqhPhQO17O6jIdc,7220
 edsl/jobs/fetch_invigilator.py,sha256=nzXAIulvOvuDpRDEN5TDNmEfikUEwrnS_XCtnYG2uPQ,2795
@@ -146,16 +147,16 @@ edsl/jobs/results_exceptions_handler.py,sha256=VCtnd60xwdFznzGhtXPbxLmyVf3kIjR24
 edsl/key_management/__init__.py,sha256=JiOJ71Ly9aw-tVYbWZu-qRjsW4QETYMQ9IJjsKgW1DQ,1274
 edsl/key_management/exceptions.py,sha256=dDtoDh1UL52BUBrAlCIc_McgtZCAQkUx6onoSz26qeM,2158
 edsl/key_management/key_lookup.py,sha256=HfIntc_i_WWUDoMOLwAHHbNlwC-0HivOyf_djeKiPlo,6080
-edsl/key_management/key_lookup_builder.py,sha256=AlQxXbUYwyJc-3JjLddXBOBPVsYJ-B2grZRAZSIT7P4,14974
+edsl/key_management/key_lookup_builder.py,sha256=s5H_DBGZpMJwaQc1fLh46GYfTpSUOOOsl_gsVCVkkKg,16050
 edsl/key_management/key_lookup_collection.py,sha256=b1STYU4FIqgCtCf90bRZh6IXf8kcoTC8ad8RSHPmw-w,3471
 edsl/key_management/models.py,sha256=z9TimNMnz47mnITM5SlJy2m2sk1aKKtt0ybV89rsaiY,6703
 edsl/language_models/__init__.py,sha256=WtefJs6XOCn5RSz22PgoAi3eTEr1NzGtnnBpDIie2mg,240
 edsl/language_models/exceptions.py,sha256=P9dMA8XfK_qcuXNJZ-Xsb_Ny-12Ldu3fPC133RB40Ek,13728
-edsl/language_models/language_model.py,sha256=gN3qW1NUK4kPl_CfgMKUd8ORdSB0iEZC0miuZDsCQUw,46462
+edsl/language_models/language_model.py,sha256=e1RZLnLin3haLUYqfu5aQ0pLhopqqQuiQjxC2pVTW9E,46582
 edsl/language_models/model.py,sha256=oYZsfgvko_EH4EWT9XZPEgLcs9KA36SGEAKZwYRFjv8,12013
 edsl/language_models/model_list.py,sha256=Eb62xQdrlayqWYyJVgYxheMiNi14e1U9b_12qYzy1ws,4522
 edsl/language_models/price_manager.py,sha256=74XEkoVdQv06w7gMFZmXeeXGW6om4_ISr-qFnmX4lFE,10711
-edsl/language_models/raw_response_handler.py,sha256=i2Ye1WzjYq_2YJ1EKX946dx9m331GilwqC5qymGJlEI,4003
+edsl/language_models/raw_response_handler.py,sha256=WynUO2q986ALb9QJ2IS6erAiDWFy8_Zr2lUAMdGWkaY,10708
 edsl/language_models/registry.py,sha256=io_Cp-7PtLpPuvZs_j8XaMxJiv-zSplbAQdrzPp2pzg,7308
 edsl/language_models/repair.py,sha256=ljm0xc9e1tMdyKc9b-v7ikpYRBh639xJ11SkDzI2vZE,5245
 edsl/language_models/unused/fake_openai_call.py,sha256=dxbL5e4NLF-eTk9IduPyGwLiVCX_-eGCJDaLYPlQTqc,364
@@ -278,8 +279,8 @@ edsl/questions/validation_logger.py,sha256=ru0y2uM3t9Hln2oaq-n-9d4zTKXQIQWiKincG
 edsl/results/__init__.py,sha256=RKbHY0g6s_k42VcdmTOZ2yB_nltiJnnbeQAkUY5WD9o,129
 edsl/results/exceptions.py,sha256=u-TQsazt_qj-G4eJKBnj0UtpnIiw6A2GcCLJ2wTYE_g,6536
 edsl/results/report.py,sha256=oHjMY981Gn8estqvoTk5SPiuEOIM0IR_QPBrRLdk5pM,7481
-edsl/results/result.py,sha256=5cT7ikHDoNASGINRLDRCpMokusz0Plx5iq7LJ9pgK5I,29723
-edsl/results/results.py,sha256=BOy_NfRAWu9Q_JeuMtfG04oQhE7hMuiJ-WAH6_ov6Vk,84973
+edsl/results/result.py,sha256=SZekHBstRMhuvhz20cPaTREY7Rq4tQIF0Nc6tyWWyjE,32160
+edsl/results/results.py,sha256=dd0MvTU0Rg4mLoyryKv8mreVmM1Eu6UPGPDJic16P_E,85002
 edsl/results/results_selector.py,sha256=4_XMS2Fb-3rcXEPUYaBRw52r1i66jttjttqNFe6PRc4,18050
 edsl/scenarios/DocxScenario.py,sha256=ul3nkX826m_T6LFptswqtnH5czP_yxMlLWgbTmFIZI4,482
 edsl/scenarios/PdfExtractor.py,sha256=6nPZ6v9x2RrU42EkqlEcW3MS-WIQpGfwg4--6WvEC8I,1972
@@ -382,8 +383,8 @@ edsl/utilities/restricted_python.py,sha256=248N2p5EWHDSpcK1G-q7DUoJeWy4sB6aO-RV0
 edsl/utilities/template_loader.py,sha256=SCAcnTnxNQ67MNSkmfz7F-S_u2peyGn2j1oRIqi1wfg,870
 edsl/utilities/utilities.py,sha256=irHheAGOnl_6RwI--Hi9StVzvsHcWCqB48PWsWJQYOw,12045
 edsl/utilities/wikipedia.py,sha256=I3Imbz3fzbaoA0ZLDsWUO2YpP_ovvaqtu-yd2Ye1BB0,6933
-edsl-0.1.59.dist-info/LICENSE,sha256=_qszBDs8KHShVYcYzdMz3HNMtH-fKN_p5zjoVAVumFc,1111
-edsl-0.1.59.dist-info/METADATA,sha256=FxWojFvdFs_p5nVxCwWquIeheS8yTHhAwXcGECq2ejg,12082
-edsl-0.1.59.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-edsl-0.1.59.dist-info/entry_points.txt,sha256=JnG7xqMtHaQu9BU-yPATxdyCeA48XJpuclnWCqMfIMU,38
-edsl-0.1.59.dist-info/RECORD,,
+edsl-0.1.60.dist-info/LICENSE,sha256=_qszBDs8KHShVYcYzdMz3HNMtH-fKN_p5zjoVAVumFc,1111
+edsl-0.1.60.dist-info/METADATA,sha256=KodgK6MWkw8_QG3LVrIJFqbcQI3oMUowIfcrvdggkBU,12075
+edsl-0.1.60.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+edsl-0.1.60.dist-info/entry_points.txt,sha256=JnG7xqMtHaQu9BU-yPATxdyCeA48XJpuclnWCqMfIMU,38
+edsl-0.1.60.dist-info/RECORD,,