edsl 0.1.39.dev1__py3-none-any.whl → 0.1.39.dev2__py3-none-any.whl

edsl/results/Results.py

@@ -9,13 +9,7 @@ import random
 from collections import UserList, defaultdict
 from typing import Optional, Callable, Any, Type, Union, List, TYPE_CHECKING
 
-if TYPE_CHECKING:
-    from edsl import Survey, Cache, AgentList, ModelList, ScenarioList
-    from edsl.results.Result import Result
-    from edsl.jobs.tasks.TaskHistory import TaskHistory
-
-from simpleeval import EvalWithCompoundTypes
-
+from edsl.Base import Base
 from edsl.exceptions.results import (
     ResultsError,
     ResultsBadMutationstringError,
@@ -26,25 +20,27 @@ from edsl.exceptions.results import (
     ResultsDeserializationError,
 )
 
+if TYPE_CHECKING:
+    from edsl.surveys.Survey import Survey
+    from edsl.data.Cache import Cache
+    from edsl.agents.AgentList import AgentList
+    from edsl.language_models.registry import Model
+    from edsl.scenarios.ScenarioList import ScenarioList
+    from edsl.results.Result import Result
+    from edsl.jobs.tasks.TaskHistory import TaskHistory
+    from edsl.language_models.ModelList import ModelList
+    from simpleeval import EvalWithCompoundTypes
+
 from edsl.results.ResultsExportMixin import ResultsExportMixin
-from edsl.results.ResultsToolsMixin import ResultsToolsMixin
-from edsl.results.ResultsDBMixin import ResultsDBMixin
 from edsl.results.ResultsGGMixin import ResultsGGMixin
 from edsl.results.ResultsFetchMixin import ResultsFetchMixin
-
-from edsl.utilities.decorators import remove_edsl_version
-from edsl.utilities.utilities import dict_hash
-
-
-from edsl.Base import Base
+from edsl.utilities.remove_edsl_version import remove_edsl_version
 
 
 class Mixins(
     ResultsExportMixin,
-    ResultsDBMixin,
     ResultsFetchMixin,
     ResultsGGMixin,
-    ResultsToolsMixin,
 ):
     def long(self):
         return self.table().long()
@@ -91,6 +87,7 @@ class Results(UserList, Mixins, Base):
         "question_type",
         "comment",
         "generated_tokens",
+        "cache_used",
     ]
 
     def __init__(
@@ -129,18 +126,13 @@ class Results(UserList, Mixins, Base):
     def _summary(self) -> dict:
         import reprlib
 
-        # import yaml
-
         d = {
-            "EDSL Class": "Results",
-            # "docs_url": self.__documentation__,
-            "# of agents": len(set(self.agents)),
-            "# of distinct models": len(set(self.models)),
-            "# of observations": len(self),
-            "# Scenarios": len(set(self.scenarios)),
-            "Survey Length (# questions)": len(self.survey),
+            "observations": len(self),
+            "agents": len(set(self.agents)),
+            "models": len(set(self.models)),
+            "scenarios": len(set(self.scenarios)),
+            "questions": len(self.survey),
             "Survey question names": reprlib.repr(self.survey.question_names),
-            "Object hash": hash(self),
         }
         return d
 
@@ -258,23 +250,23 @@ class Results(UserList, Mixins, Base):
 
         raise TypeError("Invalid argument type")
 
-    def _update_results(self) -> None:
-        from edsl import Agent, Scenario
-        from edsl.language_models import LanguageModel
-        from edsl.results import Result
-
-        if self._job_uuid and len(self.data) < self._total_results:
-            results = [
-                Result(
-                    agent=Agent.from_dict(json.loads(r.agent)),
-                    scenario=Scenario.from_dict(json.loads(r.scenario)),
-                    model=LanguageModel.from_dict(json.loads(r.model)),
-                    iteration=1,
-                    answer=json.loads(r.answer),
-                )
-                for r in CRUD.read_results(self._job_uuid)
-            ]
-            self.data = results
+    # def _update_results(self) -> None:
+    #     from edsl import Agent, Scenario
+    #     from edsl.language_models import LanguageModel
+    #     from edsl.results import Result
+
+    #     if self._job_uuid and len(self.data) < self._total_results:
+    #         results = [
+    #             Result(
+    #                 agent=Agent.from_dict(json.loads(r.agent)),
+    #                 scenario=Scenario.from_dict(json.loads(r.scenario)),
+    #                 model=LanguageModel.from_dict(json.loads(r.model)),
+    #                 iteration=1,
+    #                 answer=json.loads(r.answer),
+    #             )
+    #             for r in CRUD.read_results(self._job_uuid)
+    #         ]
+    #         self.data = results
 
     def __add__(self, other: Results) -> Results:
         """Add two Results objects together.
@@ -303,9 +295,9 @@ class Results(UserList, Mixins, Base):
         )
 
     def __repr__(self) -> str:
-        import reprlib
+        # import reprlib
 
-        return f"Results(data = {reprlib.repr(self.data)}, survey = {repr(self.survey)}, created_columns = {self.created_columns})"
+        return f"Results(data = {self.data}, survey = {repr(self.survey)}, created_columns = {self.created_columns})"
 
     def table(
         self,
@@ -345,21 +337,6 @@ class Results(UserList, Mixins, Base):
                 print_parameters=print_parameters,
             )
         )
-        # return (
-        #     self.select(f"{selector_string}")
-        #     .to_scenario_list()
-        #     .table(*fields, tablefmt=tablefmt)
-        # )
-
-    def _repr_html_(self) -> str:
-        d = self._summary()
-        from edsl import Scenario
-
-        footer = f"<a href={self.__documentation__}>(docs)</a>"
-
-        s = Scenario(d)
-        td = s.to_dataset().table(tablefmt="html")
-        return td._repr_html_() + footer
 
     def to_dict(
         self,
@@ -367,6 +344,7 @@ class Results(UserList, Mixins, Base):
         add_edsl_version=False,
         include_cache=False,
         include_task_history=False,
+        include_cache_info=True,
     ) -> dict[str, Any]:
         from edsl.data.Cache import Cache
 
@@ -377,7 +355,11 @@ class Results(UserList, Mixins, Base):
 
         d = {
             "data": [
-                result.to_dict(add_edsl_version=add_edsl_version) for result in data
+                result.to_dict(
+                    add_edsl_version=add_edsl_version,
+                    include_cache_info=include_cache_info,
+                )
+                for result in data
             ],
             "survey": self.survey.to_dict(add_edsl_version=add_edsl_version),
             "created_columns": self.created_columns,
@@ -426,7 +408,11 @@ class Results(UserList, Mixins, Base):
         return self.task_history.has_unfixed_exceptions
 
     def __hash__(self) -> int:
-        return dict_hash(self.to_dict(sort=True, add_edsl_version=False))
+        from edsl.utilities.utilities import dict_hash
+
+        return dict_hash(
+            self.to_dict(sort=True, add_edsl_version=False, include_cache_info=False)
+        )
 
     @property
     def hashes(self) -> set:
@@ -472,24 +458,31 @@ class Results(UserList, Mixins, Base):
         >>> r == r2
         True
         """
-        from edsl import Survey, Cache
+        from edsl.surveys.Survey import Survey
+        from edsl.data.Cache import Cache
         from edsl.results.Result import Result
         from edsl.jobs.tasks.TaskHistory import TaskHistory
+        from edsl.agents.Agent import Agent
+
+        survey = Survey.from_dict(data["survey"])
+        results_data = [Result.from_dict(r) for r in data["data"]]
+        created_columns = data.get("created_columns", None)
+        cache = Cache.from_dict(data.get("cache")) if "cache" in data else Cache()
+        task_history = (
+            TaskHistory.from_dict(data.get("task_history"))
+            if "task_history" in data
+            else TaskHistory(interviews=[])
+        )
+        params = {
+            "survey": survey,
+            "data": results_data,
+            "created_columns": created_columns,
+            "cache": cache,
+            "task_history": task_history,
+        }
 
         try:
-            results = cls(
-                survey=Survey.from_dict(data["survey"]),
-                data=[Result.from_dict(r) for r in data["data"]],
-                created_columns=data.get("created_columns", None),
-                cache=(
-                    Cache.from_dict(data.get("cache")) if "cache" in data else Cache()
-                ),
-                task_history=(
-                    TaskHistory.from_dict(data.get("task_history"))
-                    if "task_history" in data
-                    else TaskHistory(interviews=[])
-                ),
-            )
+            results = cls(**params)
         except Exception as e:
             raise ResultsDeserializationError(f"Error in Results.from_dict: {e}")
         return results
@@ -544,10 +537,12 @@ class Results(UserList, Mixins, Base):
 
         >>> r = Results.example()
         >>> r.columns
-        ['agent.agent_instruction', ...]
+        ['agent.agent_index', ...]
         """
         column_names = [f"{v}.{k}" for k, v in self._key_to_data_type.items()]
-        return sorted(column_names)
+        from edsl.utilities.PrettyList import PrettyList
+
+        return PrettyList(sorted(column_names))
 
     @property
     def answer_keys(self) -> dict[str, str]:
@@ -567,7 +562,7 @@ class Results(UserList, Mixins, Base):
         answer_keys = self._data_type_to_keys["answer"]
         answer_keys = {k for k in answer_keys if "_comment" not in k}
         questions_text = [
-            self.survey.get_question(k).question_text for k in answer_keys
+            self.survey._get_question_by_name(k).question_text for k in answer_keys
         ]
         short_question_text = [shorten_string(q, 80) for q in questions_text]
         initial_dict = dict(zip(answer_keys, short_question_text))
@@ -584,7 +579,7 @@ class Results(UserList, Mixins, Base):
         >>> r.agents
         AgentList([Agent(traits = {'status': 'Joyful'}), Agent(traits = {'status': 'Joyful'}), Agent(traits = {'status': 'Sad'}), Agent(traits = {'status': 'Sad'})])
         """
-        from edsl import AgentList
+        from edsl.agents.AgentList import AgentList
 
         return AgentList([r.agent for r in self.data])
 
@@ -598,10 +593,13 @@ class Results(UserList, Mixins, Base):
         >>> r.models[0]
         Model(model_name = ...)
         """
-        from edsl import ModelList
+        from edsl.language_models.ModelList import ModelList
 
         return ModelList([r.model for r in self.data])
 
+    def __eq__(self, other):
+        return hash(self) == hash(other)
+
     @property
     def scenarios(self) -> ScenarioList:
         """Return a list of all of the scenarios in the Results.
@@ -610,9 +608,9 @@ class Results(UserList, Mixins, Base):
 
         >>> r = Results.example()
         >>> r.scenarios
-        ScenarioList([Scenario({'period': 'morning'}), Scenario({'period': 'afternoon'}), Scenario({'period': 'morning'}), Scenario({'period': 'afternoon'})])
+        ScenarioList([Scenario({'period': 'morning', 'scenario_index': 0}), Scenario({'period': 'afternoon', 'scenario_index': 1}), Scenario({'period': 'morning', 'scenario_index': 0}), Scenario({'period': 'afternoon', 'scenario_index': 1})])
         """
-        from edsl import ScenarioList
+        from edsl.scenarios.ScenarioList import ScenarioList
 
         return ScenarioList([r.scenario for r in self.data])
 
@@ -624,7 +622,7 @@ class Results(UserList, Mixins, Base):
 
         >>> r = Results.example()
         >>> r.agent_keys
-        ['agent_instruction', 'agent_name', 'status']
+        ['agent_index', 'agent_instruction', 'agent_name', 'status']
         """
         return sorted(self._data_type_to_keys["agent"])
 
@@ -634,7 +632,7 @@ class Results(UserList, Mixins, Base):
 
         >>> r = Results.example()
         >>> r.model_keys
-        ['frequency_penalty', 'logprobs', 'max_tokens', 'model', 'presence_penalty', 'temperature', 'top_logprobs', 'top_p']
+        ['frequency_penalty', 'logprobs', 'max_tokens', 'model', 'model_index', 'presence_penalty', 'temperature', 'top_logprobs', 'top_p']
         """
         return sorted(self._data_type_to_keys["model"])
 
@@ -644,7 +642,7 @@ class Results(UserList, Mixins, Base):
 
         >>> r = Results.example()
         >>> r.scenario_keys
-        ['period']
+        ['period', 'scenario_index']
         """
         return sorted(self._data_type_to_keys["scenario"])
 
@@ -670,7 +668,7 @@ class Results(UserList, Mixins, Base):
 
         >>> r = Results.example()
         >>> r.all_keys
-        ['agent_instruction', 'agent_name', 'frequency_penalty', 'how_feeling', 'how_feeling_yesterday', 'logprobs', 'max_tokens', 'model', 'period', 'presence_penalty', 'status', 'temperature', 'top_logprobs', 'top_p']
+        ['agent_index', ...]
         """
         answer_keys = set(self.answer_keys)
         all_keys = (
@@ -777,7 +775,7 @@ class Results(UserList, Mixins, Base):
     @staticmethod
     def _create_evaluator(
         result: Result, functions_dict: Optional[dict] = None
-    ) -> EvalWithCompoundTypes:
+    ) -> "EvalWithCompoundTypes":
         """Create an evaluator for the expression.
 
         >>> from unittest.mock import Mock
@@ -800,6 +798,8 @@ class Results(UserList, Mixins, Base):
         ...
         simpleeval.NameNotDefined: 'how_feeling' is not defined for expression 'how_feeling== 'OK''
         """
+        from simpleeval import EvalWithCompoundTypes
+
         if functions_dict is None:
             functions_dict = {}
         evaluator = EvalWithCompoundTypes(
@@ -858,6 +858,26 @@ class Results(UserList, Mixins, Base):
             created_columns=self.created_columns + [var_name],
         )
 
+    def add_column(self, column_name: str, values: list) -> Results:
+        """Adds columns to Results
+
+        >>> r = Results.example()
+        >>> r.add_column('a', [1,2,3, 4]).select('a')
+        Dataset([{'answer.a': [1, 2, 3, 4]}])
+        """
+
+        assert len(values) == len(
+            self.data
+        ), "The number of values must match the number of results."
+        new_results = self.data.copy()
+        for i, result in enumerate(new_results):
+            result["answer"][column_name] = values[i]
+        return Results(
+            survey=self.survey,
+            data=new_results,
+            created_columns=self.created_columns + [column_name],
+        )
+
     def rename(self, old_name: str, new_name: str) -> Results:
         """Rename an answer column in a Results object.
 
@@ -987,20 +1007,12 @@ class Results(UserList, Mixins, Base):
         Example:
 
         >>> r = Results.example()
-        >>> r.sort_by('how_feeling', reverse=False).select('how_feeling').print()
-        answer.how_feeling
-        --------------------
-        Great
-        OK
-        OK
-        Terrible
-        >>> r.sort_by('how_feeling', reverse=True).select('how_feeling').print()
-        answer.how_feeling
-        --------------------
-        Terrible
-        OK
-        OK
-        Great
+        >>> r.sort_by('how_feeling', reverse=False).select('how_feeling')
+        Dataset([{'answer.how_feeling': ['Great', 'OK', 'OK', 'Terrible']}])
+
+        >>> r.sort_by('how_feeling', reverse=True).select('how_feeling')
+        Dataset([{'answer.how_feeling': ['Terrible', 'OK', 'OK', 'Great']}])
+
         """
 
         def to_numeric_if_possible(v):
@@ -1032,24 +1044,19 @@ class Results(UserList, Mixins, Base):
         Example usage: Create an example `Results` instance and apply filters to it:
 
         >>> r = Results.example()
-        >>> r.filter("how_feeling == 'Great'").select('how_feeling').print()
-        answer.how_feeling
-        --------------------
-        Great
+        >>> r.filter("how_feeling == 'Great'").select('how_feeling')
+        Dataset([{'answer.how_feeling': ['Great']}])
 
         Example usage: Using an OR operator in the filter expression.
 
-        >>> r = Results.example().filter("how_feeling = 'Great'").select('how_feeling').print()
+        >>> r = Results.example().filter("how_feeling = 'Great'").select('how_feeling')
         Traceback (most recent call last):
         ...
         edsl.exceptions.results.ResultsFilterError: You must use '==' instead of '=' in the filter expression.
         ...
 
-        >>> r.filter("how_feeling == 'Great' or how_feeling == 'Terrible'").select('how_feeling').print()
-        answer.how_feeling
-        --------------------
-        Great
-        Terrible
+        >>> r.filter("how_feeling == 'Great' or how_feeling == 'Terrible'").select('how_feeling')
+        Dataset([{'answer.how_feeling': ['Great', 'Terrible']}])
         """
 
         def has_single_equals(string):

edsl/results/ResultsExportMixin.py

@@ -14,6 +14,8 @@ def to_dataset(func):
         """Return the function with the Results object converted to a Dataset object."""
         if self.__class__.__name__ == "Results":
             return func(self.select(), *args, **kwargs)
+        elif self.__class__.__name__ == "AgentList":
+            return func(self.to_dataset(), *args, **kwargs)
         else:
             return func(self, *args, **kwargs)
 

edsl/results/Selector.py

@@ -1,7 +1,12 @@
-from typing import Union, List, Dict, Any
+from typing import Union, List, Dict, Any, Optional
+import sys
 from collections import defaultdict
 from edsl.results.Dataset import Dataset
 
+from edsl.exceptions.results import ResultsColumnNotFoundError
+
+from edsl.utilities.is_notebook import is_notebook
+
 
 class Selector:
     def __init__(
@@ -19,11 +24,17 @@ class Selector:
         self._fetch_list = fetch_list_func
         self.columns = columns
 
-    def select(self, *columns: Union[str, List[str]]) -> "Dataset":
-        columns = self._normalize_columns(columns)
-        to_fetch = self._get_columns_to_fetch(columns)
-        # breakpoint()
-        new_data = self._fetch_data(to_fetch)
+    def select(self, *columns: Union[str, List[str]]) -> Optional[Dataset]:
+        try:
+            columns = self._normalize_columns(columns)
+            to_fetch = self._get_columns_to_fetch(columns)
+            new_data = self._fetch_data(to_fetch)
+        except ResultsColumnNotFoundError as e:
+            if is_notebook():
+                print("Error:", e, file=sys.stderr)
+                return None
+            else:
+                raise e
         return Dataset(new_data)
 
     def _normalize_columns(self, columns: Union[str, List[str]]) -> tuple:
@@ -63,17 +74,16 @@ class Selector:
             search_in_list = self.columns
         else:
             search_in_list = [s.split(".")[1] for s in self.columns]
-        # breakpoint()
         matches = [s for s in search_in_list if s.startswith(partial_name)]
         return [partial_name] if partial_name in matches else matches
 
     def _validate_matches(self, column: str, matches: List[str]):
         if len(matches) > 1:
-            raise ValueError(
+            raise ResultsColumnNotFoundError(
                 f"Column '{column}' is ambiguous. Did you mean one of {matches}?"
             )
         if len(matches) == 0 and ".*" not in column:
-            raise ValueError(f"Column '{column}' not found in data.")
+            raise ResultsColumnNotFoundError(f"Column '{column}' not found in data.")
 
     def _parse_column(self, column: str) -> tuple[str, str]:
         if "." in column:
@@ -89,11 +99,11 @@ class Selector:
         close_matches = difflib.get_close_matches(column, self._key_to_data_type.keys())
         if close_matches:
             suggestions = ", ".join(close_matches)
-            raise KeyError(
+            raise ResultsColumnNotFoundError(
                 f"Column '{column}' not found in data. Did you mean: {suggestions}?"
             )
         else:
-            raise KeyError(f"Column {column} not found in data")
+            raise ResultsColumnNotFoundError(f"Column {column} not found in data")
 
     def _process_column(self, data_type: str, key: str, to_fetch: Dict[str, List[str]]):
         data_types = self._get_data_types_to_return(data_type)
@@ -108,13 +118,13 @@ class Selector:
                     self.items_in_order.append(f"{dt}.{k}")
 
         if not found_once:
-            raise ValueError(f"Key {key} not found in data.")
+            raise ResultsColumnNotFoundError(f"Key {key} not found in data.")
 
     def _get_data_types_to_return(self, parsed_data_type: str) -> List[str]:
         if parsed_data_type == "*":
             return self.known_data_types
         if parsed_data_type not in self.known_data_types:
-            raise ValueError(
+            raise ResultsColumnNotFoundError(
                 f"Data type {parsed_data_type} not found in data. Did you mean one of {self.known_data_types}"
             )
         return [parsed_data_type]