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

edsl/results/DatasetTree.py

@@ -1,18 +1,10 @@
-from typing import Dict, List, Any, Optional, List
+from typing import Dict, List, Any, Optional
 from docx import Document
 from docx.shared import Inches, Pt
 from docx.enum.text import WD_ALIGN_PARAGRAPH
 from docx.enum.style import WD_STYLE_TYPE
 
 
-def is_hashable(v):
-    try:
-        hash(v)
-        return True
-    except TypeError:
-        return False
-
-
 class TreeNode:
     def __init__(self, key=None, value=None):
         self.key = key
@@ -21,21 +13,16 @@ class TreeNode:
 
 
 class Tree:
-    def __init__(self, data: "Dataset", node_order: Optional[List[str]] = None):
+    def __init__(self, data: "Dataset"):
         d = {}
         for entry in data:
             d.update(entry)
         self.data = d
         self.root = None
 
-        self.node_order = node_order
-
-        self.construct_tree(node_order)
-
     def unique_values_by_keys(self) -> dict:
         unique_values = {}
-        for key, raw_values in self.data.items():
-            values = [v if is_hashable(v) else str(v) for v in raw_values]
+        for key, values in self.data.items():
             unique_values[key] = list(set(values))
         return unique_values
 
@@ -58,25 +45,15 @@ class Tree:
             current = self.root
             for level in node_order[:-1]:
                 value = self.data[level][i]
-                if not is_hashable(value):
-                    value = str(value)
                 if value not in current.children:
                     current.children[value] = TreeNode(key=level, value=value)
                 current = current.children[value]
 
             leaf_key = node_order[-1]
             leaf_value = self.data[leaf_key][i]
-            if not is_hashable(leaf_value):
-                leaf_value = str(leaf_value)
             if leaf_value not in current.children:
                 current.children[leaf_value] = TreeNode(key=leaf_key, value=leaf_value)
 
-    def __repr__(self):
-        if self.node_order is not None:
-            return f"Tree(Dataset({self.data}), node_order={self.node_order})"
-        else:
-            return f"Tree(Dataset({self.data}))"
-
     def print_tree(
         self, node: Optional[TreeNode] = None, level: int = 0, print_keys: bool = False
     ):
@@ -94,10 +71,7 @@ class Tree:
         for child in node.children.values():
             self.print_tree(child, level + 1, print_keys)
 
-    def to_docx(self, filename: Optional[str] = None):
-        if filename is None:
-            filename = "tree_structure.docx"
-
+    def to_docx(self, filename: str):
         doc = Document()
 
         # Create styles for headings
@@ -116,110 +90,6 @@ class Tree:
 
         self._add_to_docx(doc, self.root, 0)
         doc.save(filename)
-        from edsl.utilities.utilities import file_notice
-
-        file_notice(filename)
-
-    def _repr_html_(self):
-        """Returns an interactive HTML representation of the tree with collapsible sections."""
-
-        # Generate a unique ID for this tree instance
-        import uuid
-
-        tree_id = f"tree_{uuid.uuid4().hex[:8]}"
-
-        styles = f"""
-        <div class="{tree_id}">
-            <style>
-                .{tree_id} details {{
-                    margin-left: 20px;
-                }}
-                .{tree_id} summary {{
-                    cursor: pointer;
-                    margin: 2px 0;
-                }}
-                .{tree_id} .value {{
-                    font-family: monospace;
-                    background: #f5f5f5;
-                    padding: 2px 6px;
-                    border-radius: 3px;
-                    margin: 1px 0;
-                }}
-                .{tree_id} .key {{
-                    color: #666;
-                    font-style: italic;
-                }}
-            </style>
-        """
-
-        def node_to_html(node, level=0, print_keys=True):
-            if node is None:
-                return "Tree has not been constructed yet."
-
-            html = []
-
-            if node.value is not None:
-                # Create the node content
-                content = []
-                if print_keys and node.key is not None:
-                    content.append(f'<span class="key">{node.key}: </span>')
-                content.append(f'<span class="value">{node.value}</span>')
-                content_html = "".join(content)
-
-                if node.children:
-                    # Node with children
-                    html.append(f'<details {"open" if level < 1 else ""}>')
-                    html.append(f"<summary>{content_html}</summary>")
-                    for child in node.children.values():
-                        html.append(node_to_html(child, level + 1, print_keys))
-                    html.append("</details>")
-                else:
-                    # Leaf node
-                    html.append(f"<div>{content_html}</div>")
-            else:
-                # Root node with no value
-                if node.children:
-                    for child in node.children.values():
-                        html.append(node_to_html(child, level, print_keys))
-
-            return "\n".join(html)
-
-        tree_html = node_to_html(self.root)
-        return f"{styles}{tree_html}</div>"
-
-    # def _repr_html_(self):
-    #     """Returns an HTML representation of the tree, following the same logic as print_tree."""
-    #     styles = """
-    #     <style>
-    #         .tree-container {
-    #             font-family: monospace;
-    #             white-space: pre;
-    #             margin: 10px;
-    #         }
-    #     </style>
-    #     """
-
-    #     def node_to_html(node, level=0, print_keys=False):
-    #         if node is None:
-    #             node = self.root
-    #             if node is None:
-    #                 return "Tree has not been constructed yet."
-
-    #         html = []
-    #         if node.value is not None:
-    #             indent = "&nbsp;" * 2 * level  # Using &nbsp; for HTML spaces
-    #             if print_keys and node.key is not None:
-    #                 html.append(f"{indent}{node.key}: {node.value}<br>")
-    #             else:
-    #                 html.append(f"{indent}{node.value}<br>")
-
-    #         for child in node.children.values():
-    #             html.append(node_to_html(child, level + 1, print_keys))
-
-    #         return "".join(html)
-
-    #     tree_html = node_to_html(self.root)
-    #     return f'<div class="tree-container">{tree_html}</div>{styles}'
 
     def _add_to_docx(self, doc, node: TreeNode, level: int):
         if node.value is not None:

edsl/results/Result.py

@@ -137,15 +137,6 @@ class Result(Base, UserDict):
         self._combined_dict = None
         self._problem_keys = None
 
-    def _repr_html_(self):
-        # d = self.to_dict(add_edsl_version=False)
-        d = self.to_dict(add_edsl_version=False)
-        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>"
-
     ###############
     # Used in Results
     ###############
@@ -333,24 +324,14 @@ class Result(Base, UserDict):
     ###############
     # Serialization
     ###############
-    def to_dict(self, add_edsl_version=True) -> 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 convert_value(value, add_edsl_version=True):
-            if hasattr(value, "to_dict"):
-                return value.to_dict(add_edsl_version=add_edsl_version)
-            else:
-                return value
-
+    def _to_dict(self) -> dict[str, Any]:
+        """Return a dictionary representation of the Result object."""
         d = {}
         for key, value in self.items():
-            d[key] = convert_value(value, add_edsl_version=add_edsl_version)
-
+            if hasattr(value, "to_dict"):
+                d[key] = value.to_dict()
+            else:
+                d[key] = value
             if key == "prompt":
                 new_prompt_dict = {}
                 for prompt_name, prompt_obj in value.items():
@@ -360,19 +341,23 @@ class Result(Base, UserDict):
                         else prompt_obj.to_dict()
                     )
                 d[key] = new_prompt_dict
-        if add_edsl_version:
-            from edsl import __version__
+        return d
 
-            d["edsl_version"] = __version__
-            d["edsl_class_name"] = "Result"
+    @add_edsl_version
+    def to_dict(self) -> dict[str, Any]:
+        """Return a dictionary representation of the Result object.
 
-        return d
+        >>> 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(add_edsl_version=False))
+        return dict_hash(self._to_dict())
 
     @classmethod
     @remove_edsl_version

edsl/results/Results.py

@@ -32,7 +32,7 @@ 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.decorators import add_edsl_version, remove_edsl_version
 from edsl.utilities.utilities import dict_hash
 
 
@@ -46,9 +46,6 @@ class Mixins(
     ResultsGGMixin,
     ResultsToolsMixin,
 ):
-    def long(self):
-        return self.table().long()
-
     def print_long(self, max_rows: int = None) -> None:
         """Print the results in long format.
 
@@ -76,8 +73,6 @@ class Results(UserList, Mixins, Base):
     It also has a list of created_columns, which are columns that have been created with `mutate` and are not part of the original data.
     """
 
-    __documentation__ = "https://docs.expectedparrot.com/en/latest/results.html"
-
     known_data_types = [
         "answer",
         "scenario",
@@ -126,55 +121,13 @@ class Results(UserList, Mixins, Base):
         if hasattr(self, "_add_output_functions"):
             self._add_output_functions()
 
-    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),
-            "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:
-        """
-        Computes the cost of a completed job in USD.
-        """
-        total_cost = 0
-        for result in self:
-            for key in result.raw_model_response:
-                if key.endswith("_cost"):
-                    result_cost = result.raw_model_response[key]
-
-                    question_name = key.removesuffix("_cost")
-                    cache_used = result.cache_used_dict[question_name]
-
-                    if isinstance(result_cost, (int, float)):
-                        if include_cached_responses_in_cost:
-                            total_cost += result_cost
-                        elif not include_cached_responses_in_cost and not cache_used:
-                            total_cost += result_cost
-
-        return total_cost
-
     def leaves(self):
         leaves = []
         for result in self:
             leaves.extend(result.leaves())
         return leaves
 
-    def tree(self, node_list: Optional[List[str]] = None):
-        return self.to_scenario_list().tree(node_list)
-
-    def interactive_tree(
+    def tree(
         self,
         fold_attributes: Optional[List[str]] = None,
         drop: Optional[List[str]] = None,
@@ -307,102 +260,26 @@ class Results(UserList, Mixins, Base):
 
         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,
-        print_parameters: Optional[dict] = None,
-    ):
-        new_fields = []
-        for field in fields:
-            if "." in field:
-                data_type, key = field.split(".")
-                if data_type not in self.known_data_types:
-                    raise ResultsInvalidNameError(
-                        f"{data_type} is not a valid data type. Must be in {self.known_data_types}"
-                    )
-                if key == "*":
-                    for k in self._data_type_to_keys[data_type]:
-                        new_fields.append(k)
-                else:
-                    if key not in self._key_to_data_type:
-                        raise ResultsColumnNotFoundError(
-                            f"{key} is not a valid key. Must be in {self._key_to_data_type}"
-                        )
-                    new_fields.append(key)
-            else:
-                new_fields.append(field)
-
-        return (
-            self.to_scenario_list()
-            .to_dataset()
-            .table(
-                *new_fields,
-                tablefmt=tablefmt,
-                pretty_labels=pretty_labels,
-                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>"
+        from IPython.display import HTML
 
-        s = Scenario(d)
-        td = s.to_dataset().table(tablefmt="html")
-        return td._repr_html_() + footer
+        json_str = json.dumps(self.to_dict()["data"], indent=4)
+        return f"<pre>{json_str}</pre>"
 
-    def to_dict(
-        self,
-        sort=False,
-        add_edsl_version=False,
-        include_cache=False,
-        include_task_history=False,
-    ) -> dict[str, Any]:
+    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]
-
-        d = {
-            "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),
+        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(),
+            "task_history": self.task_history.to_dict(),
         }
-        if include_cache:
-            d.update(
-                {
-                    "cache": (
-                        Cache()
-                        if not hasattr(self, "cache")
-                        else self.cache.to_dict(add_edsl_version=add_edsl_version)
-                    )
-                }
-            )
-
-        if self.task_history.has_unfixed_exceptions or include_task_history:
-            d.update({"task_history": self.task_history.to_dict()})
-
-        if add_edsl_version:
-            from edsl import __version__
-
-            d["edsl_version"] = __version__
-            d["edsl_class_name"] = "Results"
-
-        return d
 
     def compare(self, other_results):
         """
@@ -425,8 +302,22 @@ class Results(UserList, Mixins, Base):
     def has_unfixed_exceptions(self):
         return self.task_history.has_unfixed_exceptions
 
+    @add_edsl_version
+    def to_dict(self) -> dict[str, Any]:
+        """Convert the Results object to a dictionary.
+
+        The dictionary can be quite large, as it includes all of the data in the Results object.
+
+        Example: Illustrating just the keys of the dictionary.
+
+        >>> r = Results.example()
+        >>> r.to_dict().keys()
+        dict_keys(['data', 'survey', 'created_columns', 'cache', 'task_history', 'edsl_version', 'edsl_class_name'])
+        """
+        return self._to_dict()
+
     def __hash__(self) -> int:
-        return dict_hash(self.to_dict(sort=True, add_edsl_version=False))
+        return dict_hash(self._to_dict(sort=True))
 
     @property
     def hashes(self) -> set:
@@ -484,11 +375,7 @@ class Results(UserList, Mixins, Base):
                 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=[])
-                ),
+                task_history=TaskHistory.from_dict(data.get("task_history")),
             )
         except Exception as e:
             raise ResultsDeserializationError(f"Error in Results.from_dict: {e}")
@@ -988,19 +875,31 @@ class Results(UserList, Mixins, Base):
 
         >>> r = Results.example()
         >>> r.sort_by('how_feeling', reverse=False).select('how_feeling').print()
-        answer.how_feeling
-        --------------------
-        Great
-        OK
-        OK
-        Terrible
+        ┏━━━━━━━━━━━━━━┓
+        ┃ 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
+        ┏━━━━━━━━━━━━━━┓
+        ┃ answer       ┃
+        ┃ .how_feeling ┃
+        ┡━━━━━━━━━━━━━━┩
+        │ Terrible     │
+        ├──────────────┤
+        │ OK           │
+        ├──────────────┤
+        │ OK           │
+        ├──────────────┤
+        │ Great        │
+        └──────────────┘
         """
 
         def to_numeric_if_possible(v):
@@ -1033,9 +932,12 @@ class Results(UserList, Mixins, Base):
 
         >>> r = Results.example()
         >>> r.filter("how_feeling == 'Great'").select('how_feeling').print()
-        answer.how_feeling
-        --------------------
-        Great
+        ┏━━━━━━━━━━━━━━┓
+        ┃ answer       ┃
+        ┃ .how_feeling ┃
+        ┡━━━━━━━━━━━━━━┩
+        │ Great        │
+        └──────────────┘
 
         Example usage: Using an OR operator in the filter expression.
 
@@ -1046,10 +948,14 @@ class Results(UserList, Mixins, Base):
         ...
 
         >>> r.filter("how_feeling == 'Great' or how_feeling == 'Terrible'").select('how_feeling').print()
-        answer.how_feeling
-        --------------------
-        Great
-        Terrible
+        ┏━━━━━━━━━━━━━━┓
+        ┃ answer       ┃
+        ┃ .how_feeling ┃
+        ┡━━━━━━━━━━━━━━┩
+        │ Great        │
+        ├──────────────┤
+        │ Terrible     │
+        └──────────────┘
         """
 
         def has_single_equals(string):