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

edsl/agents/InvigilatorBase.py

@@ -1,21 +1,22 @@
 from abc import ABC, abstractmethod
 import asyncio
-from typing import Coroutine, Dict, Any, Optional
+from typing import Coroutine, Dict, Any, Optional, TYPE_CHECKING
 
-from edsl.prompts.Prompt import Prompt
 from edsl.utilities.decorators import jupyter_nb_handler
 from edsl.data_transfer_models import AgentResponseDict
 
-from edsl.data.Cache import Cache
-
-from edsl.questions.QuestionBase import QuestionBase
-from edsl.scenarios.Scenario import Scenario
-from edsl.surveys.MemoryPlan import MemoryPlan
-from edsl.language_models.LanguageModel import LanguageModel
+if TYPE_CHECKING:
+    from edsl.prompts.Prompt import Prompt
+    from edsl.data.Cache import Cache
+    from edsl.questions.QuestionBase import QuestionBase
+    from edsl.scenarios.Scenario import Scenario
+    from edsl.surveys.MemoryPlan import MemoryPlan
+    from edsl.language_models.LanguageModel import LanguageModel
+    from edsl.surveys.Survey import Survey
+    from edsl.agents.Agent import Agent
 
 from edsl.data_transfer_models import EDSLResultObjectInput
 from edsl.agents.PromptConstructor import PromptConstructor
-
 from edsl.agents.prompt_helpers import PromptPlan
 
 
@@ -29,23 +30,20 @@ class InvigilatorBase(ABC):
     'Failed to get response'
 
     This returns an empty prompt because there is no memory the agent needs to have at q0.
-
-
     """
 
     def __init__(
         self,
         agent: "Agent",
-        question: QuestionBase,
-        scenario: Scenario,
-        model: LanguageModel,
-        memory_plan: MemoryPlan,
+        question: "QuestionBase",
+        scenario: "Scenario",
+        model: "LanguageModel",
+        memory_plan: "MemoryPlan",
         current_answers: dict,
         survey: Optional["Survey"],
-        cache: Optional[Cache] = None,
+        cache: Optional["Cache"] = None,
         iteration: Optional[int] = 1,
         additional_prompt_data: Optional[dict] = None,
-        sidecar_model: Optional[LanguageModel] = None,
         raise_validation_errors: Optional[bool] = True,
         prompt_plan: Optional["PromptPlan"] = None,
     ):
@@ -59,24 +57,23 @@ class InvigilatorBase(ABC):
         self.iteration = iteration
         self.additional_prompt_data = additional_prompt_data
         self.cache = cache
-        self.sidecar_model = sidecar_model
         self.survey = survey
         self.raise_validation_errors = raise_validation_errors
+
         if prompt_plan is None:
             self.prompt_plan = PromptPlan()
         else:
             self.prompt_plan = prompt_plan
 
-        self.raw_model_response = (
-            None  # placeholder for the raw response from the model
-        )
+        # placeholder to store the raw model response
+        self.raw_model_response = None
 
     @property
     def prompt_constructor(self) -> PromptConstructor:
         """Return the prompt constructor."""
         return PromptConstructor(self, prompt_plan=self.prompt_plan)
 
-    def to_dict(self):
+    def to_dict(self, include_cache=False) -> Dict[str, Any]:
         attributes = [
             "agent",
             "question",
@@ -86,10 +83,10 @@ class InvigilatorBase(ABC):
             "current_answers",
             "iteration",
             "additional_prompt_data",
-            "cache",
-            "sidecar_model",
             "survey",
         ]
+        if include_cache:
+            attributes.append("cache")
 
         def serialize_attribute(attr):
             value = getattr(self, attr)
@@ -104,43 +101,37 @@ class InvigilatorBase(ABC):
         return {attr: serialize_attribute(attr) for attr in attributes}
 
     @classmethod
-    def from_dict(cls, data):
+    def from_dict(cls, data) -> "InvigilatorBase":
         from edsl.agents.Agent import Agent
         from edsl.questions import QuestionBase
         from edsl.scenarios.Scenario import Scenario
         from edsl.surveys.MemoryPlan import MemoryPlan
         from edsl.language_models.LanguageModel import LanguageModel
         from edsl.surveys.Survey import Survey
+        from edsl.data.Cache import Cache
+
+        attributes_to_classes = {
+            "agent": Agent,
+            "question": QuestionBase,
+            "scenario": Scenario,
+            "model": LanguageModel,
+            "memory_plan": MemoryPlan,
+            "survey": Survey,
+            "cache": Cache,
+        }
+        d = {}
+        for attr, cls_ in attributes_to_classes.items():
+            if attr in data and data[attr] is not None:
+                if attr not in data:
+                    d[attr] = {}
+                else:
+                    d[attr] = cls_.from_dict(data[attr])
 
-        agent = Agent.from_dict(data["agent"])
-        question = QuestionBase.from_dict(data["question"])
-        scenario = Scenario.from_dict(data["scenario"])
-        model = LanguageModel.from_dict(data["model"])
-        memory_plan = MemoryPlan.from_dict(data["memory_plan"])
-        survey = Survey.from_dict(data["survey"])
-        current_answers = data["current_answers"]
-        iteration = data["iteration"]
-        additional_prompt_data = data["additional_prompt_data"]
-        cache = Cache.from_dict(data["cache"])
-
-        if data["sidecar_model"] is None:
-            sidecar_model = None
-        else:
-            sidecar_model = LanguageModel.from_dict(data["sidecar_model"])
+        d["current_answers"] = data["current_answers"]
+        d["iteration"] = data["iteration"]
+        d["additional_prompt_data"] = data["additional_prompt_data"]
 
-        return cls(
-            agent=agent,
-            question=question,
-            scenario=scenario,
-            model=model,
-            memory_plan=memory_plan,
-            current_answers=current_answers,
-            survey=survey,
-            iteration=iteration,
-            additional_prompt_data=additional_prompt_data,
-            cache=cache,
-            sidecar_model=sidecar_model,
-        )
+        d = cls(**d)
 
     def __repr__(self) -> str:
         """Return a string representation of the Invigilator.
@@ -149,9 +140,9 @@ class InvigilatorBase(ABC):
         'InvigilatorExample(...)'
 
         """
-        return f"{self.__class__.__name__}(agent={repr(self.agent)}, question={repr(self.question)}, scneario={repr(self.scenario)}, model={repr(self.model)}, memory_plan={repr(self.memory_plan)}, current_answers={repr(self.current_answers)}, iteration{repr(self.iteration)}, additional_prompt_data={repr(self.additional_prompt_data)}, cache={repr(self.cache)}, sidecarmodel={repr(self.sidecar_model)})"
+        return f"{self.__class__.__name__}(agent={repr(self.agent)}, question={repr(self.question)}, scneario={repr(self.scenario)}, model={repr(self.model)}, memory_plan={repr(self.memory_plan)}, current_answers={repr(self.current_answers)}, iteration{repr(self.iteration)}, additional_prompt_data={repr(self.additional_prompt_data)}, cache={repr(self.cache)})"
 
-    def get_failed_task_result(self, failure_reason) -> EDSLResultObjectInput:
+    def get_failed_task_result(self, failure_reason: str) -> EDSLResultObjectInput:
         """Return an AgentResponseDict used in case the question-asking fails.
 
         Possible reasons include:
@@ -172,8 +163,9 @@ class InvigilatorBase(ABC):
         }
         return EDSLResultObjectInput(**data)
 
-    def get_prompts(self) -> Dict[str, Prompt]:
+    def get_prompts(self) -> Dict[str, "Prompt"]:
         """Return the prompt used."""
+        from edsl.prompts.Prompt import Prompt
 
         return {
             "user_prompt": Prompt("NA"),
@@ -205,24 +197,25 @@ class InvigilatorBase(ABC):
         >>> InvigilatorBase.example()
         InvigilatorExample(...)
 
+        >>> InvigilatorBase.example().answer_question()
+        {'message': [{'text': 'SPAM!'}], 'usage': {'prompt_tokens': 1, 'completion_tokens': 1}}
+
+        >>> InvigilatorBase.example(throw_an_exception=True).answer_question()
+        Traceback (most recent call last):
+        ...
+        Exception: This is a test error
         """
         from edsl.agents.Agent import Agent
-        from edsl.questions import QuestionMultipleChoice
         from edsl.scenarios.Scenario import Scenario
-        from edsl.language_models import LanguageModel
         from edsl.surveys.MemoryPlan import MemoryPlan
-
-        from edsl.enums import InferenceServiceType
-
-        from edsl import Model
+        from edsl.language_models.registry import Model
+        from edsl.surveys.Survey import Survey
 
         model = Model("test", canned_response="SPAM!")
 
         if throw_an_exception:
-            model.throw_an_exception = True
+            model.throw_exception = True
         agent = Agent.example()
-        # question = QuestionMultipleChoice.example()
-        from edsl.surveys import Survey
 
         if not survey:
             survey = Survey.example()
@@ -232,14 +225,10 @@ class InvigilatorBase(ABC):
 
         question = question or survey.questions[0]
         scenario = scenario or Scenario.example()
-        # memory_plan = None #memory_plan = MemoryPlan()
-        from edsl import Survey
-
         memory_plan = MemoryPlan(survey=survey)
         current_answers = None
-        from edsl.agents.PromptConstructor import PromptConstructor
 
-        class InvigilatorExample(InvigilatorBase):
+        class InvigilatorExample(cls):
             """An example invigilator."""
 
             async def async_answer_question(self):

edsl/agents/PromptConstructor.py

@@ -1,10 +1,18 @@
 from __future__ import annotations
-from typing import Dict, Any, Optional, Set
-
-from jinja2 import Environment, meta
+from typing import Dict, Any, Optional, Set, Union, TYPE_CHECKING
+from functools import cached_property
 
 from edsl.prompts.Prompt import Prompt
-from edsl.agents.prompt_helpers import PromptPlan
+
+from .prompt_helpers import PromptPlan
+from .QuestionTemplateReplacementsBuilder import (
+    QuestionTemplateReplacementsBuilder,
+)
+from .QuestionOptionProcessor import QuestionOptionProcessor
+
+if TYPE_CHECKING:
+    from edsl.agents.InvigilatorBase import InvigilatorBase
+    from edsl.questions.QuestionBase import QuestionBase
 
 
 class PlaceholderAnswer:
@@ -18,39 +26,34 @@ class PlaceholderAnswer:
         return ""
 
     def __str__(self):
-        return "<<PlaceholderAnswer>>"
+        return f"<<{self.__class__.__name__}>>"
 
     def __repr__(self):
-        return "<<PlaceholderAnswer>>"
+        return f"<<{self.__class__.__name__}>>"
 
 
-def get_jinja2_variables(template_str: str) -> Set[str]:
-    """
-    Extracts all variable names from a Jinja2 template using Jinja2's built-in parsing.
+class PlaceholderComment(PlaceholderAnswer):
+    pass
 
-    Args:
-    template_str (str): The Jinja2 template string
 
-    Returns:
-    Set[str]: A set of variable names found in the template
-    """
-    env = Environment()
-    ast = env.parse(template_str)
-    return meta.find_undeclared_variables(ast)
+class PlaceholderGeneratedTokens(PlaceholderAnswer):
+    pass
 
 
 class PromptConstructor:
     """
+    This class constructs the prompts for the language model.
+
     The pieces of a prompt are:
     - The agent instructions - "You are answering questions as if you were a human. Do not break character."
     - The persona prompt - "You are an agent with the following persona: {'age': 22, 'hair': 'brown', 'height': 5.5}"
     - The question instructions - "You are being asked the following question: Do you like school? The options are 0: yes 1: no Return a valid JSON formatted like this, selecting only the number of the option: {"answer": <put answer code here>, "comment": "<put explanation here>"} Only 1 option may be selected."
     - The memory prompt - "Before the question you are now answering, you already answered the following question(s): Question: Do you like school? Answer: Prior answer"
-
-    This is mixed into the Invigilator class.
     """
 
-    def __init__(self, invigilator, prompt_plan: Optional["PromptPlan"] = None):
+    def __init__(
+        self, invigilator: "InvigilatorBase", prompt_plan: Optional["PromptPlan"] = None
+    ):
         self.invigilator = invigilator
         self.agent = invigilator.agent
         self.question = invigilator.question
@@ -61,20 +64,11 @@ class PromptConstructor:
         self.memory_plan = invigilator.memory_plan
         self.prompt_plan = prompt_plan or PromptPlan()
 
-    @property
-    def scenario_file_keys(self) -> list:
-        """We need to find all the keys in the scenario that refer to FileStore objects.
-        These will be used to append to the prompt a list of files that are part of the scenario.
-        """
-        from edsl.scenarios.FileStore import FileStore
-
-        file_entries = []
-        for key, value in self.scenario.items():
-            if isinstance(value, FileStore):
-                file_entries.append(key)
-        return file_entries
+    def get_question_options(self, question_data):
+        """Get the question options."""
+        return QuestionOptionProcessor(self).get_question_options(question_data)
 
-    @property
+    @cached_property
     def agent_instructions_prompt(self) -> Prompt:
         """
         >>> from edsl.agents.InvigilatorBase import InvigilatorBase
@@ -82,14 +76,14 @@ class PromptConstructor:
         >>> i.prompt_constructor.agent_instructions_prompt
         Prompt(text=\"""You are answering questions as if you were a human. Do not break character.\""")
         """
-        from edsl import Agent
+        from edsl.agents.Agent import Agent
 
         if self.agent == Agent():  # if agent is empty, then return an empty prompt
             return Prompt(text="")
 
         return Prompt(text=self.agent.instruction)
 
-    @property
+    @cached_property
     def agent_persona_prompt(self) -> Prompt:
         """
         >>> from edsl.agents.InvigilatorBase import InvigilatorBase
@@ -97,159 +91,93 @@ class PromptConstructor:
         >>> i.prompt_constructor.agent_persona_prompt
         Prompt(text=\"""Your traits: {'age': 22, 'hair': 'brown', 'height': 5.5}\""")
         """
-        from edsl import Agent
+        from edsl.agents.Agent import Agent
 
         if self.agent == Agent():  # if agent is empty, then return an empty prompt
             return Prompt(text="")
 
         return self.agent.prompt()
 
-    def prior_answers_dict(self) -> dict:
-        # this is all questions
-        d = self.survey.question_names_to_questions()
-        # This attaches the answer to the question
-        for question in d:
-            if question in self.current_answers:
-                d[question].answer = self.current_answers[question]
-            else:
-                d[question].answer = PlaceholderAnswer()
+    def prior_answers_dict(self) -> dict[str, "QuestionBase"]:
+        """This is a dictionary of prior answers, if they exist."""
+        return self._add_answers(
+            self.survey.question_names_to_questions(), self.current_answers
+        )
 
-                # if (new_question := question.split("_comment")[0]) in d:
-                #     d[new_question].comment = answer
-                # d[question].answer = PlaceholderAnswer()
+    @staticmethod
+    def _extract_quetion_and_entry_type(key_entry) -> tuple[str, str]:
+        """
+        Extracts the question name and type for the current answer dictionary key entry.
+
+        >>> PromptConstructor._extract_quetion_and_entry_type("q0")
+        ('q0', 'answer')
+        >>> PromptConstructor._extract_quetion_and_entry_type("q0_comment")
+        ('q0', 'comment')
+        >>> PromptConstructor._extract_quetion_and_entry_type("q0_alternate_generated_tokens")
+        ('q0_alternate', 'generated_tokens')
+        """
+        split_list = key_entry.rsplit("_", maxsplit=1)
+        if len(split_list) == 1:
+            question_name = split_list[0]
+            entry_type = "answer"
+        else:
+            if split_list[1] == "comment":
+                question_name = split_list[0]
+                entry_type = "comment"
+            elif split_list[1] == "tokens":  # it's actually 'generated_tokens'
+                question_name = key_entry.replace("_generated_tokens", "")
+                entry_type = "generated_tokens"
+            else:
+                question_name = key_entry
+                entry_type = "answer"
+        return question_name, entry_type
 
-        # breakpoint()
+    @staticmethod
+    def _augmented_answers_dict(current_answers: dict):
+        """
+        >>> PromptConstructor._augmented_answers_dict({"q0": "LOVE IT!", "q0_comment": "I love school!"})
+        {'q0': {'answer': 'LOVE IT!', 'comment': 'I love school!'}}
+        """
+        d = {}
+        for key, value in current_answers.items():
+            (
+                question_name,
+                entry_type,
+            ) = PromptConstructor._extract_quetion_and_entry_type(key)
+            if question_name not in d:
+                d[question_name] = {}
+            d[question_name][entry_type] = value
         return d
 
-    @property
-    def question_file_keys(self):
-        raw_question_text = self.question.question_text
-        variables = get_jinja2_variables(raw_question_text)
-        question_file_keys = []
-        for var in variables:
-            if var in self.scenario_file_keys:
-                question_file_keys.append(var)
-        return question_file_keys
-
-    def build_replacement_dict(self, question_data: dict):
+    @staticmethod
+    def _add_answers(answer_dict: dict, current_answers) -> dict[str, "QuestionBase"]:
         """
-        Builds a dictionary of replacement values by combining multiple data sources.
+        >>> from edsl import QuestionFreeText
+        >>> d = {"q0": QuestionFreeText(question_text="Do you like school?", question_name = "q0")}
+        >>> current_answers = {"q0": "LOVE IT!"}
+        >>> PromptConstructor._add_answers(d, current_answers)['q0'].answer
+        'LOVE IT!'
         """
-        # File references dictionary
-        file_refs = {key: f"<see file {key}>" for key in self.scenario_file_keys}
-
-        # Scenario items excluding file keys
-        scenario_items = {
-            k: v for k, v in self.scenario.items() if k not in self.scenario_file_keys
-        }
-
-        # Question settings with defaults
-        question_settings = {
-            "use_code": getattr(self.question, "_use_code", True),
-            "include_comment": getattr(self.question, "_include_comment", False),
-        }
-
-        # Combine all dictionaries using dict.update() for clarity
-        replacement_dict = {}
-        for d in [
-            file_refs,
-            question_data,
-            scenario_items,
-            self.prior_answers_dict(),
-            {"agent": self.agent},
-            question_settings,
-        ]:
-            replacement_dict.update(d)
-
-        return replacement_dict
-
-    def _get_question_options(self, question_data):
-        question_options_entry = question_data.get("question_options", None)
-        question_options = question_options_entry
-
-        placeholder = ["<< Option 1 - Placholder >>", "<< Option 2 - Placholder >>"]
-
-        # print("Question options entry: ", question_options_entry)
-
-        if isinstance(question_options_entry, str):
-            env = Environment()
-            parsed_content = env.parse(question_options_entry)
-            question_option_key = list(meta.find_undeclared_variables(parsed_content))[
-                0
-            ]
-            if isinstance(self.scenario.get(question_option_key), list):
-                question_options = self.scenario.get(question_option_key)
-
-            # might be getting it from the prior answers
-            if self.prior_answers_dict().get(question_option_key) is not None:
-                prior_question = self.prior_answers_dict().get(question_option_key)
-                if hasattr(prior_question, "answer"):
-                    if isinstance(prior_question.answer, list):
-                        question_options = prior_question.answer
-                    else:
-                        question_options = placeholder
-                else:
-                    question_options = placeholder
-
-        return question_options
-
-    def build_question_instructions_prompt(self):
-        """Buils the question instructions prompt."""
-
-        question_prompt = Prompt(self.question.get_instructions(model=self.model.model))
-
-        # Get the data for the question - this is a dictionary of the question data
-        # e.g., {'question_text': 'Do you like school?', 'question_name': 'q0', 'question_options': ['yes', 'no']}
-        question_data = self.question.data.copy()
-
-        if (
-            "question_options" in question_data
-        ):  # is this a question with question options?
-            question_options = self._get_question_options(question_data)
-            question_data["question_options"] = question_options
+        augmented_answers = PromptConstructor._augmented_answers_dict(current_answers)
 
-        replacement_dict = self.build_replacement_dict(question_data)
-        rendered_instructions = question_prompt.render(replacement_dict)
-
-        # is there anything left to render?
-        undefined_template_variables = (
-            rendered_instructions.undefined_template_variables({})
-        )
-
-        # Check if it's the name of a question in the survey
-        for question_name in self.survey.question_names:
-            if question_name in undefined_template_variables:
-                print(
-                    "Question name found in undefined_template_variables: ",
-                    question_name,
-                )
-
-        if undefined_template_variables:
-            msg = f"Question instructions still has variables: {undefined_template_variables}."
-            import warnings
-
-            warnings.warn(msg)
-            # raise QuestionScenarioRenderError(
-            #     f"Question instructions still has variables: {undefined_template_variables}."
-            # )
-
-        # Check if question has instructions - these are instructions in a Survey that can apply to multiple follow-on questions
-        relevant_instructions = self.survey.relevant_instructions(
-            self.question.question_name
-        )
-
-        if relevant_instructions != []:
-            # preamble_text = Prompt(
-            #    text="You were given the following instructions: "
-            # )
-            preamble_text = Prompt(text="")
-            for instruction in relevant_instructions:
-                preamble_text += instruction.text
-            rendered_instructions = preamble_text + rendered_instructions
-
-        return rendered_instructions
+        for question in answer_dict:
+            if question in augmented_answers:
+                for entry_type, value in augmented_answers[question].items():
+                    setattr(answer_dict[question], entry_type, value)
+            else:
+                answer_dict[question].answer = PlaceholderAnswer()
+                answer_dict[question].comment = PlaceholderComment()
+                answer_dict[question].generated_tokens = PlaceholderGeneratedTokens()
+        return answer_dict
+
+    @cached_property
+    def question_file_keys(self) -> list:
+        """Extracts the file keys from the question text.
+        It checks if the variables in the question text are in the scenario file keys.
+        """
+        return QuestionTemplateReplacementsBuilder(self).question_file_keys()
 
-    @property
+    @cached_property
     def question_instructions_prompt(self) -> Prompt:
         """
         >>> from edsl.agents.InvigilatorBase import InvigilatorBase
@@ -258,25 +186,24 @@ class PromptConstructor:
         Prompt(text=\"""...
         ...
         """
-        if not hasattr(self, "_question_instructions_prompt"):
-            self._question_instructions_prompt = (
-                self.build_question_instructions_prompt()
-            )
+        return self.build_question_instructions_prompt()
+
+    def build_question_instructions_prompt(self) -> Prompt:
+        """Buils the question instructions prompt."""
+        from edsl.agents.QuestionInstructionPromptBuilder import (
+            QuestionInstructionPromptBuilder,
+        )
 
-        return self._question_instructions_prompt
+        return QuestionInstructionPromptBuilder(self).build()
 
-    @property
+    @cached_property
     def prior_question_memory_prompt(self) -> Prompt:
-        if not hasattr(self, "_prior_question_memory_prompt"):
-            from edsl.prompts.Prompt import Prompt
-
-            memory_prompt = Prompt(text="")
-            if self.memory_plan is not None:
-                memory_prompt += self.create_memory_prompt(
-                    self.question.question_name
-                ).render(self.scenario | self.prior_answers_dict())
-            self._prior_question_memory_prompt = memory_prompt
-        return self._prior_question_memory_prompt
+        memory_prompt = Prompt(text="")
+        if self.memory_plan is not None:
+            memory_prompt += self.create_memory_prompt(
+                self.question.question_name
+            ).render(self.scenario | self.prior_answers_dict())
+        return memory_prompt
 
     def create_memory_prompt(self, question_name: str) -> Prompt:
         """Create a memory for the agent.
@@ -295,24 +222,6 @@ class PromptConstructor:
             question_name, self.current_answers
         )
 
-    def construct_system_prompt(self) -> Prompt:
-        """Construct the system prompt for the LLM call."""
-        import warnings
-
-        warnings.warn(
-            "This method is deprecated. Use get_prompts instead.", DeprecationWarning
-        )
-        return self.get_prompts()["system_prompt"]
-
-    def construct_user_prompt(self) -> Prompt:
-        """Construct the user prompt for the LLM call."""
-        import warnings
-
-        warnings.warn(
-            "This method is deprecated. Use get_prompts instead.", DeprecationWarning
-        )
-        return self.get_prompts()["user_prompt"]
-
     def get_prompts(self) -> Dict[str, Prompt]:
         """Get both prompts for the LLM call.
 
@@ -323,7 +232,6 @@ class PromptConstructor:
         >>> i.get_prompts()
         {'user_prompt': ..., 'system_prompt': ...}
         """
-        # breakpoint()
         prompts = self.prompt_plan.get_prompts(
             agent_instructions=self.agent_instructions_prompt,
             agent_persona=self.agent_persona_prompt,
@@ -337,16 +245,6 @@ class PromptConstructor:
             prompts["files_list"] = files_list
         return prompts
 
-    def _get_scenario_with_image(self) -> Scenario:
-        """This is a helper function to get a scenario with an image, for testing purposes."""
-        from edsl import Scenario
-
-        try:
-            scenario = Scenario.from_image("../../static/logo.png")
-        except FileNotFoundError:
-            scenario = Scenario.from_image("static/logo.png")
-        return scenario
-
 
 if __name__ == "__main__":
     import doctest