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

edsl/agents/PromptConstructor.py

@@ -1,78 +1,57 @@
 from __future__ import annotations
-from typing import Dict, Any, Optional, Set, Union, TYPE_CHECKING
-from functools import cached_property
+from typing import Dict, Any, Optional, Set
 
-from edsl.prompts.Prompt import Prompt
-
-from dataclasses import dataclass
+from jinja2 import Environment, meta
 
-from .prompt_helpers import PromptPlan
-from .QuestionTemplateReplacementsBuilder import (
-    QuestionTemplateReplacementsBuilder,
-)
-from .question_option_processor import QuestionOptionProcessor
-
-if TYPE_CHECKING:
-    from edsl.agents.InvigilatorBase import InvigilatorBase
-    from edsl.questions.QuestionBase import QuestionBase
-    from edsl.agents.Agent import Agent
-    from edsl.surveys.Survey import Survey
-    from edsl.language_models.LanguageModel import LanguageModel
-    from edsl.surveys.MemoryPlan import MemoryPlan
-    from edsl.questions.QuestionBase import QuestionBase
-    from edsl.scenarios.Scenario import Scenario
+from edsl.prompts.Prompt import Prompt
+from edsl.agents.prompt_helpers import PromptPlan
 
 
-class BasePlaceholder:
-    """Base class for placeholder values when a question is not yet answered."""
+class PlaceholderAnswer:
+    """A placeholder answer for when a question is not yet answered."""
 
-    def __init__(self, placeholder_type: str = "answer"):
-        self.value = "N/A"
+    def __init__(self):
+        self.answer = "N/A"
         self.comment = "Will be populated by prior answer"
-        self._type = placeholder_type
 
     def __getitem__(self, index):
         return ""
 
     def __str__(self):
-        return f"<<{self.__class__.__name__}:{self._type}>>"
+        return "<<PlaceholderAnswer>>"
 
     def __repr__(self):
-        return self.__str__()
-
+        return "<<PlaceholderAnswer>>"
 
-class PlaceholderAnswer(BasePlaceholder):
-    def __init__(self):
-        super().__init__("answer")
 
+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(BasePlaceholder):
-    def __init__(self):
-        super().__init__("comment")
-
+    Args:
+    template_str (str): The Jinja2 template string
 
-class PlaceholderGeneratedTokens(BasePlaceholder):
-    def __init__(self):
-        super().__init__("generated_tokens")
+    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 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: "InvigilatorBase", prompt_plan: Optional["PromptPlan"] = None
-    ):
+    def __init__(self, invigilator, prompt_plan: Optional["PromptPlan"] = None):
         self.invigilator = invigilator
-        self.prompt_plan = prompt_plan or PromptPlan()
-
         self.agent = invigilator.agent
         self.question = invigilator.question
         self.scenario = invigilator.scenario
@@ -80,12 +59,22 @@ class PromptConstructor:
         self.model = invigilator.model
         self.current_answers = invigilator.current_answers
         self.memory_plan = invigilator.memory_plan
+        self.prompt_plan = prompt_plan or PromptPlan()
 
-    def get_question_options(self, question_data):
-        """Get the question options."""
-        return QuestionOptionProcessor(self).get_question_options(question_data)
+    @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
 
-    @cached_property
+    @property
     def agent_instructions_prompt(self) -> Prompt:
         """
         >>> from edsl.agents.InvigilatorBase import InvigilatorBase
@@ -93,14 +82,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.agents.Agent import Agent
+        from edsl import Agent
 
         if self.agent == Agent():  # if agent is empty, then return an empty prompt
             return Prompt(text="")
 
         return Prompt(text=self.agent.instruction)
 
-    @cached_property
+    @property
     def agent_persona_prompt(self) -> Prompt:
         """
         >>> from edsl.agents.InvigilatorBase import InvigilatorBase
@@ -108,96 +97,159 @@ class PromptConstructor:
         >>> i.prompt_constructor.agent_persona_prompt
         Prompt(text=\"""Your traits: {'age': 22, 'hair': 'brown', 'height': 5.5}\""")
         """
-        from edsl.agents.Agent import Agent
+        from edsl 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[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
-        )
-
-    @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')
-        >>> PromptConstructor._extract_quetion_and_entry_type("q0_alt_comment")
-        ('q0_alt', 'comment')
-        """
-        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"
+    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:
-                question_name = key_entry
-                entry_type = "answer"
-        return question_name, entry_type
-
-    @staticmethod
-    def _augmented_answers_dict(current_answers: dict) -> dict:
+                d[question].answer = PlaceholderAnswer()
+
+                # if (new_question := question.split("_comment")[0]) in d:
+                #     d[new_question].comment = answer
+                # d[question].answer = PlaceholderAnswer()
+
+        # breakpoint()
+        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):
         """
-        >>> PromptConstructor._augmented_answers_dict({"q0": "LOVE IT!", "q0_comment": "I love school!"})
-        {'q0': {'answer': 'LOVE IT!', 'comment': 'I love school!'}}
+        Builds a dictionary of replacement values by combining multiple data sources.
         """
-        from collections import defaultdict
+        # 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."""
 
-        d = defaultdict(dict)
-        for key, value in current_answers.items():
-            question_name, entry_type = (
-                PromptConstructor._extract_quetion_and_entry_type(key)
-            )
-            d[question_name][entry_type] = value
-        return dict(d)
+        question_prompt = Prompt(self.question.get_instructions(model=self.model.model))
 
-    @staticmethod
-    def _add_answers(
-        answer_dict: dict, current_answers: dict
-    ) -> dict[str, "QuestionBase"]:
-        """
-        >>> 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!'
-        """
-        augmented_answers = PromptConstructor._augmented_answers_dict(current_answers)
+        # 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()
 
-        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()
+        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
+
+        replacement_dict = self.build_replacement_dict(question_data)
+        rendered_instructions = question_prompt.render(replacement_dict)
 
-    @cached_property
+        # 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
+
+    @property
     def question_instructions_prompt(self) -> Prompt:
         """
         >>> from edsl.agents.InvigilatorBase import InvigilatorBase
@@ -206,24 +258,25 @@ class PromptConstructor:
         Prompt(text=\"""...
         ...
         """
-        return self.build_question_instructions_prompt()
-
-    def build_question_instructions_prompt(self) -> Prompt:
-        """Buils the question instructions prompt."""
-        from edsl.agents.QuestionInstructionPromptBuilder import (
-            QuestionInstructionPromptBuilder,
-        )
+        if not hasattr(self, "_question_instructions_prompt"):
+            self._question_instructions_prompt = (
+                self.build_question_instructions_prompt()
+            )
 
-        return QuestionInstructionPromptBuilder(self).build()
+        return self._question_instructions_prompt
 
-    @cached_property
+    @property
     def prior_question_memory_prompt(self) -> 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
+        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
 
     def create_memory_prompt(self, question_name: str) -> Prompt:
         """Create a memory for the agent.
@@ -242,6 +295,24 @@ 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.
 
@@ -252,6 +323,7 @@ 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,
@@ -265,6 +337,16 @@ 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

edsl/agents/__init__.py

@@ -1,2 +1,3 @@
 from edsl.agents.Agent import Agent
 from edsl.agents.AgentList import AgentList
+from edsl.agents.InvigilatorBase import InvigilatorBase

edsl/agents/prompt_helpers.py

@@ -1,7 +1,7 @@
 import enum
 from typing import Dict, Optional
 from collections import UserList
-from edsl.prompts.Prompt import Prompt
+from edsl.prompts import Prompt
 
 
 class PromptComponent(enum.Enum):
@@ -12,14 +12,14 @@ class PromptComponent(enum.Enum):
 
 
 class PromptList(UserList):
-    separator = Prompt("")
+    separator = Prompt(" ")
 
     def reduce(self):
         """Reduce the list of prompts to a single prompt.
 
         >>> p = PromptList([Prompt("You are a happy-go lucky agent."), Prompt("You are an agent with the following persona: {'age': 22, 'hair': 'brown', 'height': 5.5}")])
         >>> p.reduce()
-        Prompt(text=\"""You are a happy-go lucky agent.You are an agent with the following persona: {'age': 22, 'hair': 'brown', 'height': 5.5}\""")
+        Prompt(text=\"""You are a happy-go lucky agent. You are an agent with the following persona: {'age': 22, 'hair': 'brown', 'height': 5.5}\""")
 
         """
         p = self[0]

edsl/auto/AutoStudy.py

@@ -1,4 +1,4 @@
-from typing import Optional, TYPE_CHECKING
+from typing import Optional
 
 from edsl import Model
 from edsl.auto.StageQuestions import StageQuestions
@@ -11,11 +11,9 @@ from edsl.auto.StagePersonaDimensionValueRanges import (
 from edsl.auto.StageLabelQuestions import StageLabelQuestions
 from edsl.auto.StageGenerateSurvey import StageGenerateSurvey
 
-from edsl.auto.utilities import agent_generator, create_agents, gen_pipeline
+# from edsl.auto.StageBase import gen_pipeline
 
-if TYPE_CHECKING:
-    from edsl.surveys.Survey import Survey
-    from edsl.agents.AgentList import AgentList
+from edsl.auto.utilities import agent_generator, create_agents, gen_pipeline
 
 
 class AutoStudy:
@@ -26,10 +24,8 @@ class AutoStudy:
         model: Optional["Model"] = None,
         survey: Optional["Survey"] = None,
         agent_list: Optional["AgentList"] = None,
-        default_num_agents: int = 11,
+        default_num_agents=11,
     ):
-        """AutoStudy class for generating surveys and agents."""
-
         self.overall_question = overall_question
         self.population = population
         self._survey = survey
@@ -40,15 +36,6 @@ class AutoStudy:
         self.default_num_agents = default_num_agents
         self.model = model or Model()
 
-    def to_dict(self):
-        return {
-            "overall_question": self.overall_question,
-            "population": self.population,
-            "survey": self.survey.to_dict(),
-            "persona_mapping": self.persona_mapping.to_dict(),
-            "results": self.results.to_dict(),
-        }
-
     @property
     def survey(self):
         if self._survey is None:
@@ -124,7 +111,7 @@ class AutoStudy:
 
 
 if __name__ == "__main__":
-    overall_question = "I have an open source Python library for working with LLMs. What are some ways we can market this to others?"
+    overall_question = "Should online platforms be regulated with respect to selling electric scooters?"
     auto_study = AutoStudy(overall_question, population="US Adults")
 
     results = auto_study.results