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

edsl/questions/QuestionRank.py

@@ -8,7 +8,7 @@ from edsl.questions.descriptors import (
     QuestionOptionsDescriptor,
     NumSelectionsDescriptor,
 )
-from edsl.questions.response_validator_abc import ResponseValidatorABC
+from edsl.questions.ResponseValidatorABC import ResponseValidatorABC
 
 
 def create_response_model(

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

@@ -1,3 +1,4 @@
+import logging
 from abc import ABC, abstractmethod
 from typing import Optional, Any, List, TypedDict
 
@@ -6,17 +7,17 @@ from pydantic import BaseModel, Field, field_validator, ValidationError
 from edsl.exceptions.questions import QuestionAnswerValidationError
 from edsl.questions.ExceptionExplainer import ExceptionExplainer
 
-from edsl.questions.data_structures import (
-    RawEdslAnswerDict,
-    EdslAnswerDict,
-)
+
+class BaseResponse(BaseModel):
+    answer: Any
+    comment: Optional[str] = None
+    generated_tokens: Optional[str] = None
 
 
 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:
@@ -51,7 +52,12 @@ class ResponseValidatorABC(ABC):
         if not hasattr(self, "permissive"):
             self.permissive = False
 
-        self.fixes_tried = 0  # how many times we've tried to fix the answer
+        self.fixes_tried = 0
+
+    class RawEdslAnswerDict(TypedDict):
+        answer: Any
+        comment: Optional[str]
+        generated_tokens: Optional[str]
 
     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.
@@ -83,6 +89,11 @@ 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,
@@ -125,6 +136,7 @@ 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/{response_validator_factory.py → ResponseValidatorFactory.py}

@@ -1,10 +1,4 @@
-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
 
@@ -16,7 +10,7 @@ class ResponseValidatorFactory:
             return self.question.create_response_model()
 
     @property
-    def response_validator(self) -> "ResponseValidatorABC":
+    def response_validator(self) -> "ResponseValidatorBase":
         """Return the response validator."""
         params = (
             {

edsl/questions/SimpleAskMixin.py

@@ -66,7 +66,7 @@ class SimpleAskMixin:
         system_prompt="You are a helpful agent pretending to be a human. Do not break character",
         top_logprobs=4,
     ):
-        from edsl.language_models.model import Model
+        from edsl.language_models.registry import Model
 
         if model is None:
             model = Model()

edsl/questions/__init__.py

@@ -1,6 +1,6 @@
 # Schemas
 from edsl.questions.settings import Settings
-from edsl.questions.register_questions_meta import RegisterQuestionsMeta
+from edsl.questions.RegisterQuestionsMeta import RegisterQuestionsMeta
 
 # Base Class
 from edsl.questions.QuestionBase import QuestionBase

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,44 +164,79 @@ class DatasetExportMixin:
             remove_prefix=remove_prefix, pretty_labels=pretty_labels
         )
 
-    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()
+    def to_jsonl(self, filename: Optional[str] = None) -> "FileStore":
+        """Export the results to a FileStore instance containing JSONL data.
 
-    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,
+        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"
+
+        # 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,
         )
-        return exporter.export()
 
     def to_csv(
         self,
         filename: Optional[str] = None,
         remove_prefix: bool = False,
         pretty_labels: Optional[dict] = None,
-    ) -> 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,
+    ) -> "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,
         )
-        return exporter.export()
 
     def to_excel(
         self,
@@ -209,16 +244,60 @@ class DatasetExportMixin:
         remove_prefix: bool = False,
         pretty_labels: Optional[dict] = None,
         sheet_name: Optional[str] = None,
-    ) -> 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,
+    ) -> "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,
         )
-        return exporter.export()
 
     def _db(self, remove_prefix: bool = True):
         """Create a SQLite database in memory and return the connection.
@@ -319,26 +398,6 @@ 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,112 +444,6 @@ 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

edsl/results/Results.py

@@ -9,8 +9,6 @@ import random
 from collections import UserList, defaultdict
 from typing import Optional, Callable, Any, Type, Union, List, TYPE_CHECKING
 
-from bisect import bisect_left
-
 from edsl.Base import Base
 from edsl.exceptions.results import (
     ResultsError,
@@ -26,7 +24,7 @@ if TYPE_CHECKING:
     from edsl.surveys.Survey import Survey
     from edsl.data.Cache import Cache
     from edsl.agents.AgentList import AgentList
-    from edsl.language_models.model import Model
+    from edsl.language_models.registry import Model
     from edsl.scenarios.ScenarioList import ScenarioList
     from edsl.results.Result import Result
     from edsl.jobs.tasks.TaskHistory import TaskHistory
@@ -35,7 +33,7 @@ if TYPE_CHECKING:
 
 from edsl.results.ResultsExportMixin import ResultsExportMixin
 from edsl.results.ResultsGGMixin import ResultsGGMixin
-from edsl.results.results_fetch_mixin import ResultsFetchMixin
+from edsl.results.ResultsFetchMixin import ResultsFetchMixin
 from edsl.utilities.remove_edsl_version import remove_edsl_version
 
 
@@ -138,33 +136,7 @@ class Results(UserList, Mixins, Base):
         }
         return d
 
-    def insert(self, item):
-        item_order = getattr(item, "order", None)
-        if item_order is not None:
-            # Get list of orders, putting None at the end
-            orders = [getattr(x, "order", None) for x in self]
-            # Filter to just the non-None orders for bisect
-            sorted_orders = [x for x in orders if x is not None]
-            if sorted_orders:
-                index = bisect_left(sorted_orders, item_order)
-                # Account for any None values before this position
-                index += orders[:index].count(None)
-            else:
-                # If no sorted items yet, insert before any unordered items
-                index = 0
-            self.data.insert(index, item)
-        else:
-            # No order - append to end
-            self.data.append(item)
-
-    def append(self, item):
-        self.insert(item)
-
-    def extend(self, other):
-        for item in other:
-            self.insert(item)
-
-    def compute_job_cost(self, include_cached_responses_in_cost: bool = False) -> float:
+    def compute_job_cost(self, include_cached_responses_in_cost=False) -> float:
         """
         Computes the cost of a completed job in USD.
         """
@@ -278,6 +250,24 @@ class Results(UserList, Mixins, Base):
 
         raise TypeError("Invalid argument type")
 
+    # def _update_results(self) -> None:
+    #     from edsl import Agent, Scenario
+    #     from edsl.language_models import LanguageModel
+    #     from edsl.results import Result
+
+    #     if self._job_uuid and len(self.data) < self._total_results:
+    #         results = [
+    #             Result(
+    #                 agent=Agent.from_dict(json.loads(r.agent)),
+    #                 scenario=Scenario.from_dict(json.loads(r.scenario)),
+    #                 model=LanguageModel.from_dict(json.loads(r.model)),
+    #                 iteration=1,
+    #                 answer=json.loads(r.answer),
+    #             )
+    #             for r in CRUD.read_results(self._job_uuid)
+    #         ]
+    #         self.data = results
+
     def __add__(self, other: Results) -> Results:
         """Add two Results objects together.
         They must have the same survey and created columns.
@@ -305,10 +295,13 @@ class Results(UserList, Mixins, Base):
         )
 
     def __repr__(self) -> str:
+        # import reprlib
+
         return f"Results(data = {self.data}, survey = {repr(self.survey)}, created_columns = {self.created_columns})"
 
     def table(
         self,
+        # selector_string: Optional[str] = "*.*",
         *fields,
         tablefmt: Optional[str] = None,
         pretty_labels: Optional[dict] = None,
@@ -347,11 +340,11 @@ class Results(UserList, Mixins, Base):
 
     def to_dict(
         self,
-        sort: bool = False,
-        add_edsl_version: bool = False,
-        include_cache: bool = False,
-        include_task_history: bool = False,
-        include_cache_info: bool = True,
+        sort=False,
+        add_edsl_version=False,
+        include_cache=False,
+        include_task_history=False,
+        include_cache_info=True,
     ) -> dict[str, Any]:
         from edsl.data.Cache import Cache
 
@@ -393,7 +386,7 @@ class Results(UserList, Mixins, Base):
 
         return d
 
-    def compare(self, other_results: Results) -> dict:
+    def compare(self, other_results):
         """
         Compare two Results objects and return the differences.
         """
@@ -411,7 +404,7 @@ class Results(UserList, Mixins, Base):
         }
 
     @property
-    def has_unfixed_exceptions(self) -> bool:
+    def has_unfixed_exceptions(self):
         return self.task_history.has_unfixed_exceptions
 
     def __hash__(self) -> int:
@@ -494,6 +487,10 @@ class Results(UserList, Mixins, Base):
             raise ResultsDeserializationError(f"Error in Results.from_dict: {e}")
         return results
 
+    ######################
+    ## Convenience methods
+    ## & Report methods
+    ######################
     @property
     def _key_to_data_type(self) -> dict[str, str]:
         """
@@ -692,19 +689,13 @@ class Results(UserList, Mixins, Base):
         """
         return self.data[0]
 
-    def answer_truncate(
-        self, column: str, top_n: int = 5, new_var_name: str = None
-    ) -> Results:
+    def answer_truncate(self, column: str, top_n=5, new_var_name=None) -> Results:
         """Create a new variable that truncates the answers to the top_n.
 
         :param column: The column to truncate.
         :param top_n: The number of top answers to keep.
         :param new_var_name: The name of the new variable. If None, it is the original name + '_truncated'.
 
-        Example:
-        >>> r = Results.example()
-        >>> r.answer_truncate('how_feeling', top_n = 2).select('how_feeling', 'how_feeling_truncated')
-        Dataset([{'answer.how_feeling': ['OK', 'Great', 'Terrible', 'OK']}, {'answer.how_feeling_truncated': ['Other', 'Other', 'Other', 'Other']}])
 
 
         """
@@ -925,7 +916,7 @@ class Results(UserList, Mixins, Base):
         n: Optional[int] = None,
         frac: Optional[float] = None,
         with_replacement: bool = True,
-        seed: Optional[str] = None,
+        seed: Optional[str] = "edsl",
     ) -> Results:
         """Sample the results.
 
@@ -940,7 +931,7 @@ class Results(UserList, Mixins, Base):
         >>> len(r.sample(2))
         2
         """
-        if seed:
+        if seed != "edsl":
             random.seed(seed)
 
         if n is None and frac is None:
@@ -978,7 +969,7 @@ class Results(UserList, Mixins, Base):
         Dataset([{'answer.how_feeling_yesterday': ['Great', 'Good', 'OK', 'Terrible']}])
         """
 
-        from edsl.results.results_selector import Selector
+        from edsl.results.Selector import Selector
 
         if len(self) == 0:
             raise Exception("No data to select from---the Results object is empty.")
@@ -993,7 +984,6 @@ class Results(UserList, Mixins, Base):
         return selector.select(*columns)
 
     def sort_by(self, *columns: str, reverse: bool = False) -> Results:
-        """Sort the results by one or more columns."""
         import warnings
 
         warnings.warn(
@@ -1002,7 +992,6 @@ class Results(UserList, Mixins, Base):
         return self.order_by(*columns, reverse=reverse)
 
     def _parse_column(self, column: str) -> tuple[str, str]:
-        """Parse a column name into a data type and key."""
         if "." in column:
             return column.split(".")
         return self._key_to_data_type[column], column