edsl 0.1.36.dev5__py3-none-any.whl → 0.1.37__py3-none-any.whl

edsl/agents/PromptConstructor.py

@@ -1,17 +1,27 @@
 from __future__ import annotations
 from typing import Dict, Any, Optional, Set
-from collections import UserList
-import pdb
 
 from jinja2 import Environment, meta
 
 from edsl.prompts.Prompt import Prompt
-from edsl.data_transfer_models import ImageInfo
+from edsl.agents.prompt_helpers import PromptPlan
 
-# from edsl.prompts.registry import get_classes as prompt_lookup
-from edsl.exceptions import QuestionScenarioRenderError
 
-from edsl.agents.prompt_helpers import PromptComponent, PromptList, PromptPlan
+class PlaceholderAnswer:
+    """A placeholder answer for when a question is not yet answered."""
+
+    def __init__(self):
+        self.answer = "N/A"
+        self.comment = "Will be populated by prior answer"
+
+    def __getitem__(self, index):
+        return ""
+
+    def __str__(self):
+        return "<<PlaceholderAnswer>>"
+
+    def __repr__(self):
+        return "<<PlaceholderAnswer>>"
 
 
 def get_jinja2_variables(template_str: str) -> Set[str]:
@@ -40,7 +50,7 @@ class PromptConstructor:
     This is mixed into the Invigilator class.
     """
 
-    def __init__(self, invigilator):
+    def __init__(self, invigilator, prompt_plan: Optional["PromptPlan"] = None):
         self.invigilator = invigilator
         self.agent = invigilator.agent
         self.question = invigilator.question
@@ -49,7 +59,7 @@ class PromptConstructor:
         self.model = invigilator.model
         self.current_answers = invigilator.current_answers
         self.memory_plan = invigilator.memory_plan
-        self.prompt_plan = PromptPlan()
+        self.prompt_plan = prompt_plan or PromptPlan()
 
     @property
     def scenario_file_keys(self) -> list:
@@ -95,15 +105,20 @@ class PromptConstructor:
         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, answer in self.current_answers.items():
-            if question in d:
-                d[question].answer = answer
+        for question in d:
+            if question in self.current_answers:
+                d[question].answer = self.current_answers[question]
             else:
-                # adds a comment to the question
-                if (new_question := question.split("_comment")[0]) in d:
-                    d[new_question].comment = answer
+                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
@@ -116,6 +131,123 @@ class PromptConstructor:
                 question_file_keys.append(var)
         return question_file_keys
 
+    def build_replacement_dict(self, question_data: dict):
+        """
+        Builds a dictionary of replacement values by combining multiple data sources.
+        """
+        # 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 >>"]
+
+        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:
+            question_options = self._get_question_options(question_data)
+            question_data["question_options"] = question_options
+
+        # check to see if the question_options is actually a string
+        # This is used when the user is using the question_options as a variable from a scenario
+        # if "question_options" in question_data:
+        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
+
     @property
     def question_instructions_prompt(self) -> Prompt:
         """
@@ -125,102 +257,11 @@ class PromptConstructor:
         Prompt(text=\"""...
         ...
         """
-        # The user might have passed a custom prompt, which would be stored in _question_instructions_prompt
         if not hasattr(self, "_question_instructions_prompt"):
-            # Gets the instructions for the question - this is how the question should be answered
-            question_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()
-
-            # check to see if the question_options is actually a string
-            # This is used when the user is using the question_options as a variable from a scenario
-            # if "question_options" in question_data:
-            if isinstance(self.question.data.get("question_options", None), str):
-                env = Environment()
-                parsed_content = env.parse(self.question.data["question_options"])
-                question_option_key = list(
-                    meta.find_undeclared_variables(parsed_content)
-                )[0]
-
-                # look to see if the question_option_key is in the scenario
-                if isinstance(
-                    question_options := self.scenario.get(question_option_key), list
-                ):
-                    question_data["question_options"] = question_options
-                    self.question.question_options = question_options
-
-                # might be getting it from the prior answers
-                if self.prior_answers_dict().get(question_option_key) is not None:
-                    if isinstance(
-                        question_options := self.prior_answers_dict()
-                        .get(question_option_key)
-                        .answer,
-                        list,
-                    ):
-                        question_data["question_options"] = question_options
-                        self.question.question_options = question_options
-
-            replacement_dict = (
-                {key: f"<see file {key}>" for key in self.scenario_file_keys}
-                | question_data
-                | {
-                    k: v
-                    for k, v in self.scenario.items()
-                    if k not in self.scenario_file_keys
-                }  # don't include images in the replacement dict
-                | self.prior_answers_dict()
-                | {"agent": self.agent}
-                | {
-                    "use_code": getattr(self.question, "_use_code", True),
-                    "include_comment": getattr(
-                        self.question, "_include_comment", False
-                    ),
-                }
-            )
-
-            rendered_instructions = question_prompt.render(replacement_dict)
-
-            # is there anything left to render?
-            undefined_template_variables = (
-                rendered_instructions.undefined_template_variables({})
+            self._question_instructions_prompt = (
+                self.build_question_instructions_prompt()
             )
 
-            # 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
-
-            self._question_instructions_prompt = rendered_instructions
         return self._question_instructions_prompt
 
     @property
@@ -285,7 +326,7 @@ class PromptConstructor:
         prompts = self.prompt_plan.get_prompts(
             agent_instructions=self.agent_instructions_prompt,
             agent_persona=self.agent_persona_prompt,
-            question_instructions=self.question_instructions_prompt,
+            question_instructions=Prompt(self.question_instructions_prompt),
             prior_question_memory=self.prior_question_memory_prompt,
         )
         if self.question_file_keys:

edsl/agents/descriptors.py

@@ -4,6 +4,20 @@ from typing import Dict
 from edsl.exceptions.agents import AgentNameError, AgentTraitKeyError
 
 
+def convert_agent_name(x):
+    # potentially a numpy int64
+    import numpy as np
+
+    if isinstance(x, np.int64):
+        return int(x)
+    elif x is None:
+        return None
+    elif isinstance(x, int):
+        return x
+    else:
+        return str(x)
+
+
 class NameDescriptor:
     """ABC for something."""
 
@@ -13,7 +27,7 @@ class NameDescriptor:
 
     def __set__(self, instance, name: str) -> None:
         """Set the value of the attribute."""
-        instance.__dict__[self.name] = name
+        instance.__dict__[self.name] = convert_agent_name(name)
 
     def __set_name__(self, owner, name: str) -> None:
         """Set the name of the attribute."""
@@ -34,9 +48,8 @@ class TraitsDescriptor:
         for key, value in traits_dict.items():
             if key == "name":
                 raise AgentNameError(
-                    """Trait keys cannot be 'name'. Instead, use the 'name' attribute directly e.g., 
-                    Agent(name="my_agent", traits={"trait1": "value1", "trait2": "value2"})
-                    """
+                    "Trait keys cannot be 'name'. Instead, use the 'name' attribute directly e.g.,\n"
+                    'Agent(name="my_agent", traits={"trait1": "value1", "trait2": "value2"})'
                 )
 
             if not is_valid_variable_name(key):

edsl/conjure/AgentConstructionMixin.py

@@ -99,6 +99,8 @@ class AgentConstructionMixin:
         sample_size: int = None,
         seed: str = "edsl",
         dryrun=False,
+        disable_remote_cache: bool = False,
+        disable_remote_inference: bool = False,
     ) -> Union[Results, None]:
         """Return the results of the survey.
 
@@ -109,7 +111,7 @@ class AgentConstructionMixin:
 
         >>> from edsl.conjure.InputData import InputDataABC
         >>> id = InputDataABC.example()
-        >>> r = id.to_results()
+        >>> r = id.to_results(disable_remote_cache = True, disable_remote_inference = True)
         >>> len(r) == id.num_observations
         True
         """
@@ -125,7 +127,10 @@ class AgentConstructionMixin:
             import time
 
             start = time.time()
-            _ = survey.by(agent_list.sample(DRYRUN_SAMPLE)).run()
+            _ = survey.by(agent_list.sample(DRYRUN_SAMPLE)).run(
+                disable_remote_cache=disable_remote_cache,
+                disable_remote_inference=disable_remote_inference,
+            )
             end = time.time()
             print(f"Time to run {DRYRUN_SAMPLE} agents (s): {round(end - start, 2)}")
             time_per_agent = (end - start) / DRYRUN_SAMPLE
@@ -143,7 +148,10 @@ class AgentConstructionMixin:
                     f"Full sample will take about {round(full_sample_time / 3600, 2)} hours."
                 )
             return None
-        return survey.by(agent_list).run()
+        return survey.by(agent_list).run(
+            disable_remote_cache=disable_remote_cache,
+            disable_remote_inference=disable_remote_inference,
+        )
 
 
 if __name__ == "__main__":

edsl/conversation/Conversation.py

@@ -5,7 +5,7 @@ from typing import Optional, Callable
 from edsl import Agent, QuestionFreeText, Results, AgentList, ScenarioList, Scenario
 from edsl.questions import QuestionBase
 from edsl.results.Result import Result
-
+from jinja2 import Template
 from edsl.data import Cache
 
 from edsl.conversation.next_speaker_utilities import (
@@ -54,6 +54,9 @@ class Conversation:
     """A conversation between a list of agents. The first agent in the list is the first speaker.
     After that, order is determined by the next_speaker function.
     The question asked to each agent is determined by the next_statement_question.
+
+    If the user has passed in a "per_round_message_template", this will be displayed at the beginning of each round.
+    {{ round_message }} must be in the question_text.
     """
 
     def __init__(
@@ -64,28 +67,62 @@ class Conversation:
         next_statement_question: Optional[QuestionBase] = None,
         next_speaker_generator: Optional[Callable] = None,
         verbose: bool = False,
+        per_round_message_template: Optional[str] = None,
         conversation_index: Optional[int] = None,
         cache=None,
+        disable_remote_inference=False,
+        default_model: Optional["LanguageModel"] = None,
     ):
+        self.disable_remote_inference = disable_remote_inference
+        self.per_round_message_template = per_round_message_template
+
         if cache is None:
             self.cache = Cache()
         else:
             self.cache = cache
 
         self.agent_list = agent_list
+
+        from edsl import Model
+
+        for agent in self.agent_list:
+            if not hasattr(agent, "model"):
+                if default_model is not None:
+                    agent.model = default_model
+                else:
+                    agent.model = Model()
+
         self.verbose = verbose
         self.agent_statements = []
         self._conversation_index = conversation_index
-
         self.agent_statements = AgentStatements()
 
         self.max_turns = max_turns
 
         if next_statement_question is None:
+            import textwrap
+
+            base_question = textwrap.dedent(
+                """\
+You are {{ agent_name }}. This is the conversation so far: {{ conversation }}
+{% if round_message is not none %}
+{{ round_message }}
+{% endif %}
+What do you say next?"""
+            )
             self.next_statement_question = QuestionFreeText(
-                question_text="You are {{ agent_name }}. This is the converstaion so far: {{ conversation }}. What do you say next?",
+                question_text=base_question,
                 question_name="dialogue",
             )
+        else:
+            self.next_statement_question = next_statement_question
+            if (
+                per_round_message_template
+                and "{{ round_message }}" not in next_statement_question.question_text
+            ):
+                raise ValueError(
+                    "If you pass in a per_round_message_template, you must include {{ round_message }} in the question_text."
+                )
 
         # Determine how the next speaker is chosen
         if next_speaker_generator is None:
@@ -93,6 +130,7 @@ class Conversation:
         else:
             func = next_speaker_generator
 
+        # Choose the next speaker
         self.next_speaker = speaker_closure(
             agent_list=self.agent_list, generator_function=func
         )
@@ -158,17 +196,32 @@ class Conversation:
         }
         return Scenario(d)
 
-    async def get_next_statement(self, *, index, speaker, conversation):
+    async def get_next_statement(self, *, index, speaker, conversation) -> "Result":
+        """Get the next statement from the speaker."""
         q = self.next_statement_question
-        assert q.parameters == {"agent_name", "conversation"}, q.parameters
-        results = await q.run_async(
-            index=index,
-            conversation=conversation,
-            conversation_index=self.conversation_index,
-            agent_name=speaker.name,
-            agent=speaker,
-            just_answer=False,
-            cache=self.cache,
+        # assert q.parameters == {"agent_name", "conversation"}, q.parameters
+        from edsl import Scenario
+
+        if self.per_round_message_template is None:
+            round_message = None
+        else:
+            round_message = Template(self.per_round_message_template).render(
+                {"max_turns": self.max_turns, "current_turn": index}
+            )
+
+        s = Scenario(
+            {
+                "agent_name": speaker.name,
+                "conversation": conversation,
+                "conversation_index": self.conversation_index,
+                "index": index,
+                "round_message": round_message,
+            }
+        )
+        jobs = q.by(s).by(speaker).by(speaker.model)
+        jobs.show_prompts()
+        results = await jobs.run_async(
+            cache=self.cache, disable_remote_inference=self.disable_remote_inference
         )
         return results[0]
 
@@ -179,7 +232,6 @@ class Conversation:
         i = 0
         while await self.continue_conversation():
             speaker = self.next_speaker()
-            # breakpoint()
 
             next_statement = AgentStatement(
                 statement=await self.get_next_statement(

edsl/conversation/chips.py

@@ -0,0 +1,95 @@
+from typing import Optional
+
+from edsl import Agent, AgentList, QuestionFreeText
+from edsl import Cache
+from edsl import QuestionList
+from edsl import Model
+
+from edsl.conversation.Conversation import Conversation, ConversationList
+
+m = Model("gemini-1.5-flash")
+
+
+class ChipLover(Agent):
+    def __init__(self, name, chip_values, initial_chips, model: Optional[Model] = None):
+        self.chip_values = chip_values
+        self.initial_chips = initial_chips
+        self.current_chips = initial_chips
+        self.model = model or Model()
+        super().__init__(
+            name=name,
+            traits={
+                "motivation": f"""
+            You are {name}. You are negotiating the trading of colored 'chips' with other players. You want to maximize your score.
+            When you want to accept a deal, say "DEAL!" 
+            Note that different players can have different values for the chips.
+            """,
+                "chip_values": chip_values,
+                "initial_chips": initial_chips,
+            },
+        )
+
+    def trade(self, chips_given_dict, chips_received_dict):
+        for color, amount in chips_given_dict.items():
+            self.current_chips[color] -= amount
+        for color, amount in chips_received_dict.items():
+            self.current_chips[color] += amount
+
+    def get_score(self):
+        return sum(
+            self.chip_values[color] * self.current_chips[color]
+            for color in self.chip_values
+        )
+
+
+a1 = ChipLover(
+    name="Alice",
+    chip_values={"Green": 7, "Blue": 1, "Red": 0},
+    model=Model("gemini-1.5-flash"),
+    initial_chips={"Green": 1, "Blue": 2, "Red": 3},
+)
+a2 = ChipLover(
+    name="Bob",
+    chip_values={"Green": 7, "Blue": 1, "Red": 0},
+    initial_chips={"Green": 1, "Blue": 2, "Red": 3},
+)
+
+c1 = Conversation(agent_list=AgentList([a1, a2]), max_turns=10, verbose=True)
+c2 = Conversation(agent_list=AgentList([a1, a2]), max_turns=10, verbose=True)
+
+with Cache() as c:
+    combo = ConversationList([c1, c2], cache=c)
+    combo.run()
+    results = combo.to_results()
+    results.select("conversation_index", "index", "agent_name", "dialogue").print(
+        format="rich"
+    )
+
+    q = QuestionFreeText(
+        question_text="""This was a conversation/negotiation: {{ transcript }}. 
+                        What trades occurred in the conversation?
+                        """,
+        question_name="trades",
+    )
+
+    q_actors = QuestionList(
+        question_text="""Here is a transcript: {{ transcript }}. 
+                        Who were the actors in the conversation?
+                        """,
+        question_name="actors",
+    )
+
+    from edsl import QuestionList
+
+    q_transfers = QuestionList(
+        question_text="""This was a conversation/negotiation: {{ transcript }}. 
+                        Extract all offers and their outcomes.
+                        Use this format: {'proposing_agent':"Alice": 'receiving_agent': "Bob", 'gives':{"Green": 1, "Blue": 2}, 'receives':{"Green": 2, "Blue": 1}, 'accepted':True}
+                        """,
+        question_name="transfers",
+    )
+
+    transcript_analysis = (
+        q.add_question(q_actors).add_question(q_transfers).by(combo.summarize()).run()
+    )
+    transcript_analysis.select("trades", "actors", "transfers").print(format="rich")