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

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/results_fetch_mixin.py

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

edsl/results/results_selector.py

@@ -0,0 +1,145 @@
+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()

edsl/results/results_tools_mixin.py

@@ -0,0 +1,98 @@
+class ResultsToolsMixin:
+    def get_themes(
+        self,
+        field: str,
+        context: str,
+        max_values=100,
+        num_themes: int = 10,
+        seed=None,
+        progress_bar=False,
+        print_exceptions=False,
+    ) -> list:
+        values = [
+            str(txt)[:1000]
+            for txt in self.shuffle(seed=seed).select(field).to_list()[:max_values]
+        ]
+        from edsl import ScenarioList
+        from edsl.questions import QuestionList, QuestionCheckBox
+
+        q = QuestionList(
+            question_text=f"""
+        {context}
+        Here are some examples: { values }. 
+        What are some 5-8 word themes that would mostly capture these examples?
+        Please shoot for {num_themes} as target number of themes.
+        """,
+            question_name="themes",
+        )
+        results = q.run(print_exceptions=print_exceptions, progress_bar=progress_bar)
+        return results.select("themes").first()
+
+    def answers_to_themes(
+        self,
+        field,
+        context: str,
+        themes: list,
+        progress_bar=False,
+        print_exceptions=False,
+    ) -> dict:
+        from edsl import ScenarioList
+        from edsl import QuestionCheckBox
+
+        values = self.select(field).to_list()
+        scenarios = ScenarioList.from_list("field", values).add_value(
+            "context", context
+        )
+        q = QuestionCheckBox(
+            question_text="""
+            {{ context }}
+            Consider the following response: 
+
+            " {{ field }} "
+
+            Please check the themes that apply to these examples.
+            If blank, please check 'None'.
+            """,
+            question_options=themes + ["None", "Other"],
+            question_name="themes",
+        )
+        results = q.by(scenarios).run(
+            progress_bar=progress_bar, print_exceptions=print_exceptions
+        )
+        return {k: v for k, v in results.select("field", "themes").to_list()}
+
+    def apply_themes(self, field: str, new_field: str, answers_to_themes: dict):
+        def translate(x):
+            return answers_to_themes.get(x, "Other")
+
+        self.mutate(f"{new_field} = f({field})", functions_dict={"f": translate})
+        return self
+
+    def auto_theme(
+        self,
+        field: str,
+        context: str,
+        themes: list[str],
+        newfield: str = None,
+        progress_bar=False,
+        print_exceptions=False,
+    ) -> tuple:
+        """
+        :param field: The field to be themed.
+        :param context: The context of the field.
+        :param themes: The list of themes.
+        :param newfield: The new field name.
+
+        """
+
+        if not newfield:
+            newfield = f"{field}_themes"
+
+        answers_to_themes = self.answers_to_themes(
+            field=field,
+            context=context,
+            themes=themes,
+            progress_bar=progress_bar,
+            print_exceptions=print_exceptions,
+        )
+        return self.apply_themes(field, newfield, answers_to_themes), themes

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