edsl 0.1.37.dev5__py3-none-any.whl → 0.1.38__py3-none-any.whl

edsl/results/TableDisplay.py

@@ -0,0 +1,198 @@
+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/table_display.css

@@ -0,0 +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;
+}

edsl/scenarios/FileStore.py

@@ -14,18 +14,87 @@ from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
 from edsl.utilities.utilities import is_notebook
 
 
-def view_pdf(pdf_path):
+def view_csv(csv_path):
+    import pandas as pd
+
+    df = pd.read_csv(csv_path)
+    return df
+
+
+def view_html(html_path):
     import os
     import subprocess
+    from IPython.display import IFrame, display, HTML
+
+    if os.path.exists(html_path):
+        if is_notebook():
+            # Display the HTML inline in Jupyter Notebook
+            display(IFrame(src=html_path, width=700, height=600))
+            display(
+                HTML(
+                    f'<a href="{html_path}" target="_blank">Open HTML in a new tab</a>'
+                )
+            )
+        else:
+            try:
+                if (os_name := os.name) == "posix":
+                    # Open with the default browser on macOS
+                    subprocess.run(["open", html_path], check=True)
+                elif os_name == "nt":
+                    # Open with the default browser on Windows
+                    os.startfile(html_path)
+                else:
+                    # Open with the default browser on Linux
+                    subprocess.run(["xdg-open", html_path], check=True)
+            except Exception as e:
+                print(f"Error opening HTML file: {e}")
+    else:
+        print("HTML file was not found.")
+
+
+def view_html(html_path):
+    import os
+    from IPython.display import display, HTML
 
     if is_notebook():
-        from IPython.display import IFrame
-        from IPython.display import display, HTML
+        with open(html_path, "r") as f:
+            html_content = f.read()
+        display(HTML(html_content))
+    else:
+        if os.path.exists(html_path):
+            try:
+                if (os_name := os.name) == "posix":
+                    subprocess.run(["open", html_path], check=True)
+                elif os_name == "nt":
+                    os.startfile(html_path)
+                else:
+                    subprocess.run(["xdg-open", html_path], check=True)
+            except Exception as e:
+                print(f"Error opening file: {e}")
+        else:
+            print("File was not created successfully.")
+
 
-        # Replace 'path/to/your/file.pdf' with the actual path to your PDF file
-        IFrame(pdf_path, width=700, height=600)
-        display(HTML(f'<a href="{pdf_path}" target="_blank">Open PDF</a>'))
-        return
+def view_pdf(pdf_path):
+    import os
+    import subprocess
+    import os
+    from IPython.display import HTML, display
+
+    if is_notebook():
+        # Convert to absolute path if needed
+        with open(pdf_path, "rb") as f:
+            base64_pdf = base64.b64encode(f.read()).decode("utf-8")
+
+        html = f"""
+        <iframe
+            src="data:application/pdf;base64,{base64_pdf}"
+            width="800px"
+            height="800px"
+            type="application/pdf"
+        ></iframe>
+        """
+        display(HTML(html))
 
     if os.path.exists(pdf_path):
         try:
@@ -43,6 +112,8 @@ def view_pdf(pdf_path):
 
 
 class FileStore(Scenario):
+    __documentation__ = "https://docs.expectedparrot.com/en/latest/filestore.html"
+
     def __init__(
         self,
         path: Optional[str] = None,
@@ -55,7 +126,10 @@ class FileStore(Scenario):
     ):
         if path is None and "filename" in kwargs:
             path = kwargs["filename"]
-        self.path = path
+
+        self._path = path  # Store the original path privately
+        self._temp_path = None  # Track any generated temporary file
+
         self.suffix = suffix or path.split(".")[-1]
         self.binary = binary or False
         self.mime_type = (
@@ -65,7 +139,7 @@ class FileStore(Scenario):
         self.external_locations = external_locations or {}
         super().__init__(
             {
-                "path": self.path,
+                "path": path,
                 "base64_string": self.base64_string,
                 "binary": self.binary,
                 "suffix": self.suffix,
@@ -74,17 +148,110 @@ class FileStore(Scenario):
             }
         )
 
+    @property
+    def path(self) -> str:
+        """
+        Property that returns a valid path to the file content.
+        If the original path doesn't exist, generates a temporary file from the base64 content.
+        """
+        # Check if original path exists and is accessible
+        if self._path and os.path.isfile(self._path):
+            return self._path
+
+        # If we already have a valid temporary file, use it
+        if self._temp_path and os.path.isfile(self._temp_path):
+            return self._temp_path
+
+        # Generate a new temporary file from base64 content
+        self._temp_path = self.to_tempfile(self.suffix)
+        return self._temp_path
+
     def __str__(self):
         return "FileStore: self.path"
 
     @classmethod
-    def example(self):
+    def example(cls, example_type="text"):
+        import textwrap
         import tempfile
 
-        with tempfile.NamedTemporaryFile(suffix=".txt", delete=False) as f:
-            f.write(b"Hello, World!")
+        if example_type == "png" or example_type == "image":
+            import importlib.resources
+            from pathlib import Path
+
+            # Get package root directory
+            package_root = Path(__file__).parent.parent.parent
+            logo_path = package_root / "static" / "logo.png"
+            return cls(str(logo_path))
+
+        if example_type == "text":
+            with tempfile.NamedTemporaryFile(suffix=".txt", delete=False) as f:
+                f.write(b"Hello, World!")
+
+            return cls(path=f.name)
 
-        return self(path=f.name)
+        elif example_type == "csv":
+            from edsl.results.Results import Results
+
+            r = Results.example()
+
+            with tempfile.NamedTemporaryFile(suffix=".csv", delete=False) as f:
+                r.to_csv(filename=f.name)
+            return cls(f.name)
+
+        elif example_type == "pdf":
+            pdf_string = textwrap.dedent(
+                """\
+            %PDF-1.4
+            1 0 obj
+            << /Type /Catalog /Pages 2 0 R >>
+            endobj
+            2 0 obj
+            << /Type /Pages /Kids [3 0 R] /Count 1 >>
+            endobj
+            3 0 obj
+            << /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Contents 4 0 R >>
+            endobj
+            4 0 obj
+            << /Length 44 >>
+            stream
+            BT
+            /F1 24 Tf
+            100 700 Td
+            (Hello, World!) Tj
+            ET
+            endstream
+            endobj
+            5 0 obj
+            << /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>
+            endobj
+            6 0 obj
+            << /ProcSet [/PDF /Text] /Font << /F1 5 0 R >> >>
+            endobj
+            xref
+            0 7
+            0000000000 65535 f 
+            0000000010 00000 n 
+            0000000053 00000 n 
+            0000000100 00000 n 
+            0000000173 00000 n 
+            0000000232 00000 n 
+            0000000272 00000 n 
+            trailer
+            << /Size 7 /Root 1 0 R >>
+            startxref
+            318
+            %%EOF"""
+            )
+            with tempfile.NamedTemporaryFile(suffix=".pdf", delete=False) as f:
+                f.write(pdf_string.encode())
+
+            return cls(f.name)
+
+        elif example_type == "html":
+            with tempfile.NamedTemporaryFile(suffix=".html", delete=False) as f:
+                f.write("<html><body><h1>Test</h1></body></html>".encode())
+
+            return cls(f.name)
 
     @property
     def size(self) -> int:
@@ -186,9 +353,16 @@ class FileStore(Scenario):
         return temp_file.name
 
     def view(self, max_size: int = 300) -> None:
+        # with self.open() as f:
+        if self.suffix == "csv":
+            return view_csv(self.path)
+
         if self.suffix == "pdf":
             view_pdf(self.path)
 
+        if self.suffix == "html":
+            view_html(self.path)
+
         if self.suffix == "png" or self.suffix == "jpg" or self.suffix == "jpeg":
             if is_notebook():
                 from IPython.display import Image

edsl/scenarios/Scenario.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 import copy
 import hashlib
 import os
+import json
 from collections import UserDict
 from typing import Union, List, Optional, Generator
 from uuid import uuid4
@@ -14,12 +15,30 @@ from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
 from edsl.exceptions.scenarios import ScenarioError
 
 
+class DisplayJSON:
+    def __init__(self, dict):
+        self.text = json.dumps(dict, indent=4)
+
+    def __repr__(self):
+        return self.text
+
+
+class DisplayYAML:
+    def __init__(self, dict):
+        import yaml
+
+        self.text = yaml.dump(dict)
+
+    def __repr__(self):
+        return self.text
+
+
 class Scenario(Base, UserDict, ScenarioHtmlMixin):
     """A Scenario is a dictionary of keys/values.
 
     They can be used parameterize EDSL questions."""
 
-    __doc__ = "https://docs.expectedparrot.com/en/latest/scenarios.html"
+    __documentation__ = "https://docs.expectedparrot.com/en/latest/scenarios.html"
 
     def __init__(self, data: Union[dict, None] = None, name: str = None):
         """Initialize a new Scenario.
@@ -137,7 +156,23 @@ class Scenario(Base, UserDict, ScenarioHtmlMixin):
                 new_scenario[key] = value
         return new_scenario
 
-    def _to_dict(self) -> dict:
+    def table(self, tablefmt: str = "grid") -> str:
+        from edsl.results.Dataset import Dataset
+
+        keys = [key for key, value in self.items()]
+        values = [value for key, value in self.items()]
+        d = Dataset([{"key": keys}, {"value": values}])
+        return d.table(tablefmt=tablefmt)
+
+    def json(self):
+        return DisplayJSON(self.to_dict(add_edsl_version=False))
+
+    def yaml(self):
+        import yaml
+
+        return DisplayYAML(self.to_dict(add_edsl_version=False))
+
+    def to_dict(self, add_edsl_version=True) -> dict:
         """Convert a scenario to a dictionary.
 
         Example:
@@ -145,26 +180,24 @@ class Scenario(Base, UserDict, ScenarioHtmlMixin):
         >>> s = Scenario({"food": "wood chips"})
         >>> s.to_dict()
         {'food': 'wood chips', 'edsl_version': '...', 'edsl_class_name': 'Scenario'}
+
+        >>> s.to_dict(add_edsl_version = False)
+        {'food': 'wood chips'}
+
         """
         from edsl.scenarios.FileStore import FileStore
 
         d = self.data.copy()
         for key, value in d.items():
             if isinstance(value, FileStore):
-                d[key] = value.to_dict()
-        return d
-
-    @add_edsl_version
-    def to_dict(self) -> dict:
-        """Convert a scenario to a dictionary.
+                d[key] = value.to_dict(add_edsl_version=add_edsl_version)
+        if add_edsl_version:
+            from edsl import __version__
 
-        Example:
+            d["edsl_version"] = __version__
+            d["edsl_class_name"] = "Scenario"
 
-        >>> s = Scenario({"food": "wood chips"})
-        >>> s.to_dict()
-        {'food': 'wood chips', 'edsl_version': '...', 'edsl_class_name': 'Scenario'}
-        """
-        return self._to_dict()
+        return d
 
     def __hash__(self) -> int:
         """
@@ -178,7 +211,7 @@ class Scenario(Base, UserDict, ScenarioHtmlMixin):
         """
         from edsl.utilities.utilities import dict_hash
 
-        return dict_hash(self._to_dict())
+        return dict_hash(self.to_dict(add_edsl_version=False))
 
     def print(self):
         from rich import print_json
@@ -187,13 +220,35 @@ class Scenario(Base, UserDict, ScenarioHtmlMixin):
         print_json(json.dumps(self.to_dict()))
 
     def __repr__(self):
-        # return "Scenario(" + reprlib.repr(self.data) + ")"
         return "Scenario(" + repr(self.data) + ")"
 
+    def to_dataset(self) -> "Dataset":
+        # d = Dataset([{'a.b':[1,2,3,4]}])
+        from edsl.results.Dataset import Dataset
+
+        keys = [key for key, value in self.items()]
+        values = [value for key, value in self.items()]
+        return Dataset([{"key": keys}, {"value": values}])
+
     def _repr_html_(self):
-        from edsl.utilities.utilities import data_to_html
+        from tabulate import tabulate
+        import reprlib
+
+        d = self.to_dict(add_edsl_version=False)
+        # return self.to_dataset()
+        r = reprlib.Repr()
+        r.maxstring = 70
+
+        data = [[k, r.repr(v)] for k, v in d.items()]
+        from tabulate import tabulate
+
+        if hasattr(self, "__documentation__"):
+            footer = f"<a href='{self.__documentation__}'>(docs)</a></p>"
+        else:
+            footer = ""
 
-        return data_to_html(self.to_dict())
+        table = str(tabulate(data, headers=["keys", "values"], tablefmt="html"))
+        return f"<pre>{table}</pre>" + footer
 
     def select(self, list_of_keys: List[str]) -> "Scenario":
         """Select a subset of keys from a scenario.