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

edsl/results/MarkdownToDocx.py

@@ -1,122 +0,0 @@
-from typing import Optional
-import subprocess
-import os
-from pathlib import Path
-import tempfile
-
-
-class MarkdownToDocx:
-    def __init__(self, markdown_content: str, filename: Optional[str] = None):
-        """
-        Initialize the converter with markdown content.
-
-        Args:
-            markdown_content (str): The markdown content to be converted
-        """
-        self.markdown_content = markdown_content
-        self.filename = filename
-        self._check_pandoc()
-
-    def _check_pandoc(self):
-        """Check if pandoc is installed and accessible."""
-        try:
-            subprocess.run(["pandoc", "--version"], capture_output=True, check=True)
-        except (subprocess.CalledProcessError, FileNotFoundError):
-            raise RuntimeError(
-                "Pandoc is not installed or not found in PATH. "
-                "Please install pandoc before using this converter."
-            )
-
-    def convert(self, output_path: str, **options) -> bool:
-        """
-        Convert the markdown content to DOCX.
-
-        Args:
-            output_path (str): Path where the DOCX should be saved
-            **options: Additional conversion options
-                reference_doc (str): Path to reference docx for styling
-                toc (bool): Include table of contents (default: False)
-                number_sections (bool): Number sections (default: False)
-                highlight_style (str): Code highlighting style (default: "tango")
-
-        Returns:
-            bool: True if conversion was successful, False otherwise
-        """
-        # Ensure output directory exists
-        output_path = Path(output_path)
-        output_path.parent.mkdir(parents=True, exist_ok=True)
-
-        # Build pandoc command
-        cmd = ["pandoc", "-f", "markdown", "-t", "docx", "-o", str(output_path)]
-
-        # Add reference doc if provided
-        if "reference_doc" in options:
-            ref_doc = Path(options["reference_doc"])
-            if ref_doc.exists():
-                cmd.extend(["--reference-doc", str(ref_doc)])
-            else:
-                print(f"Warning: Reference document {ref_doc} not found")
-
-        # Add optional parameters
-        if options.get("toc", False):
-            cmd.append("--toc")
-
-        if options.get("number_sections", False):
-            cmd.append("--number-sections")
-
-        if "highlight_style" in options:
-            cmd.extend(["--highlight-style", options["highlight_style"]])
-
-        try:
-            # Run pandoc command
-            result = subprocess.run(
-                cmd,
-                input=self.markdown_content,
-                text=True,
-                capture_output=True,
-                check=True,
-            )
-            return True
-        except subprocess.CalledProcessError as e:
-            print(f"Error converting markdown to DOCX: {e.stderr}")
-            return False
-
-    def preview(self) -> str:
-        """
-        Generate a temporary DOCX and return its path.
-
-        Returns:
-            str: Path to the temporary DOCX file
-        """
-        temp_dir = tempfile.mkdtemp()
-        if self.filename:
-            temp_docx = os.path.join(temp_dir, self.filename)
-        else:
-            temp_docx = os.path.join(temp_dir, "preview.docx")
-
-        if self.convert(temp_docx):
-            from edsl.scenarios.FileStore import FileStore
-
-            return FileStore(path=temp_docx)
-
-        return None
-
-    def create_template(self, output_path: str) -> bool:
-        """
-        Create a reference DOCX template that can be modified for styling.
-
-        Args:
-            output_path (str): Path where the template should be saved
-
-        Returns:
-            bool: True if template was created successfully, False otherwise
-        """
-        try:
-            cmd = ["pandoc", "--print-default-data-file", "reference.docx"]
-
-            with open(output_path, "wb") as f:
-                result = subprocess.run(cmd, stdout=f, check=True)
-            return True
-        except subprocess.CalledProcessError as e:
-            print(f"Error creating template: {e.stderr}")
-            return False

edsl/results/MarkdownToPDF.py

@@ -1,111 +0,0 @@
-from typing import Optional
-import subprocess
-import os
-from pathlib import Path
-import tempfile
-
-
-class MarkdownToPDF:
-    def __init__(self, markdown_content: str, filename: Optional[str] = None):
-        """
-        Initialize the converter with markdown content.
-
-        Args:
-            markdown_content (str): The markdown content to be converted
-        """
-        self.markdown_content = markdown_content
-        self.filename = filename
-        self._check_pandoc()
-        # self.convert()
-
-    def _check_pandoc(self):
-        """Check if pandoc is installed and accessible."""
-        try:
-            subprocess.run(["pandoc", "--version"], capture_output=True, check=True)
-        except (subprocess.CalledProcessError, FileNotFoundError):
-            raise RuntimeError(
-                "Pandoc is not installed or not found in PATH. "
-                "Please install pandoc before using this converter."
-            )
-
-    def convert(self, output_path: str, **options) -> bool:
-        """
-        Convert the markdown content to PDF.
-
-        Args:
-            output_path (str): Path where the PDF should be saved
-            **options: Additional conversion options
-                margin (str): Page margin (default: "1in")
-                font_size (str): Font size (default: "12pt")
-                toc (bool): Include table of contents (default: False)
-                number_sections (bool): Number sections (default: False)
-                highlight_style (str): Code highlighting style (default: "tango")
-
-        Returns:
-            bool: True if conversion was successful, False otherwise
-        """
-        # Ensure output directory exists
-        output_path = Path(output_path)
-        output_path.parent.mkdir(parents=True, exist_ok=True)
-
-        # Build pandoc command with default options
-        cmd = [
-            "pandoc",
-            "-f",
-            "markdown",
-            "-o",
-            str(output_path),
-            "--pdf-engine=xelatex",
-            "--variable",
-            f'geometry:margin={options.get("margin", "1in")}',
-            "--variable",
-            f'fontsize={options.get("font_size", "12pt")}',
-        ]
-
-        # Add font only if specifically provided
-        if "font" in options:
-            cmd.extend(["--variable", f'mainfont={options["font"]}'])
-
-        # Add optional parameters
-        if options.get("toc", False):
-            cmd.append("--toc")
-
-        if options.get("number_sections", False):
-            cmd.append("--number-sections")
-
-        if "highlight_style" in options:
-            cmd.extend(["--highlight-style", options["highlight_style"]])
-
-        try:
-            # Run pandoc command
-            result = subprocess.run(
-                cmd,
-                input=self.markdown_content,
-                text=True,
-                capture_output=True,
-                check=True,
-            )
-            return True
-        except subprocess.CalledProcessError as e:
-            print(f"Error converting markdown to PDF: {e.stderr}")
-            return False
-
-    def preview(self) -> str:
-        """
-        Generate a temporary PDF and return its path.
-
-        Returns:
-            str: Path to the temporary PDF file
-        """
-        temp_dir = tempfile.mkdtemp()
-        if self.filename:
-            temp_pdf = os.path.join(temp_dir, f"{self.filename}.pdf")
-        else:
-            temp_pdf = os.path.join(temp_dir, "preview.pdf")
-
-        if self.convert(temp_pdf):
-            from edsl.scenarios.FileStore import FileStore
-
-            return FileStore(temp_pdf)
-
-        return None

edsl/results/TextEditor.py

@@ -1,50 +0,0 @@
-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/file_exports.py

@@ -1,252 +0,0 @@
-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/smart_objects.py

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

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