edsl 0.1.38.dev3__py3-none-any.whl → 0.1.39__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

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

edsl/results/TextEditor.py

@@ -0,0 +1,50 @@
+try:
+    import gradio as gr
+except ImportError:
+    print("Gradio is not installed. Please install it using `pip install gradio`")
+
+import time
+
+
+class TextEditor:
+    def __init__(self, initial_text=""):
+        self.text = initial_text
+        self._text_saved = False
+
+    def save_text(self, new_text):
+        self.text = new_text
+        self._text_saved = True
+        return "Text saved successfully!"
+
+    def edit_gui(self):
+        js_code = """
+        async (text) => {
+            await navigator.clipboard.writeText(text);
+            return "Copied to clipboard!";
+        }
+        """
+
+        with gr.Blocks() as interface:
+            text_area = gr.Textbox(
+                value=self.text, lines=10, label="Edit Text", placeholder="Type here..."
+            )
+
+            with gr.Row():
+                save_btn = gr.Button("Save")
+                copy_btn = gr.Button("Copy to Clipboard")
+
+            output = gr.Textbox(label="Status")
+
+            save_btn.click(fn=self.save_text, inputs=[text_area], outputs=[output])
+
+            # Add copy functionality
+            copy_btn.click(
+                fn=None, inputs=text_area, outputs=output, api_name=False, js=js_code
+            )
+
+        interface.launch(share=False, prevent_thread_lock=True)
+
+        while not self._text_saved:
+            time.sleep(0.1)
+
+        return self.text

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