edsl 0.1.38.dev4__py3-none-any.whl → 0.1.39__py3-none-any.whl

edsl/results/Results.py

@@ -9,13 +9,9 @@ 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 bisect import bisect_left
 
+from edsl.Base import Base
 from edsl.exceptions.results import (
     ResultsError,
     ResultsBadMutationstringError,
@@ -26,25 +22,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.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.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.results.results_fetch_mixin import ResultsFetchMixin
+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 +89,7 @@ class Results(UserList, Mixins, Base):
         "question_type",
         "comment",
         "generated_tokens",
+        "cache_used",
     ]
 
     def __init__(
@@ -129,22 +128,43 @@ 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
 
-    def compute_job_cost(self, include_cached_responses_in_cost=False) -> float:
+    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:
         """
         Computes the cost of a completed job in USD.
         """
@@ -258,24 +278,6 @@ 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.
@@ -303,13 +305,10 @@ class Results(UserList, Mixins, Base):
         )
 
     def __repr__(self) -> str:
-        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,
-        # selector_string: Optional[str] = "*.*",
         *fields,
         tablefmt: Optional[str] = None,
         pretty_labels: Optional[dict] = None,
@@ -345,28 +344,14 @@ 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=False,
-        add_edsl_version=False,
-        include_cache=False,
-        include_task_history=False,
+        sort: bool = False,
+        add_edsl_version: bool = False,
+        include_cache: bool = False,
+        include_task_history: bool = False,
+        include_cache_info: bool = True,
     ) -> dict[str, Any]:
         from edsl.data.Cache import Cache
 
@@ -377,7 +362,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,
@@ -404,7 +393,7 @@ class Results(UserList, Mixins, Base):
 
         return d
 
-    def compare(self, other_results):
+    def compare(self, other_results: Results) -> dict:
         """
         Compare two Results objects and return the differences.
         """
@@ -422,11 +411,15 @@ class Results(UserList, Mixins, Base):
         }
 
     @property
-    def has_unfixed_exceptions(self):
+    def has_unfixed_exceptions(self) -> bool:
         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,32 +465,35 @@ 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
 
-    ######################
-    ## Convenience methods
-    ## & Report methods
-    ######################
     @property
     def _key_to_data_type(self) -> dict[str, str]:
         """
@@ -544,10 +540,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 +565,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 +582,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 +596,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 +611,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 +625,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 +635,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 +645,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 +671,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 = (
@@ -691,13 +692,19 @@ class Results(UserList, Mixins, Base):
         """
         return self.data[0]
 
-    def answer_truncate(self, column: str, top_n=5, new_var_name=None) -> Results:
+    def answer_truncate(
+        self, column: str, top_n: int = 5, new_var_name: str = 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']}])
 
 
         """
@@ -777,7 +784,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 +807,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 +867,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.
 
@@ -896,7 +925,7 @@ class Results(UserList, Mixins, Base):
         n: Optional[int] = None,
         frac: Optional[float] = None,
         with_replacement: bool = True,
-        seed: Optional[str] = "edsl",
+        seed: Optional[str] = None,
     ) -> Results:
         """Sample the results.
 
@@ -911,7 +940,7 @@ class Results(UserList, Mixins, Base):
         >>> len(r.sample(2))
         2
         """
-        if seed != "edsl":
+        if seed:
             random.seed(seed)
 
         if n is None and frac is None:
@@ -949,7 +978,7 @@ class Results(UserList, Mixins, Base):
         Dataset([{'answer.how_feeling_yesterday': ['Great', 'Good', 'OK', 'Terrible']}])
         """
 
-        from edsl.results.Selector import Selector
+        from edsl.results.results_selector import Selector
 
         if len(self) == 0:
             raise Exception("No data to select from---the Results object is empty.")
@@ -964,6 +993,7 @@ 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(
@@ -972,6 +1002,7 @@ 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
@@ -987,20 +1018,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 +1055,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)