edsl 0.1.29__py3-none-any.whl → 0.1.29.dev1__py3-none-any.whl

edsl/Base.py

@@ -6,6 +6,9 @@ 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:
@@ -13,8 +16,6 @@ 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()
@@ -27,11 +28,7 @@ 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
@@ -55,28 +52,31 @@ class PersistenceMixin:
         return c.create(self, description, visibility)
 
     @classmethod
-    def pull(cls, uuid: Optional[Union[str, UUID]] = None, url: Optional[str] = None):
+    def pull(cls, id_or_url: Union[str, UUID], exec_profile=None):
         """Pull the object from coop."""
         from edsl.coop import Coop
-        from edsl.coop.utils import ObjectRegistry
 
-        object_type = ObjectRegistry.get_object_type_by_edsl_class(cls)
-        coop = Coop()
-        return coop.get(uuid, url, object_type)
+        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)
 
     @classmethod
-    def delete(cls, uuid: Optional[Union[str, UUID]] = None, url: Optional[str] = None):
+    def delete(cls, id_or_url: Union[str, UUID]):
         """Delete the object from coop."""
         from edsl.coop import Coop
 
-        coop = Coop()
-        return coop.delete(uuid, url)
+        c = Coop()
+        return c._delete_base(cls, id_or_url)
 
     @classmethod
     def patch(
         cls,
-        uuid: Optional[Union[str, UUID]] = None,
-        url: Optional[str] = None,
+        id_or_url: Union[str, UUID],
         description: Optional[str] = None,
         value: Optional[Any] = None,
         visibility: Optional[str] = None,
@@ -89,8 +89,8 @@ class PersistenceMixin:
         """
         from edsl.coop import Coop
 
-        coop = Coop()
-        return coop.patch(uuid, url, description, value, visibility)
+        c = Coop()
+        return c._patch_base(cls, id_or_url, description, value, visibility)
 
     @classmethod
     def search(cls, query):

edsl/__init__.py

@@ -1,5 +1,4 @@
 import os
-import time
 
 BASE_DIR = os.path.dirname(os.path.abspath(__file__))
 ROOT_DIR = os.path.dirname(BASE_DIR)
@@ -8,35 +7,36 @@ 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
-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.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.surveys.Survey import Survey
 from edsl.language_models.registry import Model
-from edsl.language_models.ModelList import ModelList
+from edsl.questions.question_registry import Question
 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.Jobs import Jobs
-from edsl.notebooks.Notebook import Notebook
+from edsl.jobs import Jobs
+from edsl.notebooks import Notebook
 from edsl.study.Study import Study
-from edsl.conjure.Conjure import Conjure
 from edsl.coop.coop import Coop
+from edsl.conjure.Conjure import Conjure
+from edsl.language_models.ModelList import ModelList

edsl/__version__.py

@@ -1 +1 @@
-__version__ = "0.1.29"
+__version__ = "0.1.29.dev1"

edsl/agents/Agent.py

@@ -5,14 +5,27 @@ import copy
 import inspect
 import types
 from typing import Any, Callable, Optional, Union, Dict, Sequence
-from edsl.Base import Base
 
+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,
@@ -25,6 +38,10 @@ 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
 
 
@@ -39,7 +56,6 @@ class Agent(Base):
     name = NameDescriptor()
     dynamic_traits_function_name = ""
     answer_question_directly_function_name = ""
-    has_dynamic_traits_function = False
 
     def __init__(
         self,
@@ -113,16 +129,12 @@ 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
@@ -139,8 +151,6 @@ 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)
 
@@ -149,7 +159,7 @@ class Agent(Base):
 
         This checks whether the dynamic traits function is valid.
         """
-        if self.has_dynamic_traits_function:
+        if self.dynamic_traits_function is not None:
             sig = inspect.signature(self.dynamic_traits_function)
             if "question" in sig.parameters:
                 if len(sig.parameters) > 1:
@@ -179,7 +189,7 @@ class Agent(Base):
         {'age': 10, 'hair': 'brown', 'height': 5.5}
 
         """
-        if self.has_dynamic_traits_function:
+        if self.dynamic_traits_function is not None:
             sig = inspect.signature(self.dynamic_traits_function)
             if "question" in sig.parameters:
                 return self.dynamic_traits_function(question=self.current_question)
@@ -261,9 +271,8 @@ class Agent(Base):
     def create_invigilator(
         self,
         *,
-        question: "QuestionBase",
-        cache: "Cache",
-        survey: Optional["Survey"] = None,
+        question: QuestionBase,
+        cache,
         scenario: Optional[Scenario] = None,
         model: Optional[LanguageModel] = None,
         debug: bool = False,
@@ -271,7 +280,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.
@@ -285,8 +294,6 @@ 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()
@@ -294,7 +301,6 @@ class Agent(Base):
         invigilator = self._create_invigilator(
             question=question,
             scenario=scenario,
-            survey=survey,
             model=model,
             debug=debug,
             memory_plan=memory_plan,
@@ -308,13 +314,12 @@ class Agent(Base):
     async def async_answer_question(
         self,
         *,
-        question: "QuestionBase",
-        cache: "Cache",
-        scenario: Optional["Scenario"] = None,
-        survey: Optional["Survey"] = None,
-        model: Optional["LanguageModel"] = None,
+        question: QuestionBase,
+        cache: Cache,
+        scenario: Optional[Scenario] = 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:
@@ -344,7 +349,6 @@ class Agent(Base):
             question=question,
             cache=cache,
             scenario=scenario,
-            survey=survey,
             model=model,
             debug=debug,
             memory_plan=memory_plan,
@@ -358,35 +362,21 @@ class Agent(Base):
 
     def _create_invigilator(
         self,
-        question: "QuestionBase",
-        cache: Optional["Cache"] = None,
-        scenario: Optional["Scenario"] = None,
-        model: Optional["LanguageModel"] = None,
-        survey: Optional["Survey"] = None,
+        question: QuestionBase,
+        cache: Optional[Cache] = None,
+        scenario: Optional[Scenario] = 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,
         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:
@@ -414,7 +404,6 @@ class Agent(Base):
             self,
             question=question,
             scenario=scenario,
-            survey=survey,
             model=model,
             memory_plan=memory_plan,
             current_answers=current_answers,
@@ -490,29 +479,6 @@ 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
@@ -569,9 +535,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
@@ -587,9 +553,9 @@ 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
 
@@ -674,8 +640,6 @@ 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,7 +12,7 @@ Example usage:
 
 from __future__ import annotations
 from collections import UserList
-from typing import Optional, Union, Sequence, List, Any
+from typing import Optional, Union, Sequence
 from rich import print_json
 from rich.table import Table
 import json
@@ -22,8 +22,7 @@ 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,
@@ -33,7 +32,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.
@@ -78,7 +77,6 @@ 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})])
@@ -96,13 +94,12 @@ 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.
             """
@@ -136,8 +133,6 @@ 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)
@@ -158,7 +153,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})])
@@ -227,14 +222,12 @@ 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)
 
@@ -247,30 +240,8 @@ 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

@@ -82,25 +82,7 @@ class InvigilatorAI(PromptConstructorMixin, InvigilatorBase):
             self._remove_from_cache(raw_response)
             raise e
 
-        # 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
-        )
+        answer = question._translate_answer_code_to_answer(response["answer"], scenario)
         data = {
             "answer": answer,
             "comment": response.get(

edsl/agents/InvigilatorBase.py

@@ -46,7 +46,6 @@ 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,
@@ -58,12 +57,11 @@ class InvigilatorBase(ABC):
         self.scenario = scenario
         self.model = model
         self.memory_plan = memory_plan
-        self.current_answers = current_answers or {}
+        self.current_answers = current_answers
         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.
@@ -78,7 +76,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', ...}
+        {'answer': None, 'comment': 'Failed to get response', 'question_name': 'how_feeling', ...}
         """
         return AgentResponseDict(
             answer=None,
@@ -88,8 +86,11 @@ 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"),
@@ -128,7 +129,7 @@ class InvigilatorBase(ABC):
         )
 
     @classmethod
-    def example(cls, throw_an_exception=False, question=None, scenario=None):
+    def example(cls, throw_an_exception=False):
         """Return an example invigilator.
 
         >>> InvigilatorBase.example()
@@ -166,20 +167,15 @@ class InvigilatorBase(ABC):
         if throw_an_exception:
             model.throw_an_exception = True
         agent = Agent.example()
-        # question = QuestionMultipleChoice.example()
-        from edsl.surveys import Survey
-
-        survey = Survey.example()
-        question = question or survey.questions[0]
-        scenario = scenario or Scenario.example()
+        question = QuestionMultipleChoice.example()
+        scenario = 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(PromptConstructorMixin, InvigilatorBase):
+        class InvigilatorExample(InvigilatorBase):
             """An example invigilator."""
 
             async def async_answer_question(self):
@@ -192,7 +188,6 @@ class InvigilatorBase(ABC):
             agent=agent,
             question=question,
             scenario=scenario,
-            survey=survey,
             model=model,
             memory_plan=memory_plan,
             current_answers=current_answers,