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

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

edsl/scenarios/handlers/sqlite.py

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

@@ -0,0 +1,33 @@
+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/study/ObjectEntry.py

@@ -1,7 +1,7 @@
 import time
 import webbrowser
 from typing import Any, Dict, Optional, Type
-from edsl import QuestionBase
+from edsl.questions.QuestionBase import QuestionBase
 from edsl.Base import RegisterSubclassesMeta
 
 

edsl/study/SnapShot.py

@@ -32,7 +32,7 @@ class SnapShot:
         {'Cache': <class 'edsl.data.Cache.Cache'>}
         """
         from edsl.Base import RegisterSubclassesMeta
-        from edsl import QuestionBase
+        from edsl.questions.QuestionBase import QuestionBase
 
         all_edsl_objects = RegisterSubclassesMeta.get_registry()
 

edsl/study/Study.py

@@ -7,7 +7,9 @@ import socket
 from datetime import datetime
 from typing import Dict, Optional, Union
 from uuid import UUID, uuid4
-from edsl import Cache, set_session_cache, unset_session_cache
+
+from edsl.data.Cache import Cache
+from edsl import set_session_cache, unset_session_cache
 from edsl.utilities.utilities import dict_hash
 from edsl.study.ObjectEntry import ObjectEntry
 from edsl.study.ProofOfWork import ProofOfWork
@@ -405,7 +407,7 @@ class Study:
 
         study_file = tempfile.NamedTemporaryFile()
         with cls(filename=study_file.name, verbose=verbose) as study:
-            from edsl import QuestionFreeText
+            from edsl.questions.QuestionFreeText import QuestionFreeText
 
             q = QuestionFreeText.example(randomize=randomize)
         return study
@@ -464,7 +466,7 @@ class Study:
     def push(self) -> dict:
         """Push the objects to coop."""
 
-        from edsl import Coop
+        from edsl.coop.coop import Coop
 
         coop = Coop()
         return coop.create(self, description=self.description)
@@ -517,12 +519,3 @@ if __name__ == "__main__":
     import doctest
 
     doctest.testmod(optionflags=doctest.ELLIPSIS)
-
-    # with Study(name = "cool_study") as study:
-    #      from edsl import QuestionFreeText
-    #      q = QuestionFreeText.example()
-
-    # assert len(study.objects) == 1
-
-    # print(study.versions())
-    # {'q': [ObjectEntry(variable_name='q', object=Question('free_text', question_name = """how_are_you""", question_text = """How are you?"""), description='Question name: how_are_you', coop_info=None, created_at=1720276402.561273, edsl_class_name='QuestionFreeText')]}

edsl/surveys/ConstructDAG.py

@@ -0,0 +1,92 @@
+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()