edsl 0.1.30.dev5__py3-none-any.whl → 0.1.31.dev1__py3-none-any.whl

edsl/__version__.py

@@ -1 +1 @@
-__version__ = "0.1.30.dev5"
+__version__ = "0.1.31.dev1"

edsl/coop/utils.py

@@ -2,6 +2,7 @@ from edsl import (
     Agent,
     AgentList,
     Cache,
+    ModelList,
     Notebook,
     Results,
     Scenario,
@@ -9,6 +10,7 @@ from edsl import (
     Survey,
     Study,
 )
+from edsl.language_models import LanguageModel
 from edsl.questions import QuestionBase
 from typing import Literal, Optional, Type, Union
 
@@ -16,6 +18,8 @@ EDSLObject = Union[
     Agent,
     AgentList,
     Cache,
+    LanguageModel,
+    ModelList,
     Notebook,
     Type[QuestionBase],
     Results,
@@ -29,6 +33,8 @@ ObjectType = Literal[
     "agent",
     "agent_list",
     "cache",
+    "model",
+    "model_list",
     "notebook",
     "question",
     "results",
@@ -62,8 +68,10 @@ class ObjectRegistry:
         {"object_type": "agent", "edsl_class": Agent},
         {"object_type": "agent_list", "edsl_class": AgentList},
         {"object_type": "cache", "edsl_class": Cache},
-        {"object_type": "question", "edsl_class": QuestionBase},
+        {"object_type": "model", "edsl_class": LanguageModel},
+        {"object_type": "model_list", "edsl_class": ModelList},
         {"object_type": "notebook", "edsl_class": Notebook},
+        {"object_type": "question", "edsl_class": QuestionBase},
         {"object_type": "results", "edsl_class": Results},
         {"object_type": "scenario", "edsl_class": Scenario},
         {"object_type": "scenario_list", "edsl_class": ScenarioList},

edsl/jobs/buckets/TokenBucket.py

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

edsl/jobs/interviews/Interview.py

@@ -22,9 +22,11 @@ from edsl.jobs.interviews.InterviewStatusMixin import InterviewStatusMixin
 
 import asyncio
 
+
 def run_async(coro):
     return asyncio.run(coro)
 
+
 class Interview(InterviewStatusMixin, InterviewTaskBuildingMixin):
     """
     An 'interview' is one agent answering one survey, with one language model, for a given scenario.
@@ -41,7 +43,7 @@ class Interview(InterviewStatusMixin, InterviewTaskBuildingMixin):
         debug: Optional[bool] = False,
         iteration: int = 0,
         cache: Optional["Cache"] = None,
-        sidecar_model: Optional['LanguageModel'] = None,
+        sidecar_model: Optional["LanguageModel"] = None,
     ):
         """Initialize the Interview instance.
 
@@ -98,7 +100,7 @@ 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.
@@ -146,13 +148,11 @@ class Interview(InterviewStatusMixin, InterviewTaskBuildingMixin):
         if model_buckets is None or hasattr(self.agent, "answer_question_directly"):
             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
@@ -195,7 +195,7 @@ class Interview(InterviewStatusMixin, InterviewTaskBuildingMixin):
 
     def _record_exception(self, task, exception: Exception) -> None:
         """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()
@@ -235,14 +235,14 @@ 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:
+    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,
@@ -270,7 +270,7 @@ class Interview(InterviewStatusMixin, InterviewTaskBuildingMixin):
         scenario = Scenario.example()
         model = LanguageModel.example()
         if throw_exception:
-            model = LanguageModel.example(test_model = True, throw_exception=True)
+            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)

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,
@@ -179,8 +179,10 @@ class InterviewTaskBuildingMixin:
             return AgentResponseDict(**response)
         except Exception as e:
             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.
@@ -188,7 +190,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,8 +88,7 @@ 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
         )
@@ -145,7 +144,7 @@ class QuestionTaskCreator(UserList):
             self.task_status = TaskStatus.FAILED
             raise e
 
-        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

edsl/language_models/LanguageModel.py

@@ -494,7 +494,12 @@ 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",
+        throw_exception: bool = False,
+    ):
         """Return a default instance of the class.
 
         >>> from edsl.language_models import LanguageModel

edsl/language_models/ModelList.py

@@ -86,8 +86,14 @@ class ModelList(Base, UserList):
         pass
 
     @classmethod
-    def example(cl):
-        return ModelList([LanguageModel.example() for _ in range(3)])
+    def example(cls, randomize: bool = False) -> "ModelList":
+        """
+        Returns an example ModelList instance.
+
+        :param randomize: If True, uses Model's randomize method.
+        """
+
+        return cls([Model.example(randomize) for _ in range(3)])
 
 
 if __name__ == "__main__":

edsl/language_models/registry.py

@@ -1,4 +1,5 @@
 import textwrap
+from random import random
 
 
 def get_model_class(model_name, registry=None):
@@ -92,6 +93,17 @@ class Model(metaclass=Meta):
             print("OK!")
             print("\n")
 
+    @classmethod
+    def example(cls, randomize: bool = False) -> "Model":
+        """
+        Returns an example Model instance.
+
+        :param randomize: If True, the temperature is set to a random decimal between 0 and 1.
+        """
+        temperature = 0.5 if not randomize else round(random(), 2)
+        model_name = cls.default_model
+        return cls(model_name, temperature=temperature)
+
 
 if __name__ == "__main__":
     import doctest

edsl/questions/QuestionFunctional.py

@@ -6,11 +6,12 @@ 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()
 
@@ -21,7 +22,7 @@ class QuestionFunctional(QuestionBase):
     >>> 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
@@ -105,8 +106,6 @@ class QuestionFunctional(QuestionBase):
             "requires_loop": self.requires_loop,
             "function_name": self.function_name,
         }
-    
-    
 
     @classmethod
     def example(cls):
@@ -141,7 +140,9 @@ def main():
     results = question.by(scenario).by(agent).run()
     assert results.select("answer.*").to_list()[0] == 150
 
+
 if __name__ == "__main__":
-    #main()
+    # main()
     import doctest
-    doctest.testmod(optionflags=doctest.ELLIPSIS)
+
+    doctest.testmod(optionflags=doctest.ELLIPSIS)

edsl/questions/QuestionMultipleChoice.py

@@ -11,7 +11,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
 
     """
@@ -51,7 +51,7 @@ class QuestionMultipleChoice(QuestionBase):
         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'}
@@ -67,19 +67,17 @@ class QuestionMultipleChoice(QuestionBase):
         return answer
 
     def _translate_answer_code_to_answer(
-        self, 
-        answer_code: int, 
-        scenario: Optional["Scenario"] = None
+        self, answer_code: int, scenario: Optional["Scenario"] = None
     ):
         """Translate the answer code to the actual answer.
 
-        It is used to 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'
@@ -92,16 +90,20 @@ class QuestionMultipleChoice(QuestionBase):
         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]
+            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
+                Template(str(option)).render(scenario)
+                for option in self.question_options
             ]
-        #print("Translated options:", translated_options)
-        #breakpoint()
+        # print("Translated options:", translated_options)
+        # breakpoint()
         return translated_options[int(answer_code)]
 
     def _simulate_answer(

edsl/questions/descriptors.py

@@ -249,6 +249,7 @@ class QuestionOptionsDescriptor(BaseDescriptor):
 
             def __init__(self, question_options: List[str]):
                 self.question_options = question_options
+
         return TestQuestion
 
     def __init__(
@@ -264,16 +265,16 @@ class QuestionOptionsDescriptor(BaseDescriptor):
 
     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):
@@ -373,7 +374,8 @@ class QuestionTextDescriptor(BaseDescriptor):
                 UserWarning,
             )
 
+
 if __name__ == "__main__":
     import doctest
 
-    doctest.testmod(optionflags=doctest.ELLIPSIS)
+    doctest.testmod(optionflags=doctest.ELLIPSIS)