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

edsl/__version__.py

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

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

@@ -97,7 +97,7 @@ class InvigilatorAI(PromptConstructorMixin, InvigilatorBase):
         answer = question._translate_answer_code_to_answer(
             response["answer"], combined_dict
         )
-        # breakpoint()
+        #breakpoint()
         data = {
             "answer": answer,
             "comment": response.get(

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,7 @@ class Cache(Base):
         data: Optional[Union["SQLiteDict", dict]] = None,
         immediate_write: bool = True,
         method=None,
-        verbose=False,
+        verbose = False
     ):
         """
         Create two dictionaries to store the cache data.
@@ -473,18 +480,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,7 +17,7 @@ class AgentResponseDict(UserDict):
         cached_response=None,
         raw_model_response=None,
         simple_model_raw_response=None,
-        cache_used=None,
+        cache_used=None, 
         cache_key=None,
     ):
         """Initialize the AgentResponseDict object."""

edsl/jobs/Jobs.py

@@ -687,9 +687,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 +697,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 +743,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

@@ -24,7 +24,7 @@ class ModelBuckets:
             requests_bucket=self.requests_bucket + other.requests_bucket,
             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()

edsl/jobs/buckets/TokenBucket.py

@@ -30,17 +30,16 @@ class TokenBucket:
         if self.turbo_mode:
             pass
         else:
-            # pass
             self.turbo_mode = True
-            self.capacity = float("inf")
-            self.refill_rate = float("inf")
+            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 +72,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

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"],
+        agent: 'Agent',
+        survey: 'Survey',
+        scenario: 'Scenario',
+        model: Type['LanguageModel'],
         debug: Optional[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,17 @@ 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.
@@ -169,14 +123,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 +140,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 +156,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 +166,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 +178,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 +193,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()

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,14 +175,24 @@ 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
-
-    def _add_answer(
-        self, response: "AgentResponseDict", question: "QuestionBase"
-    ) -> None:
+            # 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:
         """Add the answer to the answers dictionary.
 
         :param response: the response to the question.
@@ -190,7 +200,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/runners/JobsRunnerAsyncio.py

@@ -89,7 +89,6 @@ class JobsRunnerAsyncio(JobsRunnerStatusMixin):
 
     async def run_async(self, cache=None) -> Results:
         from edsl.results.Results import Results
-
         if cache is None:
             self.cache = Cache()
         else:
@@ -101,7 +100,6 @@ class JobsRunnerAsyncio(JobsRunnerStatusMixin):
 
     def simple_run(self):
         from edsl.results.Results import Results
-
         data = asyncio.run(self.run_async())
         return Results(survey=self.jobs.survey, data=data)
 

edsl/jobs/tasks/QuestionTaskCreator.py

@@ -144,14 +144,18 @@ class QuestionTaskCreator(UserList):
             self.task_status = TaskStatus.FAILED
             raise e
 
-        if results.get("cache_used", False):
+        ## This isn't working 
+        #breakpoint()
+        if results.get('cache_used', False):
             self.tokens_bucket.add_tokens(requested_tokens)
             self.requests_bucket.add_tokens(1)
             self.from_cache = True
-            # Turbo mode means that we don't wait for tokens or requests.
+            #print("Turning on turbo!")
             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()
 
@@ -159,6 +163,7 @@ class QuestionTaskCreator(UserList):
 
         tracker = self.cached_token_usage if self.from_cache else self.new_token_usage
 
+
         # TODO: This is hacky. The 'func' call should return an object that definitely has a 'usage' key.
         usage = results.get("usage", {"prompt_tokens": 0, "completion_tokens": 0})
         prompt_tokens = usage.get("prompt_tokens", 0)