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

edsl/results/ResultsDBMixin.py

@@ -0,0 +1,238 @@
+"""Mixin for working with SQLite respresentation of a 'Results' object."""
+
+import sqlite3
+from enum import Enum
+from typing import Literal, Union, Optional
+
+
+class SQLDataShape(Enum):
+    """Enum for the shape of the data in the SQL database."""
+
+    WIDE = "wide"
+    LONG = "long"
+
+
+class ResultsDBMixin:
+    """Mixin for interacting with a Results object as if it were a SQL database."""
+
+    def _rows(self):
+        """Return the rows of the `Results` object as a list of tuples."""
+        for index, result in enumerate(self):
+            yield from result.rows(index)
+
+    def export_sql_dump(self, shape: Literal["wide", "long"], filename: str):
+        """Export the SQL database to a file.
+
+        :param shape: The shape of the data in the database (wide or long)
+        :param filename: The filename to save the database to
+        """
+        shape_enum = self._get_shape_enum(shape)
+        conn = self._db(shape=shape_enum)
+
+        with open(filename, "w") as f:
+            for line in conn.iterdump():
+                f.write(f"{line}\n")
+
+        conn.close()
+
+    def backup_db_to_file(self, shape: Literal["wide", "long"], filename: str):
+        """Backup the in-memory database to a file.
+
+
+        :param shape: The shape of the data in the database (wide or long)
+        :param filename: The filename to save the database to
+
+        >>> from edsl.results import Results
+        >>> r = Results.example()
+        >>> r.backup_db_to_file(filename="backup.db", shape="long")
+
+        """
+        shape_enum = self._get_shape_enum(shape)
+        # Source database connection (in-memory)
+        source_conn = self._db(shape=shape_enum)
+
+        # Destination database connection (file)
+        dest_conn = sqlite3.connect(filename)
+
+        # Backup in-memory database to file
+        with source_conn:
+            source_conn.backup(dest_conn)
+
+        # Close both connections
+        source_conn.close()
+        dest_conn.close()
+
+    def _db(self, shape: SQLDataShape, remove_prefix=False):
+        """Create a SQLite database in memory and return the connection.
+
+        :param shape: The shape of the data in the database (wide or long)
+        :param remove_prefix: Whether to remove the prefix from the column names
+
+        """
+        if shape == SQLDataShape.LONG:
+            conn = sqlite3.connect(":memory:")
+
+            create_table_query = """
+            CREATE TABLE self (
+                id INTEGER,
+                data_type TEXT,
+                key TEXT, 
+                value TEXT
+            )
+            """
+            conn.execute(create_table_query)
+
+            list_of_tuples = list(self._rows())
+            insert_query = (
+                "INSERT INTO self (id, data_type, key, value) VALUES (?, ?, ?, ?)"
+            )
+            conn.executemany(insert_query, list_of_tuples)
+            conn.commit()
+            return conn
+        elif shape == SQLDataShape.WIDE:
+            from sqlalchemy import create_engine
+
+            engine = create_engine("sqlite:///:memory:")
+            df = self.to_pandas(remove_prefix=remove_prefix, lists_as_strings=True)
+            df.to_sql("self", engine, index=False, if_exists="replace")
+            return engine.connect()
+        else:
+            raise Exception("Invalid SQLDataShape")
+
+    def _get_shape_enum(self, shape: Literal["wide", "long"]):
+        """Convert the shape string to a SQLDataShape enum."""
+        if shape is None:
+            raise Exception("Must select either 'wide' or 'long' format")
+        elif shape == "wide":
+            return SQLDataShape.WIDE
+        elif shape == "long":
+            return SQLDataShape.LONG
+        else:
+            raise Exception("Invalid shape: must be either 'long' or 'wide'")
+
+    def sql(
+        self,
+        query: str,
+        shape: Literal["wide", "long"] = "wide",
+        remove_prefix: bool = True,
+        transpose: bool = None,
+        transpose_by: str = None,
+        csv: bool = False,
+        to_list=False,
+        to_latex=False,
+        filename: Optional[str] = None,
+    ) -> Union["pd.DataFrame", str]:
+        """Execute a SQL query and return the results as a DataFrame.
+
+        :param query: The SQL query to execute
+        :param shape: The shape of the data in the database (wide or long)
+        :param remove_prefix: Whether to remove the prefix from the column names
+        :param transpose: Whether to transpose the DataFrame
+        :param transpose_by: The column to use as the index when transposing
+        :param csv: Whether to return the DataFrame as a CSV string
+
+
+        Example usage:
+
+        >>> from edsl.results import Results
+        >>> r = Results.example()
+        >>> d = r.sql("select data_type, key, value from self where data_type = 'answer' order by value limit 3", shape="long")
+        >>> sorted(list(d['value']))
+        ['Good', 'Great', 'Great']
+
+        We can also return the data in wide format.
+        Note the use of single quotes to escape the column names, as required by sql.
+
+        >>> from edsl.results import Results
+        >>> Results.example().sql("select how_feeling from self", shape = 'wide', remove_prefix=True)
+          how_feeling
+        0          OK
+        1       Great
+        2    Terrible
+        3          OK
+        """
+        import pandas as pd
+
+        shape_enum = self._get_shape_enum(shape)
+
+        conn = self._db(shape=shape_enum, remove_prefix=remove_prefix)
+        df = pd.read_sql_query(query, conn)
+
+        # Transpose the DataFrame if transpose is True
+        if transpose or transpose_by:
+            df = pd.DataFrame(df)
+            if transpose_by:
+                df = df.set_index(transpose_by)
+            else:
+                df = df.set_index(df.columns[0])
+            df = df.transpose()
+
+        if csv and to_list:
+            raise Exception("Cannot return both CSV and list")
+
+        if to_list:
+            return df.values.tolist()
+
+        if to_latex:
+            df.columns = [col.replace("_", " ") for col in df.columns]
+
+            latex_output = df.to_latex(index=False)
+            if filename:
+                with open(filename, "w") as f:
+                    f.write(latex_output)
+                return None
+            return latex_output
+
+        if csv:
+            if filename:
+                df.to_csv(filename, index=False)
+                return None
+
+            return df.to_csv(index=False)
+
+        return df
+
+    def show_schema(
+        self, shape: Literal["wide", "long"], remove_prefix: bool = False
+    ) -> None:
+        """Show the schema of the Results database.
+
+        :param shape: The shape of the data in the database (wide or long)
+        :param remove_prefix: Whether to remove the prefix from the column names
+
+        >>> from edsl.results import Results
+        >>> r = Results.example()
+        >>> r.show_schema(shape="long")
+        Type: table, Name: self, SQL: CREATE TABLE self (
+        ...
+        <BLANKLINE>
+        """
+        import pandas as pd
+
+        shape_enum = self._get_shape_enum(shape)
+        conn = self._db(shape=shape_enum, remove_prefix=remove_prefix)
+
+        if shape_enum == SQLDataShape.LONG:
+            # Query to get the schema of all tables
+            query = "SELECT type, name, sql FROM sqlite_master WHERE type='table'"
+            cursor = conn.execute(query)
+            schema = cursor.fetchall()
+            conn.close()
+
+            # Format and return the schema information
+            schema_info = ""
+            for row in schema:
+                schema_info += f"Type: {row[0]}, Name: {row[1]}, SQL: {row[2]}\n"
+
+            print(schema_info)
+        elif shape_enum == SQLDataShape.WIDE:
+            query = f"PRAGMA table_info(self)"
+            schema = pd.read_sql(query, conn)
+            # print(schema)
+            return schema
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod(optionflags=doctest.ELLIPSIS)

edsl/results/ResultsExportMixin.py

@@ -14,8 +14,6 @@ def to_dataset(func):
         """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)
 

edsl/results/{results_selector.py → Selector.py}

@@ -1,12 +1,7 @@
-from typing import Union, List, Dict, Any, Optional
-import sys
+from typing import Union, List, Dict, Any
 from collections import defaultdict
 from edsl.results.Dataset import Dataset
 
-from edsl.exceptions.results import ResultsColumnNotFoundError
-
-from edsl.utilities.is_notebook import is_notebook
-
 
 class Selector:
     def __init__(
@@ -24,17 +19,11 @@ class Selector:
         self._fetch_list = fetch_list_func
         self.columns = columns
 
-    def select(self, *columns: Union[str, List[str]]) -> Optional[Dataset]:
-        try:
-            columns = self._normalize_columns(columns)
-            to_fetch = self._get_columns_to_fetch(columns)
-            new_data = self._fetch_data(to_fetch)
-        except ResultsColumnNotFoundError as e:
-            if is_notebook():
-                print("Error:", e, file=sys.stderr)
-                return None
-            else:
-                raise e
+    def select(self, *columns: Union[str, List[str]]) -> "Dataset":
+        columns = self._normalize_columns(columns)
+        to_fetch = self._get_columns_to_fetch(columns)
+        # breakpoint()
+        new_data = self._fetch_data(to_fetch)
         return Dataset(new_data)
 
     def _normalize_columns(self, columns: Union[str, List[str]]) -> tuple:
@@ -74,16 +63,17 @@ class Selector:
             search_in_list = self.columns
         else:
             search_in_list = [s.split(".")[1] for s in self.columns]
+        # breakpoint()
         matches = [s for s in search_in_list if s.startswith(partial_name)]
         return [partial_name] if partial_name in matches else matches
 
     def _validate_matches(self, column: str, matches: List[str]):
         if len(matches) > 1:
-            raise ResultsColumnNotFoundError(
+            raise ValueError(
                 f"Column '{column}' is ambiguous. Did you mean one of {matches}?"
             )
         if len(matches) == 0 and ".*" not in column:
-            raise ResultsColumnNotFoundError(f"Column '{column}' not found in data.")
+            raise ValueError(f"Column '{column}' not found in data.")
 
     def _parse_column(self, column: str) -> tuple[str, str]:
         if "." in column:
@@ -99,11 +89,11 @@ class Selector:
         close_matches = difflib.get_close_matches(column, self._key_to_data_type.keys())
         if close_matches:
             suggestions = ", ".join(close_matches)
-            raise ResultsColumnNotFoundError(
+            raise KeyError(
                 f"Column '{column}' not found in data. Did you mean: {suggestions}?"
             )
         else:
-            raise ResultsColumnNotFoundError(f"Column {column} not found in data")
+            raise KeyError(f"Column {column} not found in data")
 
     def _process_column(self, data_type: str, key: str, to_fetch: Dict[str, List[str]]):
         data_types = self._get_data_types_to_return(data_type)
@@ -118,13 +108,13 @@ class Selector:
                     self.items_in_order.append(f"{dt}.{k}")
 
         if not found_once:
-            raise ResultsColumnNotFoundError(f"Key {key} not found in data.")
+            raise ValueError(f"Key {key} not found in data.")
 
     def _get_data_types_to_return(self, parsed_data_type: str) -> List[str]:
         if parsed_data_type == "*":
             return self.known_data_types
         if parsed_data_type not in self.known_data_types:
-            raise ResultsColumnNotFoundError(
+            raise ValueError(
                 f"Data type {parsed_data_type} not found in data. Did you mean one of {self.known_data_types}"
             )
         return [parsed_data_type]

edsl/results/TableDisplay.py

@@ -1,125 +1,198 @@
-from typing import (
-    Protocol,
-    List,
-    Any,
-    Optional,
-    TYPE_CHECKING,
-    Sequence,
-    Union,
-    Literal,
-)
+from tabulate import tabulate
+from pathlib import Path
 
-if TYPE_CHECKING:
-    from edsl.results.Dataset import Dataset
+from edsl.results.CSSParameterizer import CSSParameterizer
 
-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
+    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
 
-        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 {}
-            )
+            if raw_data_set.print_parameters:
+                self.printing_parameters = raw_data_set.print_parameters
+            else:
+                self.printing_parameters = {}
         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 to_csv(self, filename: str):
+        self.raw_data_set.to_csv(filename)
 
-    def __repr__(self):
-        from tabulate import tabulate
+    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)
 
-        return tabulate(self.data, headers=self.headers, tablefmt=self.tablefmt)
+        with open(filename, "w") as file:
+            print("Writing table to", filename)
+            file.write(table)
 
-    @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)
+    def to_pandas(self):
+        return self.raw_data_set.to_pandas()
 
-    @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 to_list(self):
+        return self.raw_data_set.to_list()
 
-    @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"""
+    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, self.tablefmt, renderer_class=self.renderer_class
-        )
+        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
 
-# Example usage:
-if __name__ == "__main__":
-    headers = ["Name", "Age", "City"]
-    data = [["John", 30, "New York"], ["Jane", 25, "London"]]
+        if height < self.min_height:
+            height = self.min_height
 
-    # Using default (Pandas) renderer
-    table1 = TableDisplay(headers, data)
+        html_template = """
+        <style>
+            {css}
+        </style>
+        <div class="table-container">
+            <div class="scroll-table-wrapper">
+                {table}
+            </div>
+        </div>
+        """
 
-    # Using DataTables renderer
-    table2 = TableDisplay(headers, data, renderer=DataTablesRenderer())
+        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/__init__.py

@@ -1,2 +1,2 @@
-# from edsl.results.Result import Result
+from edsl.results.Result import Result
 from edsl.results.Results import Results