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

edsl/results/TableDisplay.py

@@ -1,198 +1,125 @@
-from tabulate import tabulate
-from pathlib import Path
+from typing import (
+    Protocol,
+    List,
+    Any,
+    Optional,
+    TYPE_CHECKING,
+    Sequence,
+    Union,
+    Literal,
+)
 
-from edsl.results.CSSParameterizer import CSSParameterizer
+if TYPE_CHECKING:
+    from edsl.results.Dataset import Dataset
 
+from edsl.results.table_data_class import TableData
 
-class TableDisplay:
-    max_height = 400
-    min_height = 200
+from edsl.results.table_renderers import DataTablesRenderer, PandasStyleRenderer
 
-    @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()
+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
 
-    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
 
+        self.renderer_class = renderer_class or PandasStyleRenderer
+
+        # Handle printing parameters from 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 = {}
+            self.printing_parameters = (
+                raw_data_set.print_parameters if raw_data_set.print_parameters else {}
+            )
         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_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
 
-        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)
+        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)
 
-    def long(self):
+    @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)
-
-    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
+        return TableDisplay(
+            new_header, new_data, self.tablefmt, renderer_class=self.renderer_class
+        )
 
-        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
+# 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)
 
-if __name__ == "__main__":
-    TableDisplay.example()
+    # 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

edsl/results/smart_objects.py

@@ -0,0 +1,96 @@
+from typing import Optional
+
+
+class SmartInt(int):
+    pass
+
+
+class SmartFloat(float):
+    pass
+
+
+class SmartStr(str):
+    def clipboard(self) -> None:
+        try:
+            import pyperclip
+        except ImportError:
+            print(
+                "pyperclip is not installed. Run `pip install pyperclip` to install it."
+            )
+            return None
+
+        pyperclip.copy(self)
+        print("Text copied to clipboard.")
+
+    def write(self, filename: str):
+        with open(filename, "w") as f:
+            f.write(str(self))
+        return None
+
+    def _repr_html_(self):
+        pass
+
+    def markdown(self):
+        return SmartMarkdown(self)
+
+    def pdf(self, filename: Optional[str] = None):  # Markdown will have this as well
+        # renders the markdown as a pdf that can be downloaded
+        from edsl.results.MarkdownToPDF import MarkdownToPDF
+
+        return MarkdownToPDF(self, filename).preview()
+
+    def docx(self, filename: Optional[str] = None):
+        # renders the markdown as a docx that can be downloaded
+        from edsl.results.MarkdownToDocx import MarkdownToDocx
+
+        return MarkdownToDocx(self, filename).preview()
+
+    def edit(self):
+        from edsl.results.TextEditor import TextEditor
+
+        editor = TextEditor(self)
+        self = self.__class__(editor.edit_gui())
+        # print(f"Updated text: {self}")
+
+
+class SmartMarkdown(SmartStr):
+    def _repr_markdown_(self):
+        return self
+
+    def _repr_html_(self):
+        from IPython.display import Markdown, display
+
+        display(Markdown(self))
+
+
+class SmartLaTeX(SmartStr):
+    def _repr_html_(self):
+        print(self)
+
+    def pdf(self, filename: Optional[str] = None):
+        from edsl.results.LaTeXToPDF import LaTeXToPDF
+
+        return LaTeXToPDF(self, filename).preview()
+
+    def docx(self, filename: Optional[str] = None):
+        from edsl.results.LaTeXToDocx import LaTeXToDocx
+
+        return LaTeXToDocx(self, filename).preview()
+
+    def edit(self):
+        from edsl.results.TextEditor import TextEditor
+
+        editor = TextEditor(self)
+        self = self.__class__(editor.edit_gui())
+        # print(f"Updated LaTeX: {self}")
+
+
+class FirstObject:
+    def __new__(self, value):
+        if isinstance(value, int):
+            return SmartInt(value)
+        if isinstance(value, float):
+            return SmartFloat(value)
+        if isinstance(value, str):
+            return SmartStr(value)
+        return value

edsl/results/table_data_class.py

@@ -0,0 +1,12 @@
+from dataclasses import dataclass
+from typing import Any, List
+
+
+@dataclass
+class TableData:
+    """Simple data class to hold table information"""
+
+    headers: List[str]
+    data: List[List[Any]]
+    parameters: dict = None
+    raw_data_set: Any = None

edsl/results/table_renderers.py

@@ -0,0 +1,118 @@
+from abc import ABC, abstractmethod
+from edsl.results.table_data_class import TableData
+
+
+class DataTablesRendererABC(ABC):
+    def __init__(self, table_data: TableData):
+        self.table_data = table_data
+
+    @abstractmethod
+    def render_html(self) -> str:
+        pass
+
+
+class DataTablesRenderer(DataTablesRendererABC):
+    """Interactive DataTables renderer implementation"""
+
+    def render_html(self) -> str:
+        html_template = """
+        <!DOCTYPE html>
+        <html>
+        <head>
+            <link href="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/5.3.0/css/bootstrap.min.css" rel="stylesheet">
+            <link href="https://cdnjs.cloudflare.com/ajax/libs/datatables.net-bs5/1.13.6/dataTables.bootstrap5.min.css" rel="stylesheet">
+            <link href="https://cdnjs.cloudflare.com/ajax/libs/datatables.net-buttons-bs5/2.4.1/buttons.bootstrap5.min.css" rel="stylesheet">
+            <link href="https://cdnjs.cloudflare.com/ajax/libs/datatables.net-responsive-bs5/2.4.1/responsive.bootstrap5.min.css" rel="stylesheet">
+            <style>
+                {css}
+            </style>
+        </head>
+        <body>
+            <div class="container">
+                <table id="interactive-table" class="table table-striped" style="width:100%">
+                    <thead>
+                        <tr>{header_cells}</tr>
+                    </thead>
+                    <tbody>{body_rows}</tbody>
+                </table>
+            </div>
+            <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.7.0/jquery.min.js"></script>
+            <script src="https://cdnjs.cloudflare.com/ajax/libs/datatables.net/1.13.6/jquery.dataTables.min.js"></script>
+            <script src="https://cdnjs.cloudflare.com/ajax/libs/datatables.net-bs5/1.13.6/dataTables.bootstrap5.min.js"></script>
+            <script>
+                $(document).ready(function() {{
+                    $('#interactive-table').DataTable({{
+                        pageLength: 10,
+                        lengthMenu: [[5, 10, 25, -1], [5, 10, 25, "All"]],
+                        scrollX: true,
+                        responsive: true,
+                        dom: 'Bfrtip',
+                        buttons: [
+                            {{
+                                extend: 'colvis',
+                                text: 'Show/Hide Columns'
+                            }}
+                        ]
+                    }});
+                }});
+            </script>
+        </body>
+        </html>
+        """
+
+        header_cells = "".join(
+            f"<th>{header}</th>" for header in self.table_data.headers
+        )
+        body_rows = ""
+        for row in self.table_data.data:
+            body_rows += "<tr>"
+            body_rows += "".join(f"<td>{cell}</td>" for cell in row)
+            body_rows += "</tr>"
+
+        parameters = self.table_data.parameters or {}
+        css = self.get_css()
+        if hasattr(self, "css_parameterizer"):
+            css = self.css_parameterizer(css).apply_parameters(parameters)
+
+        return html_template.format(
+            css=css, header_cells=header_cells, body_rows=body_rows
+        )
+
+    @classmethod
+    def get_css(cls) -> str:
+        """Load CSS content from the file next to this module"""
+        css_path = Path(__file__).parent / "table_display.css"
+        return css_path.read_text()
+
+
+class PandasStyleRenderer(DataTablesRendererABC):
+    """Pandas-based styled renderer implementation"""
+
+    def render_html(self) -> str:
+        import pandas as pd
+
+        from contextlib import redirect_stderr
+        import io
+
+        stderr = io.StringIO()
+        with redirect_stderr(stderr):
+            if self.table_data.raw_data_set is not None and hasattr(
+                self.table_data.raw_data_set, "to_pandas"
+            ):
+                df = self.table_data.raw_data_set.to_pandas()
+            else:
+                df = pd.DataFrame(self.table_data.data, columns=self.table_data.headers)
+
+            styled_df = df.style.set_properties(
+                **{"text-align": "left"}
+            ).background_gradient()
+
+            return f"""
+            <div style="max-height: 500px; overflow-y: auto;">
+                {styled_df.to_html()}
+            </div>
+            """
+
+    @classmethod
+    def get_css(cls) -> str:
+        return ""  # Pandas styling handles its own CSS

edsl/scenarios/ConstructDownloadLink.py

@@ -0,0 +1,109 @@
+import os
+import mimetypes
+
+
+class ConstructDownloadLink:
+    """
+    A class to create HTML download links for FileStore objects.
+    The links can be displayed in Jupyter notebooks or other web interfaces.
+    """
+
+    def __init__(self, filestore):
+        """
+        Initialize with a FileStore object.
+
+        Args:
+            filestore: A FileStore object containing the file to be made downloadable
+        """
+        self.filestore = filestore
+
+    def create_link(self, custom_filename=None, style=None):
+        from IPython.display import HTML
+
+        html = self.html_create_link(custom_filename, style)
+        return HTML(html)
+
+    def html_create_link(self, custom_filename=None, style=None):
+        """
+        Create an HTML download link for the file.
+
+        Args:
+            custom_filename (str, optional): Custom name for the downloaded file.
+                                          If None, uses original filename.
+            style (dict, optional): Custom CSS styles for the download button.
+                                  If None, uses default styling.
+
+        Returns:
+            IPython.display.HTML: HTML object containing the download link
+        """
+
+        # Get filename from path or use custom filename
+        original_filename = os.path.basename(self.filestore.path)
+        filename = custom_filename or original_filename
+
+        # Use the base64 string already stored in FileStore
+        b64_data = self.filestore.base64_string
+
+        # Use mime type from FileStore or guess it
+        mime_type = self.filestore.mime_type
+
+        # Default style if none provided
+        default_style = {
+            "background-color": "#4CAF50",
+            "color": "white",
+            "padding": "10px 20px",
+            "text-decoration": "none",
+            "border-radius": "4px",
+            "display": "inline-block",
+            "margin": "10px 0",
+            "font-family": "sans-serif",
+            "cursor": "pointer",
+        }
+
+        button_style = style or default_style
+        style_str = "; ".join(f"{k}: {v}" for k, v in button_style.items())
+
+        html = f"""
+        <a download="{filename}" 
+           href="data:{mime_type};base64,{b64_data}" 
+           style="{style_str}">
+            Download {filename}
+        </a>
+        """
+        return html
+
+    def create_multiple_links(self, files, custom_filenames=None, style=None):
+        """
+        Create multiple download links at once.
+        Useful when you want to provide different versions of the same file
+        or related files together.
+
+        Args:
+            files (list): List of FileStore objects
+            custom_filenames (list, optional): List of custom filenames for downloads
+            style (dict, optional): Custom CSS styles for the download buttons
+
+        Returns:
+            IPython.display.HTML: HTML object containing all download links
+        """
+        if custom_filenames is None:
+            custom_filenames = [None] * len(files)
+
+        html_parts = []
+        for file_obj, custom_name in zip(files, custom_filenames):
+            link_creator = ConstructDownloadLink(file_obj)
+            html_parts.append(
+                link_creator.create_link(
+                    custom_filename=custom_name, style=style
+                )._repr_html_()
+            )
+
+        return HTML(
+            '<div style="display: flex; gap: 10px;">' + "".join(html_parts) + "</div>"
+        )
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()