edsl 0.1.27.dev2__py3-none-any.whl → 0.1.29__py3-none-any.whl

edsl/results/Result.py

@@ -3,16 +3,7 @@ from __future__ import annotations
 from collections import UserDict
 from typing import Any, Type, Callable, Optional
 from collections import UserDict
-
-from rich.table import Table
-
-from IPython.display import display
-
-from edsl.agents import Agent
-from edsl.language_models import LanguageModel
-from edsl.scenarios import Scenario
 from edsl.Base import Base
-from edsl.prompts import Prompt
 from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
 
 
@@ -21,6 +12,8 @@ class PromptDict(UserDict):
 
     def rich_print(self):
         """Display an object as a table."""
+        from rich.table import Table
+
         table = Table(title="")
         table.add_column("Attribute", style="bold")
         table.add_column("Value")
@@ -58,6 +51,8 @@ class Result(Base, UserDict):
 
     The answer dictionary has the structure:
 
+    >>> import warnings
+    >>> warnings.simplefilter("ignore", UserWarning)
     >>> Result.example().answer
     {'how_feeling': 'OK', 'how_feeling_comment': 'This is a real survey response from a human.', 'how_feeling_yesterday': 'Great', 'how_feeling_yesterday_comment': 'This is a real survey response from a human.'}
 
@@ -69,9 +64,9 @@ class Result(Base, UserDict):
 
     def __init__(
         self,
-        agent: Agent,
-        scenario: Scenario,
-        model: Type[LanguageModel],
+        agent: "Agent",
+        scenario: "Scenario",
+        model: Type["LanguageModel"],
         iteration: int,
         answer: str,
         prompt: dict[str, str] = None,
@@ -150,15 +145,15 @@ class Result(Base, UserDict):
             if key in self.question_to_attributes:
                 # You might be tempted to just use the naked key
                 # but this is a bad idea because it pollutes the namespace
-                question_text_dict[
-                    key + "_question_text"
-                ] = self.question_to_attributes[key]["question_text"]
-                question_options_dict[
-                    key + "_question_options"
-                ] = self.question_to_attributes[key]["question_options"]
-                question_type_dict[
-                    key + "_question_type"
-                ] = self.question_to_attributes[key]["question_type"]
+                question_text_dict[key + "_question_text"] = (
+                    self.question_to_attributes[key]["question_text"]
+                )
+                question_options_dict[key + "_question_options"] = (
+                    self.question_to_attributes[key]["question_options"]
+                )
+                question_type_dict[key + "_question_type"] = (
+                    self.question_to_attributes[key]["question_type"]
+                )
 
         return {
             "agent": self.agent.traits
@@ -237,14 +232,8 @@ class Result(Base, UserDict):
     ###############
     # Serialization
     ###############
-    @add_edsl_version
-    def to_dict(self) -> dict[str, Any]:
-        """Return a dictionary representation of the Result object.
-
-        >>> r = Result.example()
-        >>> r.to_dict()['scenario']
-        {'period': 'morning', 'edsl_version': '...', 'edsl_class_name': 'Scenario'}
-        """
+    def _to_dict(self) -> dict[str, Any]:
+        """Return a dictionary representation of the Result object."""
         d = {}
         for key, value in self.items():
             if hasattr(value, "to_dict"):
@@ -262,10 +251,32 @@ class Result(Base, UserDict):
                 d[key] = new_prompt_dict
         return d
 
+    @add_edsl_version
+    def to_dict(self) -> dict[str, Any]:
+        """Return a dictionary representation of the Result object.
+
+        >>> r = Result.example()
+        >>> r.to_dict()['scenario']
+        {'period': 'morning', 'edsl_version': '...', 'edsl_class_name': 'Scenario'}
+        """
+        return self._to_dict()
+
+    def __hash__(self):
+        """Return a hash of the Result object."""
+        from edsl.utilities.utilities import dict_hash
+
+        return dict_hash(self._to_dict())
+
     @classmethod
     @remove_edsl_version
     def from_dict(self, json_dict: dict) -> Result:
         """Return a Result object from a dictionary representation."""
+
+        from edsl import Agent
+        from edsl import Scenario
+        from edsl.language_models.LanguageModel import LanguageModel
+        from edsl.prompts.Prompt import Prompt
+
         prompt_data = json_dict.get("prompt", {})
         prompt_d = {}
         for prompt_name, prompt_obj in prompt_data.items():
@@ -289,6 +300,7 @@ class Result(Base, UserDict):
         """Display an object as a table."""
         # from edsl.utilities import print_dict_with_rich
         from rich import print
+        from rich.table import Table
 
         table = Table(title="Result")
         table.add_column("Attribute", style="bold")
@@ -313,7 +325,7 @@ class Result(Base, UserDict):
     @classmethod
     def example(cls):
         """Return an example Result object."""
-        from edsl.results import Results
+        from edsl.results.Results import Results
 
         return Results.example()[0]
 
@@ -338,59 +350,7 @@ class Result(Base, UserDict):
         return scoring_function(**params)
 
 
-def main():
-    """Run the main function."""
-    from edsl.results.Result import Result
-    import json
-
-    print("Being imported")
-    json_string = """
-    {
-        "agent": {
-            "traits": {
-                "status": "Unhappy"
-            }
-        },
-        "scenario": {
-            "period": "morning"
-        },
-        "model": {
-            "model": "gpt-3.5-turbo",
-            "parameters": {
-                "temperature": 0.5,
-                "max_tokens": 1000,
-                "top_p": 1,
-                "frequency_penalty": 0,
-                "presence_penalty": 0,
-                "use_cache": true
-            }
-        },
-        "iteration": 0,
-        "answer": {
-            "how_feeling": "Bad"
-        }, 
-        "prompt": {"how_feeling_user_prompt": "How are you feeling today?", "how_feeling_system_prompt": "Answer the question"}
-    }
-    """
-
-    result = Result.from_dict(json.loads(json_string))
-
-    result.sub_dicts
-    assert result.combined_dict["how_feeling"] == "Bad"
-
-    result.combined_dict
-    assert result.get_value("answer", "how_feeling") == "Bad"
-
-    result.key_to_data_type
-    print(result)
-
-    assert result == result.copy()
-
-    result.to_dict()
-
-
 if __name__ == "__main__":
-    # print(Result.example())
     import doctest
 
     doctest.testmod(optionflags=doctest.ELLIPSIS)

edsl/results/Results.py

@@ -7,12 +7,7 @@ from __future__ import annotations
 import json
 import random
 from collections import UserList, defaultdict
-from typing import Optional, Callable, Any, Type, Union
-
-from pygments import highlight
-from pygments.lexers import JsonLexer
-from pygments.formatters import HtmlFormatter
-from IPython.display import HTML
+from typing import Optional, Callable, Any, Type, Union, List
 
 from simpleeval import EvalWithCompoundTypes
 
@@ -23,28 +18,17 @@ from edsl.exceptions.results import (
     ResultsMutateError,
     ResultsFilterError,
 )
-from edsl.agents import Agent, AgentList
-from edsl.language_models.LanguageModel import LanguageModel
-from edsl.results.Dataset import Dataset
-from edsl.results.Result import Result
-from edsl.results.ResultsExportMixin import ResultsExportMixin
-from edsl.scenarios import Scenario
-from edsl.scenarios.ScenarioList import ScenarioList
-from edsl.surveys import Survey
-from edsl.data.Cache import Cache
-from edsl.utilities import (
-    is_valid_variable_name,
-    shorten_string,
-)
-from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
 
+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 add_edsl_version, remove_edsl_version
+from edsl.utilities.utilities import dict_hash
 
 from edsl.Base import Base
-from edsl.results.ResultsFetchMixin import ResultsFetchMixin
 
 
 class Mixins(
@@ -54,7 +38,22 @@ class Mixins(
     ResultsGGMixin,
     ResultsToolsMixin,
 ):
-    pass
+    def print_long(self, max_rows=None) -> None:
+        """Print the results in long format.
+
+        >>> from edsl.results import Results
+        >>> r = Results.example()
+        >>> r.select('how_feeling').print_long(max_rows = 2)
+        ┏━━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━┓
+        ┃ Result index ┃ Key         ┃ Value ┃
+        ┡━━━━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━┩
+        │ 0            │ how_feeling │ OK    │
+        │ 1            │ how_feeling │ Great │
+        └──────────────┴─────────────┴───────┘
+        """
+        from edsl.utilities.interface import print_results_long
+
+        print_results_long(self, max_rows=max_rows)
 
 
 class Results(UserList, Mixins, Base):
@@ -82,10 +81,10 @@ class Results(UserList, Mixins, Base):
 
     def __init__(
         self,
-        survey: Optional[Survey] = None,
-        data: Optional[list[Result]] = None,
+        survey: Optional["Survey"] = None,
+        data: Optional[list["Result"]] = None,
         created_columns: Optional[list[str]] = None,
-        cache: Optional[Cache] = None,
+        cache: Optional["Cache"] = None,
         job_uuid: Optional[str] = None,
         total_results: Optional[int] = None,
     ):
@@ -98,6 +97,8 @@ class Results(UserList, Mixins, Base):
         :param total_results: An integer representing the total number of results.
         """
         super().__init__(data)
+        from edsl.data.Cache import Cache
+
         self.survey = survey
         self.created_columns = created_columns or []
         self._job_uuid = job_uuid
@@ -123,6 +124,10 @@ 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(
@@ -166,7 +171,13 @@ class Results(UserList, Mixins, Base):
         return f"Results(data = {self.data}, survey = {repr(self.survey)}, created_columns = {self.created_columns})"
 
     def _repr_html_(self) -> str:
+        from IPython.display import HTML
+
         json_str = json.dumps(self.to_dict()["data"], indent=4)
+        from pygments import highlight
+        from pygments.lexers import JsonLexer
+        from pygments.formatters import HtmlFormatter
+
         formatted_json = highlight(
             json_str,
             JsonLexer(),
@@ -174,6 +185,37 @@ class Results(UserList, Mixins, Base):
         )
         return HTML(formatted_json).data
 
+    def _to_dict(self, sort=False):
+        from edsl.data.Cache import Cache
+
+        if sort:
+            data = sorted([result for result in self.data], key=lambda x: hash(x))
+        else:
+            data = [result for result in self.data]
+        return {
+            "data": [result.to_dict() for result in data],
+            "survey": self.survey.to_dict(),
+            "created_columns": self.created_columns,
+            "cache": Cache() if not hasattr(self, "cache") else self.cache.to_dict(),
+        }
+
+    def compare(self, other_results):
+        """
+        Compare two Results objects and return the differences.
+        """
+        hashes_0 = [hash(result) for result in self]
+        hashes_1 = [hash(result) for result in other_results]
+
+        in_self_but_not_other = set(hashes_0).difference(set(hashes_1))
+        in_other_but_not_self = set(hashes_1).difference(set(hashes_0))
+
+        indicies_self = [hashes_0.index(h) for h in in_self_but_not_other]
+        indices_other = [hashes_1.index(h) for h in in_other_but_not_self]
+        return {
+            "a_not_b": [self[i] for i in indicies_self],
+            "b_not_a": [other_results[i] for i in indices_other],
+        }
+
     @add_edsl_version
     def to_dict(self) -> dict[str, Any]:
         """Convert the Results object to a dictionary.
@@ -186,12 +228,39 @@ class Results(UserList, Mixins, Base):
         >>> r.to_dict().keys()
         dict_keys(['data', 'survey', 'created_columns', 'cache', 'edsl_version', 'edsl_class_name'])
         """
-        return {
-            "data": [result.to_dict() for result in self.data],
-            "survey": self.survey.to_dict(),
-            "created_columns": self.created_columns,
-            "cache": Cache() if not hasattr(self, "cache") else self.cache.to_dict(),
-        }
+        return self._to_dict()
+
+    def __hash__(self) -> int:
+        return dict_hash(self._to_dict(sort=True))
+
+    @property
+    def hashes(self) -> set:
+        return set(hash(result) for result in self.data)
+
+    def sample(self, n: int) -> "Results":
+        """Return a random sample of the results.
+
+        :param n: The number of samples to return.
+
+        >>> from edsl.results import Results
+        >>> r = Results.example()
+        >>> len(r.sample(2))
+        2
+        """
+        indices = None
+
+        for entry in self:
+            key, values = list(entry.items())[0]
+            if indices is None:  # gets the indices for the first time
+                indices = list(range(len(values)))
+                sampled_indices = random.sample(indices, n)
+                if n > len(indices):
+                    raise ValueError(
+                        f"Cannot sample {n} items from a list of length {len(indices)}."
+                    )
+            entry[key] = [values[i] for i in sampled_indices]
+
+        return self
 
     @classmethod
     @remove_edsl_version
@@ -208,12 +277,20 @@ class Results(UserList, Mixins, Base):
         >>> r == r2
         True
         """
-        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(),
-        )
+        from edsl import Survey, Cache
+        from edsl.results.Result import Result
+
+        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()
+                ),
+            )
+        except Exception as e:
+            breakpoint()
         return results
 
     ######################
@@ -280,6 +357,8 @@ class Results(UserList, Mixins, Base):
         >>> r.answer_keys
         {'how_feeling': 'How are you this {{ period }}?', 'how_feeling_yesterday': 'How were you feeling yesterday {{ period }}?'}
         """
+        from edsl.utilities.utilities import shorten_string
+
         if not self.survey:
             raise Exception("Survey is not defined so no answer keys are available.")
 
@@ -294,7 +373,7 @@ class Results(UserList, Mixins, Base):
         return sorted_dict
 
     @property
-    def agents(self) -> AgentList:
+    def agents(self) -> "AgentList":
         """Return a list of all of the agents in the Results.
 
         Example:
@@ -303,10 +382,12 @@ 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
+
         return AgentList([r.agent for r in self.data])
 
     @property
-    def models(self) -> list[Type[LanguageModel]]:
+    def models(self) -> list[Type["LanguageModel"]]:
         """Return a list of all of the models in the Results.
 
         Example:
@@ -318,7 +399,7 @@ class Results(UserList, Mixins, Base):
         return [r.model for r in self.data]
 
     @property
-    def scenarios(self) -> ScenarioList:
+    def scenarios(self) -> "ScenarioList":
         """Return a list of all of the scenarios in the Results.
 
         Example:
@@ -327,6 +408,8 @@ class Results(UserList, Mixins, Base):
         >>> r.scenarios
         ScenarioList([Scenario({'period': 'morning'}), Scenario({'period': 'afternoon'}), Scenario({'period': 'morning'}), Scenario({'period': 'afternoon'})])
         """
+        from edsl import ScenarioList
+
         return ScenarioList([r.scenario for r in self.data])
 
     @property
@@ -426,7 +509,7 @@ class Results(UserList, Mixins, Base):
                     )
         return data_type, key
 
-    def first(self) -> Result:
+    def first(self) -> "Result":
         """Return the first observation in the results.
 
         Example:
@@ -487,6 +570,39 @@ class Results(UserList, Mixins, Base):
             created_columns=self.created_columns + [new_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 add_columns_from_dict(self, columns: List[dict]) -> Results:
+        """Adds columns to Results from a list of dictionaries.
+
+        >>> r = Results.example()
+        >>> r.add_columns_from_dict([{'a': 1, 'b': 2}, {'a': 3, 'b': 4}, {'a':3, 'b':2}, {'a':3, 'b':2}]).select('a', 'b')
+        Dataset([{'answer.a': [1, 3, 3, 3]}, {'answer.b': [2, 4, 2, 2]}])
+        """
+        keys = list(columns[0].keys())
+        for key in keys:
+            values = [d[key] for d in columns]
+            self = self.add_column(key, values)
+        return self
+
     def mutate(
         self, new_var_string: str, functions_dict: Optional[dict] = None
     ) -> Results:
@@ -511,6 +627,8 @@ class Results(UserList, Mixins, Base):
             )
         raw_var_name, expression = new_var_string.split("=", 1)
         var_name = raw_var_name.strip()
+        from edsl.utilities.utilities import is_valid_variable_name
+
         if not is_valid_variable_name(var_name):
             raise ResultsInvalidNameError(f"{var_name} is not a valid variable name.")
 
@@ -522,7 +640,7 @@ class Results(UserList, Mixins, Base):
                 names=result.combined_dict, functions=functions_dict
             )
 
-        def new_result(old_result: Result, var_name: str) -> Result:
+        def new_result(old_result: "Result", var_name: str) -> "Result":
             evaluator = create_evaluator(old_result)
             value = evaluator.eval(expression)
             new_result = old_result.copy()
@@ -612,7 +730,7 @@ class Results(UserList, Mixins, Base):
 
         return Results(survey=self.survey, data=new_data, created_columns=None)
 
-    def select(self, *columns: Union[str, list[str]]) -> Dataset:
+    def select(self, *columns: Union[str, list[str]]) -> "Dataset":
         """
         Select data from the results and format it.
 
@@ -624,6 +742,7 @@ class Results(UserList, Mixins, Base):
         >>> results.select('how_feeling')
         Dataset([{'answer.how_feeling': ['OK', 'Great', 'Terrible', 'OK']}])
         """
+
         if len(self) == 0:
             raise Exception("No data to select from---the Results object is empty.")
 
@@ -680,13 +799,22 @@ class Results(UserList, Mixins, Base):
             return items_in_order.index(single_key)
 
         sorted(new_data, key=sort_by_key_order)
+        from edsl.results.Dataset import Dataset
 
         return Dataset(new_data)
 
-    def sort_by(self, columns, reverse: bool = False) -> Results:
+    def sort_by(self, *columns: str, reverse: bool = False) -> Results:
+        import warnings
+
+        warnings.warn(
+            "sort_by is deprecated. Use order_by instead.", DeprecationWarning
+        )
+        return self.order_by(*columns, reverse=reverse)
+
+    def order_by(self, *columns: str, reverse: bool = False) -> Results:
         """Sort the results by one or more columns.
 
-        :param columns: A string or a list of strings that are column names.
+        :param columns: One or more column names as strings.
         :param reverse: A boolean that determines whether to sort in reverse order.
 
         Each column name can be a single key, e.g. "how_feeling", or a dot-separated string, e.g. "answer.how_feeling".
@@ -694,7 +822,7 @@ class Results(UserList, Mixins, Base):
         Example:
 
         >>> r = Results.example()
-        >>> r.sort_by(['how_feeling'], reverse=False).select('how_feeling').print()
+        >>> r.sort_by('how_feeling', reverse=False).select('how_feeling').print()
         ┏━━━━━━━━━━━━━━┓
         ┃ answer       ┃
         ┃ .how_feeling ┃
@@ -707,7 +835,7 @@ class Results(UserList, Mixins, Base):
         ├──────────────┤
         │ Terrible     │
         └──────────────┘
-        >>> r.sort_by(['how_feeling'], reverse=True).select('how_feeling').print()
+        >>> r.sort_by('how_feeling', reverse=True).select('how_feeling').print()
         ┏━━━━━━━━━━━━━━┓
         ┃ answer       ┃
         ┃ .how_feeling ┃
@@ -721,8 +849,6 @@ class Results(UserList, Mixins, Base):
         │ Great        │
         └──────────────┘
         """
-        if isinstance(columns, str):
-            columns = [columns]
 
         def to_numeric_if_possible(v):
             try:
@@ -731,28 +857,14 @@ class Results(UserList, Mixins, Base):
                 return v
 
         def sort_key(item):
-            # Create an empty list to store the key components for sorting
             key_components = []
-
-            # Loop through each column specified in the sort
             for col in columns:
-                # Parse the column into its data type and key
                 data_type, key = self._parse_column(col)
-
-                # Retrieve the value from the item based on the parsed data type and key
                 value = item.get_value(data_type, key)
-
-                # Convert the value to numeric if possible, and append it to the key components
                 key_components.append(to_numeric_if_possible(value))
-
-            # Convert the list of key components into a tuple to serve as the sorting key
             return tuple(key_components)
 
-        new_data = sorted(
-            self.data,
-            key=sort_key,
-            reverse=reverse,
-        )
+        new_data = sorted(self.data, key=sort_key, reverse=reverse)
         return Results(survey=self.survey, data=new_data, created_columns=None)
 
     def filter(self, expression: str) -> Results:
@@ -846,7 +958,7 @@ class Results(UserList, Mixins, Base):
 
         :param debug: if False, uses actual API calls
         """
-        from edsl.jobs import Jobs
+        from edsl.jobs.Jobs import Jobs
         from edsl.data.Cache import Cache
 
         c = Cache()