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

edsl/results/TableDisplay.py

@@ -1,125 +1,198 @@
-from typing import (
-    Protocol,
-    List,
-    Any,
-    Optional,
-    TYPE_CHECKING,
-    Sequence,
-    Union,
-    Literal,
-)
-
-if TYPE_CHECKING:
-    from edsl.results.Dataset import Dataset
-
-from edsl.results.table_data_class import TableData
-
-from edsl.results.table_renderers import DataTablesRenderer, PandasStyleRenderer
-
-Row = Sequence[Union[str, int, float, bool, None]]
-TableFormat = Literal[
-    "grid", "simple", "pipe", "orgtbl", "rst", "mediawiki", "html", "latex"
-]
-
-
-class TableRenderer(Protocol):
-    """Table renderer protocol"""
-
-    def render_html(self, table_data: TableData) -> str:
-        pass
-
-
-# Modified TableDisplay class
-class TableDisplay:
-    def __init__(
-        self,
-        headers: Sequence[str],
-        data: Sequence[Row],
-        tablefmt: Optional[TableFormat] = None,
-        raw_data_set: "Dataset" = None,
-        renderer_class: Optional[TableRenderer] = None,
-    ):
-        assert len(headers) == len(data[0])  # Check if headers and data are consistent
-
-        self.headers = headers
-        self.data = data
-        self.tablefmt = tablefmt
-        self.raw_data_set = raw_data_set
-
-        self.renderer_class = renderer_class or PandasStyleRenderer
-
-        # Handle printing parameters from raw_data_set
-        if hasattr(raw_data_set, "print_parameters"):
-            self.printing_parameters = (
-                raw_data_set.print_parameters if raw_data_set.print_parameters else {}
-            )
-        else:
-            self.printing_parameters = {}
-
-    def _repr_html_(self) -> str:
-        table_data = TableData(
-            headers=self.headers,
-            data=self.data,
-            parameters=self.printing_parameters,
-            raw_data_set=self.raw_data_set,
-        )
-        return self.renderer_class(table_data).render_html()
-
-    def __repr__(self):
-        from tabulate import tabulate
-
-        return tabulate(self.data, headers=self.headers, tablefmt=self.tablefmt)
-
-    @classmethod
-    def from_dictionary(
-        cls,
-        dictionary: dict,
-        tablefmt: Optional[TableFormat] = None,
-        renderer: Optional[TableRenderer] = None,
-    ) -> "TableDisplay":
-        headers = list(dictionary.keys())
-        data = [list(dictionary.values())]
-        return cls(headers, data, tablefmt, renderer_class=renderer)
-
-    @classmethod
-    def from_dictionary_wide(
-        cls,
-        dictionary: dict,
-        tablefmt: Optional[TableFormat] = None,
-        renderer: Optional[TableRenderer] = None,
-    ) -> "TableDisplay":
-        headers = ["key", "value"]
-        data = [[k, v] for k, v in dictionary.items()]
-        return cls(headers, data, tablefmt, renderer_class=renderer)
-
-    @classmethod
-    def from_dataset(
-        cls,
-        dataset: "Dataset",
-        tablefmt: Optional[TableFormat] = None,
-        renderer: Optional[TableRenderer] = None,
-    ) -> "TableDisplay":
-        headers, data = dataset._tabular()
-        return cls(headers, data, tablefmt, dataset, renderer_class=renderer)
-
-    def long(self) -> "TableDisplay":
-        """Convert to long format"""
-        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, self.tablefmt, renderer_class=self.renderer_class
-        )
-
-
-# Example usage:
-if __name__ == "__main__":
-    headers = ["Name", "Age", "City"]
-    data = [["John", 30, "New York"], ["Jane", 25, "London"]]
-
-    # Using default (Pandas) renderer
-    table1 = TableDisplay(headers, data)
-
-    # Using DataTables renderer
-    table2 = TableDisplay(headers, data, renderer=DataTablesRenderer())
+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

@@ -1,78 +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;
+.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;
 }