edsl 0.1.29.dev3__py3-none-any.whl → 0.1.30__py3-none-any.whl

edsl/Base.py

@@ -6,9 +6,6 @@ import io
 import json
 from typing import Any, Optional, Union
 from uuid import UUID
-from IPython.display import display
-from rich.console import Console
-from edsl.utilities import is_notebook
 
 
 class RichPrintingMixin:
@@ -16,6 +13,8 @@ class RichPrintingMixin:
 
     def _for_console(self):
         """Return a string representation of the object for console printing."""
+        from rich.console import Console
+
         with io.StringIO() as buf:
             console = Console(file=buf, record=True)
             table = self.rich_print()
@@ -28,7 +27,11 @@ class RichPrintingMixin:
 
     def print(self):
         """Print the object to the console."""
+        from edsl.utilities.utilities import is_notebook
+
         if is_notebook():
+            from IPython.display import display
+
             display(self.rich_print())
         else:
             from rich.console import Console
@@ -52,31 +55,28 @@ class PersistenceMixin:
         return c.create(self, description, visibility)
 
     @classmethod
-    def pull(cls, id_or_url: Union[str, UUID], exec_profile=None):
+    def pull(cls, uuid: Optional[Union[str, UUID]] = None, url: Optional[str] = None):
         """Pull the object from coop."""
         from edsl.coop import Coop
+        from edsl.coop.utils import ObjectRegistry
 
-        if id_or_url.startswith("http"):
-            uuid_value = id_or_url.split("/")[-1]
-        else:
-            uuid_value = id_or_url
-
-        c = Coop()
-
-        return c._get_base(cls, uuid_value, exec_profile=exec_profile)
+        object_type = ObjectRegistry.get_object_type_by_edsl_class(cls)
+        coop = Coop()
+        return coop.get(uuid, url, object_type)
 
     @classmethod
-    def delete(cls, id_or_url: Union[str, UUID]):
+    def delete(cls, uuid: Optional[Union[str, UUID]] = None, url: Optional[str] = None):
         """Delete the object from coop."""
         from edsl.coop import Coop
 
-        c = Coop()
-        return c._delete_base(cls, id_or_url)
+        coop = Coop()
+        return coop.delete(uuid, url)
 
     @classmethod
     def patch(
         cls,
-        id_or_url: Union[str, UUID],
+        uuid: Optional[Union[str, UUID]] = None,
+        url: Optional[str] = None,
         description: Optional[str] = None,
         value: Optional[Any] = None,
         visibility: Optional[str] = None,
@@ -89,8 +89,8 @@ class PersistenceMixin:
         """
         from edsl.coop import Coop
 
-        c = Coop()
-        return c._patch_base(cls, id_or_url, description, value, visibility)
+        coop = Coop()
+        return coop.patch(uuid, url, description, value, visibility)
 
     @classmethod
     def search(cls, query):

edsl/__init__.py

@@ -1,4 +1,5 @@
 import os
+import time
 
 BASE_DIR = os.path.dirname(os.path.abspath(__file__))
 ROOT_DIR = os.path.dirname(BASE_DIR)
@@ -7,36 +8,35 @@ from edsl.__version__ import __version__
 from edsl.config import Config, CONFIG
 from edsl.agents.Agent import Agent
 from edsl.agents.AgentList import AgentList
-from edsl.questions import (
-    QuestionBase,
-    QuestionBudget,
-    QuestionCheckBox,
-    QuestionExtract,
-    QuestionFreeText,
-    QuestionFunctional,
-    QuestionLikertFive,
-    QuestionList,
-    QuestionLinearScale,
-    QuestionMultipleChoice,
-    QuestionNumerical,
-    QuestionRank,
-    QuestionTopK,
-    QuestionYesNo,
-)
-from edsl.scenarios.Scenario import Scenario
-from edsl.scenarios.ScenarioList import ScenarioList
-from edsl.utilities.interface import print_dict_with_rich
+from edsl.questions import QuestionBase
+from edsl.questions import QuestionMultipleChoice
+from edsl.questions import QuestionBudget
+from edsl.questions import QuestionCheckBox
+from edsl.questions import QuestionExtract
+from edsl.questions import QuestionFreeText
+from edsl.questions import QuestionFunctional
+from edsl.questions import QuestionLikertFive
+from edsl.questions import QuestionList
+from edsl.questions import QuestionLinearScale
+from edsl.questions import QuestionNumerical
+from edsl.questions import QuestionRank
+from edsl.questions import QuestionTopK
+from edsl.questions import QuestionYesNo
+from edsl.questions.question_registry import Question
+from edsl.scenarios import Scenario
+from edsl.scenarios import ScenarioList
+
+# from edsl.utilities.interface import print_dict_with_rich
 from edsl.surveys.Survey import Survey
 from edsl.language_models.registry import Model
-from edsl.questions.question_registry import Question
+from edsl.language_models.ModelList import ModelList
 from edsl.results.Results import Results
 from edsl.data.Cache import Cache
 from edsl.data.CacheEntry import CacheEntry
 from edsl.data.CacheHandler import set_session_cache, unset_session_cache
 from edsl.shared import shared_globals
-from edsl.jobs import Jobs
-from edsl.notebooks import Notebook
+from edsl.jobs.Jobs import Jobs
+from edsl.notebooks.Notebook import Notebook
 from edsl.study.Study import Study
 from edsl.conjure.Conjure import Conjure
-from edsl.language_models.ModelList import ModelList
 from edsl.coop.coop import Coop

edsl/__version__.py

@@ -1 +1 @@
-__version__ = "0.1.29.dev3"
+__version__ = "0.1.30"

edsl/agents/Agent.py

@@ -4,28 +4,16 @@ from __future__ import annotations
 import copy
 import inspect
 import types
-from typing import Any, Callable, Optional, Union, Dict, Sequence
-
-from rich.table import Table
-
+from typing import Callable, Optional, Union
+from uuid import uuid4
 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 +26,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 +40,7 @@ class Agent(Base):
     name = NameDescriptor()
     dynamic_traits_function_name = ""
     answer_question_directly_function_name = ""
+    has_dynamic_traits_function = False
 
     def __init__(
         self,
@@ -129,12 +114,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 +140,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 +150,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 +180,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)
@@ -271,8 +262,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,
@@ -280,7 +272,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.
@@ -294,6 +286,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()
@@ -301,6 +295,7 @@ class Agent(Base):
         invigilator = self._create_invigilator(
             question=question,
             scenario=scenario,
+            survey=survey,
             model=model,
             debug=debug,
             memory_plan=memory_plan,
@@ -314,12 +309,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:
@@ -349,6 +345,7 @@ class Agent(Base):
             question=question,
             cache=cache,
             scenario=scenario,
+            survey=survey,
             model=model,
             debug=debug,
             memory_plan=memory_plan,
@@ -362,21 +359,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:
@@ -404,6 +415,7 @@ class Agent(Base):
             self,
             question=question,
             scenario=scenario,
+            survey=survey,
             model=model,
             memory_plan=memory_plan,
             current_answers=current_answers,
@@ -479,6 +491,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
@@ -640,6 +675,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:
@@ -652,13 +689,14 @@ class Agent(Base):
         return table
 
     @classmethod
-    def example(cls) -> Agent:
-        """Return an example agent.
+    def example(cls, randomize: bool = False) -> Agent:
+        """
+        Returns an example Agent instance.
 
-        >>> Agent.example()
-        Agent(traits = {'age': 22, 'hair': 'brown', 'height': 5.5})
+        :param randomize: If True, adds a random string to the value of an example key.
         """
-        return cls(traits={"age": 22, "hair": "brown", "height": 5.5})
+        addition = "" if not randomize else str(uuid4())
+        return cls(traits={"age": 22, "hair": f"brown{addition}", "height": 5.5})
 
     def code(self) -> str:
         """Return the code for the agent.

edsl/agents/AgentList.py

@@ -11,28 +11,21 @@ Example usage:
 """
 
 from __future__ import annotations
+import csv
+import json
 from collections import UserList
-from typing import Optional, Union, Sequence, List, Any
+from typing import Any, List, Optional, Union
 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.utilities.decorators import (
-    add_edsl_version,
-    remove_edsl_version,
-)
+from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
 
 
 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.
@@ -77,6 +70,7 @@ class AgentList(UserList, Base):
     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})])
@@ -94,12 +88,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.
             """
@@ -133,6 +128,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)
@@ -153,7 +150,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})])
@@ -222,35 +219,39 @@ class AgentList(UserList, Base):
         """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)
 
     @classmethod
-    def example(cls) -> "AgentList":
-        """Return an example AgentList.
-
-        >>> al = AgentList.example()
-        >>> len(al)
-        2
+    def example(cls, randomize: bool = False) -> AgentList:
+        """
+        Returns an example AgentList instance.
 
+        :param randomize: If True, uses Agent's randomize method.
         """
-        return cls([Agent.example(), Agent.example()])
-    
+        from edsl.agents.Agent import Agent
+
+        return cls([Agent.example(randomize), Agent.example(randomize)])
+
     @classmethod
-    def from_list(self, trait_name:str, values: List[Any]):
+    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
@@ -260,7 +261,6 @@ class AgentList(UserList, Base):
             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

@@ -74,15 +74,30 @@ class InvigilatorAI(PromptConstructorMixin, InvigilatorBase):
 
         This cleans up the raw response to make it suitable to pass to AgentResponseDict.
         """
-        # not actually used, but this removes the temptation to delete agent from the signature
         _ = agent
         try:
             response = question._validate_answer(raw_response)
         except Exception as e:
+            """If the response is invalid, remove it from the cache and raise the exception."""
             self._remove_from_cache(raw_response)
             raise e
 
-        answer = question._translate_answer_code_to_answer(response["answer"], scenario)
+        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}
+        answer = question._translate_answer_code_to_answer(
+            response["answer"], combined_dict
+        )
+        # breakpoint()
         data = {
             "answer": answer,
             "comment": response.get(
@@ -93,6 +108,8 @@ class InvigilatorAI(PromptConstructorMixin, InvigilatorBase):
             "cached_response": raw_response.get("cached_response", None),
             "usage": raw_response.get("usage", {}),
             "raw_model_response": raw_model_response,
+            "cache_used": raw_response.get("cache_used", False),
+            "cache_key": raw_response.get("cache_key", None),
         }
         return AgentResponseDict(**data)
 

edsl/agents/InvigilatorBase.py

@@ -46,6 +46,7 @@ class InvigilatorBase(ABC):
         model: LanguageModel,
         memory_plan: MemoryPlan,
         current_answers: dict,
+        survey: Optional["Survey"],
         cache: Optional[Cache] = None,
         iteration: Optional[int] = 1,
         additional_prompt_data: Optional[dict] = None,
@@ -57,11 +58,12 @@ class InvigilatorBase(ABC):
         self.scenario = scenario
         self.model = model
         self.memory_plan = memory_plan
-        self.current_answers = current_answers
+        self.current_answers = current_answers or {}
         self.iteration = iteration
         self.additional_prompt_data = additional_prompt_data
         self.cache = cache
         self.sidecar_model = sidecar_model
+        self.survey = survey
 
     def __repr__(self) -> str:
         """Return a string representation of the Invigilator.
@@ -76,7 +78,7 @@ class InvigilatorBase(ABC):
         """Return an AgentResponseDict used in case the question-asking fails.
 
         >>> InvigilatorBase.example().get_failed_task_result()
-        {'answer': None, 'comment': 'Failed to get response', 'question_name': 'how_feeling', ...}
+        {'answer': None, 'comment': 'Failed to get response', ...}
         """
         return AgentResponseDict(
             answer=None,
@@ -86,11 +88,8 @@ class InvigilatorBase(ABC):
         )
 
     def get_prompts(self) -> Dict[str, Prompt]:
-        """Return the prompt used.
+        """Return the prompt used."""
 
-        >>> InvigilatorBase.example().get_prompts()
-        {'user_prompt': Prompt(text=\"""NA\"""), 'system_prompt': Prompt(text=\"""NA\""")}
-        """
         return {
             "user_prompt": Prompt("NA"),
             "system_prompt": Prompt("NA"),
@@ -129,7 +128,7 @@ class InvigilatorBase(ABC):
         )
 
     @classmethod
-    def example(cls, throw_an_exception=False):
+    def example(cls, throw_an_exception=False, question=None, scenario=None):
         """Return an example invigilator.
 
         >>> InvigilatorBase.example()
@@ -167,15 +166,20 @@ class InvigilatorBase(ABC):
         if throw_an_exception:
             model.throw_an_exception = True
         agent = Agent.example()
-        question = QuestionMultipleChoice.example()
-        scenario = Scenario.example()
+        # question = QuestionMultipleChoice.example()
+        from edsl.surveys import Survey
+
+        survey = Survey.example()
+        question = question or survey.questions[0]
+        scenario = scenario or Scenario.example()
         # memory_plan = None #memory_plan = MemoryPlan()
         from edsl import Survey
 
         memory_plan = MemoryPlan(survey=Survey.example())
         current_answers = None
+        from edsl.agents.PromptConstructionMixin import PromptConstructorMixin
 
-        class InvigilatorExample(InvigilatorBase):
+        class InvigilatorExample(PromptConstructorMixin, InvigilatorBase):
             """An example invigilator."""
 
             async def async_answer_question(self):
@@ -188,6 +192,7 @@ class InvigilatorBase(ABC):
             agent=agent,
             question=question,
             scenario=scenario,
+            survey=survey,
             model=model,
             memory_plan=memory_plan,
             current_answers=current_answers,