edsl 0.1.14__py3-none-any.whl → 0.1.40__py3-none-any.whl

edsl/results/ResultsExportMixin.py

@@ -1,142 +1,45 @@
-import base64
-import csv
-import io
-from IPython.display import HTML, display
-import pandas as pd
-from edsl.utilities import (
-    print_list_of_dicts_with_rich,
-    print_list_of_dicts_as_html_table,
-    print_dict_with_rich,
-)
+"""Mixin class for exporting results."""
 
+from functools import wraps
+from typing import Literal, Optional, Union
 
-class ResultsExportMixin:
-    def convert_decorator(func):
-        def wrapper(self, *args, **kwargs):
-            if self.__class__.__name__ == "Results":
-                return func(self.select(), *args, **kwargs)
-            elif self.__class__.__name__ == "Dataset":
-                return func(self, *args, **kwargs)
-            else:
-                raise Exception(
-                    f"Class {self.__class__.__name__} not recognized as a Results or Dataset object."
-                )
+from edsl.results.DatasetExportMixin import DatasetExportMixin
 
-        return wrapper
 
-    @convert_decorator
-    def _make_tabular(self, remove_prefix) -> tuple[list, list]:
-        "Helper function that turns the results into a tabular format."
-        d = {}
-        full_header = sorted(list(self.relevant_columns()))
-        for entry in self.data:
-            key, list_of_values = list(entry.items())[0]
-            d[key] = list_of_values
-        if remove_prefix:
-            header = [h.split(".")[-1] for h in full_header]
-        else:
-            header = full_header
-        num_observations = len(list(self[0].values())[0])
-        rows = []
-        # rows.append(header)
-        for i in range(num_observations):
-            row = [d[h][i] for h in full_header]
-            rows.append(row)
-        return header, rows
-
-    def print_long(self):
-        """ """
-        for result in self:
-            if hasattr(result, "combined_dict"):
-                d = result.combined_dict
-            else:
-                d = result
-            print_dict_with_rich(d)
-
-    @convert_decorator
-    def print(
-        self,
-        pretty_labels=None,
-        filename=None,
-        html=False,
-        interactive=False,
-        split_at_dot=True,
-    ):
-        if pretty_labels is None:
-            pretty_labels = {}
+def to_dataset(func):
+    """Convert the Results object to a Dataset object before calling the function."""
 
-        new_data = []
-        for entry in self:
-            key, list_of_values = list(entry.items())[0]
-            new_data.append({pretty_labels.get(key, key): list_of_values})
+    @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:
-            if not html:
-                print_list_of_dicts_with_rich(
-                    new_data, filename=filename, split_at_dot=split_at_dot
-                )
-            else:
-                print_list_of_dicts_as_html_table(
-                    new_data, filename=None, interactive=interactive
-                )
+            return func(self, *args, **kwargs)
 
-    @convert_decorator
-    def to_csv(self, filename: str = None, remove_prefix=False, download_link=False):
-        """
-        >>> r = create_example_results()
-        >>> r.select('how_feeling').to_csv()
-        'result.how_feeling\\r\\nBad\\r\\nBad\\r\\nGreat\\r\\nGreat\\r\\n'
-        """
-        header, rows = self._make_tabular(remove_prefix)
+    wrapper._is_wrapped = True
+    return wrapper
 
-        if filename is not None:
-            with open(filename, "w") as f:
-                writer = csv.writer(f)
-                writer.writerow(header)
-                writer.writerows(rows)
-        else:
-            output = io.StringIO()
-            writer = csv.writer(output)
-            writer.writerow(header)
-            writer.writerows(rows)
 
-            if download_link:
-                csv_file = output.getvalue()
-                b64 = base64.b64encode(csv_file.encode()).decode()
-                download_link = f'<a href="data:file/csv;base64,{b64}" download="my_data.csv">Download CSV file</a>'
-                display(HTML(download_link))
-            else:
-                return output.getvalue()
+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
 
-    @convert_decorator
-    def to_pandas(self, remove_prefix=False):
-        csv_string = self.to_csv(remove_prefix=remove_prefix)
-        csv_buffer = io.StringIO(csv_string)
-        df = pd.read_csv(csv_buffer)
-        df_sorted = df.sort_index(axis=1)  # Sort columns alphabetically
-        return df_sorted
-        # return df
 
-    @convert_decorator
-    def to_dicts(self, remove_prefix=False):
-        df = self.to_pandas(remove_prefix=remove_prefix)
-        df = df.convert_dtypes()
-        list_of_dicts = df.to_dict(orient="records")
-        # Convert any pd.NA values to None
-        list_of_dicts = [
-            {k: (None if pd.isna(v) else v) for k, v in record.items()}
-            for record in list_of_dicts
-        ]
-        return list_of_dicts
+class ResultsExportMixin(DatasetExportMixin):
+    """Mixin class for exporting Results objects."""
 
-    @convert_decorator
-    def to_list(self):
-        if len(self) == 1:
-            return list(self[0].values())[0]
-        else:
-            return tuple([list(x.values())[0] for x in self])
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        decorate_methods_from_mixin(cls, DatasetExportMixin)
 
 
 if __name__ == "__main__":
+    # pass
     import doctest
 
-    doctest.testmod()
+    doctest.testmod(optionflags=doctest.ELLIPSIS)

edsl/results/ResultsGGMixin.py

@@ -1,17 +1,47 @@
+"""Mixin class for ggplot2 plotting."""
+
 import subprocess
-import pandas as pd
 import tempfile
-import matplotlib.pyplot as plt
-import matplotlib.image as mpimg
+from typing import Optional
 
 
 class ResultsGGMixin:
-    def ggplot2(self, ggplot_code: str, filename=None, shape="wide"):
-        # Fetching DataFrame based on shape
+    """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("select * from self", shape="long")
+            df = self.sql(sql, shape="long")
         elif shape == "wide":
-            df = self.sql("select * from self", shape="wide", remove_prefix=True)
+            df = self.sql(sql, shape="wide", remove_prefix=remove_prefix)
 
         # Convert DataFrame to CSV format
         csv_data = df.to_csv(index=False)
@@ -20,18 +50,32 @@ class ResultsGGMixin:
         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=".png")
+            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 = 6, height = 4, device = "png")'
+        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", "-"],
@@ -41,13 +85,37 @@ class ResultsGGMixin:
             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)
+            self._display_plot(filename, width, height)
 
-    def _display_plot(self, filename):
-        img = mpimg.imread(filename)
-        plt.imshow(img)
-        plt.axis("off")
-        plt.show()
+    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.Result import Result
 from edsl.results.Results import Results