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

edsl/results/ResultsExportMixin.py

@@ -1,43 +1,45 @@
-"""Mixin class for exporting results."""
-
-from functools import wraps
-from typing import Literal, Optional, Union
-
-from edsl.results.DatasetExportMixin import DatasetExportMixin
-
-
-def to_dataset(func):
-    """Convert the Results object to a Dataset object before calling the function."""
-
-    @wraps(func)
-    def wrapper(self, *args, **kwargs):
-        """Return the function with the Results object converted to a Dataset object."""
-        if self.__class__.__name__ == "Results":
-            return func(self.select(), *args, **kwargs)
-        else:
-            return func(self, *args, **kwargs)
-
-    wrapper._is_wrapped = True
-    return wrapper
-
-
-def decorate_methods_from_mixin(cls, mixin_cls):
-    for attr_name, attr_value in mixin_cls.__dict__.items():
-        if callable(attr_value) and not attr_name.startswith("__"):
-            setattr(cls, attr_name, to_dataset(attr_value))
-    return cls
-
-
-class ResultsExportMixin(DatasetExportMixin):
-    """Mixin class for exporting Results objects."""
-
-    def __init_subclass__(cls, **kwargs):
-        super().__init_subclass__(**kwargs)
-        decorate_methods_from_mixin(cls, DatasetExportMixin)
-
-
-if __name__ == "__main__":
-    # pass
-    import doctest
-
-    doctest.testmod(optionflags=doctest.ELLIPSIS)
+"""Mixin class for exporting results."""
+
+from functools import wraps
+from typing import Literal, Optional, Union
+
+from edsl.results.DatasetExportMixin import DatasetExportMixin
+
+
+def to_dataset(func):
+    """Convert the Results object to a Dataset object before calling the function."""
+
+    @wraps(func)
+    def wrapper(self, *args, **kwargs):
+        """Return the function with the Results object converted to a Dataset object."""
+        if self.__class__.__name__ == "Results":
+            return func(self.select(), *args, **kwargs)
+        elif self.__class__.__name__ == "AgentList":
+            return func(self.to_dataset(), *args, **kwargs)
+        else:
+            return func(self, *args, **kwargs)
+
+    wrapper._is_wrapped = True
+    return wrapper
+
+
+def decorate_methods_from_mixin(cls, mixin_cls):
+    for attr_name, attr_value in mixin_cls.__dict__.items():
+        if callable(attr_value) and not attr_name.startswith("__"):
+            setattr(cls, attr_name, to_dataset(attr_value))
+    return cls
+
+
+class ResultsExportMixin(DatasetExportMixin):
+    """Mixin class for exporting Results objects."""
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        decorate_methods_from_mixin(cls, DatasetExportMixin)
+
+
+if __name__ == "__main__":
+    # pass
+    import doctest
+
+    doctest.testmod(optionflags=doctest.ELLIPSIS)

edsl/results/ResultsGGMixin.py

@@ -1,121 +1,121 @@
-"""Mixin class for ggplot2 plotting."""
-
-import subprocess
-import tempfile
-from typing import Optional
-
-
-class ResultsGGMixin:
-    """Mixin class for ggplot2 plotting."""
-
-    def ggplot2(
-        self,
-        ggplot_code: str,
-        filename: str = None,
-        shape="wide",
-        sql: str = None,
-        remove_prefix: bool = True,
-        debug: bool = False,
-        height=4,
-        width=6,
-        format="svg",
-        factor_orders: Optional[dict] = None,
-    ):
-        """Create a ggplot2 plot from a DataFrame.
-
-        :param ggplot_code: The ggplot2 code to execute.
-        :param filename: The filename to save the plot to.
-        :param shape: The shape of the data in the DataFrame (wide or long).
-        :param sql: The SQL query to execute beforehand to manipulate the data.
-        :param remove_prefix: Whether to remove the prefix from the column names.
-        :param debug: Whether to print the R code instead of executing it.
-        :param height: The height of the plot in inches.
-        :param width: The width of the plot in inches.
-        :param format: The format to save the plot in (png or svg).
-        :param factor_orders: A dictionary of factor columns and their order.
-        """
-
-        if sql == None:
-            sql = "select * from self"
-
-        if shape == "long":
-            df = self.sql(sql, shape="long")
-        elif shape == "wide":
-            df = self.sql(sql, shape="wide", remove_prefix=remove_prefix)
-
-        # Convert DataFrame to CSV format
-        csv_data = df.to_csv(index=False)
-
-        # Embed the CSV data within the R script
-        csv_data_escaped = csv_data.replace("\n", "\\n").replace("'", "\\'")
-        read_csv_code = f"self <- read.csv(text = '{csv_data_escaped}', sep = ',')\n"
-
-        if factor_orders is not None:
-            for factor, order in factor_orders.items():
-                # read_csv_code += f"""self${{{factor}}} <- factor(self${{{factor}}}, levels=c({','.join(['"{}"'.format(x) for x in order])}))"""
-
-                level_string = ", ".join([f'"{x}"' for x in order])
-                read_csv_code += (
-                    f"self${factor} <- factor(self${factor}, levels=c({level_string}))"
-                )
-                read_csv_code += "\n"
-
-        # Load ggplot2 library
-        load_ggplot2 = "library(ggplot2)\n"
-
-        # Check if a filename is provided for the plot, if not create a temporary one
-        if not filename:
-            filename = tempfile.mktemp(suffix=f".{format}")
-
-        # Combine all R script parts
-        full_r_code = load_ggplot2 + read_csv_code + ggplot_code
-
-        # Add command to save the plot to a file
-        full_r_code += f'\nggsave("{filename}", plot = last_plot(), width = {width}, height = {height}, device = "{format}")'
-
-        if debug:
-            print(full_r_code)
-            return
-
-        result = subprocess.run(
-            ["Rscript", "-"],
-            input=full_r_code,
-            text=True,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-        )
-
-        if result.returncode != 0:
-            if result.returncode == 127:  # 'command not found'
-                raise RuntimeError(
-                    "Rscript is probably not installed. Please install R from https://cran.r-project.org/"
-                )
-            else:
-                raise RuntimeError(
-                    f"An error occurred while running Rscript: {result.stderr}"
-                )
-
-        if result.stderr:
-            print("Error in R script:", result.stderr)
-        else:
-            self._display_plot(filename, width, height)
-
-    def _display_plot(self, filename: str, width: float, height: float):
-        """Display the plot in the notebook."""
-        import matplotlib.pyplot as plt
-        import matplotlib.image as mpimg
-
-        if filename.endswith(".png"):
-            img = mpimg.imread(filename)
-            plt.figure(
-                figsize=(width, height)
-            )  # Set the figure size (width, height) in inches
-            plt.imshow(img)
-            plt.axis("off")
-            plt.show()
-        elif filename.endswith(".svg"):
-            from IPython.display import SVG, display
-
-            display(SVG(filename=filename))
-        else:
-            print("Unsupported file format. Please provide a PNG or SVG file.")
+"""Mixin class for ggplot2 plotting."""
+
+import subprocess
+import tempfile
+from typing import Optional
+
+
+class ResultsGGMixin:
+    """Mixin class for ggplot2 plotting."""
+
+    def ggplot2(
+        self,
+        ggplot_code: str,
+        filename: str = None,
+        shape="wide",
+        sql: str = None,
+        remove_prefix: bool = True,
+        debug: bool = False,
+        height=4,
+        width=6,
+        format="svg",
+        factor_orders: Optional[dict] = None,
+    ):
+        """Create a ggplot2 plot from a DataFrame.
+
+        :param ggplot_code: The ggplot2 code to execute.
+        :param filename: The filename to save the plot to.
+        :param shape: The shape of the data in the DataFrame (wide or long).
+        :param sql: The SQL query to execute beforehand to manipulate the data.
+        :param remove_prefix: Whether to remove the prefix from the column names.
+        :param debug: Whether to print the R code instead of executing it.
+        :param height: The height of the plot in inches.
+        :param width: The width of the plot in inches.
+        :param format: The format to save the plot in (png or svg).
+        :param factor_orders: A dictionary of factor columns and their order.
+        """
+
+        if sql == None:
+            sql = "select * from self"
+
+        if shape == "long":
+            df = self.sql(sql, shape="long")
+        elif shape == "wide":
+            df = self.sql(sql, shape="wide", remove_prefix=remove_prefix)
+
+        # Convert DataFrame to CSV format
+        csv_data = df.to_csv(index=False)
+
+        # Embed the CSV data within the R script
+        csv_data_escaped = csv_data.replace("\n", "\\n").replace("'", "\\'")
+        read_csv_code = f"self <- read.csv(text = '{csv_data_escaped}', sep = ',')\n"
+
+        if factor_orders is not None:
+            for factor, order in factor_orders.items():
+                # read_csv_code += f"""self${{{factor}}} <- factor(self${{{factor}}}, levels=c({','.join(['"{}"'.format(x) for x in order])}))"""
+
+                level_string = ", ".join([f'"{x}"' for x in order])
+                read_csv_code += (
+                    f"self${factor} <- factor(self${factor}, levels=c({level_string}))"
+                )
+                read_csv_code += "\n"
+
+        # Load ggplot2 library
+        load_ggplot2 = "library(ggplot2)\n"
+
+        # Check if a filename is provided for the plot, if not create a temporary one
+        if not filename:
+            filename = tempfile.mktemp(suffix=f".{format}")
+
+        # Combine all R script parts
+        full_r_code = load_ggplot2 + read_csv_code + ggplot_code
+
+        # Add command to save the plot to a file
+        full_r_code += f'\nggsave("{filename}", plot = last_plot(), width = {width}, height = {height}, device = "{format}")'
+
+        if debug:
+            print(full_r_code)
+            return
+
+        result = subprocess.run(
+            ["Rscript", "-"],
+            input=full_r_code,
+            text=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+
+        if result.returncode != 0:
+            if result.returncode == 127:  # 'command not found'
+                raise RuntimeError(
+                    "Rscript is probably not installed. Please install R from https://cran.r-project.org/"
+                )
+            else:
+                raise RuntimeError(
+                    f"An error occurred while running Rscript: {result.stderr}"
+                )
+
+        if result.stderr:
+            print("Error in R script:", result.stderr)
+        else:
+            self._display_plot(filename, width, height)
+
+    def _display_plot(self, filename: str, width: float, height: float):
+        """Display the plot in the notebook."""
+        import matplotlib.pyplot as plt
+        import matplotlib.image as mpimg
+
+        if filename.endswith(".png"):
+            img = mpimg.imread(filename)
+            plt.figure(
+                figsize=(width, height)
+            )  # Set the figure size (width, height) in inches
+            plt.imshow(img)
+            plt.axis("off")
+            plt.show()
+        elif filename.endswith(".svg"):
+            from IPython.display import SVG, display
+
+            display(SVG(filename=filename))
+        else:
+            print("Unsupported file format. Please provide a PNG or SVG file.")

edsl/results/TableDisplay.py

@@ -1,198 +1,125 @@
-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()
+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())