edsl 0.1.39.dev3__py3-none-any.whl → 0.1.39.dev4__py3-none-any.whl

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

edsl/results/file_exports.py

@@ -0,0 +1,252 @@
+from abc import ABC, abstractmethod
+import io
+import csv
+import base64
+from typing import Optional, Union, Tuple, List, Any, Dict
+from openpyxl import Workbook
+
+from edsl.scenarios.FileStore import FileStore
+
+
+class FileExport(ABC):
+    def __init__(
+        self,
+        data: Any,
+        filename: Optional[str] = None,
+        remove_prefix: bool = False,
+        pretty_labels: Optional[Dict[str, str]] = None,
+    ):
+        self.data = data
+        self.filename = filename  # or self._get_default_filename()
+        self.remove_prefix = remove_prefix
+        self.pretty_labels = pretty_labels
+
+    @property
+    def mime_type(self) -> str:
+        """Return the MIME type for this export format."""
+        return self.__class__.mime_type
+
+    @property
+    def suffix(self) -> str:
+        """Return the file suffix for this format."""
+        return self.__class__.suffix
+
+    @property
+    def is_binary(self) -> bool:
+        """Whether the format is binary or text-based."""
+        return self.__class__.is_binary
+
+    def _get_default_filename(self) -> str:
+        """Generate default filename for this format."""
+        return f"results.{self.suffix}"
+
+    def _create_filestore(self, data: Union[str, bytes]) -> "FileStore":
+        """Create a FileStore instance with encoded data."""
+        if isinstance(data, str):
+            base64_string = base64.b64encode(data.encode()).decode()
+        else:
+            base64_string = base64.b64encode(data).decode()
+
+        from edsl.scenarios.FileStore import FileStore
+
+        path = self.filename or self._get_default_filename()
+
+        fs = FileStore(
+            path=path,
+            mime_type=self.mime_type,
+            binary=self.is_binary,
+            suffix=self.suffix,
+            base64_string=base64_string,
+        )
+
+        if self.filename is not None:
+            fs.write(self.filename)
+            return None
+        return fs
+
+    @abstractmethod
+    def format_data(self) -> Union[str, bytes]:
+        """Convert the input data to the target format."""
+        pass
+
+    def export(self) -> Optional["FileStore"]:
+        """Export the data to a FileStore instance."""
+        formatted_data = self.format_data()
+        return self._create_filestore(formatted_data)
+
+
+class JSONLExport(FileExport):
+    mime_type = "application/jsonl"
+    suffix = "jsonl"
+    is_binary = False
+
+    def format_data(self) -> str:
+        output = io.StringIO()
+        for entry in self.data:
+            key, values = list(entry.items())[0]
+            output.write(f'{{"{key}": {values}}}\n')
+        return output.getvalue()
+
+
+class TabularExport(FileExport, ABC):
+    """Base class for exports that use tabular data."""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.header, self.rows = self.data._get_tabular_data(
+            remove_prefix=self.remove_prefix, pretty_labels=self.pretty_labels
+        )
+
+
+class CSVExport(TabularExport):
+    mime_type = "text/csv"
+    suffix = "csv"
+    is_binary = False
+
+    def format_data(self) -> str:
+        output = io.StringIO()
+        writer = csv.writer(output)
+        writer.writerow(self.header)
+        writer.writerows(self.rows)
+        return output.getvalue()
+
+
+class ExcelExport(TabularExport):
+    mime_type = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+    suffix = "xlsx"
+    is_binary = True
+
+    def __init__(self, *args, sheet_name: Optional[str] = None, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.sheet_name = sheet_name or "Results"
+
+    def format_data(self) -> bytes:
+        wb = Workbook()
+        ws = wb.active
+        ws.title = self.sheet_name
+
+        # Write header
+        for col, value in enumerate(self.header, 1):
+            ws.cell(row=1, column=col, value=value)
+
+        # Write data rows
+        for row_idx, row_data in enumerate(self.rows, 2):
+            for col, value in enumerate(row_data, 1):
+                ws.cell(row=row_idx, column=col, value=value)
+
+        # Save to bytes buffer
+        buffer = io.BytesIO()
+        wb.save(buffer)
+        buffer.seek(0)
+        return buffer.getvalue()
+
+
+import sqlite3
+from typing import Any
+
+
+class SQLiteExport(TabularExport):
+    mime_type = "application/x-sqlite3"
+    suffix = "db"
+    is_binary = True
+
+    def __init__(
+        self, *args, table_name: str = "results", if_exists: str = "replace", **kwargs
+    ):
+        """
+        Initialize SQLite export.
+
+        Args:
+            table_name: Name of the table to create
+            if_exists: How to handle existing table ('fail', 'replace', or 'append')
+        """
+        super().__init__(*args, **kwargs)
+        self.table_name = table_name
+        self.if_exists = if_exists
+
+    def _get_column_types(self) -> list[tuple[str, str]]:
+        """Infer SQL column types from the data."""
+        column_types = []
+
+        # Check first row of data for types
+        if self.rows:
+            first_row = self.rows[0]
+            for header, value in zip(self.header, first_row):
+                if isinstance(value, bool):
+                    sql_type = "BOOLEAN"
+                elif isinstance(value, int):
+                    sql_type = "INTEGER"
+                elif isinstance(value, float):
+                    sql_type = "REAL"
+                else:
+                    sql_type = "TEXT"
+                column_types.append((header, sql_type))
+        else:
+            # If no data, default to TEXT
+            column_types = [(header, "TEXT") for header in self.header]
+
+        return column_types
+
+    def _create_table(self, cursor: sqlite3.Cursor) -> None:
+        """Create the table with appropriate schema."""
+        column_types = self._get_column_types()
+
+        # Drop existing table if replace mode
+        if self.if_exists == "replace":
+            cursor.execute(f"DROP TABLE IF EXISTS {self.table_name}")
+        elif self.if_exists == "fail":
+            cursor.execute(
+                f"SELECT name FROM sqlite_master WHERE type='table' AND name=?",
+                (self.table_name,),
+            )
+            if cursor.fetchone():
+                raise ValueError(f"Table {self.table_name} already exists")
+
+        # Create table
+        columns = ", ".join(f'"{col}" {dtype}' for col, dtype in column_types)
+        create_table_sql = f"""
+        CREATE TABLE IF NOT EXISTS {self.table_name} (
+            {columns}
+        )
+        """
+        cursor.execute(create_table_sql)
+
+    def format_data(self) -> bytes:
+        """Convert the data to a SQLite database file."""
+        buffer = io.BytesIO()
+
+        # Create in-memory database
+        conn = sqlite3.connect(":memory:")
+        cursor = conn.cursor()
+
+        # Create table and insert data
+        self._create_table(cursor)
+
+        # Prepare placeholders for INSERT
+        placeholders = ",".join(["?" for _ in self.header])
+        insert_sql = f"INSERT INTO {self.table_name} ({','.join(self.header)}) VALUES ({placeholders})"
+
+        # Insert data
+        cursor.executemany(insert_sql, self.rows)
+        conn.commit()
+
+        # Save to file buffer
+        conn.backup(sqlite3.connect(buffer))
+        conn.close()
+
+        buffer.seek(0)
+        return buffer.getvalue()
+
+    def _validate_params(self) -> None:
+        """Validate initialization parameters."""
+        valid_if_exists = {"fail", "replace", "append"}
+        if self.if_exists not in valid_if_exists:
+            raise ValueError(
+                f"if_exists must be one of {valid_if_exists}, got {self.if_exists}"
+            )
+
+        # Validate table name (basic SQLite identifier validation)
+        if not self.table_name.isalnum() and not all(c in "_" for c in self.table_name):
+            raise ValueError(
+                f"Invalid table name: {self.table_name}. Must contain only alphanumeric characters and underscores."
+            )

edsl/results/{ResultsFetchMixin.py → results_fetch_mixin.py}

@@ -1,33 +1,33 @@
-"""Mixin for fetching data from results."""
-
-from functools import partial
-from itertools import chain
-
-
-class ResultsFetchMixin:
-    """Mixin for fetching data from results."""
-
-    def _fetch_list(self, data_type: str, key: str) -> list:
-        """
-        Return a list of values from the data for a given data type and key.
-
-        Uses the filtered data, not the original data.
-
-        Example:
-
-        >>> from edsl.results import Results
-        >>> r = Results.example()
-        >>> r._fetch_list('answer', 'how_feeling')
-        ['OK', 'Great', 'Terrible', 'OK']
-        """
-        returned_list = []
-        for row in self.data:
-            returned_list.append(row.sub_dicts[data_type].get(key, None))
-
-        return returned_list
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod(optionflags=doctest.ELLIPSIS)
+"""Mixin for fetching data from results."""
+
+from functools import partial
+from itertools import chain
+
+
+class ResultsFetchMixin:
+    """Mixin for fetching data from results."""
+
+    def _fetch_list(self, data_type: str, key: str) -> list:
+        """
+        Return a list of values from the data for a given data type and key.
+
+        Uses the filtered data, not the original data.
+
+        Example:
+
+        >>> from edsl.results import Results
+        >>> r = Results.example()
+        >>> r._fetch_list('answer', 'how_feeling')
+        ['OK', 'Great', 'Terrible', 'OK']
+        """
+        returned_list = []
+        for row in self.data:
+            returned_list.append(row.sub_dicts[data_type].get(key, None))
+
+        return returned_list
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod(optionflags=doctest.ELLIPSIS)

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

@@ -1,135 +1,145 @@
-from typing import Union, List, Dict, Any
-from collections import defaultdict
-from edsl.results.Dataset import Dataset
-
-
-class Selector:
-    def __init__(
-        self,
-        known_data_types: List[str],
-        data_type_to_keys: Dict[str, List[str]],
-        key_to_data_type: Dict[str, str],
-        fetch_list_func,
-        columns: List[str],
-    ):
-        """Selects columns from a Results object"""
-        self.known_data_types = known_data_types
-        self._data_type_to_keys = data_type_to_keys
-        self._key_to_data_type = key_to_data_type
-        self._fetch_list = fetch_list_func
-        self.columns = columns
-
-    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:
-        """Normalize the columns to a tuple of strings
-
-        >>> s = Selector([], {}, {}, lambda x, y: x, [])
-        >>> s._normalize_columns([["a", "b"], ])
-        ('a', 'b')
-        >>> s._normalize_columns(None)
-        ('*.*',)
-        """
-        if not columns or columns == ("*",) or columns == (None,):
-            return ("*.*",)
-        if isinstance(columns[0], list):
-            return tuple(columns[0])
-        return columns
-
-    def _get_columns_to_fetch(self, columns: tuple) -> Dict[str, List[str]]:
-        to_fetch = defaultdict(list)
-        self.items_in_order = []
-
-        for column in columns:
-            matches = self._find_matching_columns(column)
-            # breakpoint()
-            self._validate_matches(column, matches)
-
-            if len(matches) == 1:
-                column = matches[0]
-
-            data_type, key = self._parse_column(column)
-            self._process_column(data_type, key, to_fetch)
-
-        return to_fetch
-
-    def _find_matching_columns(self, partial_name: str) -> list[str]:
-        if "." in partial_name:
-            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 ValueError(
-                f"Column '{column}' is ambiguous. Did you mean one of {matches}?"
-            )
-        if len(matches) == 0 and ".*" not in column:
-            raise ValueError(f"Column '{column}' not found in data.")
-
-    def _parse_column(self, column: str) -> tuple[str, str]:
-        if "." in column:
-            return column.split(".")
-        try:
-            return self._key_to_data_type[column], column
-        except KeyError:
-            self._raise_key_error(column)
-
-    def _raise_key_error(self, column: str):
-        import difflib
-
-        close_matches = difflib.get_close_matches(column, self._key_to_data_type.keys())
-        if close_matches:
-            suggestions = ", ".join(close_matches)
-            raise KeyError(
-                f"Column '{column}' not found in data. Did you mean: {suggestions}?"
-            )
-        else:
-            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)
-        found_once = False
-
-        for dt in data_types:
-            relevant_keys = self._data_type_to_keys[dt]
-            for k in relevant_keys:
-                if k == key or key == "*":
-                    found_once = True
-                    to_fetch[dt].append(k)
-                    self.items_in_order.append(f"{dt}.{k}")
-
-        if not found_once:
-            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 ValueError(
-                f"Data type {parsed_data_type} not found in data. Did you mean one of {self.known_data_types}"
-            )
-        return [parsed_data_type]
-
-    def _fetch_data(self, to_fetch: Dict[str, List[str]]) -> List[Dict[str, Any]]:
-        new_data = []
-        for data_type, keys in to_fetch.items():
-            for key in keys:
-                entries = self._fetch_list(data_type, key)
-                new_data.append({f"{data_type}.{key}": entries})
-
-        return [d for key in self.items_in_order for d in new_data if key in d]
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod()
+from typing import Union, List, Dict, Any, Optional
+import sys
+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__(
+        self,
+        known_data_types: List[str],
+        data_type_to_keys: Dict[str, List[str]],
+        key_to_data_type: Dict[str, str],
+        fetch_list_func,
+        columns: List[str],
+    ):
+        """Selects columns from a Results object"""
+        self.known_data_types = known_data_types
+        self._data_type_to_keys = data_type_to_keys
+        self._key_to_data_type = key_to_data_type
+        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
+        return Dataset(new_data)
+
+    def _normalize_columns(self, columns: Union[str, List[str]]) -> tuple:
+        """Normalize the columns to a tuple of strings
+
+        >>> s = Selector([], {}, {}, lambda x, y: x, [])
+        >>> s._normalize_columns([["a", "b"], ])
+        ('a', 'b')
+        >>> s._normalize_columns(None)
+        ('*.*',)
+        """
+        if not columns or columns == ("*",) or columns == (None,):
+            return ("*.*",)
+        if isinstance(columns[0], list):
+            return tuple(columns[0])
+        return columns
+
+    def _get_columns_to_fetch(self, columns: tuple) -> Dict[str, List[str]]:
+        to_fetch = defaultdict(list)
+        self.items_in_order = []
+
+        for column in columns:
+            matches = self._find_matching_columns(column)
+            # breakpoint()
+            self._validate_matches(column, matches)
+
+            if len(matches) == 1:
+                column = matches[0]
+
+            data_type, key = self._parse_column(column)
+            self._process_column(data_type, key, to_fetch)
+
+        return to_fetch
+
+    def _find_matching_columns(self, partial_name: str) -> list[str]:
+        if "." in partial_name:
+            search_in_list = self.columns
+        else:
+            search_in_list = [s.split(".")[1] for s in self.columns]
+        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(
+                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.")
+
+    def _parse_column(self, column: str) -> tuple[str, str]:
+        if "." in column:
+            return column.split(".")
+        try:
+            return self._key_to_data_type[column], column
+        except KeyError:
+            self._raise_key_error(column)
+
+    def _raise_key_error(self, column: str):
+        import difflib
+
+        close_matches = difflib.get_close_matches(column, self._key_to_data_type.keys())
+        if close_matches:
+            suggestions = ", ".join(close_matches)
+            raise ResultsColumnNotFoundError(
+                f"Column '{column}' not found in data. Did you mean: {suggestions}?"
+            )
+        else:
+            raise ResultsColumnNotFoundError(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)
+        found_once = False
+
+        for dt in data_types:
+            relevant_keys = self._data_type_to_keys[dt]
+            for k in relevant_keys:
+                if k == key or key == "*":
+                    found_once = True
+                    to_fetch[dt].append(k)
+                    self.items_in_order.append(f"{dt}.{k}")
+
+        if not found_once:
+            raise ResultsColumnNotFoundError(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(
+                f"Data type {parsed_data_type} not found in data. Did you mean one of {self.known_data_types}"
+            )
+        return [parsed_data_type]
+
+    def _fetch_data(self, to_fetch: Dict[str, List[str]]) -> List[Dict[str, Any]]:
+        new_data = []
+        for data_type, keys in to_fetch.items():
+            for key in keys:
+                entries = self._fetch_list(data_type, key)
+                new_data.append({f"{data_type}.{key}": entries})
+
+        return [d for key in self.items_in_order for d in new_data if key in d]
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()