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

edsl/results/Results.py

@@ -17,6 +17,7 @@ from edsl.exceptions.results import (
     ResultsInvalidNameError,
     ResultsMutateError,
     ResultsFilterError,
+    ResultsDeserializationError,
 )
 
 from edsl.results.ResultsExportMixin import ResultsExportMixin
@@ -77,6 +78,7 @@ class Results(UserList, Mixins, Base):
         "question_options",
         "question_type",
         "comment",
+        "generated_tokens",
     ]
 
     def __init__(
@@ -108,6 +110,81 @@ class Results(UserList, Mixins, Base):
         if hasattr(self, "_add_output_functions"):
             self._add_output_functions()
 
+    def leaves(self):
+        leaves = []
+        for result in self:
+            leaves.extend(result.leaves())
+        return leaves
+
+    def tree(
+        self,
+        fold_attributes: Optional[List[str]] = None,
+        drop: Optional[List[str]] = None,
+        open_file=True,
+    ) -> dict:
+        """Return the results as a tree."""
+        from edsl.results.tree_explore import FoldableHTMLTableGenerator
+
+        if drop is None:
+            drop = []
+
+        valid_attributes = [
+            "model",
+            "scenario",
+            "agent",
+            "answer",
+            "question",
+            "iteration",
+        ]
+        if fold_attributes is None:
+            fold_attributes = []
+
+        for attribute in fold_attributes:
+            if attribute not in valid_attributes:
+                raise ValueError(
+                    f"Invalid fold attribute: {attribute}; must be in {valid_attributes}"
+                )
+        data = self.leaves()
+        generator = FoldableHTMLTableGenerator(data)
+        tree = generator.tree(fold_attributes=fold_attributes, drop=drop)
+        html_content = generator.generate_html(tree, fold_attributes)
+        import tempfile
+        from edsl.utilities.utilities import is_notebook
+
+        from IPython.display import display, HTML
+
+        if is_notebook():
+            import html
+            from IPython.display import display, HTML
+
+            height = 1000
+            width = 1000
+            escaped_output = html.escape(html_content)
+            # escaped_output = rendered_html
+            iframe = f""""
+            <iframe srcdoc="{ escaped_output }" style="width: {width}px; height: {height}px;"></iframe>
+            """
+            display(HTML(iframe))
+            return None
+
+        with tempfile.NamedTemporaryFile(suffix=".html", delete=False) as f:
+            f.write(html_content.encode())
+            print(f"HTML file has been generated: {f.name}")
+
+            if open_file:
+                import webbrowser
+                import time
+
+                time.sleep(1)  # Wait for 1 second
+                # webbrowser.open(f.name)
+                import os
+
+                filename = f.name
+                webbrowser.open(f"file://{os.path.abspath(filename)}")
+
+            else:
+                return html_content
+
     def code(self):
         raise NotImplementedError
 
@@ -290,8 +367,7 @@ class Results(UserList, Mixins, Base):
                 ),
             )
         except Exception as e:
-            print(e)
-            # breakpoint()
+            raise ResultsDeserializationError(f"Error in Results.from_dict: {e}")
         return results
 
     ######################
@@ -395,7 +471,7 @@ class Results(UserList, Mixins, Base):
 
         >>> r = Results.example()
         >>> r.models[0]
-        Model(model_name = 'gpt-4-1106-preview', temperature = 0.5, max_tokens = 1000, top_p = 1, frequency_penalty = 0, presence_penalty = 0, logprobs = False, top_logprobs = 3)
+        Model(model_name = ...)
         """
         return [r.model for r in self.data]
 
@@ -477,39 +553,6 @@ class Results(UserList, Mixins, Base):
         )
         return sorted(list(all_keys))
 
-    def _parse_column(self, column: str) -> tuple[str, str]:
-        """
-        Parses a column name into a tuple containing a data type and a key.
-
-        >>> r = Results.example()
-        >>> r._parse_column("answer.how_feeling")
-        ('answer', 'how_feeling')
-
-        The standard way a column is specified is with a dot-separated string, e.g. _parse_column("agent.status")
-        But you can also specify a single key, e.g. "status", in which case it will look up the data type.
-        """
-        if "." in column:
-            data_type, key = column.split(".")
-        else:
-            try:
-                data_type, key = self._key_to_data_type[column], column
-            except KeyError:
-                import difflib
-
-                close_matches = difflib.get_close_matches(
-                    column, self._key_to_data_type.keys()
-                )
-                if close_matches:
-                    suggestions = ", ".join(close_matches)
-                    raise ResultsColumnNotFoundError(
-                        f"Column '{column}' not found in data. Did you mean: {suggestions}?"
-                    )
-                else:
-                    raise ResultsColumnNotFoundError(
-                        f"Column {column} not found in data"
-                    )
-        return data_type, key
-
     def first(self) -> "Result":
         """Return the first observation in the results.
 
@@ -632,9 +675,11 @@ class Results(UserList, Mixins, Base):
         """
         if functions_dict is None:
             functions_dict = {}
-        return EvalWithCompoundTypes(
+        evaluator = EvalWithCompoundTypes(
             names=result.combined_dict, functions=functions_dict
         )
+        evaluator.functions.update(int=int, float=float)
+        return evaluator
 
     def mutate(
         self, new_var_string: str, functions_dict: Optional[dict] = None
@@ -721,8 +766,8 @@ class Results(UserList, Mixins, Base):
 
     def sample(
         self,
-        n: int = None,
-        frac: float = None,
+        n: Optional[int] = None,
+        frac: Optional[float] = None,
         with_replacement: bool = True,
         seed: Optional[str] = "edsl",
     ) -> Results:
@@ -771,13 +816,17 @@ class Results(UserList, Mixins, Base):
         Dataset([{'answer.how_feeling': ['OK', 'Great', 'Terrible', 'OK']}])
 
         >>> results.select('how_feeling', 'model', 'how_feeling')
-        Dataset([{'answer.how_feeling': ['OK', 'Great', 'Terrible', 'OK']}, {'model.model': ['gpt-4-1106-preview', 'gpt-4-1106-preview', 'gpt-4-1106-preview', 'gpt-4-1106-preview']}, {'answer.how_feeling': ['OK', 'Great', 'Terrible', 'OK']}])
+        Dataset([{'answer.how_feeling': ['OK', 'Great', 'Terrible', 'OK']}, {'model.model': ['...', '...', '...', '...']}, {'answer.how_feeling': ['OK', 'Great', 'Terrible', 'OK']}])
+
+        >>> from edsl import Results; r = Results.example(); r.select('answer.how_feeling_y')
+        Dataset([{'answer.how_feeling_yesterday': ['Great', 'Good', 'OK', 'Terrible']}])
         """
 
-        if len(self) == 0:
-            raise Exception("No data to select from---the Results object is empty.")
+        # if len(self) == 0:
+        #    raise Exception("No data to select from---the Results object is empty.")
 
         if not columns or columns == ("*",) or columns == (None,):
+            # is the users passes nothing, then we'll return all the columns
             columns = ("*.*",)
 
         if isinstance(columns[0], list):
@@ -801,6 +850,16 @@ class Results(UserList, Mixins, Base):
         # iterate through the passed columns
         for column in columns:
             # a user could pass 'result.how_feeling' or just 'how_feeling'
+            matches = self._matching_columns(column)
+            if len(matches) > 1:
+                raise Exception(
+                    f"Column '{column}' is ambiguous. Did you mean one of {matches}?"
+                )
+            if len(matches) == 0 and ".*" not in column:
+                raise Exception(f"Column '{column}' not found in data.")
+            if len(matches) == 1:
+                column = matches[0]
+
             parsed_data_type, parsed_key = self._parse_column(column)
             data_types = get_data_types_to_return(parsed_data_type)
             found_once = False  # we need to track this to make sure we found the key at least once
@@ -843,6 +902,21 @@ class Results(UserList, Mixins, Base):
 
         return Dataset(sorted_new_data)
 
+    def select(self, *columns: Union[str, list[str]]) -> "Results":
+        from edsl.results.Selector import Selector
+
+        if len(self) == 0:
+            raise Exception("No data to select from---the Results object is empty.")
+
+        selector = Selector(
+            known_data_types=self.known_data_types,
+            data_type_to_keys=self._data_type_to_keys,
+            key_to_data_type=self._key_to_data_type,
+            fetch_list_func=self._fetch_list,
+            columns=self.columns,
+        )
+        return selector.select(*columns)
+
     def sort_by(self, *columns: str, reverse: bool = False) -> Results:
         import warnings
 
@@ -851,6 +925,11 @@ class Results(UserList, Mixins, Base):
         )
         return self.order_by(*columns, reverse=reverse)
 
+    def _parse_column(self, column: str) -> tuple[str, str]:
+        if "." in column:
+            return column.split(".")
+        return self._key_to_data_type[column], column
+
     def order_by(self, *columns: str, reverse: bool = False) -> Results:
         """Sort the results by one or more columns.
 
@@ -948,7 +1027,9 @@ class Results(UserList, Mixins, Base):
         def has_single_equals(string):
             if "!=" in string:
                 return False
-            if "=" in string and not "==" in string:
+            if "=" in string and not (
+                "==" in string or "<=" in string or ">=" in string
+            ):
                 return True
 
         if has_single_equals(expression):
@@ -989,7 +1070,7 @@ class Results(UserList, Mixins, Base):
         return Results(survey=self.survey, data=new_data, created_columns=None)
 
     @classmethod
-    def example(cls, debug: bool = False, randomize: bool = False) -> Results:
+    def example(cls, randomize: bool = False) -> Results:
         """Return an example `Results` object.
 
         Example usage:
@@ -1003,7 +1084,12 @@ class Results(UserList, Mixins, Base):
 
         c = Cache()
         job = Jobs.example(randomize=randomize)
-        results = job.run(cache=c, debug=debug)
+        results = job.run(
+            cache=c,
+            stop_on_exception=True,
+            skip_retry=True,
+            raise_validation_errors=True,
+        )
         return results
 
     def rich_print(self):

edsl/results/ResultsDBMixin.py

@@ -136,9 +136,9 @@ class ResultsDBMixin:
 
         >>> from edsl.results import Results
         >>> r = Results.example()
-        >>> d = r.sql("select data_type, key, value from self where data_type = 'answer' limit 3", shape="long")
-        >>> list(d['value'])
-        ['OK', 'This is a real survey response from a human.', 'Great']
+        >>> d = r.sql("select data_type, key, value from self where data_type = 'answer' order by value limit 3", shape="long")
+        >>> sorted(list(d['value']))
+        ['Good', 'Great', 'Great']
 
         We can also return the data in wide format.
         Note the use of single quotes to escape the column names, as required by sql.

edsl/results/Selector.py

@@ -0,0 +1,118 @@
+from typing import Union, List, Dict, Any
+from collections import defaultdict
+from edsl.results.Dataset import Dataset
+
+
+class Selector:
+    def __init__(
+        self,
+        known_data_types: List[str],
+        data_type_to_keys: Dict[str, List[str]],
+        key_to_data_type: Dict[str, str],
+        fetch_list_func,
+        columns: List[str],
+    ):
+        self.known_data_types = known_data_types
+        self._data_type_to_keys = data_type_to_keys
+        self._key_to_data_type = key_to_data_type
+        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)
+        new_data = self._fetch_data(to_fetch)
+        return Dataset(new_data)
+
+    def _normalize_columns(self, columns: Union[str, List[str]]) -> tuple:
+        if not columns or columns == ("*",) or columns == (None,):
+            return ("*.*",)
+        if isinstance(columns[0], list):
+            return tuple(columns[0])
+        return columns
+
+    def _get_columns_to_fetch(self, columns: tuple) -> Dict[str, List[str]]:
+        to_fetch = defaultdict(list)
+        self.items_in_order = []
+
+        for column in columns:
+            matches = self._find_matching_columns(column)
+            self._validate_matches(column, matches)
+
+            if len(matches) == 1:
+                column = matches[0]
+
+            data_type, key = self._parse_column(column)
+            self._process_column(data_type, key, to_fetch)
+
+        return to_fetch
+
+    def _find_matching_columns(self, partial_name: str) -> list[str]:
+        if "." in partial_name:
+            search_in_list = self.columns
+        else:
+            search_in_list = [s.split(".")[1] for s in self.columns]
+
+        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(
+                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.")
+
+    def _parse_column(self, column: str) -> tuple[str, str]:
+        if "." in column:
+            return column.split(".")
+        try:
+            return self._key_to_data_type[column], column
+        except KeyError:
+            self._raise_key_error(column)
+
+    def _raise_key_error(self, column: str):
+        import difflib
+
+        close_matches = difflib.get_close_matches(column, self._key_to_data_type.keys())
+        if close_matches:
+            suggestions = ", ".join(close_matches)
+            raise KeyError(
+                f"Column '{column}' not found in data. Did you mean: {suggestions}?"
+            )
+        else:
+            raise KeyError(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)
+        found_once = False
+
+        for dt in data_types:
+            relevant_keys = self._data_type_to_keys[dt]
+            for k in relevant_keys:
+                if k == key or key == "*":
+                    found_once = True
+                    to_fetch[dt].append(k)
+                    self.items_in_order.append(f"{dt}.{k}")
+
+        if not found_once:
+            raise ValueError(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(
+                f"Data type {parsed_data_type} not found in data. Did you mean one of {self.known_data_types}"
+            )
+        return [parsed_data_type]
+
+    def _fetch_data(self, to_fetch: Dict[str, List[str]]) -> List[Dict[str, Any]]:
+        new_data = []
+        for data_type, keys in to_fetch.items():
+            for key in keys:
+                entries = self._fetch_list(data_type, key)
+                new_data.append({f"{data_type}.{key}": entries})
+
+        return [d for key in self.items_in_order for d in new_data if key in d]

edsl/results/tree_explore.py

@@ -0,0 +1,115 @@
+from collections import defaultdict
+from typing import List, Dict, Any
+import json
+
+
+class FoldableHTMLTableGenerator:
+    def __init__(self, data: List[Dict[str, Any]]):
+        self.data = data
+
+    def tree(self, fold_attributes: List[str], drop: List[str] = None) -> Dict:
+        def nested_dict():
+            return defaultdict(nested_dict)
+
+        result = nested_dict()
+        drop = drop or []  # Use an empty list if drop is None
+
+        for item in self.data:
+            current = result
+            for attr in fold_attributes:
+                current = current[item[attr]]
+
+            row = {
+                k: v
+                for k, v in item.items()
+                if k not in fold_attributes and k not in drop
+            }
+            if "_rows" not in current:
+                current["_rows"] = []
+            current["_rows"].append(row)
+
+        return result
+
+    def generate_html(self, tree, fold_attributes: List[str]) -> str:
+        html_content = """
+        <!DOCTYPE html>
+        <html lang="en">
+        <head>
+            <meta charset="UTF-8">
+            <meta name="viewport" content="width=device-width, initial-scale=1.0">
+            <title>Foldable Nested Table</title>
+            <style>
+                .folding-section { margin-left: 20px; }
+                .fold-button { cursor: pointer; margin: 5px 0; }
+                table { border-collapse: collapse; margin-top: 10px; }
+                th, td { border: 1px solid black; padding: 5px; }
+                .attribute-label { font-weight: bold; }
+            </style>
+        </head>
+        <body>
+            <div id="root"></div>
+            <script>
+            function toggleFold(id) {
+                const element = document.getElementById(id);
+                element.style.display = element.style.display === 'none' ? 'block' : 'none';
+            }
+
+            function createFoldableSection(data, path = [], attributes = %s) {
+                const container = document.createElement('div');
+                container.className = 'folding-section';
+
+                for (const [key, value] of Object.entries(data)) {
+                    if (key === '_rows') {
+                        const table = document.createElement('table');
+                        const headerRow = table.insertRow();
+                        const headers = Object.keys(value[0]);
+                        headers.forEach(header => {
+                            const th = document.createElement('th');
+                            th.textContent = header;
+                            headerRow.appendChild(th);
+                        });
+                        value.forEach(row => {
+                            const tableRow = table.insertRow();
+                            headers.forEach(header => {
+                                const cell = tableRow.insertCell();
+                                cell.textContent = row[header];
+                            });
+                        });
+                        container.appendChild(table);
+                    } else {
+                        const button = document.createElement('button');
+                        const attributeType = attributes[path.length];
+                        button.innerHTML = `<span class="attribute-label">${attributeType}:</span> ${key}`;
+                        button.className = 'fold-button';
+                        const sectionId = `section-${path.join('-')}-${key}`;
+                        button.onclick = () => toggleFold(sectionId);
+                        container.appendChild(button);
+
+                        const section = document.createElement('div');
+                        section.id = sectionId;
+                        section.style.display = 'none';
+                        section.appendChild(createFoldableSection(value, [...path, key], attributes));
+                        container.appendChild(section);
+                    }
+                }
+
+                return container;
+            }
+
+            const treeData = %s;
+            document.getElementById('root').appendChild(createFoldableSection(treeData));
+            </script>
+        </body>
+        </html>
+        """
+
+        return html_content % (json.dumps(fold_attributes), json.dumps(tree))
+
+    def save_html(self, fold_attributes: List[str], filename: str = "output.html"):
+        tree = self.tree(fold_attributes)
+        html_content = self.generate_html(tree, fold_attributes)
+
+        with open(filename, "w", encoding="utf-8") as f:
+            f.write(html_content)
+
+        print(f"HTML file has been generated: {filename}")

edsl/scenarios/Scenario.py

@@ -219,10 +219,9 @@ class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
 
     @classmethod
     def from_pdf(cls, pdf_path):
-        import fitz  # PyMuPDF
-        from edsl import Scenario
-
         # Ensure the file exists
+        import fitz
+
         if not os.path.exists(pdf_path):
             raise FileNotFoundError(f"The file {pdf_path} does not exist.")
 
@@ -236,7 +235,14 @@ class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
         text = ""
         for page_num in range(len(document)):
             page = document.load_page(page_num)
-            text = text + page.get_text()
+            blocks = page.get_text("blocks")  # Extract text blocks
+
+            # Sort blocks by their vertical position (y0) to maintain reading order
+            blocks.sort(key=lambda b: (b[1], b[0]))  # Sort by y0 first, then x0
+
+            # Combine the text blocks in order
+            for block in blocks:
+                text += block[4] + "\n"
 
         # Create a dictionary for the combined text
         page_info = {"filename": filename, "text": text}