edsl 0.1.15__py3-none-any.whl → 0.1.40__py3-none-any.whl

edsl/conversation/Conversation.py

@@ -0,0 +1,290 @@
+from collections import UserList
+import asyncio
+import inspect
+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 (
+    default_turn_taking_generator,
+    speaker_closure,
+)
+
+
+class AgentStatement:
+    def __init__(self, statement: Result):
+        self.statement = statement
+
+    @property
+    def agent_name(self):
+        return self.statement["agent"]["name"]
+
+    def to_dict(self):
+        return self.statement.to_dict()
+
+    @classmethod
+    def from_dict(cls, data):
+        return cls(Result.from_dict(data))
+
+    @property
+    def text(self):
+        return self.statement["answer"]["dialogue"]
+
+
+class AgentStatements(UserList):
+    def __init__(self, data=None):
+        super().__init__(data)
+
+    @property
+    def transcript(self):
+        return [{s.agent_name: s.text} for s in self.data]
+
+    def to_dict(self):
+        return [d.to_dict() for d in self.data]
+
+    @classmethod
+    def from_dict(cls, data):
+        return cls([AgentStatement.from_dict(d) for d in data])
+
+
+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__(
+        self,
+        agent_list: AgentList,
+        max_turns: int = 20,
+        stopping_function: Optional[Callable] = None,
+        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=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:
+            func = default_turn_taking_generator
+        else:
+            func = next_speaker_generator
+
+        # Choose the next speaker
+        self.next_speaker = speaker_closure(
+            agent_list=self.agent_list, generator_function=func
+        )
+
+        # Determine when the conversation ends
+        if stopping_function is None:
+            self.stopping_function = lambda agent_statements: False
+        else:
+            self.stopping_function = stopping_function
+
+    async def continue_conversation(self, **kwargs) -> bool:
+        if len(self.agent_statements) >= self.max_turns:
+            return False
+
+        if inspect.iscoroutinefunction(self.stopping_function):
+            should_stop = await self.stopping_function(self.agent_statements, **kwargs)
+        else:
+            should_stop = self.stopping_function(self.agent_statements, **kwargs)
+
+        return not should_stop
+
+    def add_index(self, index) -> None:
+        self._conversation_index = index
+
+    @property
+    def conversation_index(self):
+        return self._conversation_index
+
+    def to_dict(self):
+        return {
+            "agent_list": self.agent_list.to_dict(),
+            "max_turns": self.max_turns,
+            "verbose": self.verbose,
+            "agent_statements": [d.to_dict() for d in self.agent_statements],
+            "conversation_index": self.conversation_index,
+        }
+
+    @classmethod
+    def from_dict(cls, data):
+        agent_list = AgentList.from_dict(data["agent_list"])
+        max_turns = data["max_turns"]
+        verbose = data["verbose"]
+        agent_statements = (AgentStatements.from_dict(data["agent_statements"]),)
+        conversation_index = data["conversation_index"]
+        return cls(
+            agent_list=agent_list,
+            max_turns=max_turns,
+            verbose=verbose,
+            results_data=agent_statements,
+            conversation_index=conversation_index,
+        )
+
+    def to_results(self):
+        return Results(data=[s.statement for s in self.agent_statements])
+
+    def summarize(self):
+        d = {
+            "num_agents": len(self.agent_list),
+            "max_turns": self.max_turns,
+            "conversation_index": self.conversation_index,
+            "transcript": self.to_results().select("agent_name", "dialogue").to_list(),
+            "number_of_agent_statements": len(self.agent_statements),
+        }
+        return Scenario(d)
+
+    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
+        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]
+
+    def converse(self):
+        return asyncio.run(self._converse())
+
+    async def _converse(self):
+        i = 0
+        while await self.continue_conversation():
+            speaker = self.next_speaker()
+
+            next_statement = AgentStatement(
+                statement=await self.get_next_statement(
+                    index=i,
+                    speaker=speaker,
+                    conversation=self.agent_statements.transcript,
+                )
+            )
+            self.agent_statements.append(next_statement)
+            if self.verbose:
+                print(f"'{speaker.name}':{next_statement.text}")
+                print("\n")
+            i += 1
+
+
+class ConversationList:
+    """A collection of conversations to be run in parallel."""
+
+    def __init__(self, conversations: list[Conversation], cache=None):
+        self.conversations = conversations
+        for i, conversation in enumerate(self.conversations):
+            conversation.add_index(i)
+
+        if cache is None:
+            self.cache = Cache()
+        else:
+            self.cache = cache
+
+        for c in self.conversations:
+            c.cache = self.cache
+
+    async def run_conversations(self):
+        await asyncio.gather(*[c._converse() for c in self.conversations])
+
+    def run(self) -> None:
+        """Run all conversations in parallel"""
+        asyncio.run(self.run_conversations())
+
+    def to_dict(self) -> dict:
+        return {"conversations": c.to_dict() for c in self.conversations}
+
+    @classmethod
+    def from_dict(cls, data):
+        conversations = [Conversation.from_dict(d) for d in data["conversations"]]
+        return cls(conversations)
+
+    def to_results(self) -> Results:
+        """Return the results of all conversations as a single Results"""
+        first_convo = self.conversations[0]
+        results = first_convo.to_results()
+        for conv in self.conversations[1:]:
+            results += conv.to_results()
+        return results
+
+    def summarize(self) -> ScenarioList:
+        return ScenarioList([c.summarize() for c in self.conversations])

edsl/conversation/car_buying.py

@@ -0,0 +1,59 @@
+from edsl import Agent, AgentList, QuestionFreeText
+from edsl import Cache
+from edsl.conversation.Conversation import Conversation, ConversationList
+
+a1 = Agent(
+    name="Alice",
+    traits={
+        "motivation": """
+    You are Alice. You want to buy a car. You are talking to Bob, a car salesman.
+    It is very important to you that the steering wheel not whiff out of the window while you are driving.
+    Also, the car can have no space for mother-in-law.
+    You brought your brother-in-law along, Paul, who you have an antagonistic relationship with.
+    """
+    },
+)
+a2 = Agent(
+    name="Bob",
+    traits={
+        "motivation": "You are Bob, a car salesman. You are talking to Alice, who wants to buy a car."
+    },
+)
+a3 = Agent(
+    name="Paul",
+    traits={
+        "motivation": "You are Paul, you are Alice's brother. You think her concerns are foolish and you are critical of her."
+    },
+)
+
+c1 = Conversation(agent_list=AgentList([a1, a3, a2]), max_turns=5, verbose=True)
+c2 = Conversation(agent_list=AgentList([a1, a2]), max_turns=5, verbose=True)
+
+# c = Cache.load("car_talk.json.gz")
+c = Cache()
+# breakpoint()
+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 about buying a car: {{ transcript }}. 
+                    Was a brand or style of car mentioned? If so, what was it?
+                    """,
+    question_name="car_brand",
+)
+
+from edsl import QuestionList
+
+q_actors = QuestionList(
+    question_text="""This was a conversation about buying a car: {{ transcript }}. 
+                    Who were the actors in the conversation?
+                    """,
+    question_name="actors",
+)
+
+transcript_analysis = q.add_question(q_actors).by(combo.summarize()).run()
+transcript_analysis.select("car_brand", "actors").print(format="rich")

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")

edsl/conversation/mug_negotiation.py

@@ -0,0 +1,81 @@
+from edsl import Agent, AgentList
+from edsl.conversation.Conversation import Conversation, ConversationList
+
+
+def bargaining_pairs(alice_valuation, bob_valuation):
+    a1 = Agent(
+        name="Alice",
+        traits={
+            "motivation": f"""
+        You are trying to sell your mug to Bob. You value the mug at ${ alice_valuation }---you would rather have the mug than ${alice_valuation}.
+        But you are willing to sell it for ${alice_valuation} or more if Bob is willing to pay that much.
+        You WILL NOT sell for less than ${alice_valuation}.
+        You want to get as much money as possible for the mug.
+        You are an experienced negotiator are strategic in your approach.
+        """
+        },
+    )
+    a2 = Agent(
+        name="Bob",
+        traits={
+            "motivation": f"""You are Bob. You are trying to buy a mug from Alice. You value the mug at ${bob_valuation}. You would rather have the mug than ${bob_valuation}.
+            But you want to pay as little as possible for the mug.
+            You absolutely WILL NOT pay more than ${bob_valuation}.
+            Carefully consider your valuation before making or accepting an offer.
+            You are an experienced negotiator and are strategic in your approach.
+            """
+        },
+    )
+    return AgentList([a1, a2])
+
+
+valuations = [(10, 15), (10, 100), (10, 9)]
+cl = ConversationList(
+    [
+        Conversation(agent_list=bargaining_pairs(*v), max_turns=10, verbose=True)
+        for v in valuations
+    ]
+)
+cl.run()
+results = cl.to_results()
+
+results.select("conversation_index", "index", "agent_name", "dialogue").print(
+    format="rich"
+)
+
+from edsl import (
+    QuestionFreeText,
+    QuestionMultipleChoice,
+    QuestionYesNo,
+    QuestionNumerical,
+)
+
+q_deal = QuestionYesNo(
+    question_text="""This was a negotiation: {{ transcript }}. 
+                     Was a deal reached?
+                    """,
+    question_name="deal",
+)
+
+q_price = QuestionNumerical(
+    question_text="""This was a negotiation: {{ transcript }}.
+    A deal was reached. What was the price of the deal?
+    """,
+    question_name="price",
+)
+
+q_side_deal = QuestionYesNo(
+    question_text="""This was a negotiation: {{ transcript }}.
+    Was there a side deal? I.e., seller agreed to other terms in exchange for a higher price?
+    """,
+    question_name="side_deal",
+)
+
+survey = (
+    q_deal.add_question(q_price)
+    .add_question(q_side_deal)
+    .add_stop_rule("deal", "deal == 'No'")
+)
+
+transcript_analysis = survey.by(cl.summarize()).run()
+transcript_analysis.select("deal", "price", "side_deal").print(format="rich")

edsl/conversation/next_speaker_utilities.py

@@ -0,0 +1,93 @@
+import random
+
+
+def default_turn_taking_generator(agent_list, speakers_so_far, **kwargs):
+    """Returns the next speaker in the list of agents, in order. If no speakers have spoken yet, returns the first agent in the list."""
+    if len(speakers_so_far) == 0:
+        return agent_list[0]
+    most_recent_speaker = speakers_so_far[-1]
+    index = agent_list.index(most_recent_speaker)
+    return agent_list[(index + 1) % len(agent_list)]
+
+
+def turn_taking_generator_with_focal_speaker(
+    agent_list, speakers_so_far, focal_speaker_index, **kwargs
+):
+    """Returns the focal speaker first, then the next speaker in the list of agents sequentially, going back to the focal speaker after the last agent has spoken. If no speakers have spoken yet, returns the focal speaker.
+    This would be appropriate for say, a an auction where the auctioneer always speaks first, and then the next person in line speaks, and then the auctioneer speaks again.
+    """
+    if len(speakers_so_far) == 0:
+        return agent_list[focal_speaker_index]
+
+    most_recent_speaker = speakers_so_far[-1]
+    if most_recent_speaker == agent_list[focal_speaker_index]:
+        non_focal_agents = [
+            a for a in agent_list if a != agent_list[focal_speaker_index]
+        ]
+        non_focal_speakers = [
+            a for a in speakers_so_far if a != agent_list[focal_speaker_index]
+        ]
+        return default_turn_taking_generator(
+            agent_list=non_focal_agents, speakers_so_far=non_focal_speakers
+        )
+    else:
+        return agent_list[focal_speaker_index]
+
+
+def random_turn_taking_generator(agent_list, speakers_so_far, **kwargs):
+    """Returns a random speaker from the list of agents, but ensuring no agent speaks twice in a row.
+    If no speakers have spoken yet, returns a random agent."""
+    if len(speakers_so_far) == 0:
+        return random.choice(agent_list)
+    else:
+        most_recent_speaker = speakers_so_far[-1]
+    return random.choice([a for a in agent_list if a != most_recent_speaker])
+
+
+def random_inclusive_generator(agent_list, speakers_so_far, **kwargs):
+    """Returns a random speaker from the list of agents, but ensuring no agent speaks twice in a row and that
+    every agent has spoken before the same agent speaks again.
+    """
+    if len(speakers_so_far) > 0:
+        most_recent_speaker = speakers_so_far[-1]
+    else:
+        most_recent_speaker = None
+
+    lookback_length = len(speakers_so_far) % len(agent_list)
+
+    if lookback_length == 0:
+        eligible_agents = agent_list[:]
+    else:
+        eligible_agents = [
+            a for a in agent_list if a not in speakers_so_far[-lookback_length:]
+        ]
+
+    # don't have the same speaker twice in a row
+    if most_recent_speaker in eligible_agents:
+        eligible_agents.pop(eligible_agents.index(most_recent_speaker))
+
+    return random.choice(eligible_agents)
+
+
+def speaker_closure(agent_list, generator_function, focal_speaker_index=None):
+    speakers_so_far = []
+    focal_speaker_index = focal_speaker_index
+
+    def next_speaker_generator():
+        speaker = generator_function(
+            agent_list=agent_list,
+            speakers_so_far=speakers_so_far,
+            focal_speaker_index=focal_speaker_index,
+        )
+        speakers_so_far.append(speaker)
+        return speaker
+
+    return next_speaker_generator
+
+
+# speaker_gen = speaker_closure(agent_list = ['Alice', 'Bob', 'Charlie', "Mr.X"],
+#                               generator_function = turn_taking_generator_with_focal_speaker,
+#                               focal_speaker_index = 3)
+
+# for _ in range(30):
+#     print(speaker_gen())

edsl/coop/CoopFunctionsMixin.py

@@ -0,0 +1,15 @@
+class CoopFunctionsMixin:
+    def better_names(self, existing_names):
+        from edsl import QuestionList, Scenario
+
+        s = Scenario({"existing_names": existing_names})
+        q = QuestionList(
+            question_text="""The following colum names are already in use: {{ existing_names }} 
+                         Please provide new names for the columns.
+                         They should be short, one or two words, and unique. They should be valid Python idenifiers. 
+                         No spaces - use underscores instead. 
+                         """,
+            question_name="better_names",
+        )
+        results = q.by(s).run(verbose=False)
+        return results.select("answer.better_names").first()