edsl 0.1.30.dev4__py3-none-any.whl → 0.1.30.dev5__py3-none-any.whl

edsl/__version__.py

@@ -1 +1 @@
-__version__ = "0.1.30.dev4"
+__version__ = "0.1.30.dev5"

edsl/jobs/buckets/TokenBucket.py

@@ -30,6 +30,7 @@ class TokenBucket:
         if self.turbo_mode:
             pass
         else:
+            #pass
             self.turbo_mode = True
             self.capacity = float("inf")
             self.refill_rate = float("inf")
@@ -72,7 +73,17 @@ class TokenBucket:
         self.log.append((time.monotonic(), self.tokens))
 
     def refill(self) -> None:
-        """Refill the bucket with new tokens based on elapsed time."""
+        """Refill the bucket with new tokens based on elapsed time.
+        
+
+
+        >>> bucket = TokenBucket(bucket_name="test", bucket_type="test", capacity=10, refill_rate=1)
+        >>> bucket.tokens = 0
+        >>> bucket.refill()
+        >>> bucket.tokens > 0
+        True
+        
+        """
         now = time.monotonic()
         elapsed = now - self.last_refill
         refill_amount = elapsed * self.refill_rate

edsl/jobs/interviews/Interview.py

@@ -20,6 +20,10 @@ from edsl.jobs.interviews.retry_management import retry_strategy
 from edsl.jobs.interviews.InterviewTaskBuildingMixin import InterviewTaskBuildingMixin
 from edsl.jobs.interviews.InterviewStatusMixin import InterviewStatusMixin
 
+import asyncio
+
+def run_async(coro):
+    return asyncio.run(coro)
 
 class Interview(InterviewStatusMixin, InterviewTaskBuildingMixin):
     """
@@ -36,8 +40,8 @@ class Interview(InterviewStatusMixin, InterviewTaskBuildingMixin):
         model: Type["LanguageModel"],
         debug: Optional[bool] = False,
         iteration: int = 0,
-        cache: "Cache" = None,
-        sidecar_model: "LanguageModel" = None,
+        cache: Optional["Cache"] = None,
+        sidecar_model: Optional['LanguageModel'] = None,
     ):
         """Initialize the Interview instance.
 
@@ -45,6 +49,24 @@ class Interview(InterviewStatusMixin, InterviewTaskBuildingMixin):
         :param survey: the survey being administered to the agent.
         :param scenario: the scenario that populates the survey questions.
         :param model: the language model used to answer the questions.
+        :param debug: if True, run without calls to the language model.
+        :param iteration: the iteration number of the interview.
+        :param cache: the cache used to store the answers.
+        :param sidecar_model: a sidecar model used to answer questions.
+
+        >>> i = Interview.example()
+        >>> i.task_creators
+        {}
+
+        >>> i.exceptions
+        {}
+
+        >>> _ = asyncio.run(i.async_conduct_interview())
+        >>> i.task_status_logs['q0']
+        [{'log_time': ..., 'value': <TaskStatus.NOT_STARTED: 1>}, {'log_time': ..., 'value': <TaskStatus.WAITING_FOR_DEPENDENCIES: 2>}, {'log_time': ..., 'value': <TaskStatus.API_CALL_IN_PROGRESS: 7>}, {'log_time': ..., 'value': <TaskStatus.SUCCESS: 8>}]
+
+        >>> i.to_index
+        {'q0': 0, 'q1': 1, 'q2': 2}
 
         """
         self.agent = agent
@@ -64,7 +86,7 @@ class Interview(InterviewStatusMixin, InterviewTaskBuildingMixin):
         self.exceptions = InterviewExceptionCollection()
         self._task_status_log_dict = InterviewStatusLog()
 
-        # dictionary mapping question names to their index in the survey."""
+        # dictionary mapping question names to their index in the survey.
         self.to_index = {
             question_name: index
             for index, question_name in enumerate(self.survey.question_names)
@@ -76,14 +98,16 @@ class Interview(InterviewStatusMixin, InterviewTaskBuildingMixin):
         model_buckets: ModelBuckets = None,
         debug: bool = False,
         stop_on_exception: bool = False,
-        sidecar_model: Optional[LanguageModel] = None,
+        sidecar_model: Optional['LanguageModel'] = None,
     ) -> tuple["Answers", List[dict[str, Any]]]:
         """
         Conduct an Interview asynchronously.
+        It returns a tuple with the answers and a list of valid results.
 
         :param model_buckets: a dictionary of token buckets for the model.
         :param debug: run without calls to LLM.
         :param stop_on_exception: if True, stops the interview if an exception is raised.
+        :param sidecar_model: a sidecar model used to answer questions.
 
         Example usage:
 
@@ -91,22 +115,44 @@ class Interview(InterviewStatusMixin, InterviewTaskBuildingMixin):
         >>> result, _ = asyncio.run(i.async_conduct_interview())
         >>> result['q0']
         'yes'
+
+        >>> i = Interview.example(throw_exception = True)
+        >>> result, _ = asyncio.run(i.async_conduct_interview())
+        Attempt 1 failed with exception:This is a test error now waiting 1.00 seconds before retrying.Parameters: start=1.0, max=60.0, max_attempts=5.
+        <BLANKLINE>
+        <BLANKLINE>
+        Attempt 2 failed with exception:This is a test error now waiting 2.00 seconds before retrying.Parameters: start=1.0, max=60.0, max_attempts=5.
+        <BLANKLINE>
+        <BLANKLINE>
+        Attempt 3 failed with exception:This is a test error now waiting 4.00 seconds before retrying.Parameters: start=1.0, max=60.0, max_attempts=5.
+        <BLANKLINE>
+        <BLANKLINE>
+        Attempt 4 failed with exception:This is a test error now waiting 8.00 seconds before retrying.Parameters: start=1.0, max=60.0, max_attempts=5.
+        <BLANKLINE>
+        <BLANKLINE>
+
+        >>> i.exceptions
+        {'q0': [{'exception': "Exception('This is a test error')", 'time': ..., 'traceback': ...
+
+        >>> i = Interview.example()
+        >>> result, _ = asyncio.run(i.async_conduct_interview(stop_on_exception = True))
+        Traceback (most recent call last):
+        ...
+        asyncio.exceptions.CancelledError
         """
         self.sidecar_model = sidecar_model
 
         # if no model bucket is passed, create an 'infinity' bucket with no rate limits
-        # print("model_buckets", model_buckets)
         if model_buckets is None or hasattr(self.agent, "answer_question_directly"):
             model_buckets = ModelBuckets.infinity_bucket()
 
-        # FOR TESTING
-        # model_buckets = ModelBuckets.infinity_bucket()
-
+        
         ## build the tasks using the InterviewTaskBuildingMixin
         ## This is the key part---it creates a task for each question,
         ## with dependencies on the questions that must be answered before this one can be answered.
         self.tasks = self._build_question_tasks(
-            debug=debug, model_buckets=model_buckets
+            debug=debug, 
+            model_buckets=model_buckets
         )
 
         ## 'Invigilators' are used to administer the survey
@@ -123,6 +169,14 @@ class Interview(InterviewStatusMixin, InterviewTaskBuildingMixin):
         It iterates through the tasks and invigilators, and yields the results of the tasks that are done.
         If a task is not done, it raises a ValueError.
         If an exception is raised in the task, it records the exception in the Interview instance except if the task was cancelled, which is expected behavior.
+
+        >>> i = Interview.example()
+        >>> result, _ = asyncio.run(i.async_conduct_interview())
+        >>> results = list(i._extract_valid_results())
+        >>> len(results) == len(i.survey)
+        True
+        >>> type(results[0])
+        <class 'edsl.data_transfer_models.AgentResponseDict'>
         """
         assert len(self.tasks) == len(self.invigilators)
 
@@ -140,7 +194,18 @@ class Interview(InterviewStatusMixin, InterviewTaskBuildingMixin):
             yield result
 
     def _record_exception(self, task, exception: Exception) -> None:
-        """Record an exception in the Interview instance."""
+        """Record an exception in the Interview instance.
+        
+        It records the exception in the Interview instance, with the task name and the exception entry.
+
+        >>> i = Interview.example()
+        >>> result, _ = asyncio.run(i.async_conduct_interview())
+        >>> i.exceptions
+        {}
+        >>> i._record_exception(i.tasks[0], Exception("An exception occurred."))
+        >>> i.exceptions
+        {'q0': [{'exception': "Exception('An exception occurred.')", 'time': ..., 'traceback': 'NoneType: None\\n'}]}
+        """
         exception_entry = InterviewExceptionEntry(
             exception=repr(exception),
             time=time.time(),
@@ -156,6 +221,10 @@ class Interview(InterviewStatusMixin, InterviewTaskBuildingMixin):
         It is used to determine the order in which questions should be answered.
         This reflects both agent 'memory' considerations and 'skip' logic.
         The 'textify' parameter is set to True, so that the question names are returned as strings rather than integer indices.
+
+        >>> i = Interview.example()
+        >>> i.dag == {'q2': {'q0'}, 'q1': {'q0'}}
+        True
         """
         return self.survey.dag(textify=True)
 
@@ -166,8 +235,15 @@ class Interview(InterviewStatusMixin, InterviewTaskBuildingMixin):
         """Return a string representation of the Interview instance."""
         return f"Interview(agent = {repr(self.agent)}, survey = {repr(self.survey)}, scenario = {repr(self.scenario)}, model = {repr(self.model)})"
 
-    def duplicate(self, iteration: int, cache: Cache) -> Interview:
-        """Duplicate the interview, but with a new iteration number and cache."""
+    def duplicate(self, iteration: int, cache: 'Cache') -> Interview:
+        """Duplicate the interview, but with a new iteration number and cache.
+        
+        >>> i = Interview.example()
+        >>> i2 = i.duplicate(1, None)
+        >>> i.iteration + 1 == i2.iteration
+        True
+        
+        """
         return Interview(
             agent=self.agent,
             survey=self.survey,
@@ -178,7 +254,7 @@ class Interview(InterviewStatusMixin, InterviewTaskBuildingMixin):
         )
 
     @classmethod
-    def example(self):
+    def example(self, throw_exception: bool = False) -> Interview:
         """Return an example Interview instance."""
         from edsl.agents import Agent
         from edsl.surveys import Survey
@@ -193,66 +269,15 @@ class Interview(InterviewStatusMixin, InterviewTaskBuildingMixin):
         survey = Survey.example()
         scenario = Scenario.example()
         model = LanguageModel.example()
+        if throw_exception:
+            model = LanguageModel.example(test_model = True, throw_exception=True)
+            agent = Agent.example()
+            return Interview(agent=agent, survey=survey, scenario=scenario, model=model)
         return Interview(agent=agent, survey=survey, scenario=scenario, model=model)
 
 
 if __name__ == "__main__":
     import doctest
 
-    doctest.testmod()
-    # from edsl import Model
-    # from edsl.agents import Agent
-    # from edsl.surveys import Survey
-    # from edsl.scenarios import Scenario
-    # from edsl.questions import QuestionMultipleChoice
-
-    # # from edsl.jobs.Interview import Interview
-
-    # #  a survey with skip logic
-    # q0 = QuestionMultipleChoice(
-    #     question_text="Do you like school?",
-    #     question_options=["yes", "no"],
-    #     question_name="q0",
-    # )
-    # q1 = QuestionMultipleChoice(
-    #     question_text="Why not?",
-    #     question_options=["killer bees in cafeteria", "other"],
-    #     question_name="q1",
-    # )
-    # q2 = QuestionMultipleChoice(
-    #     question_text="Why?",
-    #     question_options=["**lack*** of killer bees in cafeteria", "other"],
-    #     question_name="q2",
-    # )
-    # s = Survey(questions=[q0, q1, q2])
-    # s = s.add_rule(q0, "q0 == 'yes'", q2)
-
-    # # create an interview
-    # a = Agent(traits=None)
-
-    # def direct_question_answering_method(self, question, scenario):
-    #     """Answer a question directly."""
-    #     raise Exception("Error!")
-    #     # return "yes"
-
-    # a.add_direct_question_answering_method(direct_question_answering_method)
-    # scenario = Scenario()
-    # m = Model()
-    # I = Interview(agent=a, survey=s, scenario=scenario, model=m)
-
-    # result = asyncio.run(I.async_conduct_interview())
-    # # # conduct five interviews
-    # # for _ in range(5):
-    # #     I.conduct_interview(debug=True)
-
-    # # # replace missing answers
-    # # I
-    # # repr(I)
-    # # eval(repr(I))
-    # # print(I.task_status_logs.status_matrix(20))
-    # status_matrix = I.task_status_logs.status_matrix(20)
-    # numerical_matrix = I.task_status_logs.numerical_matrix(20)
-    # I.task_status_logs.visualize()
-
-    # I.exceptions.print()
-    # I.exceptions.ascii_table()
+    # add ellipsis
+    doctest.testmod(optionflags=doctest.ELLIPSIS)

edsl/jobs/interviews/InterviewTaskBuildingMixin.py

@@ -25,7 +25,7 @@ TIMEOUT = float(CONFIG.get("EDSL_API_TIMEOUT"))
 class InterviewTaskBuildingMixin:
     def _build_invigilators(
         self, debug: bool
-    ) -> Generator[InvigilatorBase, None, None]:
+    ) -> Generator['InvigilatorBase', None, None]:
         """Create an invigilator for each question.
 
         :param debug: whether to use debug mode, in which case `InvigilatorDebug` is used.
@@ -35,7 +35,7 @@ class InterviewTaskBuildingMixin:
         for question in self.survey.questions:
             yield self._get_invigilator(question=question, debug=debug)
 
-    def _get_invigilator(self, question: QuestionBase, debug: bool) -> "Invigilator":
+    def _get_invigilator(self, question: 'QuestionBase', debug: bool) -> "Invigilator":
         """Return an invigilator for the given question.
 
         :param question: the question to be answered
@@ -84,7 +84,7 @@ class InterviewTaskBuildingMixin:
         return tuple(tasks)  # , invigilators
 
     def _get_tasks_that_must_be_completed_before(
-        self, *, tasks: list[asyncio.Task], question: QuestionBase
+        self, *, tasks: list[asyncio.Task], question: 'QuestionBase'
     ) -> Generator[asyncio.Task, None, None]:
         """Return the tasks that must be completed before the given question can be answered.
 
@@ -100,7 +100,7 @@ class InterviewTaskBuildingMixin:
     def _create_question_task(
         self,
         *,
-        question: QuestionBase,
+        question: 'QuestionBase',
         tasks_that_must_be_completed_before: list[asyncio.Task],
         model_buckets: ModelBuckets,
         debug: bool,
@@ -175,24 +175,12 @@ class InterviewTaskBuildingMixin:
 
             self._add_answer(response=response, question=question)
 
-            # With the answer to the question, we can now cancel any skipped questions
             self._cancel_skipped_questions(question)
             return AgentResponseDict(**response)
         except Exception as e:
             raise e
-            # import traceback
-            # print("Exception caught:")
-            # traceback.print_exc()
-
-            # # Extract and print the traceback info
-            # tb = e.__traceback__
-            # while tb is not None:
-            #     print(f"File {tb.tb_frame.f_code.co_filename}, line {tb.tb_lineno}, in {tb.tb_frame.f_code.co_name}")
-            #     tb = tb.tb_next
-            #     breakpoint()
-            #     raise e
-
-    def _add_answer(self, response: AgentResponseDict, question: QuestionBase) -> None:
+        
+    def _add_answer(self, response: 'AgentResponseDict', question: 'QuestionBase') -> None:
         """Add the answer to the answers dictionary.
 
         :param response: the response to the question.
@@ -200,7 +188,7 @@ class InterviewTaskBuildingMixin:
         """
         self.answers.add_answer(response=response, question=question)
 
-    def _skip_this_question(self, current_question: QuestionBase) -> bool:
+    def _skip_this_question(self, current_question: 'QuestionBase') -> bool:
         """Determine if the current question should be skipped.
 
         :param current_question: the question to be answered.

edsl/jobs/tasks/QuestionTaskCreator.py

@@ -88,7 +88,8 @@ class QuestionTaskCreator(UserList):
         self.append(task)
 
     def generate_task(self, debug: bool) -> asyncio.Task:
-        """Create a task that depends on the passed-in dependencies."""
+        """Create a task that depends on the passed-in dependencies.        
+        """
         task = asyncio.create_task(
             self._run_task_async(debug), name=self.question.question_name
         )
@@ -144,18 +145,14 @@ class QuestionTaskCreator(UserList):
             self.task_status = TaskStatus.FAILED
             raise e
 
-        ## This isn't working
-        # breakpoint()
-        if results.get("cache_used", False):
+        if results.get('cache_used', False):
             self.tokens_bucket.add_tokens(requested_tokens)
             self.requests_bucket.add_tokens(1)
             self.from_cache = True
-            # print("Turning on turbo!")
+            # Turbo mode means that we don't wait for tokens or requests.
             self.tokens_bucket.turbo_mode_on()
             self.requests_bucket.turbo_mode_on()
         else:
-            # breakpoint()
-            # print("Turning off turbo!")
             self.tokens_bucket.turbo_mode_off()
             self.requests_bucket.turbo_mode_off()
 

edsl/language_models/LanguageModel.py

@@ -494,7 +494,7 @@ class LanguageModel(
         return table
 
     @classmethod
-    def example(cls, test_model: bool = False, canned_response: str = "Hello world"):
+    def example(cls, test_model: bool = False, canned_response: str = "Hello world", throw_exception: bool = False):
         """Return a default instance of the class.
 
         >>> from edsl.language_models import LanguageModel
@@ -519,6 +519,8 @@ 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/questions/QuestionFunctional.py

@@ -4,10 +4,33 @@ 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."""
+    """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
+
+    """
 
     question_type = "functional"
     default_instructions = ""
@@ -73,6 +96,7 @@ 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,
@@ -81,6 +105,8 @@ class QuestionFunctional(QuestionBase):
             "requires_loop": self.requires_loop,
             "function_name": self.function_name,
         }
+    
+    
 
     @classmethod
     def example(cls):
@@ -113,4 +139,9 @@ def main():
     scenario = Scenario({"numbers": [1, 2, 3, 4, 5]})
     agent = Agent(traits={"multiplier": 10})
     results = question.by(scenario).by(agent).run()
-    print(results)
+    assert results.select("answer.*").to_list()[0] == 150
+
+if __name__ == "__main__":
+    #main()
+    import doctest
+    doctest.testmod(optionflags=doctest.ELLIPSIS)

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,7 +10,11 @@ from edsl.questions.descriptors import QuestionOptionsDescriptor
 
 
 class QuestionMultipleChoice(QuestionBase):
-    """This question prompts the agent to select one option from a list of options."""
+    """This question prompts the agent to select one option from a list of options.
+    
+    https://docs.expectedparrot.com/en/latest/questions.html#questionmultiplechoice-class
+
+    """
 
     question_type = "multiple_choice"
     purpose = "When options are known and limited"
@@ -35,27 +39,69 @@ 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."""
+        """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).
+        """
         self._validate_answer_template_basic(answer)
         self._validate_answer_multiple_choice(answer)
         return answer
 
     def _translate_answer_code_to_answer(
-        self, answer_code, scenario: "Scenario" = None
+        self, 
+        answer_code: int, 
+        scenario: Optional["Scenario"] = None
     ):
-        """Translate the answer code to the actual answer."""
+        """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'
+
+        """
         from edsl.scenarios.Scenario import Scenario
 
         scenario = scenario or Scenario()
-        translated_options = [
-            Template(str(option)).render(scenario) for option in self.question_options
-        ]
+
+        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()
         return translated_options[int(answer_code)]
 
     def _simulate_answer(
@@ -75,6 +121,7 @@ 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
+from typing import Any, Callable, List, Optional
 from edsl.exceptions import (
     QuestionCreationValidationError,
     QuestionAnswerValidationError,
@@ -242,6 +242,15 @@ 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,
@@ -254,7 +263,31 @@ class QuestionOptionsDescriptor(BaseDescriptor):
         self.q_budget = q_budget
 
     def validate(self, value: Any, instance) -> None:
-        """Validate the question options."""
+        """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 }}'."
+                )
         if not isinstance(value, list):
             raise QuestionCreationValidationError(
                 f"Question options must be a list (got {value})."
@@ -339,3 +372,8 @@ 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,6 +15,9 @@ 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()
@@ -27,7 +30,6 @@ 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]
 
@@ -71,7 +73,15 @@ class DatasetExportMixin:
         return header, rows
 
     def print_long(self):
-        """Print the results in a long format."""
+        """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
+        """
         for entry in self:
             key, list_of_values = list(entry.items())[0]
             for value in list_of_values:
@@ -117,6 +127,42 @@ 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"})
@@ -154,6 +200,9 @@ 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'.")
@@ -168,8 +217,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
 
@@ -245,6 +293,10 @@ 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 = {}
@@ -309,6 +361,15 @@ 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)
@@ -344,6 +405,9 @@ 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']}])
@@ -354,6 +418,18 @@ 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(
@@ -385,7 +461,7 @@ class DatasetExportMixin:
         return list_to_return
 
     def html(
-        self, filename: str = None, cta: str = "Open in browser", return_link=False
+        self, filename: Optional[str] = None, cta: str = "Open in browser", return_link:bool=False
     ):
         import os
         import tempfile
@@ -419,7 +495,7 @@ class DatasetExportMixin:
             return filename
 
     def tally(
-        self, *fields: Optional[str], top_n=None, output="dict"
+        self, *fields: Optional[str], top_n:Optional[int]=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,6 +126,9 @@ 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
     ###############
@@ -164,25 +167,62 @@ 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 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."""
+    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:
         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})
-        return combined
+            # 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
 
     def get_value(self, data_type: str, key: str) -> Any:
         """Return the value for a given data type and key.
@@ -226,7 +266,13 @@ 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."""
+        """Return True if the Result object is equal to another Result object.
+        
+        >>> r = Result.example()
+        >>> r == r
+        True
+        
+        """
         return self.to_dict() == other.to_dict()
 
     ###############

edsl/results/Results.py

@@ -603,6 +603,36 @@ class Results(UserList, Mixins, Base):
             values = [d[key] for d in columns]
             self = self.add_column(key, values)
         return self
+    
+    @staticmethod
+    def _create_evaluator(result: Result, functions_dict: Optional[dict] = None) -> EvalWithCompoundTypes:
+        """Create an evaluator for the expression.
+        
+        >>> from unittest.mock import Mock
+        >>> result = Mock()
+        >>> result.combined_dict = {'how_feeling': 'OK'} 
+
+        >>> evaluator = Results._create_evaluator(result = result, functions_dict = {})
+        >>> evaluator.eval("how_feeling == 'OK'")
+        True
+        
+        >>> result.combined_dict = {'answer': {'how_feeling': 'OK'}}
+        >>> evaluator = Results._create_evaluator(result = result, functions_dict = {})
+        >>> evaluator.eval("answer.how_feeling== 'OK'")
+        True
+        
+        Note that you need to refer to the answer dictionary in the expression.
+
+        >>> evaluator.eval("how_feeling== 'OK'")
+        Traceback (most recent call last):
+        ...
+        simpleeval.NameNotDefined: 'how_feeling' is not defined for expression 'how_feeling== 'OK''
+        """
+        if functions_dict is None:
+            functions_dict = {}
+        return EvalWithCompoundTypes(
+            names=result.combined_dict, functions=functions_dict
+        )
 
     def mutate(
         self, new_var_string: str, functions_dict: Optional[dict] = None
@@ -636,13 +666,8 @@ class Results(UserList, Mixins, Base):
         # create the evaluator
         functions_dict = functions_dict or {}
 
-        def create_evaluator(result: Result) -> EvalWithCompoundTypes:
-            return EvalWithCompoundTypes(
-                names=result.combined_dict, functions=functions_dict
-            )
-
         def new_result(old_result: "Result", var_name: str) -> "Result":
-            evaluator = create_evaluator(old_result)
+            evaluator = self._create_evaluator(old_result, functions_dict)
             value = evaluator.eval(expression)
             new_result = old_result.copy()
             new_result["answer"][var_name] = value
@@ -742,6 +767,9 @@ class Results(UserList, Mixins, Base):
         >>> results = Results.example()
         >>> results.select('how_feeling')
         Dataset([{'answer.how_feeling': ['OK', 'Great', 'Terrible', 'OK']}])
+
+        >>> results.select('how_feeling', 'model', 'how_feeling')
+        Dataset([{'answer.how_feeling': ['OK', 'Great', 'Terrible', 'OK']}, {'model.model': ['gpt-4-1106-preview', 'gpt-4-1106-preview', 'gpt-4-1106-preview', 'gpt-4-1106-preview']}, {'answer.how_feeling': ['OK', 'Great', 'Terrible', 'OK']}])
         """
 
         if len(self) == 0:
@@ -799,10 +827,18 @@ class Results(UserList, Mixins, Base):
             # Return the index of this key in the list_of_keys
             return items_in_order.index(single_key)
 
-        sorted(new_data, key=sort_by_key_order)
+        #sorted(new_data, key=sort_by_key_order)
         from edsl.results.Dataset import Dataset
+        sorted_new_data = []
 
-        return Dataset(new_data)
+        # WORKS but slow
+        for key in items_in_order:
+            for d in new_data:
+                if key in d:
+                    sorted_new_data.append(d)
+                    break
+
+        return Dataset(sorted_new_data)
 
     def sort_by(self, *columns: str, reverse: bool = False) -> Results:
         import warnings
@@ -917,31 +953,31 @@ class Results(UserList, Mixins, Base):
                 "You must use '==' instead of '=' in the filter expression."
             )
 
-        def create_evaluator(result):
-            """Create an evaluator for the given result.
-            The 'combined_dict' is a mapping of all values for that Result object.
-            """
-            return EvalWithCompoundTypes(names=result.combined_dict)
-
         try:
             # iterates through all the results and evaluates the expression
-            new_data = [
-                result
-                for result in self.data
-                if create_evaluator(result).eval(expression)
-            ]
+            new_data = []
+            for result in self.data:
+                evaluator = self._create_evaluator(result)
+                result.check_expression(expression) # check expression
+                if evaluator.eval(expression):
+                    new_data.append(result)
+      
+        except ValueError as e:
+            raise ResultsFilterError(
+                f"Error in filter. Exception:{e}",
+                f"The expression you provided was: {expression}",
+                "See https://docs.expectedparrot.com/en/latest/results.html#filtering-results for more details.",
+            )
         except Exception as e:
             raise ResultsFilterError(
-                f"""Error in filter. Exception:{e}.
-            The expression you provided was: {expression}. 
-            Please make sure that the expression is a valid Python expression that evaluates to a boolean.
-            For example, 'how_feeling == "Great"' is a valid expression, as is 'how_feeling in ["Great", "Terrible"]'.
-            However, 'how_feeling = "Great"' is not a valid expression.
-
-            See https://docs.expectedparrot.com/en/latest/results.html#filtering-results for more details.
-            """
+            f"""Error in filter. Exception:{e}.""", 
+            f"""The expression you provided was: {expression}.""",
+            """Please make sure that the expression is a valid Python expression that evaluates to a boolean.""",
+            """For example, 'how_feeling == "Great"' is a valid expression, as is 'how_feeling in ["Great", "Terrible"]'., """,
+            """However, 'how_feeling = "Great"' is not a valid expression.""",
+            """See https://docs.expectedparrot.com/en/latest/results.html#filtering-results for more details."""
             )
-
+      
         if len(new_data) == 0:
             import warnings
 

edsl/study/Study.py

@@ -461,13 +461,13 @@ class Study:
         else:
             self.objects[oe.hash] = oe
 
-    def push(self, refresh=False) -> None:
+    def push(self) -> dict:
         """Push the objects to coop."""
 
         from edsl import Coop
 
         coop = Coop()
-        coop.create(self, description=self.description)
+        return coop.create(self, description=self.description)
 
     @classmethod
     def pull(cls, uuid: Optional[Union[str, UUID]] = None, url: Optional[str] = None):

edsl/surveys/Survey.py

@@ -105,6 +105,36 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
         from edsl.utilities.utilities import dict_hash
 
         return dict_hash(self._to_dict())
+    
+    def __add__(self, other: Survey) -> Survey:
+        """Combine two surveys.
+        
+        :param other: The other survey to combine with this one.
+        >>> s1 = Survey.example()
+        >>> from edsl import QuestionFreeText
+        >>> s2 = Survey([QuestionFreeText(question_text="What is your name?", question_name="yo")])
+        >>> s3 = s1 + s2       
+        Traceback (most recent call last):
+        ...
+        ValueError: ('Cannot combine two surveys with non-default rules.', "Please use the 'clear_non_default_rules' method to remove non-default rules from the survey.")
+        >>> s3 = s1.clear_non_default_rules() + s2
+        >>> len(s3.questions)
+        4
+
+        """
+        if len(self.rule_collection.non_default_rules) > 0 or len(other.rule_collection.non_default_rules) > 0:
+            raise ValueError(
+                "Cannot combine two surveys with non-default rules.", 
+                "Please use the 'clear_non_default_rules' method to remove non-default rules from the survey."
+            )
+
+        return Survey(questions=self.questions + other.questions)
+    
+    def clear_non_default_rules(self) -> Survey:
+        s = Survey()
+        for question in self.questions:
+            s.add_question(question)
+        return s
 
     @property
     def parameters(self):
@@ -1151,4 +1181,5 @@ def main():
 if __name__ == "__main__":
     import doctest
 
-    doctest.testmod(optionflags=doctest.ELLIPSIS | doctest.SKIP)
+    #doctest.testmod(optionflags=doctest.ELLIPSIS | doctest.SKIP)
+    doctest.testmod(optionflags=doctest.ELLIPSIS)

{edsl-0.1.30.dev4.dist-info → edsl-0.1.30.dev5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: edsl
-Version: 0.1.30.dev4
+Version: 0.1.30.dev5
 Summary: Create and analyze LLM-based surveys
 Home-page: https://www.expectedparrot.com/
 License: MIT

{edsl-0.1.30.dev4.dist-info → edsl-0.1.30.dev5.dist-info}/RECORD

@@ -1,7 +1,7 @@
 edsl/Base.py,sha256=ttNxUotSd9LSEJl2w6LdMtT78d0nMQvYDJ0q4JkqBfg,8945
 edsl/BaseDiff.py,sha256=RoVEh52UJs22yMa7k7jv8se01G62jJNWnBzaZngo-Ug,8260
 edsl/__init__.py,sha256=E6PkWI_owu8AUc4uJs2XWDVozqSbcRWzsIqf8_Kskho,1631
-edsl/__version__.py,sha256=XqB4ByNbNvd6vFzVKO_2YpxRUrkpXNUQUKNU_uIIOng,28
+edsl/__version__.py,sha256=36CHcnfZnyhdfT-d4JZkCR1tvVI-WobrzSNjUWpJx80,28
 edsl/agents/Agent.py,sha256=qNJsQkN6HuTKqJrQbuUEgRX3Wo7Dwukle0oNWPi0UIE,27191
 edsl/agents/AgentList.py,sha256=_MsdeOEgaANAceLIXwuLC22mwlBn0ruGX4GEqz8_SSY,9467
 edsl/agents/Invigilator.py,sha256=WNgGT9VRKpHbk__h-vd4LASgjnlJnzepf-2FxQ3K98I,10798
@@ -70,14 +70,14 @@ edsl/jobs/Jobs.py,sha256=JrJcpTjR3wejMVvuFXZr7PHqCyj6zaRwqNu9eatvy9Y,29339
 edsl/jobs/__init__.py,sha256=aKuAyd_GoalGj-k7djOoVwEbFUE2XLPlikXaA1_8yAg,32
 edsl/jobs/buckets/BucketCollection.py,sha256=LA8DBVwMdeTFCbSDI0S2cDzfi_Qo6kRizwrG64tE8S4,1844
 edsl/jobs/buckets/ModelBuckets.py,sha256=hxw_tzc0V42CiB7mh5jIxlgwDVJ-zFZhlLtKrHEg8ho,2419
-edsl/jobs/buckets/TokenBucket.py,sha256=jeWOzJBr70FJKpa_pOhLFwTBz6RB39tg9-ki5x4PmtM,5774
-edsl/jobs/interviews/Interview.py,sha256=mnup2JIDlFrwE23pLBXzPDZpX9tJFp5hw2DqBoFoN0U,9750
+edsl/jobs/buckets/TokenBucket.py,sha256=d9W464eYWoYeN1PmS6Nv2Agq3hSuU4S7cN7NnUYy7aQ,6023
+edsl/jobs/interviews/Interview.py,sha256=FF4jgqHVoa9cXDkgU2JkJfr5XJsozswBkHUoTxnj3TA,11434
 edsl/jobs/interviews/InterviewStatistic.py,sha256=hY5d2EkIJ96NilPpZAvZZzZoxLXM7ss3xx5MIcKtTPs,1856
 edsl/jobs/interviews/InterviewStatisticsCollection.py,sha256=_ZZ0fnZBQiIywP9Q_wWjpWhlfcPe2cn32GKut10t5RI,788
 edsl/jobs/interviews/InterviewStatusDictionary.py,sha256=MSyys4hOWe1d8gfsUvAPbcKrs8YiPnz8jpufBSJL7SU,2485
 edsl/jobs/interviews/InterviewStatusLog.py,sha256=6u0F8gf5tha39VQL-IK_QPkCsQAYVOx_IesX7TDDX_A,3252
 edsl/jobs/interviews/InterviewStatusMixin.py,sha256=VV0Pel-crUsLoGpTifeIIkXsLGj0bfuO--UtpRnH-dU,1251
-edsl/jobs/interviews/InterviewTaskBuildingMixin.py,sha256=6F-sOyccoi5RRzE_NBMBIv0oHROeMYMSle7jJMUtSD8,11658
+edsl/jobs/interviews/InterviewTaskBuildingMixin.py,sha256=sqbimDTBD5W6vOAJ_WUpyGTtOzOqmVbutKEFZ0C-bnk,11149
 edsl/jobs/interviews/ReportErrors.py,sha256=RSzDU2rWwtjfztj7sqaMab0quCiY-X2bG3AEOxhTim8,1745
 edsl/jobs/interviews/interview_exception_tracking.py,sha256=tIcX92udnkE5fcM5_WXjRF9xgTq2P0uaDXxZf3NQGG0,3271
 edsl/jobs/interviews/interview_status_enum.py,sha256=KJ-1yLAHdX-p8TiFnM0M3v1tnBwkq4aMCuBX6-ytrI8,229
@@ -85,7 +85,7 @@ edsl/jobs/interviews/retry_management.py,sha256=9Efn4B3aV45vbocnF6J5WQt88i2FgFjo
 edsl/jobs/runners/JobsRunnerAsyncio.py,sha256=L48NdyDiKrgUMQVwvd1wr2uOzT99oYfwXnlStDLHU9I,11934
 edsl/jobs/runners/JobsRunnerStatusData.py,sha256=-mxcmX0a38GGO9DQ-ItTmj6mvCUk5uC-UudT77lXTG4,10327
 edsl/jobs/runners/JobsRunnerStatusMixin.py,sha256=yxnXuOovwHgfDokNuluH_qulBcM0gCcbpCQibqVKXFI,3137
-edsl/jobs/tasks/QuestionTaskCreator.py,sha256=myiRwTJ48HERazdZRdqb7lRGlSSGYcXEVpTHcKho2I0,10483
+edsl/jobs/tasks/QuestionTaskCreator.py,sha256=CCEx8k6LK12uXOy_XnvXZJPLvgtN3ig552lgSJEXlsI,10411
 edsl/jobs/tasks/TaskCreators.py,sha256=DbCt5BzJ0CsMSquqLyLdk8el031Wst7vCszVW5EltX8,2418
 edsl/jobs/tasks/TaskHistory.py,sha256=ZVellGW1cvwqdHt98dYPl0FYhk3VqRGHAZETDOxEkqg,10939
 edsl/jobs/tasks/TaskStatusLog.py,sha256=bqH36a32F12fjX-M-4lNOhHaK2-WLFzKE-r0PxZPRjI,546
@@ -93,7 +93,7 @@ edsl/jobs/tasks/task_management.py,sha256=KMToZuXzMlnHRHUF_VHL0-lHMTGhklf2GHVuwE
 edsl/jobs/tasks/task_status_enum.py,sha256=DOyrz61YlIS8R1W7izJNphcLrJ7I_ReUlfdRmk23h0Q,5333
 edsl/jobs/tokens/InterviewTokenUsage.py,sha256=u_6-IHpGFwZ6qMEXr24-jyLVUSSp4dSs_4iAZsBv7O4,1100
 edsl/jobs/tokens/TokenUsage.py,sha256=odj2-wDNEbHl9noyFAQ0DSKV0D9cv3aDOpmXufKZ8O4,1323
-edsl/language_models/LanguageModel.py,sha256=r2wLIaF2vTlCNjEhDrDRKOZozmWvw6KkCEANLnZXOPE,18916
+edsl/language_models/LanguageModel.py,sha256=9orpce5VxYRlB3UdN-RJxjpnzy4fsTfYah_l5-Rf3uA,19043
 edsl/language_models/ModelList.py,sha256=DLeAq7o8uniZkP_-z8vJDMwf4JXksqLoPqOeeLI3QBE,2687
 edsl/language_models/RegisterLanguageModelsMeta.py,sha256=2bvWrVau2BRo-Bb1aO-QATH8xxuW_tF7NmqBMGDOfSg,8191
 edsl/language_models/__init__.py,sha256=bvY7Gy6VkX1gSbNkRbGPS-M1kUnb0EohL0FSagaEaTs,109
@@ -124,9 +124,9 @@ edsl/questions/QuestionBudget.py,sha256=K8cc1YOfoLWRoZBAkWO7WsMDZne0a5oAJMSxv2Jz
 edsl/questions/QuestionCheckBox.py,sha256=YHS-LEvR_1CWyg4usOlWfj9Gb_cCQlfIWIWhYRWn7Wo,6129
 edsl/questions/QuestionExtract.py,sha256=fjnsNLS2fNW6dfFuRyc2EgKEHx8ujjONmg2nSRynje4,3988
 edsl/questions/QuestionFreeText.py,sha256=ASj1s0EQYcZerJp476fscu_xEME8mKzVK3sPL6egiuU,3289
-edsl/questions/QuestionFunctional.py,sha256=s49mQBVGc7B4-3sX49_a_mgVZsR9bdPra2VYe4m8XoY,3961
+edsl/questions/QuestionFunctional.py,sha256=rThYy1x_5_6blp7okSUlbHWXNa_4nd477TdkxxWW204,4984
 edsl/questions/QuestionList.py,sha256=Wf7xDXJsQBsAD_yOrzZ_GstKGT7aZjimTkU6qyqOhhM,4051
-edsl/questions/QuestionMultipleChoice.py,sha256=Oin_qOJz5wfZdcFopI6dyvlUn2LGocAvbNwSTmxWcQA,4491
+edsl/questions/QuestionMultipleChoice.py,sha256=Rvmi4YgOU9SquH4WIv4RiccTQWpqMTvcIQYmiyIu10o,6603
 edsl/questions/QuestionNumerical.py,sha256=QArFDhP9Adb4l6y-udnUqPNk2Q6vT4pGsY13TkHsLGs,3631
 edsl/questions/QuestionRank.py,sha256=NEAwDt1at0zEM2S-E7jXMjglnlB0WhUlxSVJkzH4xSs,5876
 edsl/questions/RegisterQuestionsMeta.py,sha256=unON0CKpW-mveyhg9V3_BF_GYYwytMYP9h2ZZPetVNM,1994
@@ -138,13 +138,13 @@ edsl/questions/derived/QuestionLinearScale.py,sha256=7tybIaMaDTMkTFC6CymusW69so-
 edsl/questions/derived/QuestionTopK.py,sha256=TouXKZt_h6Jd-2rAjkEOCJOzzei4Wa-3hjYq9CLxWws,2744
 edsl/questions/derived/QuestionYesNo.py,sha256=KtMGuAPYWv-7-9WGa0fIS2UBxf6KKjFpuTk_h8FPZbg,2076
 edsl/questions/derived/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-edsl/questions/descriptors.py,sha256=kqjV3pRbyq0ch-fSg4vkTz1ZH3ckud5Pd1HzR-R7pdE,13310
+edsl/questions/descriptors.py,sha256=kCy7poJc_eo2ELfvI1AhDm6a-ge-PeLEeBoaViSVjYM,14812
 edsl/questions/question_registry.py,sha256=ZD7Y_towDdlnnmLq12vVewgQ3fEk9Ur0tCTWK8-WqeQ,5241
 edsl/questions/settings.py,sha256=er_z0ZW_dgmC5CHLWkaqBJiuWgAYzIund85M5YZFQAI,291
 edsl/results/Dataset.py,sha256=DZgb3vIj69ON7APQ6DimjBwAS1xZvZiXOg68CjW9E3I,8662
-edsl/results/DatasetExportMixin.py,sha256=QZEuSxJPisgJ5GvFkKbuqayCSgJzblclea1CFwsBZ2w,17959
-edsl/results/Result.py,sha256=X1qAACs9E6XhRmlIsb3CguDs6_laKkVyxE0JJpOJDZQ,12729
-edsl/results/Results.py,sha256=BgJHfOKDhvxMR8_ej6v-Lpjm0XkRL-UTTQBzFzvKuZc,36393
+edsl/results/DatasetExportMixin.py,sha256=1n67zXiDPifahEEy34AgBimRnv8taevFfNLnUxfYK5c,21361
+edsl/results/Result.py,sha256=TrsYmNFydMqk5CqsZ3dbNC4Zdzk_jPvCCldN3Oym780,14436
+edsl/results/Results.py,sha256=wgHxPvXJEzAF7HJuy8z_IL8f_5Q9d4z1Mk6wiUfOqA0,38155
 edsl/results/ResultsDBMixin.py,sha256=Vs95zbSB4G7ENY4lU7OBdekg9evwTrtPH0IIL2NAFTk,7936
 edsl/results/ResultsExportMixin.py,sha256=XizBsPNxziyffirMA4kS7UHpYM1WIE4s1K-B7TqTfDw,1266
 edsl/results/ResultsFetchMixin.py,sha256=VEa0TKDcXbnTinSKs9YaE4WjOSLmlp9Po1_9kklFvSo,848
@@ -163,14 +163,14 @@ edsl/shared.py,sha256=lgLa-mCk2flIhxXarXLtfXZjXG_6XHhC2A3O8yRTjXc,20
 edsl/study/ObjectEntry.py,sha256=e3xRPH8wCN8Pum5HZsQRYgnSoauSvjXunIEH79wu5A8,5788
 edsl/study/ProofOfWork.py,sha256=FaqYtLgeiTEQXWKukPgPUTWMcIN5t1FR7h7Re8QEtgc,3433
 edsl/study/SnapShot.py,sha256=-5zoP4uTvnqtu3zRNMD-fKsNAVYX9psoKRADfotsF9E,2439
-edsl/study/Study.py,sha256=5yv5jT1uFxQD0oi_eODcKv_K6qTDbyAdMrAqBNNwOtE,16947
+edsl/study/Study.py,sha256=zLy2mMvsX_QgZ6D4dcgYJoEacyajkRnARYjIFvyCO1o,16939
 edsl/study/__init__.py,sha256=YAvPLTPG3hK_eN9Ar3d1_d-E3laXpSya879A25-JAxU,170
 edsl/surveys/DAG.py,sha256=ozQuHo9ZQ8Eet5nDXtp7rFpiSocvvfxIHtyTnztvodg,2380
 edsl/surveys/Memory.py,sha256=-ikOtkkQldGB_BkPCW3o7AYwV5B_pIwlREw7aVCSHaQ,1113
 edsl/surveys/MemoryPlan.py,sha256=BeLuqS5Q8G2jSluHYFCAxVmj7cNPK-rDQ3mUsuDjikQ,7979
 edsl/surveys/Rule.py,sha256=ddZyZSObs4gsKtFSmcXkPigXDX8rrh1NFvAplP02TcA,11092
 edsl/surveys/RuleCollection.py,sha256=sN7aYDQJG3HmE-WxohgpctcQbHewjwE6NAqEVTxvFP8,13359
-edsl/surveys/Survey.py,sha256=oir5fnZD2chtUH1qsVSmTdVdXLRWcB0wkkby_Lcguu8,47227
+edsl/surveys/Survey.py,sha256=uj8i76UOuSH0kXHncipq_4hvLIrt0QmtnodlI1iP6EA,48553
 edsl/surveys/SurveyCSS.py,sha256=NjJezs2sTlgFprN6IukjGKwNYmNdXnLjzV2w5K4z4RI,8415
 edsl/surveys/SurveyExportMixin.py,sha256=vj9bZReHx0wBK9sVuS0alzPIUDdg6AFFMd7bl1RKWKI,6555
 edsl/surveys/SurveyFlowVisualizationMixin.py,sha256=Z-YqeedMqWOtCFy003YJ9aneJ1n4bn70lDoILwLtTc0,3966
@@ -197,7 +197,7 @@ edsl/utilities/interface.py,sha256=AaKpWiwWBwP2swNXmnFlIf3ZFsjfsR5bjXQAW47tD-8,1
 edsl/utilities/repair_functions.py,sha256=tftmklAqam6LOQQu_-9U44N-llycffhW8LfO63vBmNw,929
 edsl/utilities/restricted_python.py,sha256=5-_zUhrNbos7pLhDl9nr8d24auRlquR6w-vKkmNjPiA,2060
 edsl/utilities/utilities.py,sha256=oU5Gg6szTGqsJ2yBOS0aC3XooezLE8By3SdrQLLpqvA,10107
-edsl-0.1.30.dev4.dist-info/LICENSE,sha256=_qszBDs8KHShVYcYzdMz3HNMtH-fKN_p5zjoVAVumFc,1111
-edsl-0.1.30.dev4.dist-info/METADATA,sha256=StzD_Wua0pqicToraGkUrdMlwlCtVqmxHVUQa1VhhvM,4103
-edsl-0.1.30.dev4.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-edsl-0.1.30.dev4.dist-info/RECORD,,
+edsl-0.1.30.dev5.dist-info/LICENSE,sha256=_qszBDs8KHShVYcYzdMz3HNMtH-fKN_p5zjoVAVumFc,1111
+edsl-0.1.30.dev5.dist-info/METADATA,sha256=ZMHio4ApnpJuGkuSFhbeWi9r4mr6dTb4HNFUuZUTLfc,4103
+edsl-0.1.30.dev5.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+edsl-0.1.30.dev5.dist-info/RECORD,,

{edsl-0.1.30.dev4.dist-info → edsl-0.1.30.dev5.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.8.1
+Generator: poetry-core 1.9.0
 Root-Is-Purelib: true
 Tag: py3-none-any