edsl 0.1.38.dev2__py3-none-any.whl → 0.1.38.dev3__py3-none-any.whl

edsl/results/Selector.py

@@ -1,135 +1,135 @@
-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],
-    ):
-        """Selects columns from a Results object"""
-        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)
-        # breakpoint()
-        new_data = self._fetch_data(to_fetch)
-        return Dataset(new_data)
-
-    def _normalize_columns(self, columns: Union[str, List[str]]) -> tuple:
-        """Normalize the columns to a tuple of strings
-
-        >>> s = Selector([], {}, {}, lambda x, y: x, [])
-        >>> s._normalize_columns([["a", "b"], ])
-        ('a', 'b')
-        >>> s._normalize_columns(None)
-        ('*.*',)
-        """
-        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)
-            # breakpoint()
-            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]
-        # breakpoint()
-        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]
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod()
+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],
+    ):
+        """Selects columns from a Results object"""
+        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)
+        # breakpoint()
+        new_data = self._fetch_data(to_fetch)
+        return Dataset(new_data)
+
+    def _normalize_columns(self, columns: Union[str, List[str]]) -> tuple:
+        """Normalize the columns to a tuple of strings
+
+        >>> s = Selector([], {}, {}, lambda x, y: x, [])
+        >>> s._normalize_columns([["a", "b"], ])
+        ('a', 'b')
+        >>> s._normalize_columns(None)
+        ('*.*',)
+        """
+        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)
+            # breakpoint()
+            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]
+        # breakpoint()
+        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]
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

edsl/results/__init__.py

@@ -1,2 +1,2 @@
-from edsl.results.Result import Result
-from edsl.results.Results import Results
+from edsl.results.Result import Result
+from edsl.results.Results import Results

edsl/results/tree_explore.py

@@ -1,115 +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}")
+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}")