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

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

edsl/scenarios/handlers/sql.py

@@ -0,0 +1,313 @@
+from edsl.scenarios.file_methods import FileMethods
+import tempfile
+import re
+from typing import List, Optional
+import textwrap
+
+
+class SqlMethods(FileMethods):
+    suffix = "sql"
+
+    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 SQL file: {e}")
+        else:
+            print("SQL file was not found.")
+
+    def view_notebook(self):
+        from IPython.display import FileLink, display, HTML
+        import pygments
+        from pygments.lexers import SqlLexer
+        from pygments.formatters import HtmlFormatter
+
+        try:
+            with open(self.path, "r", encoding="utf-8") as f:
+                content = f.read()
+
+            formatter = HtmlFormatter(style="monokai")
+            highlighted_sql = pygments.highlight(content, SqlLexer(), formatter)
+            css = formatter.get_style_defs(".highlight")
+            display(HTML(f"<style>{css}</style>{highlighted_sql}"))
+            display(FileLink(self.path))
+        except Exception as e:
+            print(f"Error displaying SQL: {e}")
+
+    def _format_keywords(self, sql: str) -> str:
+        """Capitalize SQL keywords."""
+        keywords = {
+            "select",
+            "from",
+            "where",
+            "and",
+            "or",
+            "insert",
+            "update",
+            "delete",
+            "create",
+            "drop",
+            "alter",
+            "table",
+            "into",
+            "values",
+            "group",
+            "by",
+            "having",
+            "order",
+            "limit",
+            "join",
+            "left",
+            "right",
+            "inner",
+            "outer",
+            "on",
+            "as",
+            "distinct",
+            "count",
+            "sum",
+            "avg",
+            "max",
+            "min",
+            "between",
+            "like",
+            "in",
+            "is",
+            "null",
+            "not",
+            "case",
+            "when",
+            "then",
+            "else",
+            "end",
+        }
+
+        words = sql.split()
+        formatted_words = []
+        for word in words:
+            lower_word = word.lower()
+            if lower_word in keywords:
+                formatted_words.append(word.upper())
+            else:
+                formatted_words.append(word.lower())
+        return " ".join(formatted_words)
+
+    def _indent_sql(self, sql: str) -> str:
+        """Add basic indentation to SQL statement."""
+        lines = sql.split("\n")
+        indented_lines = []
+        indent_level = 0
+
+        for line in lines:
+            line = line.strip()
+
+            # Decrease indent for closing parentheses
+            if line.startswith(")"):
+                indent_level = max(0, indent_level - 1)
+
+            # Add indentation
+            if line:
+                indented_lines.append("    " * indent_level + line)
+            else:
+                indented_lines.append("")
+
+            # Increase indent after opening parentheses
+            if line.endswith("("):
+                indent_level += 1
+
+            # Special cases for common SQL clauses
+            lower_line = line.lower()
+            if any(
+                clause in lower_line
+                for clause in [
+                    "select",
+                    "from",
+                    "where",
+                    "group by",
+                    "having",
+                    "order by",
+                ]
+            ):
+                indent_level = 1
+
+        return "\n".join(indented_lines)
+
+    def format_sql(self) -> bool:
+        """Format the SQL file with proper indentation and keyword capitalization."""
+        try:
+            with open(self.path, "r", encoding="utf-8") as f:
+                content = f.read()
+
+            # Remove extra whitespace and format
+            content = " ".join(content.split())
+            content = self._format_keywords(content)
+            content = self._indent_sql(content)
+
+            # Wrap long lines
+            wrapped_content = []
+            for line in content.split("\n"):
+                if len(line) > 80:
+                    wrapped_line = textwrap.fill(
+                        line, width=80, subsequent_indent="    "
+                    )
+                    wrapped_content.append(wrapped_line)
+                else:
+                    wrapped_content.append(line)
+
+            formatted_sql = "\n".join(wrapped_content)
+
+            with open(self.path, "w", encoding="utf-8") as f:
+                f.write(formatted_sql)
+
+            return True
+        except Exception as e:
+            print(f"Error formatting SQL: {e}")
+            return False
+
+    def split_statements(self) -> List[str]:
+        """Split the SQL file into individual statements."""
+        try:
+            with open(self.path, "r", encoding="utf-8") as f:
+                content = f.read()
+
+            # Handle both semicolon and GO statement terminators
+            statements = []
+            current_stmt = []
+
+            for line in content.split("\n"):
+                line = line.strip()
+
+                # Skip empty lines and comments
+                if not line or line.startswith("--"):
+                    continue
+
+                if line.endswith(";"):
+                    current_stmt.append(line[:-1])  # Remove semicolon
+                    statements.append(" ".join(current_stmt))
+                    current_stmt = []
+                elif line.upper() == "GO":
+                    if current_stmt:
+                        statements.append(" ".join(current_stmt))
+                        current_stmt = []
+                else:
+                    current_stmt.append(line)
+
+            # Add any remaining statement
+            if current_stmt:
+                statements.append(" ".join(current_stmt))
+
+            return [stmt.strip() for stmt in statements if stmt.strip()]
+        except Exception as e:
+            print(f"Error splitting SQL statements: {e}")
+            return []
+
+    def validate_basic_syntax(self) -> bool:
+        """
+        Perform basic SQL syntax validation.
+        This is a simple check and doesn't replace proper SQL parsing.
+        """
+        try:
+            with open(self.path, "r", encoding="utf-8") as f:
+                content = f.read()
+
+            statements = self.split_statements()
+            for stmt in statements:
+                # Check for basic SQL keywords
+                stmt_upper = stmt.upper()
+                if not any(
+                    keyword in stmt_upper
+                    for keyword in [
+                        "SELECT",
+                        "INSERT",
+                        "UPDATE",
+                        "DELETE",
+                        "CREATE",
+                        "DROP",
+                        "ALTER",
+                    ]
+                ):
+                    print(f"Warning: Statement might be incomplete: {stmt}")
+
+                # Check for basic parentheses matching
+                if stmt.count("(") != stmt.count(")"):
+                    print(f"Error: Unmatched parentheses in statement: {stmt}")
+                    return False
+
+                # Check for basic quote matching
+                if stmt.count("'") % 2 != 0:
+                    print(f"Error: Unmatched quotes in statement: {stmt}")
+                    return False
+
+            return True
+        except Exception as e:
+            print(f"Error validating SQL: {e}")
+            return False
+
+    def extract_table_names(self) -> List[str]:
+        """Extract table names from the SQL file."""
+        tables = set()
+        try:
+            with open(self.path, "r", encoding="utf-8") as f:
+                content = f.read()
+
+            patterns = [
+                r"FROM\s+([a-zA-Z_][a-zA-Z0-9_]*)",
+                r"JOIN\s+([a-zA-Z_][a-zA-Z0-9_]*)",
+                r"UPDATE\s+([a-zA-Z_][a-zA-Z0-9_]*)",
+                r"INSERT\s+INTO\s+([a-zA-Z_][a-zA-Z0-9_]*)",
+                r"CREATE\s+TABLE\s+([a-zA-Z_][a-zA-Z0-9_]*)",
+            ]
+
+            for pattern in patterns:
+                tables.update(re.findall(pattern, content, re.IGNORECASE))
+
+            return sorted(list(tables))
+        except Exception as e:
+            print(f"Error extracting table names: {e}")
+            return []
+
+    def example(self):
+        sample_sql = """-- Sample SQL file with common operations
+CREATE TABLE employees (
+    id INTEGER PRIMARY KEY,
+    name VARCHAR(100) NOT NULL,
+    department VARCHAR(50),
+    salary DECIMAL(10,2),
+    hire_date DATE
+);
+
+INSERT INTO employees (name, department, salary, hire_date)
+VALUES 
+    ('John Doe', 'Engineering', 75000.00, '2023-01-15'),
+    ('Jane Smith', 'Marketing', 65000.00, '2023-02-01');
+
+-- Query to analyze employee data
+SELECT 
+    department,
+    COUNT(*) as employee_count,
+    AVG(salary) as avg_salary
+FROM employees
+GROUP BY department
+HAVING COUNT(*) > 0
+ORDER BY avg_salary DESC;
+
+-- Update salary with conditions
+UPDATE employees
+SET salary = salary * 1.1
+WHERE department = 'Engineering'
+    AND hire_date < '2024-01-01';
+"""
+        with tempfile.NamedTemporaryFile(
+            delete=False, suffix=".sql", mode="w", encoding="utf-8"
+        ) as f:
+            f.write(sample_sql)
+        return f.name