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

edsl/scenarios/handlers/pdf.py

@@ -1,68 +0,0 @@
-import os
-import base64
-
-from edsl.scenarios.file_methods import FileMethods
-
-
-class PdfMethods(FileMethods):
-    suffix = "pdf"
-
-    def extract_text(self):
-        from PyPDF2 import PdfReader
-
-        # Create a PDF reader object
-        reader = PdfReader(self.path)
-
-        # Get number of pages
-        num_pages = len(reader.pages)
-
-        # Extract text from all pages
-        text = ""
-        for page_num in range(num_pages):
-            # Get the page object
-            page = reader.pages[page_num]
-            # Extract text from page
-            text += page.extract_text()
-
-        return text
-
-    def view_system(self):
-        import os
-        import subprocess
-
-        if os.path.exists(self.path):
-            try:
-                if (os_name := os.name) == "posix":
-                    subprocess.run(["open", self.path], check=True)  # macOS
-                elif os_name == "nt":
-                    os.startfile(self.path)  # Windows
-                else:
-                    subprocess.run(["xdg-open", self.path], check=True)  # Linux
-            except Exception as e:
-                print(f"Error opening PDF: {e}")
-        else:
-            print("PDF file was not found.")
-
-    def view_notebook(self):
-        from IPython.display import HTML, display
-
-        with open(self.path, "rb") as f:
-            base64_pdf = base64.b64encode(f.read()).decode("utf-8")
-
-        html = f"""
-        <iframe
-            src="data:application/pdf;base64,{base64_pdf}"
-            width="800px"
-            height="800px"
-            type="application/pdf"
-        ></iframe>
-        """
-        display(HTML(html))
-        return
-
-    def example(self):
-        from edsl.results.Results import Results
-
-        return (
-            Results.example().select("answer.how_feeling").first().pdf().to_tempfile()
-        )

edsl/scenarios/handlers/png.py

@@ -1,39 +0,0 @@
-import tempfile
-from edsl.scenarios.file_methods import FileMethods
-
-
-class PngMethods(FileMethods):
-    suffix = "png"
-
-    def view_system(self):
-        import os
-        import subprocess
-
-        if os.path.exists(self.path):
-            try:
-                if (os_name := os.name) == "posix":
-                    subprocess.run(["open", self.path], check=True)  # macOS
-                elif os_name == "nt":
-                    os.startfile(self.path)  # Windows
-                else:
-                    subprocess.run(["xdg-open", self.path], check=True)  # Linux
-            except Exception as e:
-                print(f"Error opening PNG: {e}")
-        else:
-            print("PNG file was not found.")
-
-    def view_notebook(self):
-        from IPython.display import Image, display
-
-        display(Image(filename=self.path))
-
-    def example(self):
-        import matplotlib.pyplot as plt
-        import numpy as np
-
-        x = np.linspace(0, 10, 100)
-        y = np.sin(x)
-        plt.plot(x, y)
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as f:
-            plt.savefig(f.name)
-        return f.name

edsl/scenarios/handlers/pptx.py

@@ -1,105 +0,0 @@
-from edsl.scenarios.file_methods import FileMethods
-import os
-import tempfile
-
-
-class PptxMethods(FileMethods):
-    suffix = "pptx"
-
-    def extract_text(self):
-        from pptx import Presentation
-
-        self.ppt = Presentation(self.path)
-
-        # Extract all text from slides
-        full_text = []
-        for slide in self.ppt.slides:
-            slide_text = []
-            for shape in slide.shapes:
-                if hasattr(shape, "text"):
-                    slide_text.append(shape.text)
-            full_text.append("\n".join(slide_text))
-
-        text = "\n\n".join(full_text)
-        return text
-
-    def view_system(self):
-        import os
-        import subprocess
-
-        if os.path.exists(self.path):
-            try:
-                if (os_name := os.name) == "posix":
-                    subprocess.run(["open", self.path], check=True)  # macOS
-                elif os_name == "nt":
-                    os.startfile(self.path)  # Windows
-                else:
-                    subprocess.run(["xdg-open", self.path], check=True)  # Linux
-            except Exception as e:
-                print(f"Error opening PPTX: {e}")
-        else:
-            print("PPTX file was not found.")
-
-    def view_notebook(self):
-        from pptx import Presentation
-        from IPython.display import HTML, display
-
-        prs = Presentation(self.path)
-
-        # Create a simple HTML representation of the slides
-        html_content = []
-        for i, slide in enumerate(prs.slides, 1):
-            slide_content = []
-            for shape in slide.shapes:
-                if hasattr(shape, "text"):
-                    slide_content.append(f"<p>{shape.text}</p>")
-
-            html_content.append(
-                f"""
-                <div style='border: 1px solid #ccc; margin: 10px; padding: 10px;'>
-                    <h3>Slide {i}</h3>
-                    {''.join(slide_content)}
-                </div>
-            """
-            )
-
-        html = f"""
-        <div style="width: 800px; height: 800px; padding: 20px; 
-                   border: 1px solid #ccc; overflow-y: auto;">
-            {''.join(html_content)}
-        </div>
-        """
-        display(HTML(html))
-
-    def example(self):
-        from pptx import Presentation
-        from edsl.scenarios.Scenario import Scenario
-        from edsl.scenarios.ScenarioList import ScenarioList
-
-        os.makedirs("test_dir", exist_ok=True)
-
-        # Create first presentation
-        ppt1 = Presentation()
-        slide = ppt1.slides.add_slide(ppt1.slide_layouts[0])
-        title = slide.shapes.title
-        title.text = "First Presentation"
-        ppt1.save("test_dir/test1.pptx")
-
-        # Create second presentation
-        ppt2 = Presentation()
-        slide = ppt2.slides.add_slide(ppt2.slide_layouts[0])
-        title = slide.shapes.title
-        title.text = "Second Presentation"
-
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".pptx") as tmp:
-            ppt2.save(tmp.name)
-            tmp.close()
-
-        return tmp.name
-
-
-if __name__ == "__main__":
-    pptx_temp = PptxMethods.example()
-    from edsl.scenarios.FileStore import FileStore
-
-    fs = FileStore(pptx_temp)

edsl/scenarios/handlers/py.py

@@ -1,294 +0,0 @@
-from edsl.scenarios.file_methods import FileMethods
-import tempfile
-import re
-from typing import List, Optional, Dict
-import ast
-import black
-import textwrap
-import subprocess
-import sys
-from importlib import util
-
-
-class PyMethods(FileMethods):
-    suffix = "py"
-
-    def view_system(self):
-        """Open the Python file in the system's default editor."""
-        import os
-        import subprocess
-
-        if os.path.exists(self.path):
-            try:
-                if (os_name := os.name) == "posix":
-                    subprocess.run(["open", self.path], check=True)  # macOS
-                elif os_name == "nt":
-                    os.startfile(self.path)  # Windows
-                else:
-                    subprocess.run(["xdg-open", self.path], check=True)  # Linux
-            except Exception as e:
-                print(f"Error opening Python file: {e}")
-        else:
-            print("Python file was not found.")
-
-    def view_notebook(self):
-        """Display the Python file with syntax highlighting in a notebook."""
-        from IPython.display import FileLink, display, HTML
-        import pygments
-        from pygments.lexers import PythonLexer
-        from pygments.formatters import HtmlFormatter
-        from pygments.styles import get_style_by_name
-
-        try:
-            with open(self.path, "r", encoding="utf-8") as f:
-                content = f.read()
-
-            # Create custom CSS for better visibility in both light and dark themes
-            custom_css = """
-            .highlight {
-                background: var(--jp-cell-editor-background, #f7f7f7);
-                border: 1px solid var(--jp-border-color2, #ddd);
-                border-radius: 3px;
-                padding: 1em;
-                margin: 1em 0;
-            }
-            .highlight pre {
-                margin: 0;
-                color: var(--jp-content-font-color0, #000);
-                background: transparent;
-            }
-            .highlight .hll { background-color: var(--jp-cell-editor-active-background, #ffffcc) }
-            .highlight .c { color: #408080; font-style: italic } /* Comment */
-            .highlight .k { color: #008000; font-weight: bold } /* Keyword */
-            .highlight .o { color: #666666 } /* Operator */
-            .highlight .s { color: #BA2121 } /* String */
-            .highlight .n { color: var(--jp-content-font-color0, #000) } /* Name */
-            .highlight .p { color: var(--jp-content-font-color0, #000) } /* Punctuation */
-            """
-
-            formatter = HtmlFormatter(style="default")
-            highlighted_python = pygments.highlight(content, PythonLexer(), formatter)
-
-            # Combine the custom CSS with basic formatter CSS
-            css = formatter.get_style_defs(".highlight") + custom_css
-
-            display(HTML(f"<style>{css}</style>{highlighted_python}"))
-            display(FileLink(self.path))
-        except Exception as e:
-            print(f"Error displaying Python: {e}")
-
-    def format_python(self) -> bool:
-        """Format the Python file using black."""
-        try:
-            with open(self.path, "r", encoding="utf-8") as f:
-                content = f.read()
-
-            # Format using black
-            formatted_content = black.format_str(content, mode=black.FileMode())
-
-            with open(self.path, "w", encoding="utf-8") as f:
-                f.write(formatted_content)
-
-            return True
-        except Exception as e:
-            print(f"Error formatting Python: {e}")
-            return False
-
-    def validate_syntax(self) -> bool:
-        """Validate Python syntax using ast.parse."""
-        try:
-            with open(self.path, "r", encoding="utf-8") as f:
-                content = f.read()
-
-            ast.parse(content)
-            return True
-        except SyntaxError as e:
-            print(f"Syntax error in Python file: {e}")
-            return False
-        except Exception as e:
-            print(f"Error validating Python: {e}")
-            return False
-
-    def extract_imports(self) -> List[str]:
-        """Extract all import statements from the Python file."""
-        imports = []
-        try:
-            with open(self.path, "r", encoding="utf-8") as f:
-                content = f.read()
-
-            tree = ast.parse(content)
-            for node in ast.walk(tree):
-                if isinstance(node, ast.Import):
-                    for name in node.names:
-                        imports.append(name.name)
-                elif isinstance(node, ast.ImportFrom):
-                    module = node.module or ""
-                    for name in node.names:
-                        imports.append(f"{module}.{name.name}")
-
-            return sorted(list(set(imports)))
-        except Exception as e:
-            print(f"Error extracting imports: {e}")
-            return []
-
-    def extract_functions(self) -> List[str]:
-        """Extract all function names from the Python file."""
-        functions = []
-        try:
-            with open(self.path, "r", encoding="utf-8") as f:
-                content = f.read()
-
-            tree = ast.parse(content)
-            for node in ast.walk(tree):
-                if isinstance(node, ast.FunctionDef):
-                    functions.append(node.name)
-
-            return sorted(functions)
-        except Exception as e:
-            print(f"Error extracting functions: {e}")
-            return []
-
-    def extract_classes(self) -> List[str]:
-        """Extract all class names from the Python file."""
-        classes = []
-        try:
-            with open(self.path, "r", encoding="utf-8") as f:
-                content = f.read()
-
-            tree = ast.parse(content)
-            for node in ast.walk(tree):
-                if isinstance(node, ast.ClassDef):
-                    classes.append(node.name)
-
-            return sorted(classes)
-        except Exception as e:
-            print(f"Error extracting classes: {e}")
-            return []
-
-    def get_docstrings(self) -> Dict[str, str]:
-        """Extract docstrings for all functions and classes."""
-        docstrings = {}
-        try:
-            with open(self.path, "r", encoding="utf-8") as f:
-                content = f.read()
-
-            tree = ast.parse(content)
-            for node in ast.walk(tree):
-                if isinstance(node, (ast.FunctionDef, ast.ClassDef)):
-                    docstring = ast.get_docstring(node)
-                    if docstring:
-                        docstrings[node.name] = docstring
-
-            return docstrings
-        except Exception as e:
-            print(f"Error extracting docstrings: {e}")
-            return {}
-
-    def run_file(self, args: List[str] = None) -> Optional[int]:
-        """Run the Python file as a script with optional arguments."""
-        try:
-            cmd = [sys.executable, self.path]
-            if args:
-                cmd.extend(args)
-
-            result = subprocess.run(cmd, capture_output=True, text=True)
-            print(result.stdout)
-            if result.stderr:
-                print("Errors:", result.stderr, file=sys.stderr)
-            return result.returncode
-        except Exception as e:
-            print(f"Error running Python file: {e}")
-            return None
-
-    def check_dependencies(self) -> List[str]:
-        """Check if all imported modules are available."""
-        missing_deps = []
-        try:
-            imports = self.extract_imports()
-            for imp in imports:
-                # Get the top-level module name
-                top_module = imp.split(".")[0]
-                if not util.find_spec(top_module):
-                    missing_deps.append(top_module)
-            return missing_deps
-        except Exception as e:
-            print(f"Error checking dependencies: {e}")
-            return []
-
-    def example(self):
-        """Create a sample Python file with common patterns."""
-        sample_python = '''#!/usr/bin/env python3
-"""Example Python module demonstrating common patterns."""
-
-import sys
-from typing import List, Optional
-from dataclasses import dataclass
-
-
-@dataclass
-class Employee:
-    """Represents an employee in the system."""
-    name: str
-    department: str
-    salary: float
-    hire_date: str
-
-
-class EmployeeManager:
-    """Manages employee operations."""
-
-    def __init__(self):
-        self.employees: List[Employee] = []
-
-    def add_employee(self, employee: Employee) -> None:
-        """Add a new employee to the system."""
-        self.employees.append(employee)
-
-    def get_department_stats(self, department: str) -> Optional[dict]:
-        """Calculate statistics for a department."""
-        dept_employees = [e for e in self.employees if e.department == department]
-        
-        if not dept_employees:
-            return None
-            
-        return {
-            'count': len(dept_employees),
-            'avg_salary': sum(e.salary for e in dept_employees) / len(dept_employees)
-        }
-
-
-def main(args: List[str]) -> int:
-    """Main entry point for the script."""
-    manager = EmployeeManager()
-    
-    # Add sample employees
-    manager.add_employee(Employee(
-        "John Doe",
-        "Engineering",
-        75000.00,
-        "2023-01-15"
-    ))
-    
-    manager.add_employee(Employee(
-        "Jane Smith",
-        "Marketing",
-        65000.00,
-        "2023-02-01"
-    ))
-    
-    # Print department statistics
-    stats = manager.get_department_stats("Engineering")
-    if stats:
-        print(f"Engineering department stats: {stats}")
-    
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main(sys.argv[1:]))
-'''
-        with tempfile.NamedTemporaryFile(
-            delete=False, suffix=".py", mode="w", encoding="utf-8"
-        ) as f:
-            f.write(sample_python)
-        return f.name