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

edsl/Base.py

@@ -9,46 +9,37 @@ from uuid import UUID
 
 # from edsl.utilities.MethodSuggesterMixin import MethodSuggesterMixin
 
-from edsl.utilities.utilities import is_notebook
-
 
 class RichPrintingMixin:
-    pass
-
-    # def print(self):
-    #     print(self)
-
+    """Mixin for rich printing and persistence of objects."""
 
-#     """Mixin for rich printing and persistence of objects."""
+    def _for_console(self):
+        """Return a string representation of the object for console printing."""
+        from rich.console import Console
 
-#     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()
+            console.print(table)
+            return console.export_text()
 
-#         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()
-#         return self.__repr__()
+    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
+    def print(self):
+        """Print the object to the console."""
+        from edsl.utilities.utilities import is_notebook
 
-#         if is_notebook():
-#             from IPython.display import display
+        if is_notebook():
+            from IPython.display import display
 
-#             display(self.rich_print())
-#         else:
-#             from rich.console import Console
+            display(self.rich_print())
+        else:
+            from rich.console import Console
 
-#             console = Console()
-#             console.print(self.rich_print())
+            console = Console()
+            console.print(self.rich_print())
 
 
 class PersistenceMixin:
@@ -210,7 +201,7 @@ class DiffMethodsMixin:
 
 
 class Base(
-    # RichPrintingMixin,
+    RichPrintingMixin,
     PersistenceMixin,
     DiffMethodsMixin,
     ABC,
@@ -218,36 +209,16 @@ class Base(
 ):
     """Base class for all classes in the package."""
 
-    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.")
+    # def __getitem__(self, key):
+    #     return getattr(self, key)
 
-        if hasattr(self, "table"):
-            return self.table()
-        else:
-            return self
+    # @abstractmethod
+    # def _repr_html_(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")
+    # @abstractmethod
+    # def _repr_(self) -> str:
+    #     raise NotImplementedError("This method is not implemented yet.")
 
     def keys(self):
         """Return the keys of the object."""
@@ -285,10 +256,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,8 +41,7 @@ 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.38"
+__version__ = "0.1.38.dev1"

edsl/agents/Agent.py

@@ -243,15 +243,6 @@ 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:
@@ -640,10 +631,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
@@ -703,10 +694,14 @@ class Agent(Base):
     def __hash__(self) -> int:
         from edsl.utilities.utilities import dict_hash
 
-        return dict_hash(self.to_dict(add_edsl_version=False))
+        return dict_hash(self._to_dict())
 
-    # @add_edsl_version
-    def to_dict(self, add_edsl_version=True) -> dict[str, Union[dict, bool]]:
+    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]]:
         """Serialize to a dictionary with EDSL info.
 
         Example usage:
@@ -715,14 +710,7 @@ class Agent(Base):
         >>> a.to_dict()
         {'name': 'Steve', 'traits': {'age': 10, 'hair': 'brown', 'height': 5.5}, 'edsl_version': '...', 'edsl_class_name': 'Agent'}
         """
-        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
+        return self._to_dict()
 
     @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, TYPE_CHECKING
+from typing import Any, List, Optional, Union
 from rich import print_json
 from rich.table import Table
 from simpleeval import EvalWithCompoundTypes
@@ -23,11 +23,6 @@ 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)
@@ -36,10 +31,6 @@ 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.
 
@@ -61,7 +52,7 @@ class AgentList(UserList, Base):
         random.shuffle(self.data)
         return self
 
-    def sample(self, n: int, seed: Optional[str] = None) -> AgentList:
+    def sample(self, n: int, seed="edsl") -> AgentList:
         """Return a random sample of agents.
 
         :param n: The number of agents to sample.
@@ -69,17 +60,9 @@ class AgentList(UserList, Base):
         """
         import random
 
-        if seed:
-            random.seed(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.
 
@@ -130,7 +113,7 @@ class AgentList(UserList, Base):
             ]
         except Exception as e:
             print(f"Exception:{e}")
-            raise AgentListError(f"Error in filter. Exception:{e}")
+            raise Exception(f"Error in filter. Exception:{e}")
 
         return AgentList(new_data)
 
@@ -216,8 +199,7 @@ class AgentList(UserList, Base):
         >>> al.add_trait('new_trait', [1, 2, 3])
         Traceback (most recent call last):
         ...
-        edsl.exceptions.agents.AgentListError: The passed values have to be the same length as the agent list.
-        ...
+        ValueError: The passed values have to be the same length as the agent list.
         """
         if not is_iterable(values):
             value = values
@@ -226,7 +208,7 @@ class AgentList(UserList, Base):
             return self
 
         if len(values) != len(self):
-            raise AgentListError(
+            raise ValueError(
                 "The passed values have to be the same length as the agent list."
             )
         for agent, value in zip(self.data, values):
@@ -246,89 +228,47 @@ class AgentList(UserList, Base):
     def __hash__(self) -> int:
         from edsl.utilities.utilities import dict_hash
 
-        return dict_hash(self.to_dict(add_edsl_version=False, sorted=True))
+        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))
 
-    def to_dict(self, sorted=False, add_edsl_version=True):
-        """Serialize the AgentList to a dictionary."""
+    def _to_dict(self, sorted=False):
         if sorted:
             data = self.data[:]
             data.sort(key=lambda x: hash(x))
         else:
             data = self.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__
-
-            d["edsl_version"] = __version__
-            d["edsl_class_name"] = "AgentList"
-
-        return d
+        return {"agent_list": [agent.to_dict() for agent in data]}
 
     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
-        )
+        return self._to_dict(sorted=True) == other._to_dict(sorted=True)
+
+    @add_edsl_version
+    def to_dict(self):
+        """Return dictionary of AgentList to serialization."""
+        return self._to_dict()
 
     def __repr__(self):
         return f"AgentList({self.data})"
 
-    def _summary(self):
-        return {
-            "EDSL Class": "AgentList",
-            "Number of agents": len(self),
-            "Agent trait fields": self.all_traits,
-        }
+    def print(self, format: Optional[str] = None):
+        """Print the AgentList."""
+        print_json(json.dumps(self._to_dict()))
 
     def _repr_html_(self):
         """Return an HTML representation of the AgentList."""
-        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.
+        from edsl.utilities.utilities import data_to_html
 
-        :param file_path: The path to the CSV file.
-        """
-        self.to_scenario_list().to_csv(file_path)
+        return data_to_html(self.to_dict()["agent_list"])
 
-    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:
+    def to_scenario_list(self) -> "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":
@@ -363,9 +303,6 @@ 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,10 +45,6 @@ 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
         )
@@ -87,26 +83,19 @@ class InvigilatorAI(InvigilatorBase):
         exception_occurred = None
         validated = False
         try:
-            # if the question has jinja parameters, it is easier to make a new question with the parameters
+            # 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 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,6 +172,25 @@ 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,8 +169,6 @@ 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)
@@ -202,12 +200,13 @@ 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
-        ):  # is this a question with question options?
+        if "question_options" in question_data:
             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.utilities.naming_utilities import sanitize_string
+from edsl.conjure.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.utilities.naming_utilities import sanitize_string
+from edsl.conjure.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,16 +229,26 @@ 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,14 +61,6 @@ 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",
-    },
 }