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

edsl/scenarios/handlers/sql.py

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

edsl/scenarios/handlers/sqlite.py

@@ -1,149 +0,0 @@
-from edsl.scenarios.file_methods import FileMethods
-import os
-import tempfile
-import sqlite3
-
-
-class SQLiteMethods(FileMethods):
-    suffix = "db"  # or "sqlite", depending on your preference
-
-    def extract_text(self):
-        """
-        Extracts a text representation of the database schema and table contents.
-        """
-        with sqlite3.connect(self.path) as conn:
-            cursor = conn.cursor()
-
-            # Get all table names
-            cursor.execute("SELECT name FROM sqlite_master WHERE type='table';")
-            tables = cursor.fetchall()
-
-            full_text = []
-
-            # For each table, get schema and contents
-            for (table_name,) in tables:
-                # Get table schema
-                cursor.execute(
-                    f"SELECT sql FROM sqlite_master WHERE type='table' AND name='{table_name}';"
-                )
-                schema = cursor.fetchone()[0]
-                full_text.append(f"Table: {table_name}")
-                full_text.append(f"Schema: {schema}")
-
-                # Get table contents
-                cursor.execute(f"SELECT * FROM {table_name};")
-                rows = cursor.fetchall()
-
-                # Get column names
-                column_names = [description[0] for description in cursor.description]
-                full_text.append(f"Columns: {', '.join(column_names)}")
-
-                # Add row data
-                for row in rows:
-                    full_text.append(str(row))
-                full_text.append("\n")
-
-        return "\n".join(full_text)
-
-    def view_system(self):
-        """
-        Opens the database with the system's default SQLite viewer if available.
-        """
-        import os
-        import subprocess
-
-        if os.path.exists(self.path):
-            try:
-                if (os_name := os.name) == "posix":
-                    # Try DB Browser for SQLite on macOS
-                    subprocess.run(
-                        ["open", "-a", "DB Browser for SQLite", self.path], check=True
-                    )
-                elif os_name == "nt":
-                    # Try DB Browser for SQLite on Windows
-                    subprocess.run(["DB Browser for SQLite.exe", self.path], check=True)
-                else:
-                    # Try sqlitebrowser on Linux
-                    subprocess.run(["sqlitebrowser", self.path], check=True)
-            except Exception as e:
-                print(f"Error opening SQLite database: {e}")
-        else:
-            print("SQLite database file was not found.")
-
-    def view_notebook(self):
-        """
-        Displays database contents in a Jupyter notebook.
-        """
-        import pandas as pd
-        from IPython.display import HTML, display
-
-        with sqlite3.connect(self.path) as conn:
-            # Get all table names
-            cursor = conn.cursor()
-            cursor.execute("SELECT name FROM sqlite_master WHERE type='table';")
-            tables = cursor.fetchall()
-
-            html_parts = []
-            for (table_name,) in tables:
-                # Read table into pandas DataFrame
-                df = pd.read_sql_query(f"SELECT * FROM {table_name}", conn)
-
-                # Convert to HTML with styling
-                table_html = f"""
-                <div style="margin-bottom: 20px;">
-                    <h3>{table_name}</h3>
-                    {df.to_html(index=False)}
-                </div>
-                """
-                html_parts.append(table_html)
-
-            # Combine all tables into one scrollable div
-            html = f"""
-            <div style="width: 800px; height: 800px; padding: 20px; 
-                       border: 1px solid #ccc; overflow-y: auto;">
-                {''.join(html_parts)}
-            </div>
-            """
-            display(HTML(html))
-
-    def example(self):
-        """
-        Creates an example SQLite database for testing.
-        """
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".db") as tmp:
-            conn = sqlite3.connect(tmp.name)
-            cursor = conn.cursor()
-
-            # Create a sample table
-            cursor.execute(
-                """
-                CREATE TABLE survey_responses (
-                    id INTEGER PRIMARY KEY,
-                    question TEXT,
-                    response TEXT
-                )
-            """
-            )
-
-            # Insert some sample data
-            sample_data = [
-                (1, "First Survey Question", "Response 1"),
-                (2, "Second Survey Question", "Response 2"),
-            ]
-            cursor.executemany(
-                "INSERT INTO survey_responses (id, question, response) VALUES (?, ?, ?)",
-                sample_data,
-            )
-
-            conn.commit()
-            conn.close()
-            tmp.close()
-
-            return tmp.name
-
-
-if __name__ == "__main__":
-    sqlite_temp = SQLiteMethods.example()
-    from edsl.scenarios.FileStore import FileStore
-
-    fs = FileStore(sqlite_temp)

edsl/scenarios/handlers/txt.py

@@ -1,33 +0,0 @@
-from edsl.scenarios.file_methods import FileMethods
-import tempfile
-
-
-class TxtMethods(FileMethods):
-    suffix = "txt"
-
-    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 TXT: {e}")
-        else:
-            print("TXT file was not found.")
-
-    def view_notebook(self):
-        from IPython.display import FileLink, display
-
-        display(FileLink(self.path))
-
-    def example(self):
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".txt") as f:
-            f.write(b"Hello, World!")
-        return f.name

edsl/surveys/ConstructDAG.py

@@ -1,92 +0,0 @@
-from edsl.surveys.base import EndOfSurvey
-from edsl.surveys.DAG import DAG
-from edsl.exceptions.surveys import SurveyError
-
-
-class ConstructDAG:
-    def __init__(self, survey):
-        self.survey = survey
-        self.questions = survey.questions
-
-        self.parameters_by_question = self.survey.parameters_by_question
-        self.question_name_to_index = self.survey.question_name_to_index
-
-    def dag(self, textify: bool = False) -> DAG:
-        memory_dag = self.survey.memory_plan.dag
-        rule_dag = self.survey.rule_collection.dag
-        piping_dag = self.piping_dag
-        if textify:
-            memory_dag = DAG(self.textify(memory_dag))
-            rule_dag = DAG(self.textify(rule_dag))
-            piping_dag = DAG(self.textify(piping_dag))
-        return memory_dag + rule_dag + piping_dag
-
-    @property
-    def piping_dag(self) -> DAG:
-        """Figures out the DAG of piping dependencies.
-
-        >>> from edsl import Survey
-        >>> from edsl import QuestionFreeText
-        >>> q0 = QuestionFreeText(question_text="Here is a question", question_name="q0")
-        >>> q1 = QuestionFreeText(question_text="You previously answered {{ q0 }}---how do you feel now?", question_name="q1")
-        >>> s = Survey([q0, q1])
-        >>> ConstructDAG(s).piping_dag
-        {1: {0}}
-        """
-        d = {}
-        for question_name, depenencies in self.parameters_by_question.items():
-            if depenencies:
-                question_index = self.question_name_to_index[question_name]
-                for dependency in depenencies:
-                    if dependency not in self.question_name_to_index:
-                        pass
-                    else:
-                        dependency_index = self.question_name_to_index[dependency]
-                        if question_index not in d:
-                            d[question_index] = set()
-                        d[question_index].add(dependency_index)
-        return d
-
-    def textify(self, index_dag: DAG) -> DAG:
-        """Convert the DAG of question indices to a DAG of question names.
-
-        :param index_dag: The DAG of question indices.
-
-        Example:
-
-        >>> from edsl import Survey
-        >>> s = Survey.example()
-        >>> d = s.dag()
-        >>> d
-        {1: {0}, 2: {0}}
-        >>> ConstructDAG(s).textify(d)
-        {'q1': {'q0'}, 'q2': {'q0'}}
-        """
-
-        def get_name(index: int):
-            """Return the name of the question given the index."""
-            if index >= len(self.questions):
-                return EndOfSurvey
-            try:
-                return self.questions[index].question_name
-            except IndexError:
-                print(
-                    f"The index is {index} but the length of the questions is {len(self.questions)}"
-                )
-                raise SurveyError
-
-        try:
-            text_dag = {}
-            for child_index, parent_indices in index_dag.items():
-                parent_names = {get_name(index) for index in parent_indices}
-                child_name = get_name(child_index)
-                text_dag[child_name] = parent_names
-            return text_dag
-        except IndexError:
-            raise
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod()