edsl 0.1.29.dev6__py3-none-any.whl → 0.1.30.dev1__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.dev1"

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
 
 
@@ -156,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)
 
@@ -276,8 +261,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 +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.
@@ -300,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()
@@ -321,13 +308,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 +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:
@@ -502,7 +502,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 +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

@@ -22,7 +22,8 @@ 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,
@@ -32,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.
@@ -77,6 +78,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 +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.
             """
@@ -133,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)
@@ -153,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})])
@@ -222,12 +227,14 @@ 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)
 
@@ -240,6 +247,8 @@ class AgentList(UserList, Base):
         2
 
         """
+        from edsl.agents.Agent import Agent
+
         return cls([Agent.example(), Agent.example()])
 
     @classmethod
@@ -249,6 +258,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

@@ -82,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(

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(

edsl/base/Base.py

@@ -0,0 +1,289 @@
+"""Base class for all classes in the package. It provides rich printing and persistence of objects."""
+
+from abc import ABC, abstractmethod, ABCMeta
+import gzip
+import io
+import json
+from typing import Any, Optional, Union
+from uuid import UUID
+from IPython.display import display
+from rich.console import Console
+
+
+class RichPrintingMixin:
+    """Mixin for rich printing and persistence of objects."""
+
+    def _for_console(self):
+        """Return a string representation of the object for console printing."""
+        with io.StringIO() as buf:
+            console = Console(file=buf, record=True)
+            table = self.rich_print()
+            console.print(table)
+            return console.export_text()
+
+    def __str__(self):
+        """Return a string representation of the object for console printing."""
+        return self._for_console()
+
+    def print(self):
+        """Print the object to the console."""
+        from edsl.utilities.utilities import is_notebook
+
+        if is_notebook():
+            display(self.rich_print())
+        else:
+            from rich.console import Console
+
+            console = Console()
+            console.print(self.rich_print())
+
+
+class PersistenceMixin:
+    """Mixin for saving and loading objects to and from files."""
+
+    def push(
+        self,
+        description: Optional[str] = None,
+        visibility: Optional[str] = "unlisted",
+    ):
+        """Post the object to coop."""
+        from edsl.coop import Coop
+
+        c = Coop()
+        return c.create(self, description, visibility)
+
+    @classmethod
+    def pull(cls, id_or_url: Union[str, UUID], exec_profile=None):
+        """Pull the object from coop."""
+        from edsl.coop import Coop
+
+        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, id_or_url: Union[str, UUID]):
+        """Delete the object from coop."""
+        from edsl.coop import Coop
+
+        c = Coop()
+        return c._delete_base(cls, id_or_url)
+
+    @classmethod
+    def patch(
+        cls,
+        id_or_url: Union[str, UUID],
+        description: Optional[str] = None,
+        value: Optional[Any] = None,
+        visibility: Optional[str] = None,
+    ):
+        """
+        Patch an uploaded objects attributes.
+        - `description` changes the description of the object on Coop
+        - `value` changes the value of the object on Coop. **has to be an EDSL object**
+        - `visibility` changes the visibility of the object on Coop
+        """
+        from edsl.coop import Coop
+
+        c = Coop()
+        return c._patch_base(cls, id_or_url, description, value, visibility)
+
+    @classmethod
+    def search(cls, query):
+        """Search for objects on coop."""
+        from edsl.coop import Coop
+
+        c = Coop()
+        return c.search(cls, query)
+
+    def save(self, filename, compress=True):
+        """Save the object to a file as zippped JSON.
+
+        >>> obj.save("obj.json.gz")
+
+        """
+        if filename.endswith("json.gz"):
+            import warnings
+
+            warnings.warn(
+                "Do not apply the file extensions. The filename should not end with 'json.gz'."
+            )
+            filename = filename[:-7]
+        if filename.endswith("json"):
+            filename = filename[:-4]
+            warnings.warn(
+                "Do not apply the file extensions. The filename should not end with 'json'."
+            )
+
+        if compress:
+            with gzip.open(filename + ".json.gz", "wb") as f:
+                f.write(json.dumps(self.to_dict()).encode("utf-8"))
+        else:
+            with open(filename + ".json", "w") as f:
+                f.write(json.dumps(self.to_dict()))
+
+    @staticmethod
+    def open_compressed_file(filename):
+        with gzip.open(filename, "rb") as f:
+            file_contents = f.read()
+            file_contents_decoded = file_contents.decode("utf-8")
+            d = json.loads(file_contents_decoded)
+        return d
+
+    @staticmethod
+    def open_regular_file(filename):
+        with open(filename, "r") as f:
+            d = json.loads(f.read())
+        return d
+
+    @classmethod
+    def load(cls, filename):
+        """Load the object from a file.
+
+        >>> obj = cls.load("obj.json.gz")
+
+        """
+
+        if filename.endswith("json.gz"):
+            d = cls.open_compressed_file(filename)
+        elif filename.endswith("json"):
+            d = cls.open_regular_file(filename)
+        else:
+            try:
+                d = cls.open_compressed_file(filename)
+            except:
+                d = cls.open_regular_file(filename)
+            finally:
+                raise ValueError("File must be a json or json.gz file")
+
+        return cls.from_dict(d)
+
+
+class RegisterSubclassesMeta(ABCMeta):
+    """Metaclass for registering subclasses."""
+
+    _registry = {}
+
+    def __init__(cls, name, bases, nmspc):
+        """Register the class in the registry upon creation."""
+        super(RegisterSubclassesMeta, cls).__init__(name, bases, nmspc)
+        if cls.__name__ != "Base":
+            RegisterSubclassesMeta._registry[cls.__name__] = cls
+
+    @staticmethod
+    def get_registry():
+        """Return the registry of subclasses."""
+        return dict(RegisterSubclassesMeta._registry)
+
+
+class DiffMethodsMixin:
+    def __sub__(self, other):
+        """Return the difference between two objects."""
+        from edsl.BaseDiff import BaseDiff
+
+        return BaseDiff(self, other)
+
+
+class Base(
+    RichPrintingMixin,
+    PersistenceMixin,
+    DiffMethodsMixin,
+    ABC,
+    metaclass=RegisterSubclassesMeta,
+):
+    """Base class for all classes in the package."""
+
+    # def __getitem__(self, key):
+    #     return getattr(self, key)
+
+    # @abstractmethod
+    # def _repr_html_(self) -> str:
+    #     raise NotImplementedError("This method is not implemented yet.")
+
+    # @abstractmethod
+    # def _repr_(self) -> str:
+    #     raise NotImplementedError("This method is not implemented yet.")
+
+    def keys(self):
+        """Return the keys of the object."""
+        _keys = list(self.to_dict().keys())
+        if "edsl_version" in _keys:
+            _keys.remove("edsl_version")
+        if "edsl_class_name" in _keys:
+            _keys.remove("edsl_class_name")
+        return _keys
+
+    def values(self):
+        """Return the values of the object."""
+        data = self.to_dict()
+        keys = self.keys()
+        return {data[key] for key in keys}
+
+    def _repr_html_(self):
+        from edsl.utilities.utilities import data_to_html
+
+        return data_to_html(self.to_dict())
+
+    # def html(self):
+    #     html_string = self._repr_html_()
+    #     import tempfile
+    #     import webbrowser
+
+    #     with tempfile.NamedTemporaryFile("w", delete=False, suffix=".html") as f:
+    #         # print("Writing HTML to", f.name)
+    #         f.write(html_string)
+    #         webbrowser.open(f.name)
+
+    def __eq__(self, other):
+        """Return whether two objects are equal."""
+        import inspect
+
+        if not isinstance(other, self.__class__):
+            return False
+        if "sort" in inspect.signature(self._to_dict).parameters:
+            return self._to_dict(sort=True) == other._to_dict(sort=True)
+        else:
+            return self._to_dict() == other._to_dict()
+
+    @abstractmethod
+    def example():
+        """This method should be implemented by subclasses."""
+        raise NotImplementedError("This method is not implemented yet.")
+
+    @abstractmethod
+    def rich_print():
+        """This method should be implemented by subclasses."""
+        raise NotImplementedError("This method is not implemented yet.")
+
+    @abstractmethod
+    def to_dict():
+        """This method should be implemented by subclasses."""
+        raise NotImplementedError("This method is not implemented yet.")
+
+    @abstractmethod
+    def from_dict():
+        """This method should be implemented by subclasses."""
+        raise NotImplementedError("This method is not implemented yet.")
+
+    @abstractmethod
+    def code():
+        """This method should be implemented by subclasses."""
+        raise NotImplementedError("This method is not implemented yet.")
+
+    def show_methods(self, show_docstrings=True):
+        """Show the methods of the object."""
+        public_methods_with_docstrings = [
+            (method, getattr(self, method).__doc__)
+            for method in dir(self)
+            if callable(getattr(self, method)) and not method.startswith("_")
+        ]
+        if show_docstrings:
+            for method, documentation in public_methods_with_docstrings:
+                print(f"{method}: {documentation}")
+        else:
+            return [x[0] for x in public_methods_with_docstrings]