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

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/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

edsl/results/table_renderers.py

@@ -1,118 +0,0 @@
-from abc import ABC, abstractmethod
-from edsl.results.table_data_class import TableData
-
-
-class DataTablesRendererABC(ABC):
-    def __init__(self, table_data: TableData):
-        self.table_data = table_data
-
-    @abstractmethod
-    def render_html(self) -> str:
-        pass
-
-
-class DataTablesRenderer(DataTablesRendererABC):
-    """Interactive DataTables renderer implementation"""
-
-    def render_html(self) -> str:
-        html_template = """
-        <!DOCTYPE html>
-        <html>
-        <head>
-            <link href="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/5.3.0/css/bootstrap.min.css" rel="stylesheet">
-            <link href="https://cdnjs.cloudflare.com/ajax/libs/datatables.net-bs5/1.13.6/dataTables.bootstrap5.min.css" rel="stylesheet">
-            <link href="https://cdnjs.cloudflare.com/ajax/libs/datatables.net-buttons-bs5/2.4.1/buttons.bootstrap5.min.css" rel="stylesheet">
-            <link href="https://cdnjs.cloudflare.com/ajax/libs/datatables.net-responsive-bs5/2.4.1/responsive.bootstrap5.min.css" rel="stylesheet">
-            <style>
-                {css}
-            </style>
-        </head>
-        <body>
-            <div class="container">
-                <table id="interactive-table" class="table table-striped" style="width:100%">
-                    <thead>
-                        <tr>{header_cells}</tr>
-                    </thead>
-                    <tbody>{body_rows}</tbody>
-                </table>
-            </div>
-            <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.7.0/jquery.min.js"></script>
-            <script src="https://cdnjs.cloudflare.com/ajax/libs/datatables.net/1.13.6/jquery.dataTables.min.js"></script>
-            <script src="https://cdnjs.cloudflare.com/ajax/libs/datatables.net-bs5/1.13.6/dataTables.bootstrap5.min.js"></script>
-            <script>
-                $(document).ready(function() {{
-                    $('#interactive-table').DataTable({{
-                        pageLength: 10,
-                        lengthMenu: [[5, 10, 25, -1], [5, 10, 25, "All"]],
-                        scrollX: true,
-                        responsive: true,
-                        dom: 'Bfrtip',
-                        buttons: [
-                            {{
-                                extend: 'colvis',
-                                text: 'Show/Hide Columns'
-                            }}
-                        ]
-                    }});
-                }});
-            </script>
-        </body>
-        </html>
-        """
-
-        header_cells = "".join(
-            f"<th>{header}</th>" for header in self.table_data.headers
-        )
-        body_rows = ""
-        for row in self.table_data.data:
-            body_rows += "<tr>"
-            body_rows += "".join(f"<td>{cell}</td>" for cell in row)
-            body_rows += "</tr>"
-
-        parameters = self.table_data.parameters or {}
-        css = self.get_css()
-        if hasattr(self, "css_parameterizer"):
-            css = self.css_parameterizer(css).apply_parameters(parameters)
-
-        return html_template.format(
-            css=css, header_cells=header_cells, body_rows=body_rows
-        )
-
-    @classmethod
-    def get_css(cls) -> str:
-        """Load CSS content from the file next to this module"""
-        css_path = Path(__file__).parent / "table_display.css"
-        return css_path.read_text()
-
-
-class PandasStyleRenderer(DataTablesRendererABC):
-    """Pandas-based styled renderer implementation"""
-
-    def render_html(self) -> str:
-        import pandas as pd
-
-        from contextlib import redirect_stderr
-        import io
-
-        stderr = io.StringIO()
-        with redirect_stderr(stderr):
-            if self.table_data.raw_data_set is not None and hasattr(
-                self.table_data.raw_data_set, "to_pandas"
-            ):
-                df = self.table_data.raw_data_set.to_pandas()
-            else:
-                df = pd.DataFrame(self.table_data.data, columns=self.table_data.headers)
-
-            styled_df = df.style.set_properties(
-                **{"text-align": "left"}
-            ).background_gradient()
-
-            return f"""
-            <div style="max-height: 500px; overflow-y: auto;">
-                {styled_df.to_html()}
-            </div>
-            """
-
-    @classmethod
-    def get_css(cls) -> str:
-        return ""  # Pandas styling handles its own CSS

edsl/scenarios/ConstructDownloadLink.py

@@ -1,109 +0,0 @@
-import os
-import mimetypes
-
-
-class ConstructDownloadLink:
-    """
-    A class to create HTML download links for FileStore objects.
-    The links can be displayed in Jupyter notebooks or other web interfaces.
-    """
-
-    def __init__(self, filestore):
-        """
-        Initialize with a FileStore object.
-
-        Args:
-            filestore: A FileStore object containing the file to be made downloadable
-        """
-        self.filestore = filestore
-
-    def create_link(self, custom_filename=None, style=None):
-        from IPython.display import HTML
-
-        html = self.html_create_link(custom_filename, style)
-        return HTML(html)
-
-    def html_create_link(self, custom_filename=None, style=None):
-        """
-        Create an HTML download link for the file.
-
-        Args:
-            custom_filename (str, optional): Custom name for the downloaded file.
-                                          If None, uses original filename.
-            style (dict, optional): Custom CSS styles for the download button.
-                                  If None, uses default styling.
-
-        Returns:
-            IPython.display.HTML: HTML object containing the download link
-        """
-
-        # Get filename from path or use custom filename
-        original_filename = os.path.basename(self.filestore.path)
-        filename = custom_filename or original_filename
-
-        # Use the base64 string already stored in FileStore
-        b64_data = self.filestore.base64_string
-
-        # Use mime type from FileStore or guess it
-        mime_type = self.filestore.mime_type
-
-        # Default style if none provided
-        default_style = {
-            "background-color": "#4CAF50",
-            "color": "white",
-            "padding": "10px 20px",
-            "text-decoration": "none",
-            "border-radius": "4px",
-            "display": "inline-block",
-            "margin": "10px 0",
-            "font-family": "sans-serif",
-            "cursor": "pointer",
-        }
-
-        button_style = style or default_style
-        style_str = "; ".join(f"{k}: {v}" for k, v in button_style.items())
-
-        html = f"""
-        <a download="{filename}" 
-           href="data:{mime_type};base64,{b64_data}" 
-           style="{style_str}">
-            Download {filename}
-        </a>
-        """
-        return html
-
-    def create_multiple_links(self, files, custom_filenames=None, style=None):
-        """
-        Create multiple download links at once.
-        Useful when you want to provide different versions of the same file
-        or related files together.
-
-        Args:
-            files (list): List of FileStore objects
-            custom_filenames (list, optional): List of custom filenames for downloads
-            style (dict, optional): Custom CSS styles for the download buttons
-
-        Returns:
-            IPython.display.HTML: HTML object containing all download links
-        """
-        if custom_filenames is None:
-            custom_filenames = [None] * len(files)
-
-        html_parts = []
-        for file_obj, custom_name in zip(files, custom_filenames):
-            link_creator = ConstructDownloadLink(file_obj)
-            html_parts.append(
-                link_creator.create_link(
-                    custom_filename=custom_name, style=style
-                )._repr_html_()
-            )
-
-        return HTML(
-            '<div style="display: flex; gap: 10px;">' + "".join(html_parts) + "</div>"
-        )
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod()

edsl/scenarios/DirectoryScanner.py

@@ -1,96 +0,0 @@
-# directory_scanner.py
-from dataclasses import dataclass
-from typing import Optional, List, Iterator, TypeVar, Generic, Callable, Any
-import os
-
-T = TypeVar("T")
-
-
-@dataclass
-class DirectoryScanner:
-    """
-    Scanner for finding files in a directory based on various criteria.
-    """
-
-    directory_path: str
-
-    def scan(
-        self,
-        factory: Callable[[str], T],
-        recursive: bool = False,
-        suffix_allow_list: Optional[List[str]] = None,
-        suffix_exclude_list: Optional[List[str]] = None,
-        example_suffix: Optional[str] = None,
-        include_no_extension: bool = True,
-    ) -> List[T]:
-        """
-        Eagerly scan directory and return list of objects created by factory.
-
-        Args:
-            factory: Callable that creates objects from file paths
-            recursive: If True, recursively traverse subdirectories
-            suffix_allow_list: List of allowed file extensions (without dots)
-            suffix_exclude_list: List of excluded file extensions (takes precedence over allow list)
-            example_suffix: If provided, only include files with this example suffix
-            include_no_extension: Whether to include files without extensions
-        """
-        return list(
-            self.iter_scan(
-                factory,
-                recursive=recursive,
-                suffix_allow_list=suffix_allow_list,
-                suffix_exclude_list=suffix_exclude_list,
-                example_suffix=example_suffix,
-                include_no_extension=include_no_extension,
-            )
-        )
-
-    def iter_scan(
-        self,
-        factory: Callable[[str], T],
-        recursive: bool = False,
-        suffix_allow_list: Optional[List[str]] = None,
-        suffix_exclude_list: Optional[List[str]] = None,
-        example_suffix: Optional[str] = None,
-        include_no_extension: bool = True,
-    ) -> Iterator[T]:
-        """
-        Lazily scan directory and yield objects created by factory.
-        """
-
-        def should_include_file(filepath: str) -> bool:
-            _, ext = os.path.splitext(filepath)
-            ext = ext[1:] if ext else ""
-
-            # Handle no extension case
-            if not ext:
-                return include_no_extension
-
-            # Check exclusions first (they take precedence)
-            if suffix_exclude_list and ext in suffix_exclude_list:
-                return False
-
-            # Check example suffix if specified
-            if example_suffix and not filepath.endswith(example_suffix):
-                return False
-
-            # Check allowed suffixes if specified
-            if suffix_allow_list and ext not in suffix_allow_list:
-                return False
-
-            return True
-
-        def iter_files():
-            if recursive:
-                for root, _, files in os.walk(self.directory_path):
-                    for file in files:
-                        yield os.path.join(root, file)
-            else:
-                for file in os.listdir(self.directory_path):
-                    file_path = os.path.join(self.directory_path, file)
-                    if os.path.isfile(file_path):
-                        yield file_path
-
-        for file_path in iter_files():
-            if should_include_file(file_path):
-                yield factory(file_path)

edsl/scenarios/DocumentChunker.py

@@ -1,102 +0,0 @@
-from __future__ import annotations
-from typing import Optional, Generator, TYPE_CHECKING
-import copy
-
-if TYPE_CHECKING:
-    from edsl.scenarios.Scenario import Scenario
-    from edsl.scenarios.ScenarioList import ScenarioList
-
-
-class DocumentChunker:
-    def __init__(self, scenario: "Scenario"):
-        self.scenario = scenario
-
-    @staticmethod
-    def _line_chunks(text, num_lines: int) -> Generator[str, None, None]:
-        """Split a text into chunks of a given size.
-
-        :param text: The text to split.
-        :param num_lines: The number of lines in each chunk.
-
-        Example:
-
-        >>> list(DocumentChunker._line_chunks("This is a test.\\nThis is a test. This is a test.", 1))
-        ['This is a test.', 'This is a test. This is a test.']
-        """
-        lines = text.split("\n")
-        for i in range(0, len(lines), num_lines):
-            chunk = "\n".join(lines[i : i + num_lines])
-            yield chunk
-
-    @staticmethod
-    def _word_chunks(text, num_words: int) -> Generator[str, None, None]:
-        """Split a text into chunks of a given size.
-
-        :param text: The text to split.
-        :param num_words: The number of words in each chunk.
-
-        Example:
-
-        >>> list(DocumentChunker._word_chunks("This is a test.", 2))
-        ['This is', 'a test.']
-        """
-        words = text.split()
-        for i in range(0, len(words), num_words):
-            chunk = " ".join(words[i : i + num_words])
-            yield chunk
-
-    def chunk(
-        self,
-        field,
-        num_words: Optional[int] = None,
-        num_lines: Optional[int] = None,
-        include_original=False,
-        hash_original=False,
-    ) -> ScenarioList:
-        """Split a field into chunks of a given size.
-
-        :param field: The field to split.
-        :param num_words: The number of words in each chunk.
-        :param num_lines: The number of lines in each chunk.
-        :param include_original: Whether to include the original field in the new scenarios.
-        :param hash_original: Whether to hash the original field in the new scenarios.
-
-        If you specify `include_original=True`, the original field will be included in the new scenarios with an "_original" suffix.
-        """
-        from edsl.scenarios.ScenarioList import ScenarioList
-        import hashlib
-
-        if num_words is not None:
-            chunks = list(self._word_chunks(self.scenario[field], num_words))
-
-        if num_lines is not None:
-            chunks = list(self._line_chunks(self.scenario[field], num_lines))
-
-        if num_words is None and num_lines is None:
-            raise ValueError("You must specify either num_words or num_lines.")
-
-        if num_words is not None and num_lines is not None:
-            raise ValueError(
-                "You must specify either num_words or num_lines, but not both."
-            )
-
-        scenarios = []
-        for i, chunk in enumerate(chunks):
-            new_scenario = copy.deepcopy(self.scenario)
-            new_scenario[field] = chunk
-            new_scenario[field + "_chunk"] = i
-            if include_original:
-                if hash_original:
-                    new_scenario[field + "_original"] = hashlib.md5(
-                        self.scenario[field].encode()
-                    ).hexdigest()
-                else:
-                    new_scenario[field + "_original"] = self.scenario[field]
-            scenarios.append(new_scenario)
-        return ScenarioList(scenarios)
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod()