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

edsl/language_models/LanguageModel.py

@@ -494,12 +494,7 @@ class LanguageModel(
         return table
 
     @classmethod
-    def example(
-        cls,
-        test_model: bool = False,
-        canned_response: str = "Hello world",
-        throw_exception: bool = False,
-    ):
+    def example(cls, test_model: bool = False, canned_response: str = "Hello world"):
         """Return a default instance of the class.
 
         >>> from edsl.language_models import LanguageModel
@@ -524,8 +519,6 @@ class LanguageModel(
             ) -> dict[str, Any]:
                 await asyncio.sleep(0.1)
                 # return {"message": """{"answer": "Hello, world"}"""}
-                if throw_exception:
-                    raise Exception("This is a test error")
                 return {"message": f'{{"answer": "{canned_response}"}}'}
 
             def parse_response(self, raw_response: dict[str, Any]) -> str:

edsl/notebooks/Notebook.py

@@ -1,11 +1,14 @@
 """A Notebook is a utility class that allows you to easily share/pull ipynbs from Coop."""
 
-from __future__ import annotations
 import json
 from typing import Dict, List, Optional
-from uuid import uuid4
+
+
 from edsl.Base import Base
-from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
+from edsl.utilities.decorators import (
+    add_edsl_version,
+    remove_edsl_version,
+)
 
 
 class Notebook(Base):
@@ -189,13 +192,10 @@ class Notebook(Base):
         return table
 
     @classmethod
-    def example(cls, randomize: bool = False) -> Notebook:
+    def example(cls) -> "Notebook":
         """
-        Returns an example Notebook instance.
-
-        :param randomize: If True, adds a random string one of the cells' output.
+        Return an example Notebook.
         """
-        addition = "" if not randomize else str(uuid4())
         cells = [
             {
                 "cell_type": "markdown",
@@ -210,7 +210,7 @@ class Notebook(Base):
                     {
                         "name": "stdout",
                         "output_type": "stream",
-                        "text": f"Hello world!\n{addition}",
+                        "text": "Hello world!\n",
                     }
                 ],
                 "source": 'print("Hello world!")',

edsl/questions/QuestionFreeText.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 import textwrap
 from typing import Any, Optional
-from uuid import uuid4
 from edsl.questions.QuestionBase import QuestionBase
 
 
@@ -66,10 +65,9 @@ class QuestionFreeText(QuestionBase):
         return question_html_content
 
     @classmethod
-    def example(cls, randomize: bool = False) -> QuestionFreeText:
+    def example(cls) -> QuestionFreeText:
         """Return an example instance of a free text question."""
-        addition = "" if not randomize else str(uuid4())
-        return cls(question_name="how_are_you", question_text=f"How are you?{addition}")
+        return cls(question_name="how_are_you", question_text="How are you?")
 
 
 def main():

edsl/questions/QuestionFunctional.py

@@ -4,34 +4,10 @@ import inspect
 from edsl.questions.QuestionBase import QuestionBase
 
 from edsl.utilities.restricted_python import create_restricted_function
-from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
 
 
 class QuestionFunctional(QuestionBase):
-    """A special type of question that is *not* answered by an LLM.
-
-    >>> from edsl import Scenario, Agent
-
-    # Create an instance of QuestionFunctional with the new function
-    >>> question = QuestionFunctional.example()
-
-    # Activate and test the function
-    >>> question.activate()
-    >>> scenario = Scenario({"numbers": [1, 2, 3, 4, 5]})
-    >>> agent = Agent(traits={"multiplier": 10})
-    >>> results = question.by(scenario).by(agent).run()
-    >>> results.select("answer.*").to_list()[0] == 150
-    True
-
-    # Serialize the question to a dictionary
-
-    >>> from edsl.questions.QuestionBase import QuestionBase
-    >>> new_question = QuestionBase.from_dict(question.to_dict())
-    >>> results = new_question.by(scenario).by(agent).run()
-    >>> results.select("answer.*").to_list()[0] == 150
-    True
-
-    """
+    """A special type of question that is *not* answered by an LLM."""
 
     question_type = "functional"
     default_instructions = ""
@@ -97,7 +73,6 @@ class QuestionFunctional(QuestionBase):
         """Required by Question, but not used by QuestionFunctional."""
         raise NotImplementedError
 
-    @add_edsl_version
     def to_dict(self):
         return {
             "question_name": self.question_name,
@@ -138,11 +113,4 @@ def main():
     scenario = Scenario({"numbers": [1, 2, 3, 4, 5]})
     agent = Agent(traits={"multiplier": 10})
     results = question.by(scenario).by(agent).run()
-    assert results.select("answer.*").to_list()[0] == 150
-
-
-if __name__ == "__main__":
-    # main()
-    import doctest
-
-    doctest.testmod(optionflags=doctest.ELLIPSIS)
+    print(results)

edsl/questions/QuestionMultipleChoice.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 import time
 from typing import Union
 import random
-from typing import Optional
+
 from jinja2 import Template
 
 from edsl.questions.QuestionBase import QuestionBase
@@ -10,11 +10,7 @@ from edsl.questions.descriptors import QuestionOptionsDescriptor
 
 
 class QuestionMultipleChoice(QuestionBase):
-    """This question prompts the agent to select one option from a list of options.
-
-    https://docs.expectedparrot.com/en/latest/questions.html#questionmultiplechoice-class
-
-    """
+    """This question prompts the agent to select one option from a list of options."""
 
     question_type = "multiple_choice"
     purpose = "When options are known and limited"
@@ -39,71 +35,27 @@ class QuestionMultipleChoice(QuestionBase):
         self.question_text = question_text
         self.question_options = question_options
 
-    # @property
-    # def question_options(self) -> Union[list[str], list[list], list[float], list[int]]:
-    #     """Return the question options."""
-    #     return self._question_options
-
     ################
     # Answer methods
     ################
     def _validate_answer(
         self, answer: dict[str, Union[str, int]]
     ) -> dict[str, Union[str, int]]:
-        """Validate the answer.
-
-        >>> q = QuestionMultipleChoice.example()
-        >>> q._validate_answer({"answer": 0, "comment": "I like custard"})
-        {'answer': 0, 'comment': 'I like custard'}
-
-        >>> q = QuestionMultipleChoice(question_name="how_feeling", question_text="How are you?", question_options=["Good", "Great", "OK", "Bad"])
-        >>> q._validate_answer({"answer": -1, "comment": "I like custard"})
-        Traceback (most recent call last):
-        ...
-        edsl.exceptions.questions.QuestionAnswerValidationError: Answer code must be a non-negative integer (got -1).
-        """
+        """Validate the answer."""
         self._validate_answer_template_basic(answer)
         self._validate_answer_multiple_choice(answer)
         return answer
 
     def _translate_answer_code_to_answer(
-        self, answer_code: int, scenario: Optional["Scenario"] = None
+        self, answer_code, scenario: "Scenario" = None
     ):
-        """Translate the answer code to the actual answer.
-
-        It is used to translate the answer code to the actual answer.
-        The question options might be templates, so they need to be rendered with the scenario.
-
-        >>> q = QuestionMultipleChoice.example()
-        >>> q._translate_answer_code_to_answer(0, {})
-        'Good'
-
-        >>> q = QuestionMultipleChoice(question_name="how_feeling", question_text="How are you?", question_options=["{{emotion[0]}}", "emotion[1]"])
-        >>> q._translate_answer_code_to_answer(0, {"emotion": ["Happy", "Sad"]})
-        'Happy'
-
-        """
+        """Translate the answer code to the actual answer."""
         from edsl.scenarios.Scenario import Scenario
 
         scenario = scenario or Scenario()
-
-        if isinstance(self.question_options, str):
-            # If dynamic options are provided like {{ options }}, render them with the scenario
-            from jinja2 import Environment, meta
-
-            env = Environment()
-            parsed_content = env.parse(self.question_options)
-            question_option_key = list(meta.find_undeclared_variables(parsed_content))[
-                0
-            ]
-            translated_options = scenario.get(question_option_key)
-        else:
-            translated_options = [
-                Template(str(option)).render(scenario)
-                for option in self.question_options
-            ]
-        # print("Translated options:", translated_options)
-        # breakpoint()
+        translated_options = [
+            Template(str(option)).render(scenario) for option in self.question_options
+        ]
         return translated_options[int(answer_code)]
 
     def _simulate_answer(
@@ -123,7 +75,6 @@ class QuestionMultipleChoice(QuestionBase):
 
     @property
     def question_html_content(self) -> str:
-        """Return the HTML version of the question."""
         if hasattr(self, "option_labels"):
             option_labels = self.option_labels
         else:

edsl/questions/descriptors.py

@@ -2,7 +2,7 @@
 
 from abc import ABC, abstractmethod
 import re
-from typing import Any, Callable, List, Optional
+from typing import Any, Callable
 from edsl.exceptions import (
     QuestionCreationValidationError,
     QuestionAnswerValidationError,
@@ -242,16 +242,6 @@ class QuestionNameDescriptor(BaseDescriptor):
 class QuestionOptionsDescriptor(BaseDescriptor):
     """Validate that `question_options` is a list, does not exceed the min/max lengths, and has unique items."""
 
-    @classmethod
-    def example(cls):
-        class TestQuestion:
-            question_options = QuestionOptionsDescriptor()
-
-            def __init__(self, question_options: List[str]):
-                self.question_options = question_options
-
-        return TestQuestion
-
     def __init__(
         self,
         num_choices: int = None,
@@ -264,31 +254,7 @@ class QuestionOptionsDescriptor(BaseDescriptor):
         self.q_budget = q_budget
 
     def validate(self, value: Any, instance) -> None:
-        """Validate the question options.
-
-        >>> q_class = QuestionOptionsDescriptor.example()
-        >>> _ = q_class(["a", "b", "c"])
-        >>> _ = q_class(["a", "b", "c", "d", "d"])
-        Traceback (most recent call last):
-        ...
-        edsl.exceptions.questions.QuestionCreationValidationError: Question options must be unique (got ['a', 'b', 'c', 'd', 'd']).
-
-        We allow dynamic question options, which are strings of the form '{{ question_options }}'.
-
-        >>> _ = q_class("{{dynamic_options}}")
-        >>> _ = q_class("dynamic_options")
-        Traceback (most recent call last):
-        ...
-        edsl.exceptions.questions.QuestionCreationValidationError: Dynamic question options must be of the form: '{{ question_options }}'.
-        """
-        if isinstance(value, str):
-            # Check if the string is a dynamic question option
-            if "{{" in value and "}}" in value:
-                return None
-            else:
-                raise QuestionCreationValidationError(
-                    "Dynamic question options must be of the form: '{{ question_options }}'."
-                )
+        """Validate the question options."""
         if not isinstance(value, list):
             raise QuestionCreationValidationError(
                 f"Question options must be a list (got {value})."
@@ -373,9 +339,3 @@ class QuestionTextDescriptor(BaseDescriptor):
                 f"WARNING: Question text contains a single-braced substring: If you intended to parameterize the question with a Scenario this should be changed to a double-braced substring, e.g. {{variable}}.\nSee details on constructing Scenarios in the docs: https://docs.expectedparrot.com/en/latest/scenarios.html",
                 UserWarning,
             )
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod(optionflags=doctest.ELLIPSIS)

edsl/results/DatasetExportMixin.py

@@ -15,9 +15,6 @@ class DatasetExportMixin:
     ) -> list:
         """Return the set of keys that are present in the dataset.
 
-        :param data_type: The data type to filter by.
-        :param remove_prefix: Whether to remove the prefix from the column names.
-
         >>> from edsl.results.Dataset import Dataset
         >>> d = Dataset([{'a.b':[1,2,3,4]}])
         >>> d.relevant_columns()
@@ -30,6 +27,7 @@ class DatasetExportMixin:
         ['answer.how_feeling', 'answer.how_feeling_yesterday']
         """
         columns = [list(x.keys())[0] for x in self]
+        # columns = set([list(result.keys())[0] for result in self.data])
         if remove_prefix:
             columns = [column.split(".")[-1] for column in columns]
 
@@ -73,15 +71,7 @@ class DatasetExportMixin:
         return header, rows
 
     def print_long(self):
-        """Print the results in a long format.
-        >>> from edsl.results import Results
-        >>> r = Results.example()
-        >>> r.select('how_feeling').print_long()
-        answer.how_feeling: OK
-        answer.how_feeling: Great
-        answer.how_feeling: Terrible
-        answer.how_feeling: OK
-        """
+        """Print the results in a long format."""
         for entry in self:
             key, list_of_values = list(entry.items())[0]
             for value in list_of_values:
@@ -127,42 +117,6 @@ class DatasetExportMixin:
         │ OK           │
         └──────────────┘
 
-        >>> r = Results.example()
-        >>> r2 = r.select("how_feeling").print(format = "rich", tee = True, max_rows = 2)
-        ┏━━━━━━━━━━━━━━┓
-        ┃ answer       ┃
-        ┃ .how_feeling ┃
-        ┡━━━━━━━━━━━━━━┩
-        │ OK           │
-        ├──────────────┤
-        │ Great        │
-        └──────────────┘
-        >>> r2
-        Dataset([{'answer.how_feeling': ['OK', 'Great', 'Terrible', 'OK']}])
-
-        >>> r.select('how_feeling').print(format = "rich", max_rows = 2)
-        ┏━━━━━━━━━━━━━━┓
-        ┃ answer       ┃
-        ┃ .how_feeling ┃
-        ┡━━━━━━━━━━━━━━┩
-        │ OK           │
-        ├──────────────┤
-        │ Great        │
-        └──────────────┘
-
-        >>> r.select('how_feeling').print(format = "rich", split_at_dot = False)
-        ┏━━━━━━━━━━━━━━━━━━━━┓
-        ┃ answer.how_feeling ┃
-        ┡━━━━━━━━━━━━━━━━━━━━┩
-        │ OK                 │
-        ├────────────────────┤
-        │ Great              │
-        ├────────────────────┤
-        │ Terrible           │
-        ├────────────────────┤
-        │ OK                 │
-        └────────────────────┘
-
         Example: using the pretty_labels parameter
 
         >>> r.select('how_feeling').print(format="rich", pretty_labels = {'answer.how_feeling': "How are you feeling"})
@@ -200,9 +154,6 @@ class DatasetExportMixin:
 
         if pretty_labels is None:
             pretty_labels = {}
-        else:
-            # if the user passes in pretty_labels, we don't want to split at the dot
-            split_at_dot = False
 
         if format not in ["rich", "html", "markdown", "latex"]:
             raise ValueError("format must be one of 'rich', 'html', or 'markdown'.")
@@ -217,6 +168,7 @@ class DatasetExportMixin:
                 for key in entry:
                     actual_rows = len(entry[key])
                     entry[key] = entry[key][:max_rows]
+            # print(f"Showing only the first {max_rows} rows of {actual_rows} rows.")
 
         if format == "rich":
             from edsl.utilities.interface import print_dataset_with_rich
@@ -293,10 +245,6 @@ class DatasetExportMixin:
         >>> r = Results.example()
         >>> r.select('how_feeling').to_csv()
         'answer.how_feeling\\r\\nOK\\r\\nGreat\\r\\nTerrible\\r\\nOK\\r\\n'
-
-        >>> r.select('how_feeling').to_csv(pretty_labels = {'answer.how_feeling': "How are you feeling"})
-        'How are you feeling\\r\\nOK\\r\\nGreat\\r\\nTerrible\\r\\nOK\\r\\n'
-
         """
         if pretty_labels is None:
             pretty_labels = {}
@@ -361,15 +309,6 @@ class DatasetExportMixin:
         return ScenarioList([Scenario(d) for d in list_of_dicts])
 
     def to_agent_list(self, remove_prefix: bool = True):
-        """Convert the results to a list of dictionaries, one per agent.
-
-        :param remove_prefix: Whether to remove the prefix from the column names.
-
-        >>> from edsl.results import Results
-        >>> r = Results.example()
-        >>> r.select('how_feeling').to_agent_list()
-        AgentList([Agent(traits = {'how_feeling': 'OK'}), Agent(traits = {'how_feeling': 'Great'}), Agent(traits = {'how_feeling': 'Terrible'}), Agent(traits = {'how_feeling': 'OK'})])
-        """
         from edsl import AgentList, Agent
 
         list_of_dicts = self.to_dicts(remove_prefix=remove_prefix)
@@ -405,9 +344,6 @@ class DatasetExportMixin:
     def to_list(self, flatten=False, remove_none=False) -> list[list]:
         """Convert the results to a list of lists.
 
-        :param flatten: Whether to flatten the list of lists.
-        :param remove_none: Whether to remove None values from the list.
-
         >>> from edsl.results import Results
         >>> Results.example().select('how_feeling', 'how_feeling_yesterday')
         Dataset([{'answer.how_feeling': ['OK', 'Great', 'Terrible', 'OK']}, {'answer.how_feeling_yesterday': ['Great', 'Good', 'OK', 'Terrible']}])
@@ -418,18 +354,6 @@ class DatasetExportMixin:
         >>> r = Results.example()
         >>> r.select('how_feeling').to_list()
         ['OK', 'Great', 'Terrible', 'OK']
-
-        >>> from edsl.results.Dataset import Dataset
-        >>> Dataset([{'a.b': [[1, 9], 2, 3, 4]}]).select('a.b').to_list(flatten = True)
-        [1, 9, 2, 3, 4]
-
-        >>> from edsl.results.Dataset import Dataset
-        >>> Dataset([{'a.b': [[1, 9], 2, 3, 4]}, {'c': [6, 2, 3, 4]}]).select('a.b', 'c').to_list(flatten = True)
-        Traceback (most recent call last):
-        ...
-        ValueError: Cannot flatten a list of lists when there are multiple columns selected.
-
-
         """
         if len(self.relevant_columns()) > 1 and flatten:
             raise ValueError(
@@ -461,10 +385,7 @@ class DatasetExportMixin:
         return list_to_return
 
     def html(
-        self,
-        filename: Optional[str] = None,
-        cta: str = "Open in browser",
-        return_link: bool = False,
+        self, filename: str = None, cta: str = "Open in browser", return_link=False
     ):
         import os
         import tempfile
@@ -498,7 +419,7 @@ class DatasetExportMixin:
             return filename
 
     def tally(
-        self, *fields: Optional[str], top_n: Optional[int] = None, output="dict"
+        self, *fields: Optional[str], top_n=None, output="dict"
     ) -> Union[dict, "Dataset"]:
         """Tally the values of a field or perform a cross-tab of multiple fields.
 

edsl/results/Result.py

@@ -126,9 +126,6 @@ class Result(Base, UserDict):
         self.survey = survey
         self.question_to_attributes = question_to_attributes
 
-        self._combined_dict = None
-        self._problem_keys = None
-
     ###############
     # Used in Results
     ###############
@@ -167,64 +164,25 @@ class Result(Base, UserDict):
             "answer": self.answer,
             "prompt": self.prompt,
             "raw_model_response": self.raw_model_response,
-            #            "iteration": {"iteration": self.iteration},
+            "iteration": {"iteration": self.iteration},
             "question_text": question_text_dict,
             "question_options": question_options_dict,
             "question_type": question_type_dict,
             "comment": comments_dict,
         }
 
-    def check_expression(self, expression) -> None:
-        for key in self.problem_keys:
-            if key in expression and not key + "." in expression:
-                raise ValueError(
-                    f"Key by iself {key} is problematic. Use the full key {key + '.' + key} name instead."
-                )
-        return None
-
     def code(self):
         """Return a string of code that can be used to recreate the Result object."""
         raise NotImplementedError
 
     @property
-    def problem_keys(self):
-        """Return a list of keys that are problematic."""
-        return self._problem_keys
-
-    def _compute_combined_dict_and_problem_keys(self) -> None:
+    def combined_dict(self) -> dict[str, Any]:
+        """Return a dictionary that includes all sub_dicts, but also puts the key-value pairs in each sub_dict as a key_value pair in the combined dictionary."""
         combined = {}
-        problem_keys = []
         for key, sub_dict in self.sub_dicts.items():
             combined.update(sub_dict)
-            # in some cases, the sub_dict might have keys that conflict with the main dict
-            if key in combined:
-                # The key is already in the combined dict
-                problem_keys = problem_keys + [key]
-
             combined.update({key: sub_dict})
-            # I *think* this allows us to do do things like "answer.how_feelling" i.e., that the evaluator can use
-            # dot notation to access the subdicts.
-        self._combined_dict = combined
-        self._problem_keys = problem_keys
-
-    @property
-    def combined_dict(self) -> dict[str, Any]:
-        """Return a dictionary that includes all sub_dicts, but also puts the key-value pairs in each sub_dict as a key_value pair in the combined dictionary.
-
-        >>> r = Result.example()
-        >>> r.combined_dict['how_feeling']
-        'OK'
-        """
-        if self._combined_dict is None or self._problem_keys is None:
-            self._compute_combined_dict_and_problem_keys()
-        return self._combined_dict
-
-    @property
-    def problem_keys(self):
-        """Return a list of keys that are problematic."""
-        if self._combined_dict is None or self._problem_keys is None:
-            self._compute_combined_dict_and_problem_keys()
-        return self._problem_keys
+        return combined
 
     def get_value(self, data_type: str, key: str) -> Any:
         """Return the value for a given data type and key.
@@ -268,13 +226,7 @@ class Result(Base, UserDict):
         return Result.from_dict(self.to_dict())
 
     def __eq__(self, other) -> bool:
-        """Return True if the Result object is equal to another Result object.
-
-        >>> r = Result.example()
-        >>> r == r
-        True
-
-        """
+        """Return True if the Result object is equal to another Result object."""
         return self.to_dict() == other.to_dict()
 
     ###############