edsl 0.1.38.dev4__py3-none-any.whl → 0.1.39__py3-none-any.whl

edsl/agents/AgentList.py

@@ -1,38 +1,41 @@
-"""A list of Agent objects.
-
-Example usage:
-
-.. code-block:: python
-
-    al = AgentList([Agent.example(), Agent.example()])
-    len(al)
-    2
-    
+"""A list of Agents
 """
 
 from __future__ import annotations
 import csv
-import json
+import sys
 from collections import UserList
+from collections.abc import Iterable
+
 from typing import Any, List, Optional, Union, TYPE_CHECKING
-from rich import print_json
-from rich.table import Table
-from simpleeval import EvalWithCompoundTypes
-from edsl.Base import Base
-from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
 
-from collections.abc import Iterable
+from simpleeval import EvalWithCompoundTypes, NameNotDefined
 
+from edsl.Base import Base
+from edsl.utilities.remove_edsl_version import remove_edsl_version
 from edsl.exceptions.agents import AgentListError
+from edsl.utilities.is_notebook import is_notebook
+from edsl.results.ResultsExportMixin import ResultsExportMixin
+import logging
+
+logger = logging.getLogger(__name__)
 
 if TYPE_CHECKING:
     from edsl.scenarios.ScenarioList import ScenarioList
+    from edsl.agents.Agent import Agent
+    from pandas import DataFrame
 
 
 def is_iterable(obj):
     return isinstance(obj, Iterable)
 
 
+class EmptyAgentList:
+    def __repr__(self):
+        return "Empty AgentList"
+
+
+# ResultsExportMixin,
 class AgentList(UserList, Base):
     """A list of Agents."""
 
@@ -50,14 +53,15 @@ class AgentList(UserList, Base):
         else:
             super().__init__()
 
-    def shuffle(self, seed: Optional[str] = "edsl") -> AgentList:
+    def shuffle(self, seed: Optional[str] = None) -> AgentList:
         """Shuffle the AgentList.
 
         :param seed: The seed for the random number generator.
         """
         import random
 
-        random.seed(seed)
+        if seed is not None:
+            random.seed(seed)
         random.shuffle(self.data)
         return self
 
@@ -73,22 +77,60 @@ class AgentList(UserList, Base):
             random.seed(seed)
         return AgentList(random.sample(self.data, n))
 
-    def to_pandas(self):
-        """Return a pandas DataFrame."""
+    def to_pandas(self) -> "DataFrame":
+        """Return a pandas DataFrame.
+
+        >>> from edsl.agents.Agent import Agent
+        >>> al = AgentList([Agent(traits = {'age': 22, 'hair': 'brown', 'height': 5.5}), Agent(traits = {'age': 22, 'hair': 'brown', 'height': 5.5})])
+        >>> al.to_pandas()
+           age   hair  height
+        0   22  brown     5.5
+        1   22  brown     5.5
+        """
         return self.to_scenario_list().to_pandas()
 
-    def tally(self):
-        return self.to_scenario_list().tally()
+    def tally(
+        self, *fields: Optional[str], top_n: Optional[int] = None, output="Dataset"
+    ) -> Union[dict, "Dataset"]:
+        """Tally the values of a field or perform a cross-tab of multiple fields.
+
+        :param fields: The field(s) to tally, multiple fields for cross-tabulation.
 
-    def rename(self, old_name, new_name):
+        >>> al = AgentList.example()
+        >>> al.tally('age')
+        Dataset([{'age': [22]}, {'count': [2]}])
+        """
+        return self.to_scenario_list().tally(*fields, top_n=top_n, output=output)
+
+    def duplicate(self):
+        """Duplicate the AgentList.
+
+        >>> al = AgentList.example()
+        >>> al2 = al.duplicate()
+        >>> al2 == al
+        True
+        >>> id(al2) == id(al)
+        False
+        """
+        return AgentList([a.duplicate() for a in self.data])
+
+    def rename(self, old_name, new_name) -> AgentList:
         """Rename a trait in the AgentList.
 
         :param old_name: The old name of the trait.
         :param new_name: The new name of the trait.
+        :param inplace: Whether to rename the trait in place.
+
+        >>> from edsl.agents.Agent import Agent
+        >>> al = AgentList([Agent(traits = {'a': 1, 'b': 1}), Agent(traits = {'a': 1, 'b': 2})])
+        >>> al2 = al.rename('a', 'c')
+        >>> assert al2 == AgentList([Agent(traits = {'c': 1, 'b': 1}), Agent(traits = {'c': 1, 'b': 2})])
+        >>> assert al != al2
         """
-        for agent in self.data:
-            agent.rename(old_name, new_name)
-        return self
+        newagents = []
+        for agent in self:
+            newagents.append(agent.rename(old_name, new_name))
+        return AgentList(newagents)
 
     def select(self, *traits) -> AgentList:
         """Selects agents with only the references traits.
@@ -123,19 +165,36 @@ class AgentList(UserList, Base):
             """
             return EvalWithCompoundTypes(names=agent.traits)
 
-        try:
             # iterates through all the results and evaluates the expression
+
+        try:
             new_data = [
                 agent for agent in self.data if create_evaluator(agent).eval(expression)
             ]
-        except Exception as e:
-            print(f"Exception:{e}")
-            raise AgentListError(f"Error in filter. Exception:{e}")
+        except NameNotDefined as e:
+            e = AgentListError(f"'{expression}' is not a valid expression.")
+            if is_notebook():
+                print(e, file=sys.stderr)
+            else:
+                raise e
+
+            return EmptyAgentList()
+
+        if len(new_data) == 0:
+            return EmptyAgentList()
 
         return AgentList(new_data)
 
     @property
-    def all_traits(self):
+    def all_traits(self) -> list[str]:
+        """Return all traits in the AgentList.
+        >>> from edsl.agents.Agent import Agent
+        >>> agent_1 = Agent(traits = {'age': 22})
+        >>> agent_2 = Agent(traits = {'hair': 'brown'})
+        >>> al = AgentList([agent_1, agent_2])
+        >>> al.all_traits
+        ['age', 'hair']
+        """
         d = {}
         for agent in self:
             d.update(agent.traits)
@@ -180,14 +239,20 @@ class AgentList(UserList, Base):
                     agent_list.append(Agent(traits=row))
         return cls(agent_list)
 
-    def translate_traits(self, values_codebook: dict[str, str]):
+    def translate_traits(self, codebook: dict[str, str]):
         """Translate traits to a new codebook.
 
         :param codebook: The new codebook.
+
+        >>> al = AgentList.example()
+        >>> codebook = {'hair': {'brown':'Secret word for green'}}
+        >>> al.translate_traits(codebook)
+        AgentList([Agent(traits = {'age': 22, 'hair': 'Secret word for green', 'height': 5.5}), Agent(traits = {'age': 22, 'hair': 'Secret word for green', 'height': 5.5})])
         """
+        new_agents = []
         for agent in self.data:
-            agent.translate_traits(codebook)
-        return self
+            new_agents.append(agent.translate_traits(codebook))
+        return AgentList(new_agents)
 
     def remove_trait(self, trait: str):
         """Remove traits from the AgentList.
@@ -198,20 +263,21 @@ class AgentList(UserList, Base):
         >>> al.remove_trait('age')
         AgentList([Agent(traits = {'hair': 'brown', 'height': 5.5}), Agent(traits = {'hair': 'brown', 'height': 5.5})])
         """
-        for agent in self.data:
-            _ = agent.remove_trait(trait)
-        return self
+        agents = []
+        new_al = self.duplicate()
+        for agent in new_al.data:
+            agents.append(agent.remove_trait(trait))
+        return AgentList(agents)
 
-    def add_trait(self, trait, values):
+    def add_trait(self, trait: str, values: List[Any]) -> AgentList:
         """Adds a new trait to every agent, with values taken from values.
 
         :param trait: The name of the trait.
         :param values: The valeues(s) of the trait. If a single value is passed, it is used for all agents.
 
         >>> al = AgentList.example()
-        >>> al.add_trait('new_trait', 1)
-        AgentList([Agent(traits = {'age': 22, 'hair': 'brown', 'height': 5.5, 'new_trait': 1}), Agent(traits = {'age': 22, 'hair': 'brown', 'height': 5.5, 'new_trait': 1})])
-        >>> al.select('new_trait').to_scenario_list().to_list()
+        >>> new_al = al.add_trait('new_trait', 1)
+        >>> new_al.select('new_trait').to_scenario_list().to_list()
         [1, 1]
         >>> al.add_trait('new_trait', [1, 2, 3])
         Traceback (most recent call last):
@@ -220,18 +286,24 @@ class AgentList(UserList, Base):
         ...
         """
         if not is_iterable(values):
+            new_agents = []
             value = values
             for agent in self.data:
-                agent.add_trait(trait, value)
-            return self
+                new_agents.append(agent.add_trait(trait, value))
+            return AgentList(new_agents)
 
         if len(values) != len(self):
-            raise AgentListError(
+            e = AgentListError(
                 "The passed values have to be the same length as the agent list."
             )
+            if is_notebook():
+                print(e, file=sys.stderr)
+            else:
+                raise e
+        new_agents = []
         for agent, value in zip(self.data, values):
-            agent.add_trait(trait, value)
-        return self
+            new_agents.append(agent.add_trait(trait, value))
+        return AgentList(new_agents)
 
     @staticmethod
     def get_codebook(file_path: str):
@@ -244,12 +316,23 @@ class AgentList(UserList, Base):
             return {field: None for field in reader.fieldnames}
 
     def __hash__(self) -> int:
+        """Return the hash of the AgentList.
+
+        >>> al = AgentList.example()
+        >>> hash(al)
+        1681154913465662422
+        """
         from edsl.utilities.utilities import dict_hash
 
         return dict_hash(self.to_dict(add_edsl_version=False, sorted=True))
 
     def to_dict(self, sorted=False, add_edsl_version=True):
-        """Serialize the AgentList to a dictionary."""
+        """Serialize the AgentList to a dictionary.
+
+        >>> AgentList.example().to_dict(add_edsl_version=False)
+        {'agent_list': [{'traits': {'age': 22, 'hair': 'brown', 'height': 5.5}}, {'traits': {'age': 22, 'hair': 'brown', 'height': 5.5}}]}
+
+        """
         if sorted:
             data = self.data[:]
             data.sort(key=lambda x: hash(x))
@@ -279,15 +362,26 @@ class AgentList(UserList, Base):
 
     def _summary(self):
         return {
-            "EDSL Class": "AgentList",
-            "Number of agents": len(self),
-            "Agent trait fields": self.all_traits,
+            "agents": len(self),
         }
 
-    def _repr_html_(self):
-        """Return an HTML representation of the AgentList."""
-        footer = f"<a href={self.__documentation__}>(docs)</a>"
-        return str(self.summary(format="html")) + footer
+    def set_codebook(self, codebook: dict[str, str]) -> AgentList:
+        """Set the codebook for the AgentList.
+
+        >>> from edsl.agents.Agent import Agent
+        >>> a = Agent(traits = {'hair': 'brown'})
+        >>> al = AgentList([a, a])
+        >>> _ = al.set_codebook({'hair': "Color of hair on driver's license"})
+        >>> al[0].codebook
+        {'hair': "Color of hair on driver's license"}
+
+
+        :param codebook: The codebook.
+        """
+        for agent in self.data:
+            agent.codebook = codebook
+
+        return self
 
     def to_csv(self, file_path: str):
         """Save the AgentList to a CSV file.
@@ -300,19 +394,33 @@ class AgentList(UserList, Base):
         """Return a list of tuples."""
         return self.to_scenario_list(include_agent_name).to_list()
 
-    def to_scenario_list(self, include_agent_name=False) -> ScenarioList:
-        """Return a list of scenarios."""
+    def to_scenario_list(
+        self, include_agent_name: bool = False, include_instruction: bool = False
+    ) -> ScenarioList:
+        """Converts the agent to a scenario list."""
         from edsl.scenarios.ScenarioList import ScenarioList
         from edsl.scenarios.Scenario import Scenario
 
-        if include_agent_name:
-            return ScenarioList(
-                [
-                    Scenario(agent.traits | {"agent_name": agent.name})
-                    for agent in self.data
-                ]
-            )
-        return ScenarioList([Scenario(agent.traits) for agent in self.data])
+        # raise NotImplementedError("This method is not implemented yet.")
+
+        scenario_list = ScenarioList()
+        for agent in self.data:
+            d = agent.traits
+            if include_agent_name:
+                d["agent_name"] = agent.name
+            if include_instruction:
+                d["instruction"] = agent.instruction
+            scenario_list.append(Scenario(d))
+        return scenario_list
+
+        # if include_agent_name:
+        #     return ScenarioList(
+        #         [
+        #             Scenario(agent.traits | {"agent_name": agent.name} | })
+        #             for agent in self.data
+        #         ]
+        #     )
+        # return ScenarioList([Scenario(agent.traits) for agent in self.data])
 
     def table(
         self,
@@ -320,12 +428,50 @@ class AgentList(UserList, Base):
         tablefmt: Optional[str] = None,
         pretty_labels: Optional[dict] = None,
     ) -> Table:
+        if len(self) == 0:
+            e = AgentListError("Cannot create a table from an empty AgentList.")
+            if is_notebook():
+                print(e, file=sys.stderr)
+                return None
+            else:
+                raise e
         return (
             self.to_scenario_list()
             .to_dataset()
             .table(*fields, tablefmt=tablefmt, pretty_labels=pretty_labels)
         )
 
+    def to_dataset(self, traits_only: bool = True):
+        """
+        Convert the AgentList to a Dataset.
+
+        >>> from edsl.agents.AgentList import AgentList
+        >>> al = AgentList.example()
+        >>> al.to_dataset()
+        Dataset([{'age': [22, 22]}, {'hair': ['brown', 'brown']}, {'height': [5.5, 5.5]}])
+        >>> al.to_dataset(traits_only = False)
+        Dataset([{'age': [22, 22]}, {'hair': ['brown', 'brown']}, {'height': [5.5, 5.5]}, {'agent_parameters': [{'instruction': 'You are answering questions as if you were a human. Do not break character.', 'agent_name': None}, {'instruction': 'You are answering questions as if you were a human. Do not break character.', 'agent_name': None}]}])
+        """
+        from edsl.results.Dataset import Dataset
+        from collections import defaultdict
+
+        agent_trait_keys = []
+        for agent in self:
+            agent_keys = list(agent.traits.keys())
+            for key in agent_keys:
+                if key not in agent_trait_keys:
+                    agent_trait_keys.append(key)
+
+        data = defaultdict(list)
+        for agent in self:
+            for trait_key in agent_trait_keys:
+                data[trait_key].append(agent.traits.get(trait_key, None))
+            if not traits_only:
+                data["agent_parameters"].append(
+                    {"instruction": agent.instruction, "agent_name": agent.name}
+                )
+        return Dataset([{key: entry} for key, entry in data.items()])
+
     def tree(self, node_order: Optional[List[str]] = None):
         return self.to_scenario_list().tree(node_order)
 
@@ -398,14 +544,6 @@ class AgentList(UserList, Base):
             return "\n".join(lines)
         return lines
 
-    def rich_print(self) -> Table:
-        """Display an object as a rich table."""
-        table = Table(title="AgentList")
-        table.add_column("Agents", style="bold")
-        for agent in self.data:
-            table.add_row(agent.rich_print())
-        return table
-
 
 if __name__ == "__main__":
     import doctest

edsl/agents/Invigilator.py

@@ -1,38 +1,29 @@
 """Module for creating Invigilators, which are objects to administer a question to an Agent."""
 
-from typing import Dict, Any, Optional
+from typing import Dict, Any, Optional, TYPE_CHECKING
 
-from edsl.prompts.Prompt import Prompt
-from edsl.utilities.decorators import sync_wrapper, jupyter_nb_handler
-
-# from edsl.prompts.registry import get_classes as prompt_lookup
+from edsl.utilities.decorators import sync_wrapper
 from edsl.exceptions.questions import QuestionAnswerValidationError
 from edsl.agents.InvigilatorBase import InvigilatorBase
 from edsl.data_transfer_models import AgentResponseDict, EDSLResultObjectInput
-from edsl.agents.PromptConstructor import PromptConstructor
+
+if TYPE_CHECKING:
+    from edsl.prompts.Prompt import Prompt
+    from edsl.scenarios.Scenario import Scenario
+    from edsl.surveys.Survey import Survey
 
 
-class NotApplicable(str):
-    def __new__(cls):
-        instance = super().__new__(cls, "Not Applicable")
-        instance.literal = "Not Applicable"
-        return instance
+NA = "Not Applicable"
 
 
 class InvigilatorAI(InvigilatorBase):
     """An invigilator that uses an AI model to answer questions."""
 
-    def get_prompts(self) -> Dict[str, Prompt]:
+    def get_prompts(self) -> Dict[str, "Prompt"]:
         """Return the prompts used."""
         return self.prompt_constructor.get_prompts()
 
-    async def async_answer_question(self) -> AgentResponseDict:
-        """Answer a question using the AI model.
-
-        >>> i = InvigilatorAI.example()
-        >>> i.answer_question()
-        {'message': [{'text': 'SPAM!'}], 'usage': {'prompt_tokens': 1, 'completion_tokens': 1}}
-        """
+    async def async_get_agent_response(self) -> AgentResponseDict:
         prompts = self.get_prompts()
         params = {
             "user_prompt": prompts["user_prompt"].text,
@@ -40,33 +31,95 @@ class InvigilatorAI(InvigilatorBase):
         }
         if "encoded_image" in prompts:
             params["encoded_image"] = prompts["encoded_image"]
+            raise NotImplementedError("encoded_image not implemented")
+
         if "files_list" in prompts:
             params["files_list"] = prompts["files_list"]
 
         params.update({"iteration": self.iteration, "cache": self.cache})
-
         params.update({"invigilator": self})
-        # if hasattr(self.question, "answer_template"):
-        #    breakpoint()
 
-        agent_response_dict: AgentResponseDict = await self.model.async_get_response(
-            **params
-        )
-        # store to self in case validation failure
+        if self.key_lookup:
+            self.model.set_key_lookup(self.key_lookup)
+
+        return await self.model.async_get_response(**params)
+
+    def store_response(self, agent_response_dict: AgentResponseDict) -> None:
+        """Store the response in the invigilator, in case it is needed later because of validation failure."""
         self.raw_model_response = agent_response_dict.model_outputs.response
         self.generated_tokens = agent_response_dict.edsl_dict.generated_tokens
 
-        return self.extract_edsl_result_entry_and_validate(agent_response_dict)
+    async def async_answer_question(self) -> AgentResponseDict:
+        """Answer a question using the AI model.
+
+        >>> i = InvigilatorAI.example()
+        """
+        agent_response_dict = await self.async_get_agent_response()
+        self.store_response(agent_response_dict)
+        return self._extract_edsl_result_entry_and_validate(agent_response_dict)
 
     def _remove_from_cache(self, cache_key) -> None:
         """Remove an entry from the cache."""
         if cache_key:
             del self.cache.data[cache_key]
 
-    def determine_answer(self, raw_answer: str) -> Any:
-        question_dict = self.survey.question_names_to_questions()
+    def _determine_answer(self, raw_answer: str) -> Any:
+        """Determine the answer from the raw answer.
+
+        >>> i = InvigilatorAI.example()
+        >>> i._determine_answer("SPAM!")
+        'SPAM!'
+
+        >>> from edsl.questions import QuestionMultipleChoice
+        >>> q = QuestionMultipleChoice(question_text = "How are you?", question_name = "how_are_you", question_options = ["Good", "Bad"], use_code = True)
+        >>> i = InvigilatorAI.example(question = q)
+        >>> i._determine_answer("1")
+        'Bad'
+        >>> i._determine_answer("0")
+        'Good'
+
+        This shows how the answer can depend on scenario details
+
+        >>> from edsl import Scenario
+        >>> s = Scenario({'feeling_options':['Good', 'Bad']})
+        >>> q = QuestionMultipleChoice(question_text = "How are you?", question_name = "how_are_you", question_options = "{{ feeling_options }}", use_code = True)
+        >>> i = InvigilatorAI.example(question = q, scenario = s)
+        >>> i._determine_answer("1")
+        'Bad'
+
+        >>> from edsl import QuestionList, QuestionMultipleChoice, Survey
+        >>> q1 = QuestionList(question_name = "favs", question_text = "What are your top 3 colors?")
+        >>> q2 = QuestionMultipleChoice(question_text = "What is your favorite color?", question_name = "best", question_options = "{{ favs.answer }}", use_code = True)
+        >>> survey = Survey([q1, q2])
+        >>> i = InvigilatorAI.example(question = q2, scenario = s, survey = survey)
+        >>> i.current_answers = {"favs": ["Green", "Blue", "Red"]}
+        >>> i._determine_answer("2")
+        'Red'
+        """
+        substitution_dict = self._prepare_substitution_dict(
+            self.survey, self.current_answers, self.scenario
+        )
+        return self.question._translate_answer_code_to_answer(
+            raw_answer, substitution_dict
+        )
+
+    @staticmethod
+    def _prepare_substitution_dict(
+        survey: "Survey", current_answers: dict, scenario: "Scenario"
+    ) -> Dict[str, Any]:
+        """Prepares a substitution dictionary for the question based on the survey, current answers, and scenario.
+
+        This is necessary beause sometimes the model's answer to a question could depend on details in
+        the prompt that were provided by the answer to a previous question or a scenario detail.
+
+        Note that the question object is getting the answer & a the comment appended to it, as the
+        jinja2 template might be referencing these values with a dot notation.
+
+        """
+        question_dict = survey.duplicate().question_names_to_questions()
+
         # iterates through the current answers and updates the question_dict (which is all questions)
-        for other_question, answer in self.current_answers.items():
+        for other_question, answer in current_answers.items():
             if other_question in question_dict:
                 question_dict[other_question].answer = answer
             else:
@@ -76,13 +129,12 @@ class InvigilatorAI(InvigilatorBase):
                 ) in question_dict:
                     question_dict[new_question].comment = answer
 
-        combined_dict = {**question_dict, **self.scenario}
-        # sometimes the answer is a code, so we need to translate it
-        return self.question._translate_answer_code_to_answer(raw_answer, combined_dict)
+        return {**question_dict, **scenario}
 
-    def extract_edsl_result_entry_and_validate(
+    def _extract_edsl_result_entry_and_validate(
         self, agent_response_dict: AgentResponseDict
     ) -> EDSLResultObjectInput:
+        """Extract the EDSL result entry and validate it."""
         edsl_dict = agent_response_dict.edsl_dict._asdict()
         exception_occurred = None
         validated = False
@@ -94,10 +146,8 @@ class InvigilatorAI(InvigilatorBase):
                 # question options have be treated differently because of dynamic question
                 # this logic is all in the prompt constructor
                 if "question_options" in self.question.data:
-                    new_question_options = (
-                        self.prompt_constructor._get_question_options(
-                            self.question.data
-                        )
+                    new_question_options = self.prompt_constructor.get_question_options(
+                        self.question.data
                     )
                     if new_question_options != self.question.data["question_options"]:
                         # I don't love this direct writing but it seems to work
@@ -110,9 +160,8 @@ class InvigilatorAI(InvigilatorBase):
             else:
                 question_with_validators = self.question
 
-            # breakpoint()
             validated_edsl_dict = question_with_validators._validate_answer(edsl_dict)
-            answer = self.determine_answer(validated_edsl_dict["answer"])
+            answer = self._determine_answer(validated_edsl_dict["answer"])
             comment = validated_edsl_dict.get("comment", "")
             validated = True
         except QuestionAnswerValidationError as e:
@@ -182,13 +231,13 @@ class InvigilatorHuman(InvigilatorBase):
                 exception_occurred = e
         finally:
             data = {
-                "generated_tokens": NotApplicable(),
+                "generated_tokens": NA,  # NotApplicable(),
                 "question_name": self.question.question_name,
                 "prompts": self.get_prompts(),
-                "cached_response": NotApplicable(),
-                "raw_model_response": NotApplicable(),
-                "cache_used": NotApplicable(),
-                "cache_key": NotApplicable(),
+                "cached_response": NA,
+                "raw_model_response": NA,
+                "cache_used": NA,
+                "cache_key": NA,
                 "answer": answer,
                 "comment": comment,
                 "validated": validated,
@@ -209,17 +258,19 @@ class InvigilatorFunctional(InvigilatorBase):
             generated_tokens=str(answer),
             question_name=self.question.question_name,
             prompts=self.get_prompts(),
-            cached_response=NotApplicable(),
-            raw_model_response=NotApplicable(),
-            cache_used=NotApplicable(),
-            cache_key=NotApplicable(),
+            cached_response=NA,
+            raw_model_response=NA,
+            cache_used=NA,
+            cache_key=NA,
             answer=answer["answer"],
             comment="This is the result of a functional question.",
             validated=True,
             exception_occurred=None,
         )
 
-    def get_prompts(self) -> Dict[str, Prompt]:
+    def get_prompts(self) -> Dict[str, "Prompt"]:
+        from edsl.prompts.Prompt import Prompt
+
         """Return the prompts used."""
         return {
             "user_prompt": Prompt("NA"),