edsl 0.1.27.dev2__py3-none-any.whl → 0.1.29__py3-none-any.whl

edsl/agents/Agent.py

@@ -5,27 +5,14 @@ import copy
 import inspect
 import types
 from typing import Any, Callable, Optional, Union, Dict, Sequence
-
-from rich.table import Table
-
 from edsl.Base import Base
-from edsl.questions.QuestionBase import QuestionBase
-from edsl.language_models import LanguageModel
-from edsl.surveys.MemoryPlan import MemoryPlan
+
 from edsl.exceptions.agents import (
     AgentCombinationError,
     AgentDirectAnswerFunctionError,
     AgentDynamicTraitsFunctionError,
 )
-from edsl.agents.Invigilator import (
-    InvigilatorDebug,
-    InvigilatorHuman,
-    InvigilatorFunctional,
-    InvigilatorAI,
-    InvigilatorBase,
-)
-from edsl.language_models.registry import Model
-from edsl.scenarios import Scenario
+
 from edsl.agents.descriptors import (
     TraitsDescriptor,
     CodebookDescriptor,
@@ -38,10 +25,6 @@ from edsl.utilities.decorators import (
     remove_edsl_version,
 )
 from edsl.data_transfer_models import AgentResponseDict
-from edsl.prompts.library.agent_persona import AgentPersona
-from edsl.data.Cache import Cache
-
-
 from edsl.utilities.restricted_python import create_restricted_function
 
 
@@ -56,6 +39,7 @@ class Agent(Base):
     name = NameDescriptor()
     dynamic_traits_function_name = ""
     answer_question_directly_function_name = ""
+    has_dynamic_traits_function = False
 
     def __init__(
         self,
@@ -98,7 +82,7 @@ class Agent(Base):
 
         >>> a = Agent(traits = {"age": 10}, traits_presentation_template = "I am a {{age}} year old.")
         >>> repr(a.agent_persona)
-        "Prompt(text='I am a {{age}} year old.')"
+        'Prompt(text=\"""I am a {{age}} year old.\""")'
 
         When this is rendered for presentation to the LLM, it will replace the `{{age}}` with the actual age.
         it is also possible to use the `codebook` to provide a more human-readable description of the trait.
@@ -109,7 +93,7 @@ class Agent(Base):
         >>> a = Agent(traits = traits, codebook = codebook, traits_presentation_template = "This agent is Dave. {{codebook['age']}} {{age}}")
         >>> d = a.traits | {'codebook': a.codebook}
         >>> a.agent_persona.render(d)
-        Prompt(text='This agent is Dave. Their age is 10')
+        Prompt(text=\"""This agent is Dave. Their age is 10\""")
 
         Instructions
         ------------
@@ -129,12 +113,16 @@ class Agent(Base):
 
         if self.dynamic_traits_function:
             self.dynamic_traits_function_name = self.dynamic_traits_function.__name__
+            self.has_dynamic_traits_function = True
+        else:
+            self.has_dynamic_traits_function = False
 
         if dynamic_traits_function_source_code:
             self.dynamic_traits_function_name = dynamic_traits_function_name
             self.dynamic_traits_function = create_restricted_function(
                 dynamic_traits_function_name, dynamic_traits_function
             )
+
         if answer_question_directly_source_code:
             self.answer_question_directly_function_name = (
                 answer_question_directly_function_name
@@ -151,6 +139,8 @@ class Agent(Base):
         self.current_question = None
 
         if traits_presentation_template is not None:
+            from edsl.prompts.library.agent_persona import AgentPersona
+
             self.traits_presentation_template = traits_presentation_template
             self.agent_persona = AgentPersona(text=self.traits_presentation_template)
 
@@ -159,7 +149,7 @@ class Agent(Base):
 
         This checks whether the dynamic traits function is valid.
         """
-        if self.dynamic_traits_function is not None:
+        if self.has_dynamic_traits_function:
             sig = inspect.signature(self.dynamic_traits_function)
             if "question" in sig.parameters:
                 if len(sig.parameters) > 1:
@@ -189,7 +179,7 @@ class Agent(Base):
         {'age': 10, 'hair': 'brown', 'height': 5.5}
 
         """
-        if self.dynamic_traits_function is not None:
+        if self.has_dynamic_traits_function:
             sig = inspect.signature(self.dynamic_traits_function)
             if "question" in sig.parameters:
                 return self.dynamic_traits_function(question=self.current_question)
@@ -198,6 +188,18 @@ class Agent(Base):
         else:
             return self._traits
 
+    def rename(self, old_name: str, new_name: str) -> Agent:
+        """Rename a trait.
+
+        Example usage:
+
+        >>> a = Agent(traits = {"age": 10, "hair": "brown", "height": 5.5})
+        >>> a.rename("age", "years") == Agent(traits = {'years': 10, 'hair': 'brown', 'height': 5.5})
+        True
+        """
+        self.traits[new_name] = self.traits.pop(old_name)
+        return self
+
     def __getitem__(self, key):
         """Allow for accessing traits using the bracket notation.
 
@@ -259,8 +261,9 @@ class Agent(Base):
     def create_invigilator(
         self,
         *,
-        question: QuestionBase,
-        cache,
+        question: "QuestionBase",
+        cache: "Cache",
+        survey: Optional["Survey"] = None,
         scenario: Optional[Scenario] = None,
         model: Optional[LanguageModel] = None,
         debug: bool = False,
@@ -268,7 +271,7 @@ class Agent(Base):
         current_answers: Optional[dict] = None,
         iteration: int = 1,
         sidecar_model=None,
-    ) -> InvigilatorBase:
+    ) -> "InvigilatorBase":
         """Create an Invigilator.
 
         An invigilator is an object that is responsible for administering a question to an agent.
@@ -282,6 +285,8 @@ class Agent(Base):
         An invigator is an object that is responsible for administering a question to an agent and
         recording the responses.
         """
+        from edsl import Model, Scenario
+
         cache = cache
         self.current_question = question
         model = model or Model()
@@ -289,6 +294,7 @@ class Agent(Base):
         invigilator = self._create_invigilator(
             question=question,
             scenario=scenario,
+            survey=survey,
             model=model,
             debug=debug,
             memory_plan=memory_plan,
@@ -302,12 +308,13 @@ class Agent(Base):
     async def async_answer_question(
         self,
         *,
-        question: QuestionBase,
-        cache: Cache,
-        scenario: Optional[Scenario] = None,
-        model: Optional[LanguageModel] = None,
+        question: "QuestionBase",
+        cache: "Cache",
+        scenario: Optional["Scenario"] = None,
+        survey: Optional["Survey"] = None,
+        model: Optional["LanguageModel"] = None,
         debug: bool = False,
-        memory_plan: Optional[MemoryPlan] = None,
+        memory_plan: Optional["MemoryPlan"] = None,
         current_answers: Optional[dict] = None,
         iteration: int = 0,
     ) -> AgentResponseDict:
@@ -327,7 +334,7 @@ class Agent(Base):
         >>> from edsl import QuestionFreeText
         >>> q = QuestionFreeText.example()
         >>> a.answer_question(question = q, cache = False)
-        {'answer': 'I am a direct answer.', 'comment': 'This is a real survey response from a human.', 'question_name': 'how_are_you', 'prompts': {'user_prompt': Prompt(text='NA'), 'system_prompt': Prompt(text='NA')}, 'usage': {'prompt_tokens': 0, 'completion_tokens': 0}, 'cached_response': None, 'raw_model_response': None, 'simple_model_raw_response': None}
+        {'answer': 'I am a direct answer.', 'comment': 'This is a real survey response from a human.', ...}
 
         This is a function where an agent returns an answer to a particular question.
         However, there are several different ways an agent can answer a question, so the
@@ -337,6 +344,7 @@ class Agent(Base):
             question=question,
             cache=cache,
             scenario=scenario,
+            survey=survey,
             model=model,
             debug=debug,
             memory_plan=memory_plan,
@@ -350,21 +358,35 @@ class Agent(Base):
 
     def _create_invigilator(
         self,
-        question: QuestionBase,
-        cache: Optional[Cache] = None,
-        scenario: Optional[Scenario] = None,
-        model: Optional[LanguageModel] = None,
+        question: "QuestionBase",
+        cache: Optional["Cache"] = None,
+        scenario: Optional["Scenario"] = None,
+        model: Optional["LanguageModel"] = None,
+        survey: Optional["Survey"] = None,
         debug: bool = False,
-        memory_plan: Optional[MemoryPlan] = None,
+        memory_plan: Optional["MemoryPlan"] = None,
         current_answers: Optional[dict] = None,
         iteration: int = 0,
         sidecar_model=None,
-    ) -> InvigilatorBase:
+    ) -> "InvigilatorBase":
         """Create an Invigilator."""
+        from edsl import Model
+        from edsl import Scenario
+
         model = model or Model()
         scenario = scenario or Scenario()
 
+        from edsl.agents.Invigilator import (
+            InvigilatorDebug,
+            InvigilatorHuman,
+            InvigilatorFunctional,
+            InvigilatorAI,
+            InvigilatorBase,
+        )
+
         if cache is None:
+            from edsl.data.Cache import Cache
+
             cache = Cache()
 
         if debug:
@@ -392,6 +414,7 @@ class Agent(Base):
             self,
             question=question,
             scenario=scenario,
+            survey=survey,
             model=model,
             memory_plan=memory_plan,
             current_answers=current_answers,
@@ -467,6 +490,29 @@ class Agent(Base):
         """
         return self.data == other.data
 
+    def __getattr__(self, name):
+        # This will be called only if 'name' is not found in the usual places
+        # breakpoint()
+        if name == "has_dynamic_traits_function":
+            return self.has_dynamic_traits_function
+
+        if name in self.traits:
+            return self.traits[name]
+        raise AttributeError(
+            f"'{type(self).__name__}' object has no attribute '{name}'"
+        )
+
+    def __getstate__(self):
+        state = self.__dict__.copy()
+        # Include any additional state that needs to be serialized
+        return state
+
+    def __setstate__(self, state):
+        self.__dict__.update(state)
+        # Ensure _traits is initialized if it's missing
+        if "_traits" not in self.__dict__:
+            self._traits = {}
+
     def print(self) -> None:
         from rich import print_json
         import json
@@ -523,9 +569,9 @@ class Agent(Base):
             if dynamic_traits_func:
                 func = inspect.getsource(dynamic_traits_func)
                 raw_data["dynamic_traits_function_source_code"] = func
-                raw_data[
-                    "dynamic_traits_function_name"
-                ] = self.dynamic_traits_function_name
+                raw_data["dynamic_traits_function_name"] = (
+                    self.dynamic_traits_function_name
+                )
         if hasattr(self, "answer_question_directly"):
             raw_data.pop(
                 "answer_question_directly", None
@@ -541,12 +587,21 @@ class Agent(Base):
                 raw_data["answer_question_directly_source_code"] = inspect.getsource(
                     answer_question_directly_func
                 )
-                raw_data[
-                    "answer_question_directly_function_name"
-                ] = self.answer_question_directly_function_name
+                raw_data["answer_question_directly_function_name"] = (
+                    self.answer_question_directly_function_name
+                )
 
         return raw_data
 
+    def __hash__(self) -> int:
+        from edsl.utilities.utilities import dict_hash
+
+        return dict_hash(self._to_dict())
+
+    def _to_dict(self) -> dict[str, Union[dict, bool]]:
+        """Serialize to a dictionary."""
+        return self.data
+
     @add_edsl_version
     def to_dict(self) -> dict[str, Union[dict, bool]]:
         """Serialize to a dictionary.
@@ -557,7 +612,7 @@ class Agent(Base):
         >>> a.to_dict()
         {'name': 'Steve', 'traits': {'age': 10, 'hair': 'brown', 'height': 5.5}, 'edsl_version': '...', 'edsl_class_name': 'Agent'}
         """
-        return self.data
+        return self._to_dict()
 
     @classmethod
     @remove_edsl_version
@@ -567,7 +622,7 @@ class Agent(Base):
         Example usage:
 
         >>> Agent.from_dict({'name': "Steve", 'traits': {'age': 10, 'hair': 'brown', 'height': 5.5}})
-        Agent(name = 'Steve', traits = {'age': 10, 'hair': 'brown', 'height': 5.5})
+        Agent(name = \"""Steve\""", traits = {'age': 10, 'hair': 'brown', 'height': 5.5})
 
         """
         return cls(**agent_dict)
@@ -619,6 +674,8 @@ class Agent(Base):
         >>> a.rich_print()
         <rich.table.Table object at ...>
         """
+        from rich.table import Table
+
         table_data, column_names = self._table()
         table = Table(title=f"{self.__class__.__name__} Attributes")
         for column in column_names:

edsl/agents/AgentList.py

@@ -12,16 +12,18 @@ Example usage:
 
 from __future__ import annotations
 from collections import UserList
-from typing import Optional, Union, Sequence
+from typing import Optional, Union, Sequence, List, Any
 from rich import print_json
 from rich.table import Table
 import json
 import csv
 
+
 from simpleeval import EvalWithCompoundTypes
 
 from edsl.Base import Base
-from edsl.agents import Agent
+
+# from edsl.agents import Agent
 from edsl.utilities.decorators import (
     add_edsl_version,
     remove_edsl_version,
@@ -31,7 +33,7 @@ from edsl.utilities.decorators import (
 class AgentList(UserList, Base):
     """A list of Agents."""
 
-    def __init__(self, data: Optional[list[Agent]] = None):
+    def __init__(self, data: Optional[list["Agent"]] = None):
         """Initialize a new AgentList.
 
         :param data: A list of Agents.
@@ -41,9 +43,42 @@ class AgentList(UserList, Base):
         else:
             super().__init__()
 
+    def shuffle(self, seed: Optional[str] = "edsl") -> AgentList:
+        """Shuffle the AgentList.
+
+        :param seed: The seed for the random number generator.
+        """
+        import random
+
+        random.seed(seed)
+        random.shuffle(self.data)
+        return self
+
+    def sample(self, n: int, seed="edsl") -> AgentList:
+        """Return a random sample of agents.
+
+        :param n: The number of agents to sample.
+        :param seed: The seed for the random number generator.
+        """
+        import random
+
+        random.seed(seed)
+        return AgentList(random.sample(self.data, n))
+
+    def rename(self, old_name, new_name):
+        """Rename a trait in the AgentList.
+
+        :param old_name: The old name of the trait.
+        :param new_name: The new name of the trait.
+        """
+        for agent in self.data:
+            agent.rename(old_name, new_name)
+        return self
+
     def select(self, *traits) -> AgentList:
         """Selects agents with only the references traits.
 
+        >>> from edsl.agents.Agent import Agent
         >>> al = AgentList([Agent(traits = {'a': 1, 'b': 1}), Agent(traits = {'a': 1, 'b': 2})])
         >>> al.select('a')
         AgentList([Agent(traits = {'a': 1}), Agent(traits = {'a': 1})])
@@ -61,12 +96,13 @@ class AgentList(UserList, Base):
         """
         Filter a list of agents based on an expression.
 
+        >>> from edsl.agents.Agent import Agent
         >>> al = AgentList([Agent(traits = {'a': 1, 'b': 1}), Agent(traits = {'a': 1, 'b': 2})])
         >>> al.filter("b == 2")
         AgentList([Agent(traits = {'a': 1, 'b': 2})])
         """
 
-        def create_evaluator(agent: Agent):
+        def create_evaluator(agent: "Agent"):
             """Create an evaluator for the given result.
             The 'combined_dict' is a mapping of all values for that Result object.
             """
@@ -100,6 +136,8 @@ class AgentList(UserList, Base):
 
         :param file_path: The path to the CSV file.
         """
+        from edsl.agents.Agent import Agent
+
         agent_list = []
         with open(file_path, "r") as f:
             reader = csv.DictReader(f)
@@ -120,7 +158,7 @@ class AgentList(UserList, Base):
         """Remove traits from the AgentList.
 
         :param traits: The traits to remove.
-
+        >>> from edsl.agents.Agent import Agent
         >>> al = AgentList([Agent({'age': 22, 'hair': 'brown', 'height': 5.5}), Agent({'age': 22, 'hair': 'brown', 'height': 5.5})])
         >>> al.remove_trait('age')
         AgentList([Agent(traits = {'hair': 'brown', 'height': 5.5}), Agent(traits = {'hair': 'brown', 'height': 5.5})])
@@ -139,21 +177,36 @@ class AgentList(UserList, Base):
             reader = csv.DictReader(f)
             return {field: None for field in reader.fieldnames}
 
+    def __hash__(self) -> int:
+        from edsl.utilities.utilities import dict_hash
+
+        data = self.to_dict()
+        # data['agent_list'] = sorted(data['agent_list'], key=lambda x: dict_hash(x)
+        return dict_hash(self._to_dict(sorted=True))
+
+    def _to_dict(self, sorted=False):
+        if sorted:
+            data = self.data[:]
+            data.sort(key=lambda x: hash(x))
+        else:
+            data = self.data
+
+        return {"agent_list": [agent.to_dict() for agent in data]}
+
+    def __eq__(self, other: AgentList) -> bool:
+        return self._to_dict(sorted=True) == other._to_dict(sorted=True)
+
     @add_edsl_version
     def to_dict(self):
-        """Return dictionary of AgentList to serialization.
-
-        >>> AgentList.example().to_dict()
-        {'agent_list': [{'traits': {'age': 22, 'hair': 'brown', 'height': 5.5}, 'edsl_version': '...', 'edsl_class_name': 'Agent'}, {'traits': {'age': 22, 'hair': 'brown', 'height': 5.5}, 'edsl_version': '...', 'edsl_class_name': 'Agent'}], 'edsl_version': '...', 'edsl_class_name': 'AgentList'}
-        """
-        return {"agent_list": [agent.to_dict() for agent in self.data]}
+        """Return dictionary of AgentList to serialization."""
+        return self._to_dict()
 
     def __repr__(self):
         return f"AgentList({self.data})"
 
     def print(self, format: Optional[str] = None):
         """Print the AgentList."""
-        print_json(json.dumps(self.to_dict()))
+        print_json(json.dumps(self._to_dict()))
 
     def _repr_html_(self):
         """Return an HTML representation of the AgentList."""
@@ -161,18 +214,27 @@ class AgentList(UserList, Base):
 
         return data_to_html(self.to_dict()["agent_list"])
 
+    def to_scenario_list(self) -> "ScenarioList":
+        """Return a list of scenarios."""
+        from edsl.scenarios.ScenarioList import ScenarioList
+        from edsl.scenarios.Scenario import Scenario
+
+        return ScenarioList([Scenario(agent.traits) for agent in self.data])
+
     @classmethod
     @remove_edsl_version
     def from_dict(cls, data: dict) -> "AgentList":
         """Deserialize the dictionary back to an AgentList object.
 
         :param: data: A dictionary representing an AgentList.
-
+        >>> from edsl.agents.Agent import Agent
         >>> al = AgentList([Agent.example(), Agent.example()])
         >>> al2 = AgentList.from_dict(al.to_dict())
         >>> al2 == al
         True
         """
+        from edsl.agents.Agent import Agent
+
         agents = [Agent.from_dict(agent_dict) for agent_dict in data["agent_list"]]
         return cls(agents)
 
@@ -185,8 +247,30 @@ class AgentList(UserList, Base):
         2
 
         """
+        from edsl.agents.Agent import Agent
+
         return cls([Agent.example(), Agent.example()])
 
+    @classmethod
+    def from_list(self, trait_name: str, values: List[Any]):
+        """Create an AgentList from a list of values.
+
+        :param trait_name: The name of the trait.
+        :param values: A list of values.
+        """
+        from edsl.agents.Agent import Agent
+
+        return AgentList([Agent({trait_name: value}) for value in values])
+
+    def __mul__(self, other: AgentList) -> AgentList:
+        """Takes the cross product of two AgentLists."""
+        from itertools import product
+
+        new_sl = []
+        for s1, s2 in list(product(self, other)):
+            new_sl.append(s1 + s2)
+        return AgentList(new_sl)
+
     def code(self, string=True) -> Union[str, list[str]]:
         """Return code to construct an AgentList.
 

edsl/agents/Invigilator.py

@@ -63,14 +63,9 @@ class InvigilatorAI(PromptConstructorMixin, InvigilatorBase):
 
     def _remove_from_cache(self, raw_response) -> None:
         """Remove an entry from the cache."""
-        if (
-            "raw_model_response" in raw_response
-            and "cache_key" in raw_response["raw_model_response"]
-        ):
-            cache_key = raw_response["raw_model_response"]["cache_key"]
-        else:
-            cache_key = None
-        del self.cache.data[cache_key]
+        cache_key = raw_response.get("cache_key", None)
+        if cache_key:
+            del self.cache.data[cache_key]
 
     def _format_raw_response(
         self, *, agent, question, scenario, raw_response, raw_model_response
@@ -87,7 +82,25 @@ class InvigilatorAI(PromptConstructorMixin, InvigilatorBase):
             self._remove_from_cache(raw_response)
             raise e
 
-        answer = question._translate_answer_code_to_answer(response["answer"], scenario)
+        # breakpoint()
+        question_dict = self.survey.question_names_to_questions()
+        for other_question, answer in self.current_answers.items():
+            if other_question in question_dict:
+                question_dict[other_question].answer = answer
+            else:
+                # adds a comment to the question
+                if (
+                    new_question := other_question.split("_comment")[0]
+                ) in question_dict:
+                    question_dict[new_question].comment = answer
+
+        combined_dict = {**question_dict, **scenario}
+        # print("combined_dict: ", combined_dict)
+        # print("response: ", response)
+        # breakpoint()
+        answer = question._translate_answer_code_to_answer(
+            response["answer"], combined_dict
+        )
         data = {
             "answer": answer,
             "comment": response.get(
@@ -95,7 +108,7 @@ class InvigilatorAI(PromptConstructorMixin, InvigilatorBase):
             ),  # not all question have comment fields,
             "question_name": question.question_name,
             "prompts": self.get_prompts(),
-            "cached_response": raw_response["cached_response"],
+            "cached_response": raw_response.get("cached_response", None),
             "usage": raw_response.get("usage", {}),
             "raw_model_response": raw_model_response,
         }