edsl 0.1.32__py3-none-any.whl → 0.1.33__py3-none-any.whl

edsl/Base.py

@@ -47,21 +47,27 @@ class PersistenceMixin:
         self,
         description: Optional[str] = None,
         visibility: Optional[str] = "unlisted",
+        expected_parrot_url: Optional[str] = None,
     ):
         """Post the object to coop."""
         from edsl.coop import Coop
 
-        c = Coop()
+        c = Coop(url=expected_parrot_url)
         return c.create(self, description, visibility)
 
     @classmethod
-    def pull(cls, uuid: Optional[Union[str, UUID]] = None, url: Optional[str] = None):
+    def pull(
+        cls,
+        uuid: Optional[Union[str, UUID]] = None,
+        url: Optional[str] = None,
+        expected_parrot_url: Optional[str] = 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()
+        coop = Coop(url=expected_parrot_url)
         return coop.get(uuid, url, object_type)
 
     @classmethod

edsl/TemplateLoader.py

@@ -0,0 +1,24 @@
+from importlib import resources
+from jinja2 import BaseLoader, TemplateNotFound
+import os
+
+
+class TemplateLoader(BaseLoader):
+    def __init__(self, package_name, templates_dir):
+        self.package_name = package_name
+        self.templates_dir = templates_dir
+
+    def get_source(self, environment, template):
+        try:
+            parts = [self.templates_dir] + template.split("/")
+            template_path = os.path.join(*parts)
+
+            # Use resources.files() to get a Traversable object
+            templates = resources.files(self.package_name).joinpath(self.templates_dir)
+
+            # Use the read_text() method of the Traversable object
+            content = templates.joinpath(template).read_text()
+
+            return content, None, lambda: True
+        except FileNotFoundError:
+            raise TemplateNotFound(template)

edsl/__init__.py

@@ -8,9 +8,10 @@ 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.question_registry import Question
 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
@@ -19,10 +20,11 @@ from edsl.questions import QuestionLikertFive
 from edsl.questions import QuestionList
 from edsl.questions import QuestionLinearScale
 from edsl.questions import QuestionNumerical
+from edsl.questions import QuestionYesNo
+from edsl.questions import QuestionBudget
 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
 
@@ -40,3 +42,6 @@ from edsl.notebooks.Notebook import Notebook
 from edsl.study.Study import Study
 from edsl.conjure.Conjure import Conjure
 from edsl.coop.coop import Coop
+
+from edsl.surveys.instructions.Instruction import Instruction
+from edsl.surveys.instructions.ChangeInstruction import ChangeInstruction

edsl/__version__.py

@@ -1 +1 @@
-__version__ = "0.1.32"
+__version__ = "0.1.33"

edsl/agents/Agent.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 import copy
 import inspect
 import types
-from typing import Callable, Optional, Union
+from typing import Callable, Optional, Union, Any
 from uuid import uuid4
 from edsl.Base import Base
 
@@ -228,7 +228,12 @@ class Agent(Base):
         if hasattr(self, "answer_question_directly"):
             delattr(self, "answer_question_directly")
 
-    def add_direct_question_answering_method(self, method: Callable) -> None:
+    def add_direct_question_answering_method(
+        self,
+        method: Callable,
+        validate_response: bool = False,
+        translate_response: bool = False,
+    ) -> None:
         """Add a method to the agent that can answer a particular question type.
 
         :param method: A method that can answer a question directly.
@@ -249,6 +254,9 @@ class Agent(Base):
             )
             # print("Warning: overwriting existing answer_question_directly method")
 
+        self.validate_response = validate_response
+        self.translate_response = translate_response
+
         signature = inspect.signature(method)
         for argument in ["question", "scenario", "self"]:
             if argument not in signature.parameters:
@@ -272,6 +280,7 @@ class Agent(Base):
         current_answers: Optional[dict] = None,
         iteration: int = 1,
         sidecar_model=None,
+        raise_validation_errors: bool = True,
     ) -> "InvigilatorBase":
         """Create an Invigilator.
 
@@ -303,7 +312,12 @@ class Agent(Base):
             iteration=iteration,
             cache=cache,
             sidecar_model=sidecar_model,
+            raise_validation_errors=raise_validation_errors,
         )
+        if hasattr(self, "validate_response"):
+            invigilator.validate_response = self.validate_response
+        if hasattr(self, "translate_response"):
+            invigilator.translate_response = self.translate_response
         return invigilator
 
     async def async_answer_question(
@@ -334,8 +348,8 @@ class Agent(Base):
         >>> a.add_direct_question_answering_method(lambda self, question, scenario: "I am a direct answer.")
         >>> 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.', ...}
+        >>> a.answer_question(question = q, cache = False).answer
+        'I am a direct answer.'
 
         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
@@ -369,6 +383,7 @@ class Agent(Base):
         current_answers: Optional[dict] = None,
         iteration: int = 0,
         sidecar_model=None,
+        raise_validation_errors: bool = True,
     ) -> "InvigilatorBase":
         """Create an Invigilator."""
         from edsl import Model
@@ -378,7 +393,6 @@ class Agent(Base):
         scenario = scenario or Scenario()
 
         from edsl.agents.Invigilator import (
-            InvigilatorDebug,
             InvigilatorHuman,
             InvigilatorFunctional,
             InvigilatorAI,
@@ -391,8 +405,9 @@ class Agent(Base):
             cache = Cache()
 
         if debug:
+            raise NotImplementedError("Debug mode is not yet implemented.")
             # use the question's _simulate_answer method
-            invigilator_class = InvigilatorDebug
+            # invigilator_class = InvigilatorDebug
         elif hasattr(question, "answer_question_directly"):
             # It's a functional question and the answer only depends on the agent's traits & the scenario
             invigilator_class = InvigilatorFunctional
@@ -422,6 +437,7 @@ class Agent(Base):
             iteration=iteration,
             cache=cache,
             sidecar_model=sidecar_model,
+            raise_validation_errors=raise_validation_errors,
         )
         return invigilator
 
@@ -497,8 +513,8 @@ class Agent(Base):
         if name == "has_dynamic_traits_function":
             return self.has_dynamic_traits_function
 
-        if name in self.traits:
-            return self.traits[name]
+        if name in self._traits:
+            return self._traits[name]
         raise AttributeError(
             f"'{type(self).__name__}' object has no attribute '{name}'"
         )
@@ -640,6 +656,22 @@ class Agent(Base):
         column_names = ["Attribute", "Value"]
         return table_data, column_names
 
+    def add_trait(self, trait_name_or_dict: str, value: Optional[Any] = None) -> Agent:
+        """Adds a trait to an agent and returns that agent"""
+        if isinstance(trait_name_or_dict, dict) and value is None:
+            self.traits.update(trait_name_or_dict)
+            return self
+
+        if isinstance(trait_name_or_dict, dict) and value:
+            raise ValueError(f"You passed a dict: {trait_name_or_dict}")
+
+        if isinstance(trait_name_or_dict, str):
+            trait = trait_name_or_dict
+            self.traits[trait] = value
+            return self
+
+        raise Exception("Something is not right with adding")
+
     def remove_trait(self, trait: str) -> Agent:
         """Remove a trait from the agent.
 

edsl/agents/AgentList.py

@@ -21,6 +21,12 @@ from simpleeval import EvalWithCompoundTypes
 from edsl.Base import Base
 from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
 
+from collections.abc import Iterable
+
+
+def is_iterable(obj):
+    return isinstance(obj, Iterable)
+
 
 class AgentList(UserList, Base):
     """A list of Agents."""
@@ -111,6 +117,13 @@ class AgentList(UserList, Base):
 
         return AgentList(new_data)
 
+    @property
+    def all_traits(self):
+        d = {}
+        for agent in self:
+            d.update(agent.traits)
+        return list(d.keys())
+
     @classmethod
     def from_csv(cls, file_path: str):
         """Load AgentList from a CSV file.
@@ -159,6 +172,36 @@ class AgentList(UserList, Base):
             _ = agent.remove_trait(trait)
         return self
 
+    def add_trait(self, trait, values):
+        """Adds a new trait to every agent, with values taken from values.
+
+        :param trait: The name of the trait.
+        :param values: The valeues(s) of the trait. If a single value is passed, it is used for all agents.
+
+        >>> al = AgentList.example()
+        >>> al.add_trait('new_trait', 1)
+        AgentList([Agent(traits = {'age': 22, 'hair': 'brown', 'height': 5.5, 'new_trait': 1}), Agent(traits = {'age': 22, 'hair': 'brown', 'height': 5.5, 'new_trait': 1})])
+        >>> al.select('new_trait').to_scenario_list().to_list()
+        [1, 1]
+        >>> al.add_trait('new_trait', [1, 2, 3])
+        Traceback (most recent call last):
+        ...
+        ValueError: The passed values have to be the same length as the agent list.
+        """
+        if not is_iterable(values):
+            value = values
+            for agent in self.data:
+                agent.add_trait(trait, value)
+            return self
+
+        if len(values) != len(self):
+            raise ValueError(
+                "The passed values have to be the same length as the agent list."
+            )
+        for agent, value in zip(self.data, values):
+            agent.add_trait(trait, value)
+        return self
+
     @staticmethod
     def get_codebook(file_path: str):
         """Return the codebook for a CSV file.