edsl 0.1.39.dev2__py3-none-any.whl → 0.1.39.dev4__py3-none-any.whl

edsl/questions/{QuestionBaseGenMixin.py → question_base_gen_mixin.py}

@@ -1,11 +1,16 @@
 from __future__ import annotations
 import copy
 import itertools
-from typing import Optional, List, Callable, Type
-from typing import TypeVar
+from typing import Optional, List, Callable, Type, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from edsl.questions.QuestionBase import QuestionBase
+    from edsl.scenarios.ScenarioList import ScenarioList
 
 
 class QuestionBaseGenMixin:
+    """Mixin for QuestionBase."""
+
     def copy(self) -> QuestionBase:
         """Return a deep copy of the question.
 
@@ -39,6 +44,31 @@ class QuestionBaseGenMixin:
             questions.append(question)
         return questions
 
+    def draw(self) -> "QuestionBase":
+        """Return a new question with a randomly selected permutation of the options.
+
+        If the question has no options, returns a copy of the original question.
+
+        >>> from edsl.questions.QuestionMultipleChoice import QuestionMultipleChoice as Q
+        >>> q = Q.example()
+        >>> drawn = q.draw()
+        >>> len(drawn.question_options) == len(q.question_options)
+        True
+        >>> q is drawn
+        False
+        """
+
+        if not hasattr(self, "question_options"):
+            return copy.deepcopy(self)
+
+        import random
+
+        question = copy.deepcopy(self)
+        question.question_options = list(
+            random.sample(self.question_options, len(self.question_options))
+        )
+        return question
+
     def loop(self, scenario_list: ScenarioList) -> List[QuestionBase]:
         """Return a list of questions with the question name modified for each scenario.
 
@@ -50,57 +80,22 @@ class QuestionBaseGenMixin:
         >>> len(q.loop(ScenarioList.from_list("subject", ["Math", "Economics", "Chemistry"])))
         3
         """
-        from edsl.questions.LoopProcessor import LoopProcessor
+        from edsl.questions.loop_processor import LoopProcessor
 
         lp = LoopProcessor(self)
         return lp.process_templates(scenario_list)
 
-        # from jinja2 import Environment
-        # from edsl.questions.QuestionBase import QuestionBase
-
-        # starting_name = self.question_name
-        # questions = []
-        # for index, scenario in enumerate(scenario_list):
-        #     env = Environment()
-        #     new_data = self.to_dict().copy()
-        #     for key, value in [(k, v) for k, v in new_data.items() if v is not None]:
-        #         if (
-        #             isinstance(value, str) or isinstance(value, int)
-        #         ) and key != "question_options":
-        #             new_data[key] = env.from_string(value).render(scenario)
-        #         elif isinstance(value, list):
-        #             new_data[key] = [
-        #                 env.from_string(v).render(scenario) if isinstance(v, str) else v
-        #                 for v in value
-        #             ]
-        #         elif isinstance(value, dict):
-        #             new_data[key] = {
-        #                 (
-        #                     env.from_string(k).render(scenario)
-        #                     if isinstance(k, str)
-        #                     else k
-        #                 ): (
-        #                     env.from_string(v).render(scenario)
-        #                     if isinstance(v, str)
-        #                     else v
-        #                 )
-        #                 for k, v in value.items()
-        #             }
-        #         elif key == "question_options" and isinstance(value, str):
-        #             new_data[key] = value
-        #         else:
-        #             raise ValueError(
-        #                 f"Unexpected value type: {type(value)} for key '{key}'"
-        #             )
-
-        #     if new_data["question_name"] == starting_name:
-        #         new_data["question_name"] = new_data["question_name"] + f"_{index}"
-
-        #     questions.append(QuestionBase.from_dict(new_data))
-        # return questions
-
     def render(self, replacement_dict: dict) -> "QuestionBase":
-        """Render the question components as jinja2 templates with the replacement dictionary."""
+        """Render the question components as jinja2 templates with the replacement dictionary.
+
+        :param replacement_dict: The dictionary of values to replace in the question components.
+
+        >>> from edsl.questions.QuestionFreeText import QuestionFreeText
+        >>> q = QuestionFreeText(question_name = "color", question_text = "What is your favorite {{ thing }}?")
+        >>> q.render({"thing": "color"})
+        Question('free_text', question_name = \"""color\""", question_text = \"""What is your favorite color?\""")
+
+        """
         from jinja2 import Environment
         from edsl.scenarios.Scenario import Scenario
 
@@ -127,15 +122,23 @@ class QuestionBaseGenMixin:
 
         return self.apply_function(render_string)
 
-    def apply_function(self, func: Callable, exclude_components=None) -> QuestionBase:
+    def apply_function(
+        self, func: Callable, exclude_components: List[str] = None
+    ) -> QuestionBase:
         """Apply a function to the question parts
 
+        :param func: The function to apply to the question parts.
+        :param exclude_components: The components to exclude from the function application.
+
         >>> from edsl.questions import QuestionFreeText
         >>> q = QuestionFreeText(question_name = "color", question_text = "What is your favorite color?")
         >>> shouting = lambda x: x.upper()
         >>> q.apply_function(shouting)
         Question('free_text', question_name = \"""color\""", question_text = \"""WHAT IS YOUR FAVORITE COLOR?\""")
 
+        >>> q.apply_function(shouting, exclude_components = ["question_type"])
+        Question('free_text', question_name = \"""COLOR\""", question_text = \"""WHAT IS YOUR FAVORITE COLOR?\""")
+
         """
         from edsl.questions.QuestionBase import QuestionBase
 

edsl/questions/{ResponseValidatorABC.py → response_validator_abc.py}

@@ -1,4 +1,3 @@
-import logging
 from abc import ABC, abstractmethod
 from typing import Optional, Any, List, TypedDict
 
@@ -7,17 +6,17 @@ from pydantic import BaseModel, Field, field_validator, ValidationError
 from edsl.exceptions.questions import QuestionAnswerValidationError
 from edsl.questions.ExceptionExplainer import ExceptionExplainer
 
-
-class BaseResponse(BaseModel):
-    answer: Any
-    comment: Optional[str] = None
-    generated_tokens: Optional[str] = None
+from edsl.questions.data_structures import (
+    RawEdslAnswerDict,
+    EdslAnswerDict,
+)
 
 
 class ResponseValidatorABC(ABC):
     required_params: List[str] = []
 
     def __init_subclass__(cls, **kwargs):
+        """This is a metaclass that ensures that all subclasses of ResponseValidatorABC have the required class variables."""
         super().__init_subclass__(**kwargs)
         required_class_vars = ["required_params", "valid_examples", "invalid_examples"]
         for var in required_class_vars:
@@ -52,12 +51,7 @@ class ResponseValidatorABC(ABC):
         if not hasattr(self, "permissive"):
             self.permissive = False
 
-        self.fixes_tried = 0
-
-    class RawEdslAnswerDict(TypedDict):
-        answer: Any
-        comment: Optional[str]
-        generated_tokens: Optional[str]
+        self.fixes_tried = 0  # how many times we've tried to fix the answer
 
     def _preprocess(self, data: RawEdslAnswerDict) -> RawEdslAnswerDict:
         """This is for testing purposes. A question can be given an exception to throw or an answer to always return.
@@ -89,11 +83,6 @@ class ResponseValidatorABC(ABC):
     def post_validation_answer_convert(self, data):
         return data
 
-    class EdslAnswerDict(TypedDict):
-        answer: Any
-        comment: Optional[str]
-        generated_tokens: Optional[str]
-
     def validate(
         self,
         raw_edsl_answer_dict: RawEdslAnswerDict,
@@ -136,7 +125,6 @@ class ResponseValidatorABC(ABC):
     def human_explanation(self, e: QuestionAnswerValidationError):
         explanation = ExceptionExplainer(e, model_response=e.data).explain()
         return explanation
-        # return e
 
     def _handle_exception(self, e: Exception, raw_edsl_answer_dict) -> EdslAnswerDict:
         if self.fixes_tried == 0:

edsl/questions/{ResponseValidatorFactory.py → response_validator_factory.py}

@@ -1,4 +1,10 @@
+from edsl.questions.data_structures import BaseModel
+from edsl.questions.response_validator_abc import ResponseValidatorABC
+
+
 class ResponseValidatorFactory:
+    """Factory class to create a response validator for a question."""
+
     def __init__(self, question):
         self.question = question
 
@@ -10,7 +16,7 @@ class ResponseValidatorFactory:
             return self.question.create_response_model()
 
     @property
-    def response_validator(self) -> "ResponseValidatorBase":
+    def response_validator(self) -> "ResponseValidatorABC":
         """Return the response validator."""
         params = (
             {

edsl/results/DatasetExportMixin.py

@@ -1,12 +1,12 @@
 """Mixin class for exporting results."""
 
-import base64
-import csv
 import io
 import warnings
 import textwrap
 from typing import Optional, Tuple, Union, List
 
+from edsl.results.file_exports import CSVExport, ExcelExport, JSONLExport, SQLiteExport
+
 
 class DatasetExportMixin:
     """Mixin class for exporting Dataset objects."""
@@ -164,79 +164,44 @@ class DatasetExportMixin:
             remove_prefix=remove_prefix, pretty_labels=pretty_labels
         )
 
-    def to_jsonl(self, filename: Optional[str] = None) -> "FileStore":
-        """Export the results to a FileStore instance containing JSONL data.
-
-        Args:
-            filename: Optional filename for the JSONL file (defaults to "results.jsonl")
-
-        Returns:
-            FileStore: Instance containing the JSONL data
-        """
-        if filename is None:
-            filename = "results.jsonl"
+    def to_jsonl(self, filename: Optional[str] = None) -> Optional["FileStore"]:
+        """Export the results to a FileStore instance containing JSONL data."""
+        exporter = JSONLExport(data=self, filename=filename)
+        return exporter.export()
 
-        # Write to string buffer
-        output = io.StringIO()
-        for entry in self:
-            key, values = list(entry.items())[0]
-            output.write(f'{{"{key}": {values}}}\n')
-
-        # Get the CSV string and encode to base64
-        jsonl_string = output.getvalue()
-        base64_string = base64.b64encode(jsonl_string.encode()).decode()
-        from edsl.scenarios.FileStore import FileStore
-
-        return FileStore(
-            path=filename,
-            mime_type="application/jsonl",
-            binary=False,
-            suffix="jsonl",
-            base64_string=base64_string,
+    def to_sqlite(
+        self,
+        filename: Optional[str] = None,
+        remove_prefix: bool = False,
+        pretty_labels: Optional[dict] = None,
+        table_name: str = "results",
+        if_exists: str = "replace",
+    ) -> Optional["FileStore"]:
+        """Export the results to a SQLite database file."""
+        exporter = SQLiteExport(
+            data=self,
+            filename=filename,
+            remove_prefix=remove_prefix,
+            pretty_labels=pretty_labels,
+            table_name=table_name,
+            if_exists=if_exists,
         )
+        return exporter.export()
 
     def to_csv(
         self,
         filename: Optional[str] = None,
         remove_prefix: bool = False,
         pretty_labels: Optional[dict] = None,
-    ) -> "FileStore":
-        """Export the results to a FileStore instance containing CSV data.
-
-        Args:
-            filename: Optional filename for the CSV (defaults to "results.csv")
-            remove_prefix: Whether to remove the prefix from column names
-            pretty_labels: Dictionary mapping original column names to pretty labels
-
-        Returns:
-            FileStore: Instance containing the CSV data
-        """
-        if filename is None:
-            filename = "results.csv"
-
-        # Get the tabular data
-        header, rows = self._get_tabular_data(
-            remove_prefix=remove_prefix, pretty_labels=pretty_labels
-        )
-
-        # Write to string buffer
-        output = io.StringIO()
-        writer = csv.writer(output)
-        writer.writerow(header)
-        writer.writerows(rows)
-
-        # Get the CSV string and encode to base64
-        csv_string = output.getvalue()
-        base64_string = base64.b64encode(csv_string.encode()).decode()
-        from edsl.scenarios.FileStore import FileStore
-
-        return FileStore(
-            path=filename,
-            mime_type="text/csv",
-            binary=False,
-            suffix="csv",
-            base64_string=base64_string,
+    ) -> Optional["FileStore"]:
+        """Export the results to a FileStore instance containing CSV data."""
+        exporter = CSVExport(
+            data=self,
+            filename=filename,
+            remove_prefix=remove_prefix,
+            pretty_labels=pretty_labels,
         )
+        return exporter.export()
 
     def to_excel(
         self,
@@ -244,60 +209,16 @@ class DatasetExportMixin:
         remove_prefix: bool = False,
         pretty_labels: Optional[dict] = None,
         sheet_name: Optional[str] = None,
-    ) -> "FileStore":
-        """Export the results to a FileStore instance containing Excel data.
-
-        Args:
-            filename: Optional filename for the Excel file (defaults to "results.xlsx")
-            remove_prefix: Whether to remove the prefix from column names
-            pretty_labels: Dictionary mapping original column names to pretty labels
-            sheet_name: Name of the worksheet (defaults to "Results")
-
-        Returns:
-            FileStore: Instance containing the Excel data
-        """
-        from openpyxl import Workbook
-
-        if filename is None:
-            filename = "results.xlsx"
-        if sheet_name is None:
-            sheet_name = "Results"
-
-        # Get the tabular data
-        header, rows = self._get_tabular_data(
-            remove_prefix=remove_prefix, pretty_labels=pretty_labels
-        )
-
-        # Create Excel workbook in memory
-        wb = Workbook()
-        ws = wb.active
-        ws.title = sheet_name
-
-        # Write header
-        for col, value in enumerate(header, 1):
-            ws.cell(row=1, column=col, value=value)
-
-        # Write data rows
-        for row_idx, row_data in enumerate(rows, 2):
-            for col, value in enumerate(row_data, 1):
-                ws.cell(row=row_idx, column=col, value=value)
-
-        # Save to bytes buffer
-        buffer = io.BytesIO()
-        wb.save(buffer)
-        buffer.seek(0)
-
-        # Convert to base64
-        base64_string = base64.b64encode(buffer.getvalue()).decode()
-        from edsl.scenarios.FileStore import FileStore
-
-        return FileStore(
-            path=filename,
-            mime_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-            binary=True,
-            suffix="xlsx",
-            base64_string=base64_string,
+    ) -> Optional["FileStore"]:
+        """Export the results to a FileStore instance containing Excel data."""
+        exporter = ExcelExport(
+            data=self,
+            filename=filename,
+            remove_prefix=remove_prefix,
+            pretty_labels=pretty_labels,
+            sheet_name=sheet_name,
         )
+        return exporter.export()
 
     def _db(self, remove_prefix: bool = True):
         """Create a SQLite database in memory and return the connection.
@@ -398,6 +319,26 @@ class DatasetExportMixin:
         # df_sorted = df.sort_index(axis=1)  # Sort columns alphabetically
         return df
 
+    def to_polars(
+        self, remove_prefix: bool = False, lists_as_strings=False
+    ) -> "pl.DataFrame":
+        """Convert the results to a Polars DataFrame.
+
+        :param remove_prefix: Whether to remove the prefix from the column names.
+        """
+        return self._to_polars_strings(remove_prefix)
+
+    def _to_polars_strings(self, remove_prefix: bool = False) -> "pl.DataFrame":
+        """Convert the results to a Polars DataFrame.
+
+        :param remove_prefix: Whether to remove the prefix from the column names.
+        """
+        import polars as pl
+
+        csv_string = self.to_csv(remove_prefix=remove_prefix).text
+        df = pl.read_csv(io.StringIO(csv_string))
+        return df
+
     def to_scenario_list(self, remove_prefix: bool = True) -> list[dict]:
         """Convert the results to a list of dictionaries, one per scenario.
 

edsl/results/Result.py

@@ -173,9 +173,9 @@ class Result(Base, UserDict):
             if question_name in self.question_to_attributes:
                 for dictionary_name in sub_dicts_needing_new_keys:
                     new_key = question_name + "_" + dictionary_name
-                    sub_dicts_needing_new_keys[dictionary_name][
-                        new_key
-                    ] = self.question_to_attributes[question_name][dictionary_name]
+                    sub_dicts_needing_new_keys[dictionary_name][new_key] = (
+                        self.question_to_attributes[question_name][dictionary_name]
+                    )
 
         new_cache_dict = {
             f"{k}_cache_used": v for k, v in self.data["cache_used_dict"].items()
@@ -444,6 +444,112 @@ class Result(Base, UserDict):
                 raise ValueError(f"Parameter {k} not found in Result object")
         return scoring_function(**params)
 
+    @classmethod
+    def from_interview(
+        cls, interview, extracted_answers, model_response_objects
+    ) -> Result:
+        """Return a Result object from an interview dictionary."""
+
+        def get_question_results(
+            model_response_objects,
+        ) -> dict[str, "EDSLResultObjectInput"]:
+            """Maps the question name to the EDSLResultObjectInput."""
+            question_results = {}
+            for result in model_response_objects:
+                question_results[result.question_name] = result
+            return question_results
+
+        def get_generated_tokens_dict(answer_key_names) -> dict[str, str]:
+            generated_tokens_dict = {
+                k + "_generated_tokens": question_results[k].generated_tokens
+                for k in answer_key_names
+            }
+            return generated_tokens_dict
+
+        def get_comments_dict(answer_key_names) -> dict[str, str]:
+            comments_dict = {
+                k + "_comment": question_results[k].comment for k in answer_key_names
+            }
+            return comments_dict
+
+        def get_question_name_to_prompts(
+            model_response_objects,
+        ) -> dict[str, dict[str, str]]:
+            question_name_to_prompts = dict({})
+            for result in model_response_objects:
+                question_name = result.question_name
+                question_name_to_prompts[question_name] = {
+                    "user_prompt": result.prompts["user_prompt"],
+                    "system_prompt": result.prompts["system_prompt"],
+                }
+            return question_name_to_prompts
+
+        def get_prompt_dictionary(answer_key_names, question_name_to_prompts):
+            prompt_dictionary = {}
+            for answer_key_name in answer_key_names:
+                prompt_dictionary[answer_key_name + "_user_prompt"] = (
+                    question_name_to_prompts[answer_key_name]["user_prompt"]
+                )
+                prompt_dictionary[answer_key_name + "_system_prompt"] = (
+                    question_name_to_prompts[answer_key_name]["system_prompt"]
+                )
+            return prompt_dictionary
+
+        def get_raw_model_results_and_cache_used_dictionary(model_response_objects):
+            raw_model_results_dictionary = {}
+            cache_used_dictionary = {}
+            for result in model_response_objects:
+                question_name = result.question_name
+                raw_model_results_dictionary[question_name + "_raw_model_response"] = (
+                    result.raw_model_response
+                )
+                raw_model_results_dictionary[question_name + "_cost"] = result.cost
+                one_use_buys = (
+                    "NA"
+                    if isinstance(result.cost, str)
+                    or result.cost == 0
+                    or result.cost is None
+                    else 1.0 / result.cost
+                )
+                raw_model_results_dictionary[question_name + "_one_usd_buys"] = (
+                    one_use_buys
+                )
+                cache_used_dictionary[question_name] = result.cache_used
+
+            return raw_model_results_dictionary, cache_used_dictionary
+
+        question_results = get_question_results(model_response_objects)
+        answer_key_names = list(question_results.keys())
+        generated_tokens_dict = get_generated_tokens_dict(answer_key_names)
+        comments_dict = get_comments_dict(answer_key_names)
+        answer_dict = {k: extracted_answers[k] for k in answer_key_names}
+
+        question_name_to_prompts = get_question_name_to_prompts(model_response_objects)
+        prompt_dictionary = get_prompt_dictionary(
+            answer_key_names, question_name_to_prompts
+        )
+        raw_model_results_dictionary, cache_used_dictionary = (
+            get_raw_model_results_and_cache_used_dictionary(model_response_objects)
+        )
+
+        result = cls(
+            agent=interview.agent,
+            scenario=interview.scenario,
+            model=interview.model,
+            iteration=interview.iteration,
+            # Computed objects
+            answer=answer_dict,
+            prompt=prompt_dictionary,
+            raw_model_response=raw_model_results_dictionary,
+            survey=interview.survey,
+            generated_tokens=generated_tokens_dict,
+            comments_dict=comments_dict,
+            cache_used_dict=cache_used_dictionary,
+            indices=interview.indices,
+        )
+        result.interview_hash = interview.initial_hash
+        return result
+
 
 if __name__ == "__main__":
     import doctest