edsl 0.1.38.dev3__py3-none-any.whl → 0.1.38.dev4__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/TableDisplay.py

@@ -0,0 +1,198 @@
+from tabulate import tabulate
+from pathlib import Path
+
+from edsl.results.CSSParameterizer import CSSParameterizer
+
+
+class TableDisplay:
+    max_height = 400
+    min_height = 200
+
+    @classmethod
+    def get_css(cls):
+        """Load CSS content from the file next to this module"""
+        css_path = Path(__file__).parent / "table_display.css"
+        return css_path.read_text()
+
+    def __init__(self, headers, data, tablefmt=None, raw_data_set=None):
+        self.headers = headers
+        self.data = data
+        self.tablefmt = tablefmt
+        self.raw_data_set = raw_data_set
+
+        if hasattr(raw_data_set, "print_parameters"):
+            if raw_data_set.print_parameters:
+                self.printing_parameters = raw_data_set.print_parameters
+            else:
+                self.printing_parameters = {}
+        else:
+            self.printing_parameters = {}
+
+    def to_csv(self, filename: str):
+        self.raw_data_set.to_csv(filename)
+
+    def write(self, filename: str):
+        if self.tablefmt is None:
+            table = tabulate(self.data, headers=self.headers, tablefmt="simple")
+        else:
+            table = tabulate(self.data, headers=self.headers, tablefmt=self.tablefmt)
+
+        with open(filename, "w") as file:
+            print("Writing table to", filename)
+            file.write(table)
+
+    def to_pandas(self):
+        return self.raw_data_set.to_pandas()
+
+    def to_list(self):
+        return self.raw_data_set.to_list()
+
+    def __repr__(self):
+        from tabulate import tabulate
+
+        if self.tablefmt is None:
+            return tabulate(self.data, headers=self.headers, tablefmt="simple")
+        else:
+            return tabulate(self.data, headers=self.headers, tablefmt=self.tablefmt)
+
+    def long(self):
+        new_header = ["row", "key", "value"]
+        new_data = []
+        for index, row in enumerate(self.data):
+            new_data.extend([[index, k, v] for k, v in zip(self.headers, row)])
+        return TableDisplay(new_header, new_data)
+
+    def _repr_html_(self):
+        if self.tablefmt is not None:
+            return (
+                "<pre>"
+                + tabulate(self.data, headers=self.headers, tablefmt=self.tablefmt)
+                + "</pre>"
+            )
+
+        num_rows = len(self.data)
+        height = min(
+            num_rows * 30 + 50, self.max_height
+        )  # Added extra space for header
+
+        if height < self.min_height:
+            height = self.min_height
+
+        html_template = """
+        <style>
+            {css}
+        </style>
+        <div class="table-container">
+            <div class="scroll-table-wrapper">
+                {table}
+            </div>
+        </div>
+        """
+
+        html_content = tabulate(self.data, headers=self.headers, tablefmt="html")
+        html_content = html_content.replace("<table>", '<table class="scroll-table">')
+
+        height_string = f"{height}px"
+        parameters = {"containerHeight": height_string, "headerColor": "blue"}
+        parameters.update(self.printing_parameters)
+        rendered_css = CSSParameterizer(self.get_css()).apply_parameters(parameters)
+
+        return html_template.format(table=html_content, css=rendered_css)
+
+    @classmethod
+    def example(
+        cls,
+        headers=None,
+        data=None,
+        filename: str = "table_example.html",
+        auto_open: bool = True,
+    ):
+        """
+        Creates a standalone HTML file with an example table in an iframe and optionally opens it in a new tab.
+
+        Args:
+            cls: The class itself
+            headers (list): List of column headers. If None, uses example headers
+            data (list): List of data rows. If None, uses example data
+            filename (str): The name of the HTML file to create. Defaults to "table_example.html"
+            auto_open (bool): Whether to automatically open the file in the default web browser. Defaults to True
+
+        Returns:
+            str: The path to the created HTML file
+        """
+        import os
+        import webbrowser
+
+        # Use example data if none provided
+        if headers is None:
+            headers = ["Name", "Age", "City", "Occupation"]
+        if data is None:
+            data = [
+                [
+                    "John Doe",
+                    30,
+                    "New York",
+                    """cls: The class itself
+        headers (list): List of column headers. If None, uses example headers
+        data (list): List of data rows. If None, uses example data
+        filename (str): The name of the HTML file to create. Defaults to "table_example.html"
+        auto_open (bool): Whether to automatically open the file in the default web browser. Defaults to True
+        """,
+                ],
+                ["Jane Smith", 28, "San Francisco", "Designer"],
+                ["Bob Johnson", 35, "Chicago", "Manager"],
+                ["Alice Brown", 25, "Boston", "Developer"],
+                ["Charlie Wilson", 40, "Seattle", "Architect"],
+            ]
+
+        # Create instance with the data
+        instance = cls(headers=headers, data=data)
+
+        # Get the table HTML content
+        table_html = instance._repr_html_()
+
+        # Calculate the appropriate iframe height
+        num_rows = len(data)
+        iframe_height = min(num_rows * 140 + 50, cls.max_height)
+        print(f"Table height: {iframe_height}px")
+
+        # Create the full HTML document
+        html_content = f"""
+        <!DOCTYPE html>
+        <html>
+        <head>
+            <title>Table Display Example</title>
+            <style>
+                body {{
+                    margin: 0;
+                    padding: 20px;
+                    font-family: Arial, sans-serif;
+                }}
+                iframe {{
+                    width: 100%;
+                    height: {iframe_height}px;
+                    border: none;
+                    overflow: hidden;
+                }}
+            </style>
+        </head>
+        <body>
+            <iframe srcdoc='{table_html}'></iframe>
+        </body>
+        </html>
+        """
+
+        # Write the HTML file
+        abs_path = os.path.abspath(filename)
+        with open(filename, "w", encoding="utf-8") as f:
+            f.write(html_content)
+
+        # Open in browser if requested
+        if auto_open:
+            webbrowser.open("file://" + abs_path, new=2)
+
+        return abs_path
+
+
+if __name__ == "__main__":
+    TableDisplay.example()

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/table_display.css

@@ -0,0 +1,78 @@
+.table-container {
+    height: var(--containerHeight) !important;
+    width: 100%;
+    overflow: auto;  /* This enables both horizontal and vertical scrolling */
+    border: 1px solid #d4d4d4;
+    background: transparent;
+    position: relative;  /* Create stacking context for sticky header */
+}
+
+.scroll-table {
+    /* Remove width: 100% to prevent table from being constrained */
+    /* min-width: 100% ensures table takes at least full container width */
+    min-width: 100%;
+    border-collapse: separate;
+    border-spacing: 4px;
+    background: transparent;
+    table-layout: auto;  /* Allow table to size based on content */
+}
+
+.scroll-table th {
+    background: transparent;  /* Semi-transparent background to ensure text readability */
+    position: sticky;
+    top: 0;
+    z-index: 1;
+    text-align: left !important;
+    padding: 8px;
+    font-weight: bold;
+    white-space: nowrap;  /* Prevent header text from wrapping */
+    min-width: 100px;    /* Ensure minimum column width */
+    backdrop-filter: blur(8px);  /* Optional: adds extra clarity */
+    color: var(--headerColor);
+}
+
+.scroll-table td {
+    padding: 8px;
+    text-align: left !important;
+    white-space: pre-wrap;
+    word-wrap: break-word;
+    vertical-align: top;
+    color: inherit;
+    border-bottom: none;
+    background: transparent;
+    min-width: 100px;    /* Match header minimum width */
+}
+
+.scroll-table tbody tr:hover {
+    background: transparent;
+}
+
+/* Additional rule to ensure header background is truly transparent */
+.scroll-table thead tr {
+    background: transparent !important;
+}
+
+/* Add shadow to indicate scrollable content */
+.table-container::after {
+    content: '';
+    position: absolute;
+    top: 0;
+    right: 0;
+    bottom: 0;
+    width: 5px;
+    background: linear-gradient(to right, transparent, rgba(242, 6, 6, 0.1));
+    pointer-events: none;
+    opacity: 0;
+    transition: opacity 0.3s;
+}
+
+.table-container:hover::after {
+    opacity: 1;
+}
+
+/* Handle Jupyter notebook specific styling */
+.jp-OutputArea-output .table-container {
+    max-width: 100%;
+    margin: 0;
+    overflow-x: auto;
+}