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

edsl/results/Results.py

@@ -9,9 +9,13 @@ import random
 from collections import UserList, defaultdict
 from typing import Optional, Callable, Any, Type, Union, List, TYPE_CHECKING
 
-from bisect import bisect_left
+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,
@@ -22,27 +26,25 @@ 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.model 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.results_fetch_mixin import ResultsFetchMixin
-from edsl.utilities.remove_edsl_version import remove_edsl_version
+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
 
 
 class Mixins(
     ResultsExportMixin,
+    ResultsDBMixin,
     ResultsFetchMixin,
     ResultsGGMixin,
+    ResultsToolsMixin,
 ):
     def long(self):
         return self.table().long()
@@ -89,7 +91,6 @@ class Results(UserList, Mixins, Base):
         "question_type",
         "comment",
         "generated_tokens",
-        "cache_used",
     ]
 
     def __init__(
@@ -128,43 +129,22 @@ class Results(UserList, Mixins, Base):
     def _summary(self) -> dict:
         import reprlib
 
+        # import yaml
+
         d = {
-            "observations": len(self),
-            "agents": len(set(self.agents)),
-            "models": len(set(self.models)),
-            "scenarios": len(set(self.scenarios)),
-            "questions": len(self.survey),
+            "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),
             "Survey question names": reprlib.repr(self.survey.question_names),
+            "Object hash": hash(self),
         }
         return d
 
-    def insert(self, item):
-        item_order = getattr(item, "order", None)
-        if item_order is not None:
-            # Get list of orders, putting None at the end
-            orders = [getattr(x, "order", None) for x in self]
-            # Filter to just the non-None orders for bisect
-            sorted_orders = [x for x in orders if x is not None]
-            if sorted_orders:
-                index = bisect_left(sorted_orders, item_order)
-                # Account for any None values before this position
-                index += orders[:index].count(None)
-            else:
-                # If no sorted items yet, insert before any unordered items
-                index = 0
-            self.data.insert(index, item)
-        else:
-            # No order - append to end
-            self.data.append(item)
-
-    def append(self, item):
-        self.insert(item)
-
-    def extend(self, other):
-        for item in other:
-            self.insert(item)
-
-    def compute_job_cost(self, include_cached_responses_in_cost: bool = False) -> float:
+    def compute_job_cost(self, include_cached_responses_in_cost=False) -> float:
         """
         Computes the cost of a completed job in USD.
         """
@@ -278,6 +258,24 @@ 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 __add__(self, other: Results) -> Results:
         """Add two Results objects together.
         They must have the same survey and created columns.
@@ -305,10 +303,13 @@ class Results(UserList, Mixins, Base):
         )
 
     def __repr__(self) -> str:
-        return f"Results(data = {self.data}, survey = {repr(self.survey)}, created_columns = {self.created_columns})"
+        import reprlib
+
+        return f"Results(data = {reprlib.repr(self.data)}, survey = {repr(self.survey)}, created_columns = {self.created_columns})"
 
     def table(
         self,
+        # selector_string: Optional[str] = "*.*",
         *fields,
         tablefmt: Optional[str] = None,
         pretty_labels: Optional[dict] = None,
@@ -344,14 +345,28 @@ 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,
-        sort: bool = False,
-        add_edsl_version: bool = False,
-        include_cache: bool = False,
-        include_task_history: bool = False,
-        include_cache_info: bool = True,
+        sort=False,
+        add_edsl_version=False,
+        include_cache=False,
+        include_task_history=False,
     ) -> dict[str, Any]:
         from edsl.data.Cache import Cache
 
@@ -362,11 +377,7 @@ class Results(UserList, Mixins, Base):
 
         d = {
             "data": [
-                result.to_dict(
-                    add_edsl_version=add_edsl_version,
-                    include_cache_info=include_cache_info,
-                )
-                for result in data
+                result.to_dict(add_edsl_version=add_edsl_version) for result in data
             ],
             "survey": self.survey.to_dict(add_edsl_version=add_edsl_version),
             "created_columns": self.created_columns,
@@ -393,7 +404,7 @@ class Results(UserList, Mixins, Base):
 
         return d
 
-    def compare(self, other_results: Results) -> dict:
+    def compare(self, other_results):
         """
         Compare two Results objects and return the differences.
         """
@@ -411,15 +422,11 @@ class Results(UserList, Mixins, Base):
         }
 
     @property
-    def has_unfixed_exceptions(self) -> bool:
+    def has_unfixed_exceptions(self):
         return self.task_history.has_unfixed_exceptions
 
     def __hash__(self) -> int:
-        from edsl.utilities.utilities import dict_hash
-
-        return dict_hash(
-            self.to_dict(sort=True, add_edsl_version=False, include_cache_info=False)
-        )
+        return dict_hash(self.to_dict(sort=True, add_edsl_version=False))
 
     @property
     def hashes(self) -> set:
@@ -465,35 +472,32 @@ class Results(UserList, Mixins, Base):
         >>> r == r2
         True
         """
-        from edsl.surveys.Survey import Survey
-        from edsl.data.Cache import Cache
+        from edsl import Survey, 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(**params)
+            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=[])
+                ),
+            )
         except Exception as e:
             raise ResultsDeserializationError(f"Error in Results.from_dict: {e}")
         return results
 
+    ######################
+    ## Convenience methods
+    ## & Report methods
+    ######################
     @property
     def _key_to_data_type(self) -> dict[str, str]:
         """
@@ -540,12 +544,10 @@ class Results(UserList, Mixins, Base):
 
         >>> r = Results.example()
         >>> r.columns
-        ['agent.agent_index', ...]
+        ['agent.agent_instruction', ...]
         """
         column_names = [f"{v}.{k}" for k, v in self._key_to_data_type.items()]
-        from edsl.utilities.PrettyList import PrettyList
-
-        return PrettyList(sorted(column_names))
+        return sorted(column_names)
 
     @property
     def answer_keys(self) -> dict[str, str]:
@@ -565,7 +567,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_by_name(k).question_text for k in answer_keys
+            self.survey.get_question(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))
@@ -582,7 +584,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.agents.AgentList import AgentList
+        from edsl import AgentList
 
         return AgentList([r.agent for r in self.data])
 
@@ -596,13 +598,10 @@ class Results(UserList, Mixins, Base):
         >>> r.models[0]
         Model(model_name = ...)
         """
-        from edsl.language_models.ModelList import ModelList
+        from edsl 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.
@@ -611,9 +610,9 @@ class Results(UserList, Mixins, Base):
 
         >>> r = Results.example()
         >>> r.scenarios
-        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})])
+        ScenarioList([Scenario({'period': 'morning'}), Scenario({'period': 'afternoon'}), Scenario({'period': 'morning'}), Scenario({'period': 'afternoon'})])
         """
-        from edsl.scenarios.ScenarioList import ScenarioList
+        from edsl import ScenarioList
 
         return ScenarioList([r.scenario for r in self.data])
 
@@ -625,7 +624,7 @@ class Results(UserList, Mixins, Base):
 
         >>> r = Results.example()
         >>> r.agent_keys
-        ['agent_index', 'agent_instruction', 'agent_name', 'status']
+        ['agent_instruction', 'agent_name', 'status']
         """
         return sorted(self._data_type_to_keys["agent"])
 
@@ -635,7 +634,7 @@ class Results(UserList, Mixins, Base):
 
         >>> r = Results.example()
         >>> r.model_keys
-        ['frequency_penalty', 'logprobs', 'max_tokens', 'model', 'model_index', 'presence_penalty', 'temperature', 'top_logprobs', 'top_p']
+        ['frequency_penalty', 'logprobs', 'max_tokens', 'model', 'presence_penalty', 'temperature', 'top_logprobs', 'top_p']
         """
         return sorted(self._data_type_to_keys["model"])
 
@@ -645,7 +644,7 @@ class Results(UserList, Mixins, Base):
 
         >>> r = Results.example()
         >>> r.scenario_keys
-        ['period', 'scenario_index']
+        ['period']
         """
         return sorted(self._data_type_to_keys["scenario"])
 
@@ -671,7 +670,7 @@ class Results(UserList, Mixins, Base):
 
         >>> r = Results.example()
         >>> r.all_keys
-        ['agent_index', ...]
+        ['agent_instruction', 'agent_name', 'frequency_penalty', 'how_feeling', 'how_feeling_yesterday', 'logprobs', 'max_tokens', 'model', 'period', 'presence_penalty', 'status', 'temperature', 'top_logprobs', 'top_p']
         """
         answer_keys = set(self.answer_keys)
         all_keys = (
@@ -692,19 +691,13 @@ class Results(UserList, Mixins, Base):
         """
         return self.data[0]
 
-    def answer_truncate(
-        self, column: str, top_n: int = 5, new_var_name: str = None
-    ) -> Results:
+    def answer_truncate(self, column: str, top_n=5, new_var_name=None) -> Results:
         """Create a new variable that truncates the answers to the top_n.
 
         :param column: The column to truncate.
         :param top_n: The number of top answers to keep.
         :param new_var_name: The name of the new variable. If None, it is the original name + '_truncated'.
 
-        Example:
-        >>> r = Results.example()
-        >>> r.answer_truncate('how_feeling', top_n = 2).select('how_feeling', 'how_feeling_truncated')
-        Dataset([{'answer.how_feeling': ['OK', 'Great', 'Terrible', 'OK']}, {'answer.how_feeling_truncated': ['Other', 'Other', 'Other', 'Other']}])
 
 
         """
@@ -784,7 +777,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
@@ -807,8 +800,6 @@ 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(
@@ -867,26 +858,6 @@ 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.
 
@@ -925,7 +896,7 @@ class Results(UserList, Mixins, Base):
         n: Optional[int] = None,
         frac: Optional[float] = None,
         with_replacement: bool = True,
-        seed: Optional[str] = None,
+        seed: Optional[str] = "edsl",
     ) -> Results:
         """Sample the results.
 
@@ -940,7 +911,7 @@ class Results(UserList, Mixins, Base):
         >>> len(r.sample(2))
         2
         """
-        if seed:
+        if seed != "edsl":
             random.seed(seed)
 
         if n is None and frac is None:
@@ -978,7 +949,7 @@ class Results(UserList, Mixins, Base):
         Dataset([{'answer.how_feeling_yesterday': ['Great', 'Good', 'OK', 'Terrible']}])
         """
 
-        from edsl.results.results_selector import Selector
+        from edsl.results.Selector import Selector
 
         if len(self) == 0:
             raise Exception("No data to select from---the Results object is empty.")
@@ -993,7 +964,6 @@ class Results(UserList, Mixins, Base):
         return selector.select(*columns)
 
     def sort_by(self, *columns: str, reverse: bool = False) -> Results:
-        """Sort the results by one or more columns."""
         import warnings
 
         warnings.warn(
@@ -1002,7 +972,6 @@ class Results(UserList, Mixins, Base):
         return self.order_by(*columns, reverse=reverse)
 
     def _parse_column(self, column: str) -> tuple[str, str]:
-        """Parse a column name into a data type and key."""
         if "." in column:
             return column.split(".")
         return self._key_to_data_type[column], column
@@ -1018,12 +987,20 @@ class Results(UserList, Mixins, Base):
         Example:
 
         >>> r = Results.example()
-        >>> 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']}])
-
+        >>> 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
         """
 
         def to_numeric_if_possible(v):
@@ -1055,19 +1032,24 @@ 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')
-        Dataset([{'answer.how_feeling': ['Great']}])
+        >>> r.filter("how_feeling == 'Great'").select('how_feeling').print()
+        answer.how_feeling
+        --------------------
+        Great
 
         Example usage: Using an OR operator in the filter expression.
 
-        >>> r = Results.example().filter("how_feeling = 'Great'").select('how_feeling')
+        >>> r = Results.example().filter("how_feeling = 'Great'").select('how_feeling').print()
         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')
-        Dataset([{'answer.how_feeling': ['Great', 'Terrible']}])
+        >>> r.filter("how_feeling == 'Great' or how_feeling == 'Terrible'").select('how_feeling').print()
+        answer.how_feeling
+        --------------------
+        Great
+        Terrible
         """
 
         def has_single_equals(string):