edsl 0.1.37.dev5__py3-none-any.whl → 0.1.38__py3-none-any.whl

edsl/Base.py

@@ -9,37 +9,46 @@ from uuid import UUID
 
 # from edsl.utilities.MethodSuggesterMixin import MethodSuggesterMixin
 
+from edsl.utilities.utilities import is_notebook
+
 
 class RichPrintingMixin:
-    """Mixin for rich printing and persistence of objects."""
+    pass
 
-    def _for_console(self):
-        """Return a string representation of the object for console printing."""
-        from rich.console import Console
+    # def print(self):
+    #     print(self)
 
-        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()
+#     """Mixin for rich printing and persistence of objects."""
 
-    def print(self):
-        """Print the object to the console."""
-        from edsl.utilities.utilities import is_notebook
+#     def _for_console(self):
+#         """Return a string representation of the object for console printing."""
+#         from rich.console import Console
 
-        if is_notebook():
-            from IPython.display import display
+#         with io.StringIO() as buf:
+#             console = Console(file=buf, record=True)
+#             table = self.rich_print()
+#             console.print(table)
+#             return console.export_text()
 
-            display(self.rich_print())
-        else:
-            from rich.console import Console
+#     def __str__(self):
+#         """Return a string representation of the object for console printing."""
+#         # return self._for_console()
+#         return self.__repr__()
+
+#     def print(self):
+#         """Print the object to the console."""
+#         from edsl.utilities.utilities import is_notebook
+
+#         if is_notebook():
+#             from IPython.display import display
 
-            console = Console()
-            console.print(self.rich_print())
+#             display(self.rich_print())
+#         else:
+#             from rich.console import Console
+
+#             console = Console()
+#             console.print(self.rich_print())
 
 
 class PersistenceMixin:
@@ -201,7 +210,7 @@ class DiffMethodsMixin:
 
 
 class Base(
-    RichPrintingMixin,
+    # RichPrintingMixin,
     PersistenceMixin,
     DiffMethodsMixin,
     ABC,
@@ -209,16 +218,36 @@ class Base(
 ):
     """Base class for all classes in the package."""
 
-    # def __getitem__(self, key):
-    #     return getattr(self, key)
+    def json(self):
+        return json.loads(json.dumps(self.to_dict(add_edsl_version=False)))
+
+    def print(self, **kwargs):
+        if "format" in kwargs:
+            if kwargs["format"] not in ["html", "markdown", "rich", "latex"]:
+                raise ValueError(f"Format '{kwargs['format']}' not supported.")
 
-    # @abstractmethod
-    # def _repr_html_(self) -> str:
-    #     raise NotImplementedError("This method is not implemented yet.")
+        if hasattr(self, "table"):
+            return self.table()
+        else:
+            return self
 
-    # @abstractmethod
-    # def _repr_(self) -> str:
-    #     raise NotImplementedError("This method is not implemented yet.")
+    def __str__(self):
+        return self.__repr__()
+
+    def summary(self, format="table"):
+        from edsl import Scenario
+
+        d = self._summary()
+        if format == "table":
+            return Scenario(d).table()
+        if format == "dict":
+            return d
+        if format == "json":
+            return Scenario(d).json()
+        if format == "yaml":
+            return Scenario(d).yaml()
+        if format == "html":
+            return Scenario(d).table(tablefmt="html")
 
     def keys(self):
         """Return the keys of the object."""
@@ -256,10 +285,10 @@ class Base(
 
         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)
+        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()
+            return self.to_dict() == other.to_dict()
 
     @abstractmethod
     def example():

edsl/BaseDiff.py

@@ -25,7 +25,7 @@ class DummyObject:
     def __init__(self, object_dict):
         self.object_dict = object_dict
 
-    def _to_dict(self):
+    def to_dict(self):
         return self.object_dict
 
 
@@ -38,12 +38,12 @@ class BaseDiff:
         self.obj1 = obj1
         self.obj2 = obj2
 
-        if "sort" in inspect.signature(obj1._to_dict).parameters:
-            self._dict1 = obj1._to_dict(sort=True)
-            self._dict2 = obj2._to_dict(sort=True)
+        if "sort" in inspect.signature(obj1.to_dict).parameters:
+            self._dict1 = obj1.to_dict(sort=True)
+            self._dict2 = obj2.to_dict(sort=True)
         else:
-            self._dict1 = obj1._to_dict()
-            self._dict2 = obj2._to_dict()
+            self._dict1 = obj1.to_dict()
+            self._dict2 = obj2.to_dict()
         self._obj_class = type(obj1)
 
         self.added = added
@@ -139,7 +139,7 @@ class BaseDiff:
     def apply(self, obj: Any):
         """Apply the diff to the object."""
 
-        new_obj_dict = obj._to_dict()
+        new_obj_dict = obj.to_dict()
         for k, v in self.added.items():
             new_obj_dict[k] = v
         for k in self.removed.keys():

edsl/__init__.py

@@ -41,7 +41,8 @@ from edsl.shared import shared_globals
 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.conjure.Conjure import Conjure
 from edsl.coop.coop import Coop
 
 from edsl.surveys.instructions.Instruction import Instruction

edsl/__version__.py

@@ -1 +1 @@
-__version__ = "0.1.37.dev5"
+__version__ = "0.1.38"

edsl/agents/Agent.py

@@ -243,6 +243,15 @@ class Agent(Base):
         else:
             return self._traits
 
+    def _repr_html_(self):
+        # d = self.to_dict(add_edsl_version=False)
+        d = self.traits
+        data = [[k, v] for k, v in d.items()]
+        from tabulate import tabulate
+
+        table = str(tabulate(data, headers=["keys", "values"], tablefmt="html"))
+        return f"<pre>{table}</pre>"
+
     def rename(
         self, old_name_or_dict: Union[str, dict], new_name: Optional[str] = None
     ) -> Agent:
@@ -631,10 +640,10 @@ class Agent(Base):
         ]
         return f"{class_name}({', '.join(items)})"
 
-    def _repr_html_(self):
-        from edsl.utilities.utilities import data_to_html
+    # def _repr_html_(self):
+    #     from edsl.utilities.utilities import data_to_html
 
-        return data_to_html(self.to_dict())
+    #     return data_to_html(self.to_dict())
 
     #######################
     # SERIALIZATION METHODS
@@ -694,14 +703,10 @@ class Agent(Base):
     def __hash__(self) -> int:
         from edsl.utilities.utilities import dict_hash
 
-        return dict_hash(self._to_dict())
+        return dict_hash(self.to_dict(add_edsl_version=False))
 
-    def _to_dict(self) -> dict[str, Union[dict, bool]]:
-        """Serialize to a dictionary without EDSL info"""
-        return self.data
-
-    @add_edsl_version
-    def to_dict(self) -> dict[str, Union[dict, bool]]:
+    # @add_edsl_version
+    def to_dict(self, add_edsl_version=True) -> dict[str, Union[dict, bool]]:
         """Serialize to a dictionary with EDSL info.
 
         Example usage:
@@ -710,7 +715,14 @@ class Agent(Base):
         >>> a.to_dict()
         {'name': 'Steve', 'traits': {'age': 10, 'hair': 'brown', 'height': 5.5}, 'edsl_version': '...', 'edsl_class_name': 'Agent'}
         """
-        return self._to_dict()
+        d = copy.deepcopy(self.data)
+        if add_edsl_version:
+            from edsl import __version__
+
+            d["edsl_version"] = __version__
+            d["edsl_class_name"] = self.__class__.__name__
+
+        return d
 
     @classmethod
     @remove_edsl_version

edsl/agents/AgentList.py

@@ -14,7 +14,7 @@ from __future__ import annotations
 import csv
 import json
 from collections import UserList
-from typing import Any, List, Optional, Union
+from typing import Any, List, Optional, Union, TYPE_CHECKING
 from rich import print_json
 from rich.table import Table
 from simpleeval import EvalWithCompoundTypes
@@ -23,6 +23,11 @@ from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
 
 from collections.abc import Iterable
 
+from edsl.exceptions.agents import AgentListError
+
+if TYPE_CHECKING:
+    from edsl.scenarios.ScenarioList import ScenarioList
+
 
 def is_iterable(obj):
     return isinstance(obj, Iterable)
@@ -31,6 +36,10 @@ def is_iterable(obj):
 class AgentList(UserList, Base):
     """A list of Agents."""
 
+    __documentation__ = (
+        "https://docs.expectedparrot.com/en/latest/agents.html#agentlist-class"
+    )
+
     def __init__(self, data: Optional[list["Agent"]] = None):
         """Initialize a new AgentList.
 
@@ -52,7 +61,7 @@ class AgentList(UserList, Base):
         random.shuffle(self.data)
         return self
 
-    def sample(self, n: int, seed="edsl") -> AgentList:
+    def sample(self, n: int, seed: Optional[str] = None) -> AgentList:
         """Return a random sample of agents.
 
         :param n: The number of agents to sample.
@@ -60,9 +69,17 @@ class AgentList(UserList, Base):
         """
         import random
 
-        random.seed(seed)
+        if seed:
+            random.seed(seed)
         return AgentList(random.sample(self.data, n))
 
+    def to_pandas(self):
+        """Return a pandas DataFrame."""
+        return self.to_scenario_list().to_pandas()
+
+    def tally(self):
+        return self.to_scenario_list().tally()
+
     def rename(self, old_name, new_name):
         """Rename a trait in the AgentList.
 
@@ -113,7 +130,7 @@ class AgentList(UserList, Base):
             ]
         except Exception as e:
             print(f"Exception:{e}")
-            raise Exception(f"Error in filter. Exception:{e}")
+            raise AgentListError(f"Error in filter. Exception:{e}")
 
         return AgentList(new_data)
 
@@ -199,7 +216,8 @@ class AgentList(UserList, Base):
         >>> 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.
+        edsl.exceptions.agents.AgentListError: The passed values have to be the same length as the agent list.
+        ...
         """
         if not is_iterable(values):
             value = values
@@ -208,7 +226,7 @@ class AgentList(UserList, Base):
             return self
 
         if len(values) != len(self):
-            raise ValueError(
+            raise AgentListError(
                 "The passed values have to be the same length as the agent list."
             )
         for agent, value in zip(self.data, values):
@@ -228,47 +246,89 @@ class AgentList(UserList, Base):
     def __hash__(self) -> int:
         from edsl.utilities.utilities import dict_hash
 
-        data = self.to_dict()
-        # data['agent_list'] = sorted(data['agent_list'], key=lambda x: dict_hash(x)
-        return dict_hash(self._to_dict(sorted=True))
+        return dict_hash(self.to_dict(add_edsl_version=False, sorted=True))
 
-    def _to_dict(self, sorted=False):
+    def to_dict(self, sorted=False, add_edsl_version=True):
+        """Serialize the AgentList to a dictionary."""
         if sorted:
             data = self.data[:]
             data.sort(key=lambda x: hash(x))
         else:
             data = self.data
 
-        return {"agent_list": [agent.to_dict() for agent in data]}
+        d = {
+            "agent_list": [
+                agent.to_dict(add_edsl_version=add_edsl_version) for agent in data
+            ]
+        }
+        if add_edsl_version:
+            from edsl import __version__
 
-    def __eq__(self, other: AgentList) -> bool:
-        return self._to_dict(sorted=True) == other._to_dict(sorted=True)
+            d["edsl_version"] = __version__
+            d["edsl_class_name"] = "AgentList"
 
-    @add_edsl_version
-    def to_dict(self):
-        """Return dictionary of AgentList to serialization."""
-        return self._to_dict()
+        return d
+
+    def __eq__(self, other: AgentList) -> bool:
+        return self.to_dict(sorted=True, add_edsl_version=False) == other.to_dict(
+            sorted=True, add_edsl_version=False
+        )
 
     def __repr__(self):
         return f"AgentList({self.data})"
 
-    def print(self, format: Optional[str] = None):
-        """Print the AgentList."""
-        print_json(json.dumps(self._to_dict()))
+    def _summary(self):
+        return {
+            "EDSL Class": "AgentList",
+            "Number of agents": len(self),
+            "Agent trait fields": self.all_traits,
+        }
 
     def _repr_html_(self):
         """Return an HTML representation of the AgentList."""
-        from edsl.utilities.utilities import data_to_html
+        footer = f"<a href={self.__documentation__}>(docs)</a>"
+        return str(self.summary(format="html")) + footer
+
+    def to_csv(self, file_path: str):
+        """Save the AgentList to a CSV file.
 
-        return data_to_html(self.to_dict()["agent_list"])
+        :param file_path: The path to the CSV file.
+        """
+        self.to_scenario_list().to_csv(file_path)
 
-    def to_scenario_list(self) -> "ScenarioList":
+    def to_list(self, include_agent_name=False) -> list[tuple]:
+        """Return a list of tuples."""
+        return self.to_scenario_list(include_agent_name).to_list()
+
+    def to_scenario_list(self, include_agent_name=False) -> ScenarioList:
         """Return a list of scenarios."""
         from edsl.scenarios.ScenarioList import ScenarioList
         from edsl.scenarios.Scenario import Scenario
 
+        if include_agent_name:
+            return ScenarioList(
+                [
+                    Scenario(agent.traits | {"agent_name": agent.name})
+                    for agent in self.data
+                ]
+            )
         return ScenarioList([Scenario(agent.traits) for agent in self.data])
 
+    def table(
+        self,
+        *fields,
+        tablefmt: Optional[str] = None,
+        pretty_labels: Optional[dict] = None,
+    ) -> Table:
+        return (
+            self.to_scenario_list()
+            .to_dataset()
+            .table(*fields, tablefmt=tablefmt, pretty_labels=pretty_labels)
+        )
+
+    def tree(self, node_order: Optional[List[str]] = None):
+        return self.to_scenario_list().tree(node_order)
+
     @classmethod
     @remove_edsl_version
     def from_dict(cls, data: dict) -> "AgentList":
@@ -303,6 +363,9 @@ class AgentList(UserList, Base):
 
         :param trait_name: The name of the trait.
         :param values: A list of values.
+
+        >>> AgentList.from_list('age', [22, 23])
+        AgentList([Agent(traits = {'age': 22}), Agent(traits = {'age': 23})])
         """
         from edsl.agents.Agent import Agent
 

edsl/agents/Invigilator.py

@@ -45,6 +45,10 @@ class InvigilatorAI(InvigilatorBase):
 
         params.update({"iteration": self.iteration, "cache": self.cache})
 
+        params.update({"invigilator": self})
+        # if hasattr(self.question, "answer_template"):
+        #    breakpoint()
+
         agent_response_dict: AgentResponseDict = await self.model.async_get_response(
             **params
         )
@@ -83,19 +87,26 @@ class InvigilatorAI(InvigilatorBase):
         exception_occurred = None
         validated = False
         try:
-            # if the question has jinja parameters, it might be easier to make a new question
-            # with those all filled in & then validate that
-            # breakpoint()
+            # if the question has jinja parameters, it is easier to make a new question with the parameters
             if self.question.parameters:
                 prior_answers_dict = self.prompt_constructor.prior_answers_dict()
+
+                # question options have be treated differently because of dynamic question
+                # this logic is all in the prompt constructor
+                if "question_options" in self.question.data:
+                    new_question_options = (
+                        self.prompt_constructor._get_question_options(
+                            self.question.data
+                        )
+                    )
+                    if new_question_options != self.question.data["question_options"]:
+                        # I don't love this direct writing but it seems to work
+                        self.question.question_options = new_question_options
+
                 question_with_validators = self.question.render(
                     self.scenario | prior_answers_dict
                 )
                 question_with_validators.use_code = self.question.use_code
-                # if question_with_validators.parameters:
-                #     raise ValueError(
-                #         f"The question still has parameters after rendering: {question_with_validators}"
-                #     )
             else:
                 question_with_validators = self.question
 

edsl/agents/InvigilatorBase.py

@@ -172,25 +172,6 @@ class InvigilatorBase(ABC):
         }
         return EDSLResultObjectInput(**data)
 
-        # breakpoint()
-        # if hasattr(self, "augmented_model_response"):
-        #     import json
-
-        #     generated_tokens = json.loads(self.augmented_model_response)["answer"][
-        #         "generated_tokens"
-        #     ]
-        # else:
-        #     generated_tokens = "Filled in by InvigilatorBase.get_failed_task_result"
-        # agent_response_dict = AgentResponseDict(
-        #     answer=None,
-        #     comment="Failed to get usable response",
-        #     generated_tokens=generated_tokens,
-        #     question_name=self.question.question_name,
-        #     prompts=self.get_prompts(),
-        # )
-        # # breakpoint()
-        # return agent_response_dict
-
     def get_prompts(self) -> Dict[str, Prompt]:
         """Return the prompt used."""
 

edsl/agents/PromptConstructor.py

@@ -169,6 +169,8 @@ class PromptConstructor:
 
         placeholder = ["<< Option 1 - Placholder >>", "<< Option 2 - Placholder >>"]
 
+        # print("Question options entry: ", question_options_entry)
+
         if isinstance(question_options_entry, str):
             env = Environment()
             parsed_content = env.parse(question_options_entry)
@@ -200,13 +202,12 @@ class PromptConstructor:
         # e.g., {'question_text': 'Do you like school?', 'question_name': 'q0', 'question_options': ['yes', 'no']}
         question_data = self.question.data.copy()
 
-        if "question_options" in question_data:
+        if (
+            "question_options" in question_data
+        ):  # is this a question with question options?
             question_options = self._get_question_options(question_data)
             question_data["question_options"] = question_options
 
-        # check to see if the question_options is actually a string
-        # This is used when the user is using the question_options as a variable from a scenario
-        # if "question_options" in question_data:
         replacement_dict = self.build_replacement_dict(question_data)
         rendered_instructions = question_prompt.render(replacement_dict)
 

edsl/auto/SurveyCreatorPipeline.py

@@ -15,7 +15,7 @@ from edsl.surveys.Survey import Survey
 from edsl.questions.QuestionMultipleChoice import QuestionMultipleChoice
 from edsl.questions.QuestionFreeText import QuestionFreeText
 from edsl.auto.utilities import gen_pipeline
-from edsl.conjure.naming_utilities import sanitize_string
+from edsl.utilities.naming_utilities import sanitize_string
 
 
 m = Model()

edsl/auto/utilities.py

@@ -2,7 +2,7 @@ from textwrap import dedent
 import random
 from typing import List, TypeVar, Generator, Optional
 from edsl.auto.StageBase import StageBase
-from edsl.conjure.naming_utilities import sanitize_string
+from edsl.utilities.naming_utilities import sanitize_string
 from edsl import Agent, Survey, Model, Cache, AgentList
 from edsl import QuestionFreeText, Scenario
 from edsl import QuestionMultipleChoice, Scenario, Agent, ScenarioList

edsl/base/Base.py

@@ -229,26 +229,16 @@ class Base(
 
         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)
+        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()
+            return self.to_dict() == other.to_dict()
 
     @abstractmethod
     def example():

edsl/config.py

@@ -61,6 +61,14 @@ CONFIG_MAP = {
         "default": "https://www.expectedparrot.com",
         "info": "This config var holds the URL of the Expected Parrot API.",
     },
+    "EDSL_MAX_CONCURRENT_TASKS": {
+        "default": "500",
+        "info": "This config var determines the maximum number of concurrent tasks that can be run by the async job-runner",
+    },
+    "EDSL_OPEN_EXCEPTION_REPORT_URL": {
+        "default": "False",
+        "info": "This config var determines whether to open the exception report URL in the browser",
+    },
 }