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

edsl/__version__.py

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

edsl/agents/Agent.py

@@ -4,8 +4,7 @@ from __future__ import annotations
 import copy
 import inspect
 import types
-from typing import Callable, Optional, Union
-from uuid import uuid4
+from typing import Any, Callable, Optional, Union, Dict, Sequence
 from edsl.Base import Base
 
 from edsl.exceptions.agents import (
@@ -689,14 +688,13 @@ class Agent(Base):
         return table
 
     @classmethod
-    def example(cls, randomize: bool = False) -> Agent:
-        """
-        Returns an example Agent instance.
+    def example(cls) -> Agent:
+        """Return an example agent.
 
-        :param randomize: If True, adds a random string to the value of an example key.
+        >>> Agent.example()
+        Agent(traits = {'age': 22, 'hair': 'brown', 'height': 5.5})
         """
-        addition = "" if not randomize else str(uuid4())
-        return cls(traits={"age": 22, "hair": f"brown{addition}", "height": 5.5})
+        return cls(traits={"age": 22, "hair": "brown", "height": 5.5})
 
     def code(self) -> str:
         """Return the code for the agent.

edsl/agents/AgentList.py

@@ -11,15 +11,23 @@ Example usage:
 """
 
 from __future__ import annotations
-import csv
-import json
 from collections import UserList
-from typing import Any, List, Optional, Union
+from typing import Optional, Union, Sequence, List, Any
 from rich import print_json
 from rich.table import Table
+import json
+import csv
+
+
 from simpleeval import EvalWithCompoundTypes
+
 from edsl.Base import Base
-from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
+
+# from edsl.agents import Agent
+from edsl.utilities.decorators import (
+    add_edsl_version,
+    remove_edsl_version,
+)
 
 
 class AgentList(UserList, Base):
@@ -231,15 +239,17 @@ class AgentList(UserList, Base):
         return cls(agents)
 
     @classmethod
-    def example(cls, randomize: bool = False) -> AgentList:
-        """
-        Returns an example AgentList instance.
+    def example(cls) -> "AgentList":
+        """Return an example AgentList.
+
+        >>> al = AgentList.example()
+        >>> len(al)
+        2
 
-        :param randomize: If True, uses Agent's randomize method.
         """
         from edsl.agents.Agent import Agent
 
-        return cls([Agent.example(randomize), Agent.example(randomize)])
+        return cls([Agent.example(), Agent.example()])
 
     @classmethod
     def from_list(self, trait_name: str, values: List[Any]):

edsl/agents/Invigilator.py

@@ -74,14 +74,15 @@ class InvigilatorAI(PromptConstructorMixin, InvigilatorBase):
 
         This cleans up the raw response to make it suitable to pass to AgentResponseDict.
         """
+        # not actually used, but this removes the temptation to delete agent from the signature
         _ = agent
         try:
             response = question._validate_answer(raw_response)
         except Exception as e:
-            """If the response is invalid, remove it from the cache and raise the exception."""
             self._remove_from_cache(raw_response)
             raise e
 
+        # breakpoint()
         question_dict = self.survey.question_names_to_questions()
         for other_question, answer in self.current_answers.items():
             if other_question in question_dict:
@@ -94,10 +95,12 @@ class InvigilatorAI(PromptConstructorMixin, InvigilatorBase):
                     question_dict[new_question].comment = answer
 
         combined_dict = {**question_dict, **scenario}
+        # print("combined_dict: ", combined_dict)
+        # print("response: ", response)
+        # breakpoint()
         answer = question._translate_answer_code_to_answer(
             response["answer"], combined_dict
         )
-        # breakpoint()
         data = {
             "answer": answer,
             "comment": response.get(
@@ -108,8 +111,6 @@ class InvigilatorAI(PromptConstructorMixin, InvigilatorBase):
             "cached_response": raw_response.get("cached_response", None),
             "usage": raw_response.get("usage", {}),
             "raw_model_response": raw_model_response,
-            "cache_used": raw_response.get("cache_used", False),
-            "cache_key": raw_response.get("cache_key", None),
         }
         return AgentResponseDict(**data)
 

edsl/conversation/car_buying.py

@@ -30,7 +30,7 @@ c1 = Conversation(agent_list=AgentList([a1, a3, a2]), max_turns=5, verbose=True)
 c2 = Conversation(agent_list=AgentList([a1, a2]), max_turns=5, verbose=True)
 
 c = Cache.load("car_talk.json.gz")
-# breakpoint()
+breakpoint()
 combo = ConversationList([c1, c2], cache=c)
 combo.run()
 results = combo.to_results()

edsl/data/Cache.py

@@ -7,10 +7,17 @@ import json
 import os
 import warnings
 from typing import Optional, Union
-from edsl.Base import Base
+import time
+from edsl.config import CONFIG
 from edsl.data.CacheEntry import CacheEntry
+
+# from edsl.data.SQLiteDict import SQLiteDict
+from edsl.Base import Base
 from edsl.utilities.utilities import dict_hash
-from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
+from edsl.utilities.decorators import (
+    add_edsl_version,
+    remove_edsl_version,
+)
 
 
 class Cache(Base):
@@ -34,7 +41,6 @@ class Cache(Base):
         data: Optional[Union["SQLiteDict", dict]] = None,
         immediate_write: bool = True,
         method=None,
-        verbose=False,
     ):
         """
         Create two dictionaries to store the cache data.
@@ -53,7 +59,6 @@ class Cache(Base):
         self.new_entries = {}
         self.new_entries_to_write_later = {}
         self.coop = None
-        self.verbose = verbose
 
         self.filename = filename
         if filename and data:
@@ -117,7 +122,7 @@ class Cache(Base):
         system_prompt: str,
         user_prompt: str,
         iteration: int,
-    ) -> tuple(Union[None, str], str):
+    ) -> Union[None, str]:
         """
         Fetch a value (LLM output) from the cache.
 
@@ -130,7 +135,7 @@ class Cache(Base):
         Return None if the response is not found.
 
         >>> c = Cache()
-        >>> c.fetch(model="gpt-3", parameters="default", system_prompt="Hello", user_prompt="Hi", iteration=1)[0] is None
+        >>> c.fetch(model="gpt-3", parameters="default", system_prompt="Hello", user_prompt="Hi", iteration=1) is None
         True
 
 
@@ -146,13 +151,8 @@ class Cache(Base):
         )
         entry = self.data.get(key, None)
         if entry is not None:
-            if self.verbose:
-                print(f"Cache hit for key: {key}")
             self.fetched_data[key] = entry
-        else:
-            if self.verbose:
-                print(f"Cache miss for key: {key}")
-        return None if entry is None else entry.output, key
+        return None if entry is None else entry.output
 
     def store(
         self,
@@ -354,9 +354,6 @@ class Cache(Base):
         for key, entry in self.new_entries_to_write_later.items():
             self.data[key] = entry
 
-        if self.filename:
-            self.write(self.filename)
-
     ####################
     # DUNDER / USEFUL
     ####################
@@ -473,18 +470,12 @@ class Cache(Base):
         webbrowser.open("file://" + filepath)
 
     @classmethod
-    def example(cls, randomize: bool = False) -> Cache:
+    def example(cls) -> Cache:
         """
-        Returns an example Cache instance.
-
-        :param randomize: If True, uses CacheEntry's randomize method.
+        Return an example Cache.
+        The example Cache has one entry.
         """
-        return cls(
-            data={
-                CacheEntry.example(randomize).key: CacheEntry.example(),
-                CacheEntry.example(randomize).key: CacheEntry.example(),
-            }
-        )
+        return cls(data={CacheEntry.example().key: CacheEntry.example()})
 
 
 if __name__ == "__main__":

edsl/data/CacheEntry.py

@@ -2,8 +2,11 @@ from __future__ import annotations
 import json
 import datetime
 import hashlib
+import random
 from typing import Optional
-from uuid import uuid4
+
+
+# TODO: Timestamp should probably be float?
 
 
 class CacheEntry:
@@ -148,12 +151,10 @@ class CacheEntry:
     @classmethod
     def example(cls, randomize: bool = False) -> CacheEntry:
         """
-        Returns an example CacheEntry instance.
-
-        :param randomize: If True, adds a random string to the system prompt.
+        Returns a CacheEntry example.
         """
-        # if random, create a uuid
-        addition = "" if not randomize else str(uuid4())
+        # if random, create a random number for 0-100
+        addition = "" if not randomize else str(random.randint(0, 1000))
         return CacheEntry(
             model="gpt-3.5-turbo",
             parameters={"temperature": 0.5},

edsl/data_transfer_models.py

@@ -17,8 +17,6 @@ class AgentResponseDict(UserDict):
         cached_response=None,
         raw_model_response=None,
         simple_model_raw_response=None,
-        cache_used=None,
-        cache_key=None,
     ):
         """Initialize the AgentResponseDict object."""
         usage = usage or {"prompt_tokens": 0, "completion_tokens": 0}
@@ -32,7 +30,5 @@ class AgentResponseDict(UserDict):
                 "cached_response": cached_response,
                 "raw_model_response": raw_model_response,
                 "simple_model_raw_response": simple_model_raw_response,
-                "cache_used": cache_used,
-                "cache_key": cache_key,
             }
         )

edsl/jobs/Jobs.py

@@ -461,13 +461,6 @@ class Jobs(Base):
             remote_inference = False
 
         if remote_inference:
-            from edsl.agents.Agent import Agent
-            from edsl.language_models.registry import Model
-            from edsl.results.Result import Result
-            from edsl.results.Results import Results
-            from edsl.scenarios.Scenario import Scenario
-            from edsl.surveys.Survey import Survey
-
             self._output("Remote inference activated. Sending job to server...")
             if remote_cache:
                 self._output(
@@ -687,9 +680,7 @@ class Jobs(Base):
     # Example methods
     #######################
     @classmethod
-    def example(
-        cls, throw_exception_probability: int = 0, randomize: bool = False
-    ) -> Jobs:
+    def example(cls, throw_exception_probability=0) -> Jobs:
         """Return an example Jobs instance.
 
         :param throw_exception_probability: the probability that an exception will be thrown when answering a question. This is useful for testing error handling.
@@ -699,13 +690,10 @@ class Jobs(Base):
 
         """
         import random
-        from uuid import uuid4
         from edsl.questions import QuestionMultipleChoice
         from edsl.agents.Agent import Agent
         from edsl.scenarios.Scenario import Scenario
 
-        addition = "" if not randomize else str(uuid4())
-
         # (status, question, period)
         agent_answers = {
             ("Joyful", "how_feeling", "morning"): "OK",
@@ -748,10 +736,7 @@ class Jobs(Base):
         base_survey = Survey(questions=[q1, q2])
 
         scenario_list = ScenarioList(
-            [
-                Scenario({"period": f"morning{addition}"}),
-                Scenario({"period": "afternoon"}),
-            ]
+            [Scenario({"period": "morning"}), Scenario({"period": "afternoon"})]
         )
         job = base_survey.by(scenario_list).by(joy_agent, sad_agent)
 

edsl/jobs/buckets/ModelBuckets.py

@@ -25,16 +25,6 @@ class ModelBuckets:
             tokens_bucket=self.tokens_bucket + other.tokens_bucket,
         )
 
-    def turbo_mode_on(self):
-        """Set the refill rate to infinity for both buckets."""
-        self.requests_bucket.turbo_mode_on()
-        self.tokens_bucket.turbo_mode_on()
-
-    def turbo_mode_off(self):
-        """Restore the refill rate to its original value for both buckets."""
-        self.requests_bucket.turbo_mode_off()
-        self.tokens_bucket.turbo_mode_off()
-
     @classmethod
     def infinity_bucket(cls, model_name: str = "not_specified") -> "ModelBuckets":
         """Create a bucket with infinite capacity and refill rate."""

edsl/jobs/buckets/TokenBucket.py

@@ -17,29 +17,11 @@ class TokenBucket:
         self.bucket_name = bucket_name
         self.bucket_type = bucket_type
         self.capacity = capacity  # Maximum number of tokens
-        self._old_capacity = capacity
         self.tokens = capacity  # Current number of available tokens
         self.refill_rate = refill_rate  # Rate at which tokens are refilled
-        self._old_refill_rate = refill_rate
         self.last_refill = time.monotonic()  # Last refill time
+
         self.log: List[Any] = []
-        self.turbo_mode = False
-
-    def turbo_mode_on(self):
-        """Set the refill rate to infinity."""
-        if self.turbo_mode:
-            pass
-        else:
-            # pass
-            self.turbo_mode = True
-            self.capacity = float("inf")
-            self.refill_rate = float("inf")
-
-    def turbo_mode_off(self):
-        """Restore the refill rate to its original value."""
-        self.turbo_mode = False
-        self.capacity = self._old_capacity
-        self.refill_rate = self._old_refill_rate
 
     def __add__(self, other) -> "TokenBucket":
         """Combine two token buckets.
@@ -73,17 +55,7 @@ class TokenBucket:
         self.log.append((time.monotonic(), self.tokens))
 
     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)
-        >>> bucket.tokens = 0
-        >>> bucket.refill()
-        >>> bucket.tokens > 0
-        True
-
-        """
+        """Refill the bucket with new tokens based on elapsed time."""
         now = time.monotonic()
         elapsed = now - self.last_refill
         refill_amount = elapsed * self.refill_rate
@@ -126,7 +98,7 @@ class TokenBucket:
             raise ValueError(msg)
         while self.tokens < amount:
             self.refill()
-            await asyncio.sleep(0.01)  # Sleep briefly to prevent busy waiting
+            await asyncio.sleep(0.1)  # Sleep briefly to prevent busy waiting
         self.tokens -= amount
 
         now = time.monotonic()

edsl/jobs/interviews/Interview.py

@@ -20,12 +20,6 @@ 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,14 +30,14 @@ class Interview(InterviewStatusMixin, InterviewTaskBuildingMixin):
 
     def __init__(
         self,
-        agent: "Agent",
-        survey: "Survey",
-        scenario: "Scenario",
-        model: Type["LanguageModel"],
-        debug: Optional[bool] = False,
+        agent: Agent,
+        survey: Survey,
+        scenario: Scenario,
+        model: Type[LanguageModel],
+        debug: bool = False,
         iteration: int = 0,
-        cache: Optional["Cache"] = None,
-        sidecar_model: Optional["LanguageModel"] = None,
+        cache: "Cache" = None,
+        sidecar_model: LanguageModel = None,
     ):
         """Initialize the Interview instance.
 
@@ -51,24 +45,6 @@ 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
@@ -88,7 +64,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)
@@ -100,16 +76,14 @@ 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:
 
@@ -117,37 +91,16 @@ 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()
 
+        # 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.
@@ -169,14 +122,6 @@ 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)
 
@@ -194,18 +139,7 @@ class Interview(InterviewStatusMixin, InterviewTaskBuildingMixin):
             yield result
 
     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()
-        >>> 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'}]}
-        """
+        """Record an exception in the Interview instance."""
         exception_entry = InterviewExceptionEntry(
             exception=repr(exception),
             time=time.time(),
@@ -221,10 +155,6 @@ 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)
 
@@ -235,15 +165,8 @@ 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.
-
-        >>> i = Interview.example()
-        >>> i2 = i.duplicate(1, None)
-        >>> i.iteration + 1 == i2.iteration
-        True
-
-        """
+    def duplicate(self, iteration: int, cache: Cache) -> Interview:
+        """Duplicate the interview, but with a new iteration number and cache."""
         return Interview(
             agent=self.agent,
             survey=self.survey,
@@ -254,7 +177,7 @@ class Interview(InterviewStatusMixin, InterviewTaskBuildingMixin):
         )
 
     @classmethod
-    def example(self, throw_exception: bool = False) -> Interview:
+    def example(self):
         """Return an example Interview instance."""
         from edsl.agents import Agent
         from edsl.surveys import Survey
@@ -269,15 +192,66 @@ 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
 
-    # add ellipsis
-    doctest.testmod(optionflags=doctest.ELLIPSIS)
+    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()