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

edsl/__version__.py

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

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
@@ -678,9 +669,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
@@ -694,9 +685,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,10 +36,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 +57,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 +65,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.
 
@@ -249,7 +237,6 @@ 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))
@@ -277,58 +264,23 @@ class AgentList(UserList, Base):
     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(add_edsl_version=False)))
 
     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.
-
-        :param file_path: The path to the CSV file.
-        """
-        self.to_scenario_list().to_csv(file_path)
+        from edsl.utilities.utilities import data_to_html
 
-    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()
+        return data_to_html(self.to_dict()["agent_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 +315,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/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",
-    },
 }
 
 

edsl/coop/coop.py

@@ -102,57 +102,12 @@ 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)
@@ -625,7 +580,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', 'iterations': None, 'visibility': 'unlisted', 'version': '0.1.38.dev1'}
+        {'uuid': '9f8484ee-b407-40e4-9652-4133a7236c9c', 'description': 'My job', 'status': 'queued', 'visibility': 'unlisted', 'version': '0.1.29.dev4'}
         """
         response = self._send_server_request(
             uri="api/v0/remote-inference",
@@ -666,7 +621,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")
-        {'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'}
+        {'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'}
         """
         if job_uuid is None and results_uuid is None:
             raise ValueError("Either job_uuid or results_uuid must be provided.")
@@ -682,28 +637,10 @@ 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": results_uuid,
-            "results_url": results_url,
-            "latest_error_report_uuid": latest_error_report_uuid,
-            "latest_error_report_url": latest_error_report_url,
+            "results_uuid": data.get("results_uuid"),
+            "results_url": f"{self.url}/content/{data.get('results_uuid')}",
             "status": data.get("status"),
             "reason": data.get("reason"),
             "credits_consumed": data.get("price"),
@@ -720,7 +657,7 @@ class Coop:
 
         >>> job = Jobs.example()
         >>> coop.remote_inference_cost(input=job)
-        {'credits': 0.77, 'usd': 0.0076950000000000005}
+        16
         """
         if isinstance(input, Jobs):
             job = input
@@ -800,15 +737,11 @@ class Coop:
 
         from edsl.config import CONFIG
 
-        if CONFIG.get("EDSL_FETCH_TOKEN_PRICES") == "True":
+        if bool(CONFIG.get("EDSL_FETCH_TOKEN_PRICES")):
             price_fetcher = PriceFetcher()
             return price_fetcher.fetch_prices()
-        elif CONFIG.get("EDSL_FETCH_TOKEN_PRICES") == "False":
-            return {}
         else:
-            raise ValueError(
-                "Invalid EDSL_FETCH_TOKEN_PRICES value---should be 'True' or 'False'."
-            )
+            return {}
 
     def fetch_models(self) -> dict:
         """

edsl/data/Cache.py

@@ -27,8 +27,6 @@ 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__(
@@ -411,33 +409,10 @@ 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
-        # 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)
+        from edsl.utilities.utilities import data_to_html
 
-    def to_dataset(self):
-        return self.to_scenario_list().to_dataset()
+        return data_to_html(self.to_dict())
 
     @classmethod
     @remove_edsl_version

edsl/data/CacheEntry.py

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

edsl/data/RemoteCacheSync.py

@@ -76,3 +76,22 @@ 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,7 +64,6 @@ class InferenceServiceType(EnumWithChecks):
     OLLAMA = "ollama"
     MISTRAL = "mistral"
     TOGETHER = "together"
-    PERPLEXITY = "perplexity"
 
 
 service_to_api_keyname = {
@@ -79,7 +78,6 @@ 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",
 }