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

edsl/scenarios/handlers/json.py

@@ -0,0 +1,111 @@
+from edsl.scenarios.file_methods import FileMethods
+import tempfile
+import json
+from typing import Optional, Dict, Any
+
+
+class JsonMethods(FileMethods):
+    suffix = "json"
+
+    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 JSON: {e}")
+        else:
+            print("JSON file was not found.")
+
+    def view_notebook(self):
+        from IPython.display import FileLink, JSON, display
+        import json
+
+        # Read and parse the JSON file
+        try:
+            with open(self.path, "r", encoding="utf-8") as f:
+                content = json.load(f)
+
+            # Display formatted JSON
+            display(JSON(content))
+
+            # Provide download link
+            display(FileLink(self.path))
+        except json.JSONDecodeError as e:
+            print(f"Error parsing JSON: {e}")
+        except Exception as e:
+            print(f"Error reading file: {e}")
+
+    def validate_json(self, schema: Optional[Dict[str, Any]] = None) -> bool:
+        """
+        Validate the JSON file against a schema if provided,
+        or check if it's valid JSON if no schema is provided.
+        """
+        try:
+            with open(self.path, "r", encoding="utf-8") as f:
+                content = json.load(f)
+
+            if schema is not None:
+                from jsonschema import validate
+
+                validate(instance=content, schema=schema)
+
+            return True
+        except json.JSONDecodeError as e:
+            print(f"Invalid JSON format: {e}")
+            return False
+        except Exception as e:
+            print(f"Validation error: {e}")
+            return False
+
+    def pretty_print(self):
+        """Pretty print the JSON content with proper indentation."""
+        try:
+            with open(self.path, "r", encoding="utf-8") as f:
+                content = json.load(f)
+
+            pretty_json = json.dumps(content, indent=2, sort_keys=True)
+            print(pretty_json)
+        except Exception as e:
+            print(f"Error pretty printing JSON: {e}")
+
+    def example(self):
+        sample_json = {
+            "person": {
+                "name": "John Doe",
+                "age": 30,
+                "contact": {"email": "john@example.com", "phone": "+1-555-555-5555"},
+                "interests": ["programming", "data science", "machine learning"],
+                "active": True,
+                "metadata": {"last_updated": "2024-01-01", "version": 1.0},
+            }
+        }
+
+        with tempfile.NamedTemporaryFile(
+            delete=False, suffix=".json", mode="w", encoding="utf-8"
+        ) as f:
+            json.dump(sample_json, f, indent=2)
+        return f.name
+
+    def format_file(self):
+        """Read, format, and write back the JSON with consistent formatting."""
+        try:
+            # Read the current content
+            with open(self.path, "r", encoding="utf-8") as f:
+                content = json.load(f)
+
+            # Write back with consistent formatting
+            with open(self.path, "w", encoding="utf-8") as f:
+                json.dump(content, f, indent=2, sort_keys=True)
+
+            return True
+        except Exception as e:
+            print(f"Error formatting JSON file: {e}")
+            return False

edsl/scenarios/handlers/latex.py

@@ -0,0 +1,5 @@
+from edsl.scenarios.handlers.txt import TxtMethods
+
+
+class LaTeXMethods(TxtMethods):
+    pass

edsl/scenarios/handlers/md.py

@@ -0,0 +1,51 @@
+from edsl.scenarios.file_methods import FileMethods
+import tempfile
+
+
+class MarkdownMethods(FileMethods):
+    suffix = "md"
+
+    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 Markdown: {e}")
+        else:
+            print("Markdown file was not found.")
+
+    def view_notebook(self):
+        from IPython.display import FileLink, Markdown, display
+
+        # First display the content of the markdown file
+        with open(self.path, "r", encoding="utf-8") as f:
+            content = f.read()
+            display(Markdown(content))
+
+        # Then provide a download link
+        display(FileLink(self.path))
+
+    def example(self):
+        markdown_content = """# Sample Markdown
+        
+## Features
+- **Bold text** demonstration
+- *Italic text* demonstration
+- Code block example:
+```python
+print("Hello, World!")
+```
+"""
+        with tempfile.NamedTemporaryFile(
+            delete=False, suffix=".md", mode="w", encoding="utf-8"
+        ) as f:
+            f.write(markdown_content)
+        return f.name

edsl/scenarios/handlers/pdf.py

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

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

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

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