edsl 0.1.29.dev6__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

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.dev6"
+__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
 
 
@@ -156,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)
 
@@ -276,8 +262,8 @@ 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,
@@ -286,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.
@@ -300,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()
@@ -321,13 +309,13 @@ class Agent(Base):
     async def async_answer_question(
         self,
         *,
-        question: QuestionBase,
-        cache: Cache,
-        scenario: Optional[Scenario] = None,
+        question: "QuestionBase",
+        cache: "Cache",
+        scenario: Optional["Scenario"] = None,
         survey: Optional["Survey"] = None,
-        model: Optional[LanguageModel] = 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:
@@ -371,22 +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:
@@ -502,7 +503,6 @@ class Agent(Base):
             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
@@ -675,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:
@@ -687,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,25 +219,27 @@ 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]):
@@ -249,6 +248,8 @@ class AgentList(UserList, Base):
         :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:

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/descriptors.py

@@ -1,7 +1,6 @@
 """This module contains the descriptors used to set the attributes of the Agent class."""
 
 from typing import Dict
-from edsl.utilities.utilities import is_valid_variable_name
 from edsl.exceptions.agents import AgentNameError, AgentTraitKeyError
 
 
@@ -30,6 +29,8 @@ class TraitsDescriptor:
 
     def __set__(self, instance, traits_dict: Dict[str, str]) -> None:
         """Set the value of the attribute."""
+        from edsl.utilities.utilities import is_valid_variable_name
+
         for key, value in traits_dict.items():
             if key == "name":
                 raise AgentNameError(