edsl 0.1.38.dev2__py3-none-any.whl → 0.1.38.dev4__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."""

edsl/__version__.py

@@ -1 +1 @@
-__version__ = "0.1.38.dev2"
+__version__ = "0.1.38.dev4"

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
@@ -669,9 +678,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
@@ -685,9 +694,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
 

edsl/agents/AgentList.py

@@ -36,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.
 
@@ -57,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.
@@ -65,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.
 
@@ -237,6 +249,7 @@ class AgentList(UserList, Base):
         return dict_hash(self.to_dict(add_edsl_version=False, sorted=True))
 
     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))
@@ -264,23 +277,58 @@ class AgentList(UserList, Base):
     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(add_edsl_version=False)))
+    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.
+
+        :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) -> ScenarioList:
+    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":
@@ -315,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/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",
+    },
 }
 
 

edsl/coop/coop.py

@@ -102,12 +102,57 @@ class Coop:
 
         return response
 
+    def _get_latest_stable_version(self, version: str) -> str:
+        """
+        Extract the latest stable PyPI version from a version string.
+
+        Examples:
+        - Decrement the patch number of a dev version: "0.1.38.dev1" -> "0.1.37"
+        - Return a stable version as is: "0.1.37" -> "0.1.37"
+        """
+        if "dev" not in version:
+            return version
+        else:
+            # For 0.1.38.dev1, split into ["0", "1", "38", "dev1"]
+            major, minor, patch = version.split(".")[:3]
+
+            current_patch = int(patch)
+            latest_patch = current_patch - 1
+            return f"{major}.{minor}.{latest_patch}"
+
+    def _user_version_is_outdated(
+        self, user_version_str: str, server_version_str: str
+    ) -> bool:
+        """
+        Check if the user's EDSL version is outdated compared to the server's.
+        """
+        server_stable_version_str = self._get_latest_stable_version(server_version_str)
+        user_stable_version_str = self._get_latest_stable_version(user_version_str)
+
+        # Turn the version strings into tuples of ints for comparison
+        user_stable_version = tuple(map(int, user_stable_version_str.split(".")))
+        server_stable_version = tuple(map(int, server_stable_version_str.split(".")))
+
+        return user_stable_version < server_stable_version
+
     def _resolve_server_response(
         self, response: requests.Response, check_api_key: bool = True
     ) -> None:
         """
         Check the response from the server and raise errors as appropriate.
         """
+        # Get EDSL version from header
+        server_edsl_version = response.headers.get("X-EDSL-Version")
+
+        if server_edsl_version:
+            if self._user_version_is_outdated(
+                user_version_str=self._edsl_version,
+                server_version_str=server_edsl_version,
+            ):
+                print(
+                    "Please upgrade your EDSL version to access our latest features. To upgrade, open your terminal and run `pip upgrade edsl`"
+                )
+
         if response.status_code >= 400:
             message = response.json().get("detail")
             # print(response.text)
@@ -580,7 +625,7 @@ class Coop:
 
         >>> job = Jobs.example()
         >>> coop.remote_inference_create(job=job, description="My job")
-        {'uuid': '9f8484ee-b407-40e4-9652-4133a7236c9c', 'description': 'My job', 'status': 'queued', 'visibility': 'unlisted', 'version': '0.1.29.dev4'}
+        {'uuid': '9f8484ee-b407-40e4-9652-4133a7236c9c', 'description': 'My job', 'status': 'queued', 'iterations': None, 'visibility': 'unlisted', 'version': '0.1.38.dev1'}
         """
         response = self._send_server_request(
             uri="api/v0/remote-inference",
@@ -621,7 +666,7 @@ class Coop:
         :param results_uuid: The UUID of the results associated with the EDSL job.
 
         >>> coop.remote_inference_get("9f8484ee-b407-40e4-9652-4133a7236c9c")
-        {'jobs_uuid': '9f8484ee-b407-40e4-9652-4133a7236c9c', 'results_uuid': 'dd708234-31bf-4fe1-8747-6e232625e026', 'results_url': 'https://www.expectedparrot.com/content/dd708234-31bf-4fe1-8747-6e232625e026', 'status': 'completed', 'reason': None, 'price': 16, 'version': '0.1.29.dev4'}
+        {'job_uuid': '9f8484ee-b407-40e4-9652-4133a7236c9c', 'results_uuid': 'dd708234-31bf-4fe1-8747-6e232625e026', 'results_url': 'https://www.expectedparrot.com/content/dd708234-31bf-4fe1-8747-6e232625e026', 'latest_error_report_uuid': None, 'latest_error_report_url': None, 'status': 'completed', 'reason': None, 'credits_consumed': 0.35, 'version': '0.1.38.dev1'}
         """
         if job_uuid is None and results_uuid is None:
             raise ValueError("Either job_uuid or results_uuid must be provided.")
@@ -637,10 +682,28 @@ class Coop:
         )
         self._resolve_server_response(response)
         data = response.json()
+
+        results_uuid = data.get("results_uuid")
+        latest_error_report_uuid = data.get("latest_error_report_uuid")
+
+        if results_uuid is None:
+            results_url = None
+        else:
+            results_url = f"{self.url}/content/{results_uuid}"
+
+        if latest_error_report_uuid is None:
+            latest_error_report_url = None
+        else:
+            latest_error_report_url = (
+                f"{self.url}/home/remote-inference/error/{latest_error_report_uuid}"
+            )
+
         return {
             "job_uuid": data.get("job_uuid"),
-            "results_uuid": data.get("results_uuid"),
-            "results_url": f"{self.url}/content/{data.get('results_uuid')}",
+            "results_uuid": results_uuid,
+            "results_url": results_url,
+            "latest_error_report_uuid": latest_error_report_uuid,
+            "latest_error_report_url": latest_error_report_url,
             "status": data.get("status"),
             "reason": data.get("reason"),
             "credits_consumed": data.get("price"),
@@ -657,7 +720,7 @@ class Coop:
 
         >>> job = Jobs.example()
         >>> coop.remote_inference_cost(input=job)
-        16
+        {'credits': 0.77, 'usd': 0.0076950000000000005}
         """
         if isinstance(input, Jobs):
             job = input
@@ -737,11 +800,15 @@ class Coop:
 
         from edsl.config import CONFIG
 
-        if bool(CONFIG.get("EDSL_FETCH_TOKEN_PRICES")):
+        if CONFIG.get("EDSL_FETCH_TOKEN_PRICES") == "True":
             price_fetcher = PriceFetcher()
             return price_fetcher.fetch_prices()
-        else:
+        elif CONFIG.get("EDSL_FETCH_TOKEN_PRICES") == "False":
             return {}
+        else:
+            raise ValueError(
+                "Invalid EDSL_FETCH_TOKEN_PRICES value---should be 'True' or 'False'."
+            )
 
     def fetch_models(self) -> dict:
         """

edsl/data/Cache.py

@@ -27,6 +27,8 @@ class Cache(Base):
     :param method: The method of storage to use for the cache.
     """
 
+    __documentation__ = "https://docs.expectedparrot.com/en/latest/data.html"
+
     data = {}
 
     def __init__(
@@ -409,10 +411,33 @@ class Cache(Base):
 
         return d
 
+    def _summary(self):
+        return {"EDSL Class": "Cache", "Number of entries": len(self.data)}
+
     def _repr_html_(self):
-        from edsl.utilities.utilities import data_to_html
+        # from edsl.utilities.utilities import data_to_html
+        # return data_to_html(self.to_dict())
+        footer = f"<a href={self.__documentation__}>(docs)</a>"
+        return str(self.summary(format="html")) + footer
+
+    def table(
+        self,
+        *fields,
+        tablefmt: Optional[str] = None,
+        pretty_labels: Optional[dict] = None,
+    ) -> str:
+        return self.to_dataset().table(
+            *fields, tablefmt=tablefmt, pretty_labels=pretty_labels
+        )
+
+    def select(self, *fields):
+        return self.to_dataset().select(*fields)
+
+    def tree(self, node_list: Optional[list[str]] = None):
+        return self.to_scenario_list().tree(node_list)
 
-        return data_to_html(self.to_dict())
+    def to_dataset(self):
+        return self.to_scenario_list().to_dataset()
 
     @classmethod
     @remove_edsl_version

edsl/data/CacheEntry.py

@@ -96,9 +96,14 @@ class CacheEntry:
         """
         Returns an HTML representation of a CacheEntry.
         """
-        from edsl.utilities.utilities import data_to_html
-
-        return data_to_html(self.to_dict())
+        # from edsl.utilities.utilities import data_to_html
+        # return data_to_html(self.to_dict())
+        d = self.to_dict()
+        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 keys(self):
         return list(self.to_dict().keys())

edsl/data/RemoteCacheSync.py

@@ -76,22 +76,3 @@ class RemoteCacheSync:
         self._output(
             f"There are {len(self.cache.keys()):,} entries in the local cache."
         )
-
-
-# # Usage example
-# def run_job(self, n, progress_bar, cache, stop_on_exception, sidecar_model, print_exceptions, raise_validation_errors, use_remote_cache=True):
-#     with RemoteCacheSync(self.coop, cache, self._output, remote_cache=use_remote_cache):
-#         self._output("Running job...")
-#         results = self._run_local(
-#             n=n,
-#             progress_bar=progress_bar,
-#             cache=cache,
-#             stop_on_exception=stop_on_exception,
-#             sidecar_model=sidecar_model,
-#             print_exceptions=print_exceptions,
-#             raise_validation_errors=raise_validation_errors,
-#         )
-#         self._output("Job completed!")
-
-#     results.cache = cache.new_entries_cache()
-#     return results

edsl/enums.py

@@ -64,6 +64,7 @@ class InferenceServiceType(EnumWithChecks):
     OLLAMA = "ollama"
     MISTRAL = "mistral"
     TOGETHER = "together"
+    PERPLEXITY = "perplexity"
 
 
 service_to_api_keyname = {
@@ -78,6 +79,7 @@ service_to_api_keyname = {
     InferenceServiceType.BEDROCK.value: ["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY"],
     InferenceServiceType.MISTRAL.value: "MISTRAL_API_KEY",
     InferenceServiceType.TOGETHER.value: "TOGETHER_API_KEY",
+    InferenceServiceType.PERPLEXITY.value: "PERPLEXITY_API_KEY",
 }