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

edsl/agents/AgentList.py

@@ -1,41 +1,38 @@
-"""A list of Agents
+"""A list of Agent objects.
+
+Example usage:
+
+.. code-block:: python
+
+    al = AgentList([Agent.example(), Agent.example()])
+    len(al)
+    2
+    
 """
 
 from __future__ import annotations
 import csv
-import sys
+import json
 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 simpleeval import EvalWithCompoundTypes, NameNotDefined
+from collections.abc import Iterable
 
-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."""
 
@@ -53,15 +50,14 @@ class AgentList(UserList, Base):
         else:
             super().__init__()
 
-    def shuffle(self, seed: Optional[str] = None) -> AgentList:
+    def shuffle(self, seed: Optional[str] = "edsl") -> AgentList:
         """Shuffle the AgentList.
 
         :param seed: The seed for the random number generator.
         """
         import random
 
-        if seed is not None:
-            random.seed(seed)
+        random.seed(seed)
         random.shuffle(self.data)
         return self
 
@@ -77,60 +73,22 @@ class AgentList(UserList, Base):
             random.seed(seed)
         return AgentList(random.sample(self.data, n))
 
-    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
-        """
+    def to_pandas(self):
+        """Return a pandas DataFrame."""
         return self.to_scenario_list().to_pandas()
 
-    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 tally(self):
+        return self.to_scenario_list().tally()
 
-        >>> 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:
+    def rename(self, old_name, new_name):
         """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
         """
-        newagents = []
-        for agent in self:
-            newagents.append(agent.rename(old_name, new_name))
-        return AgentList(newagents)
+        for agent in self.data:
+            agent.rename(old_name, new_name)
+        return self
 
     def select(self, *traits) -> AgentList:
         """Selects agents with only the references traits.
@@ -165,36 +123,19 @@ class AgentList(UserList, Base):
             """
             return EvalWithCompoundTypes(names=agent.traits)
 
-            # iterates through all the results and evaluates the expression
-
         try:
+            # iterates through all the results and evaluates the expression
             new_data = [
                 agent for agent in self.data if create_evaluator(agent).eval(expression)
             ]
-        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()
+        except Exception as e:
+            print(f"Exception:{e}")
+            raise AgentListError(f"Error in filter. Exception:{e}")
 
         return AgentList(new_data)
 
     @property
-    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']
-        """
+    def all_traits(self):
         d = {}
         for agent in self:
             d.update(agent.traits)
@@ -239,20 +180,14 @@ class AgentList(UserList, Base):
                     agent_list.append(Agent(traits=row))
         return cls(agent_list)
 
-    def translate_traits(self, codebook: dict[str, str]):
+    def translate_traits(self, values_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:
-            new_agents.append(agent.translate_traits(codebook))
-        return AgentList(new_agents)
+            agent.translate_traits(codebook)
+        return self
 
     def remove_trait(self, trait: str):
         """Remove traits from the AgentList.
@@ -263,21 +198,20 @@ class AgentList(UserList, Base):
         >>> al.remove_trait('age')
         AgentList([Agent(traits = {'hair': 'brown', 'height': 5.5}), Agent(traits = {'hair': 'brown', 'height': 5.5})])
         """
-        agents = []
-        new_al = self.duplicate()
-        for agent in new_al.data:
-            agents.append(agent.remove_trait(trait))
-        return AgentList(agents)
+        for agent in self.data:
+            _ = agent.remove_trait(trait)
+        return self
 
-    def add_trait(self, trait: str, values: List[Any]) -> AgentList:
+    def add_trait(self, trait, values):
         """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()
-        >>> new_al = al.add_trait('new_trait', 1)
-        >>> new_al.select('new_trait').to_scenario_list().to_list()
+        >>> 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()
         [1, 1]
         >>> al.add_trait('new_trait', [1, 2, 3])
         Traceback (most recent call last):
@@ -286,24 +220,18 @@ class AgentList(UserList, Base):
         ...
         """
         if not is_iterable(values):
-            new_agents = []
             value = values
             for agent in self.data:
-                new_agents.append(agent.add_trait(trait, value))
-            return AgentList(new_agents)
+                agent.add_trait(trait, value)
+            return self
 
         if len(values) != len(self):
-            e = AgentListError(
+            raise 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):
-            new_agents.append(agent.add_trait(trait, value))
-        return AgentList(new_agents)
+            agent.add_trait(trait, value)
+        return self
 
     @staticmethod
     def get_codebook(file_path: str):
@@ -316,23 +244,12 @@ 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.
-
-        >>> 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}}]}
-
-        """
+        """Serialize the AgentList to a dictionary."""
         if sorted:
             data = self.data[:]
             data.sort(key=lambda x: hash(x))
@@ -362,26 +279,15 @@ class AgentList(UserList, Base):
 
     def _summary(self):
         return {
-            "agents": len(self),
+            "EDSL Class": "AgentList",
+            "Number of agents": len(self),
+            "Agent trait fields": self.all_traits,
         }
 
-    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 _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 to_csv(self, file_path: str):
         """Save the AgentList to a CSV file.
@@ -394,33 +300,19 @@ 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: bool = False, include_instruction: bool = False
-    ) -> ScenarioList:
-        """Converts the agent to a scenario list."""
+    def to_scenario_list(self, include_agent_name=False) -> ScenarioList:
+        """Return a list of scenarios."""
         from edsl.scenarios.ScenarioList import ScenarioList
         from edsl.scenarios.Scenario import Scenario
 
-        # 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])
+        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,
@@ -428,50 +320,12 @@ 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)
 
@@ -544,6 +398,14 @@ 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,29 +1,38 @@
 """Module for creating Invigilators, which are objects to administer a question to an Agent."""
 
-from typing import Dict, Any, Optional, TYPE_CHECKING
+from typing import Dict, Any, Optional
 
-from edsl.utilities.decorators import sync_wrapper
+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.exceptions.questions import QuestionAnswerValidationError
 from edsl.agents.InvigilatorBase import InvigilatorBase
 from edsl.data_transfer_models import AgentResponseDict, EDSLResultObjectInput
-
-if TYPE_CHECKING:
-    from edsl.prompts.Prompt import Prompt
-    from edsl.scenarios.Scenario import Scenario
-    from edsl.surveys.Survey import Survey
+from edsl.agents.PromptConstructor import PromptConstructor
 
 
-NA = "Not Applicable"
+class NotApplicable(str):
+    def __new__(cls):
+        instance = super().__new__(cls, "Not Applicable")
+        instance.literal = "Not Applicable"
+        return instance
 
 
 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_get_agent_response(self) -> AgentResponseDict:
+    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}}
+        """
         prompts = self.get_prompts()
         params = {
             "user_prompt": prompts["user_prompt"].text,
@@ -31,95 +40,33 @@ 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 self.key_lookup:
-            self.model.set_key_lookup(self.key_lookup)
 
-        return await self.model.async_get_response(**params)
+        params.update({"invigilator": self})
+        # if hasattr(self.question, "answer_template"):
+        #    breakpoint()
 
-    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."""
+        agent_response_dict: AgentResponseDict = await self.model.async_get_response(
+            **params
+        )
+        # store to self in case validation failure
         self.raw_model_response = agent_response_dict.model_outputs.response
         self.generated_tokens = agent_response_dict.edsl_dict.generated_tokens
 
-    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)
+        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:
-        """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()
-
+    def determine_answer(self, raw_answer: str) -> Any:
+        question_dict = self.survey.question_names_to_questions()
         # iterates through the current answers and updates the question_dict (which is all questions)
-        for other_question, answer in current_answers.items():
+        for other_question, answer in self.current_answers.items():
             if other_question in question_dict:
                 question_dict[other_question].answer = answer
             else:
@@ -129,12 +76,13 @@ class InvigilatorAI(InvigilatorBase):
                 ) in question_dict:
                     question_dict[new_question].comment = answer
 
-        return {**question_dict, **scenario}
+        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)
 
-    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
@@ -146,8 +94,10 @@ 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
@@ -160,8 +110,9 @@ 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:
@@ -231,13 +182,13 @@ class InvigilatorHuman(InvigilatorBase):
                 exception_occurred = e
         finally:
             data = {
-                "generated_tokens": NA,  # NotApplicable(),
+                "generated_tokens": NotApplicable(),
                 "question_name": self.question.question_name,
                 "prompts": self.get_prompts(),
-                "cached_response": NA,
-                "raw_model_response": NA,
-                "cache_used": NA,
-                "cache_key": NA,
+                "cached_response": NotApplicable(),
+                "raw_model_response": NotApplicable(),
+                "cache_used": NotApplicable(),
+                "cache_key": NotApplicable(),
                 "answer": answer,
                 "comment": comment,
                 "validated": validated,
@@ -258,19 +209,17 @@ class InvigilatorFunctional(InvigilatorBase):
             generated_tokens=str(answer),
             question_name=self.question.question_name,
             prompts=self.get_prompts(),
-            cached_response=NA,
-            raw_model_response=NA,
-            cache_used=NA,
-            cache_key=NA,
+            cached_response=NotApplicable(),
+            raw_model_response=NotApplicable(),
+            cache_used=NotApplicable(),
+            cache_key=NotApplicable(),
             answer=answer["answer"],
             comment="This is the result of a functional question.",
             validated=True,
             exception_occurred=None,
         )
 
-    def get_prompts(self) -> Dict[str, "Prompt"]:
-        from edsl.prompts.Prompt import Prompt
-
+    def get_prompts(self) -> Dict[str, Prompt]:
         """Return the prompts used."""
         return {
             "user_prompt": Prompt("NA"),