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

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/scenarios/scenario_selector.py

@@ -1,156 +0,0 @@
-from typing import TYPE_CHECKING
-
-
-class ScenarioSelector:
-    """
-    A class for performing advanced field selection on ScenarioList objects,
-    including support for wildcard patterns.
-
-    Args:
-        scenario_list: The ScenarioList object to perform selections on
-
-    Examples:
-        >>> from edsl import Scenario, ScenarioList
-        >>> scenarios = ScenarioList([Scenario({'test_1': 1, 'test_2': 2, 'other': 3}), Scenario({'test_1': 4, 'test_2': 5, 'other': 6})])
-        >>> selector = ScenarioSelector(scenarios)
-        >>> selector.select('test*')
-        ScenarioList([Scenario({'test_1': 1, 'test_2': 2}), Scenario({'test_1': 4, 'test_2': 5})])
-    """
-
-    def __init__(self, scenario_list: "ScenarioList"):
-        """Initialize with a ScenarioList object."""
-        self.scenario_list = scenario_list
-        self.available_fields = (
-            list(scenario_list.data[0].keys()) if scenario_list.data else []
-        )
-
-    def _match_field_pattern(self, pattern: str, field: str) -> bool:
-        """
-        Checks if a field name matches a pattern with wildcards.
-        Supports '*' as wildcard at start or end of pattern.
-
-        Args:
-            pattern: The pattern to match against, may contain '*' at start or end
-            field: The field name to check
-
-        Examples:
-            >>> from edsl.scenarios import ScenarioList, Scenario
-            >>> selector = ScenarioSelector(ScenarioList([]))
-            >>> selector._match_field_pattern('test*', 'test_field')
-            True
-            >>> selector._match_field_pattern('*field', 'test_field')
-            True
-            >>> selector._match_field_pattern('test', 'test')
-            True
-            >>> selector._match_field_pattern('*test*', 'my_test_field')
-            True
-        """
-        if "*" not in pattern:
-            return pattern == field
-
-        if pattern.startswith("*") and pattern.endswith("*"):
-            return pattern[1:-1] in field
-        elif pattern.startswith("*"):
-            return field.endswith(pattern[1:])
-        elif pattern.endswith("*"):
-            return field.startswith(pattern[:-1])
-        return pattern == field
-
-    def _get_matching_fields(self, patterns: list[str]) -> list[str]:
-        """
-        Gets all fields that match any of the given patterns.
-
-        Args:
-            patterns: List of field patterns, may contain wildcards
-
-        Returns:
-            List of field names that match at least one pattern
-
-        Examples:
-            >>> from edsl import Scenario, ScenarioList
-            >>> scenarios = ScenarioList([
-            ...     Scenario({'test_1': 1, 'test_2': 2, 'other': 3})
-            ... ])
-            >>> selector = ScenarioSelector(scenarios)
-            >>> selector._get_matching_fields(['test*'])
-            ['test_1', 'test_2']
-        """
-        matching_fields = set()
-        for pattern in patterns:
-            matches = [
-                field
-                for field in self.available_fields
-                if self._match_field_pattern(pattern, field)
-            ]
-            matching_fields.update(matches)
-        return sorted(list(matching_fields))
-
-    def select(self, *fields) -> "ScenarioList":
-        """
-        Selects scenarios with only the referenced fields.
-        Supports wildcard patterns using '*' at the start or end of field names.
-
-        Args:
-            *fields: Field names or patterns to select. Patterns may include '*' for wildcards.
-
-        Returns:
-            A new ScenarioList containing only the matched fields.
-
-        Raises:
-            ValueError: If no fields match the given patterns.
-
-        Examples:
-            >>> from edsl import Scenario, ScenarioList
-            >>> scenarios = ScenarioList([
-            ...     Scenario({'test_1': 1, 'test_2': 2, 'other': 3}),
-            ...     Scenario({'test_1': 4, 'test_2': 5, 'other': 6})
-            ... ])
-            >>> selector = ScenarioSelector(scenarios)
-            >>> selector.select('test*')  # Selects all fields starting with 'test'
-            ScenarioList([Scenario({'test_1': 1, 'test_2': 2}), Scenario({'test_1': 4, 'test_2': 5})])
-            >>> selector.select('*_1')  # Selects all fields ending with '_1'
-            ScenarioList([Scenario({'test_1': 1}), Scenario({'test_1': 4})])
-            >>> selector.select('test_1', '*_2')  # Multiple patterns
-            ScenarioList([Scenario({'test_1': 1, 'test_2': 2}), Scenario({'test_1': 4, 'test_2': 5})])
-        """
-        if not self.scenario_list.data:
-            return self.scenario_list.__class__([])
-
-        # Convert single string to list for consistent processing
-        patterns = list(fields)
-
-        # Get all fields that match the patterns
-        fields_to_select = self._get_matching_fields(patterns)
-
-        # If no fields match, raise an informative error
-        if not fields_to_select:
-            raise ValueError(
-                f"No fields matched the given patterns: {patterns}. "
-                f"Available fields are: {self.available_fields}"
-            )
-
-        return self.scenario_list.__class__(
-            [scenario.select(fields_to_select) for scenario in self.scenario_list.data]
-        )
-
-    def get_available_fields(self) -> list[str]:
-        """
-        Returns a list of all available fields in the ScenarioList.
-
-        Returns:
-            List of field names available for selection.
-
-        Examples:
-            >>> from edsl import Scenario, ScenarioList
-            >>> scenarios = ScenarioList([Scenario({'test_1': 1, 'test_2': 2, 'other': 3})])
-            >>> selector = ScenarioSelector(scenarios)
-            >>> selector.get_available_fields()
-            ['other', 'test_1', 'test_2']
-        """
-        return sorted(self.available_fields)
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod(optionflags=doctest.ELLIPSIS)

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()

edsl/surveys/EditSurvey.py

@@ -1,221 +0,0 @@
-from typing import Union, Optional, TYPE_CHECKING
-from edsl.exceptions.surveys import SurveyError
-
-if TYPE_CHECKING:
-    from edsl.questions.QuestionBase import QuestionBase
-
-from edsl.exceptions.surveys import SurveyError, SurveyCreationError
-from edsl.surveys.Rule import Rule
-from edsl.surveys.base import RulePriority, EndOfSurvey
-
-
-class EditSurvey:
-    def __init__(self, survey):
-        self.survey = survey
-
-    def move_question(self, identifier: Union[str, int], new_index: int) -> "Survey":
-        if isinstance(identifier, str):
-            if identifier not in self.survey.question_names:
-                raise SurveyError(
-                    f"Question name '{identifier}' does not exist in the survey."
-                )
-            index = self.survey.question_name_to_index[identifier]
-        elif isinstance(identifier, int):
-            if identifier < 0 or identifier >= len(self.survey.questions):
-                raise SurveyError(f"Index {identifier} is out of range.")
-            index = identifier
-        else:
-            raise SurveyError(
-                "Identifier must be either a string (question name) or an integer (question index)."
-            )
-
-        moving_question = self.survey._questions[index]
-
-        new_survey = self.survey.delete_question(index)
-        new_survey.add_question(moving_question, new_index)
-        return new_survey
-
-    def add_question(
-        self, question: "QuestionBase", index: Optional[int] = None
-    ) -> "Survey":
-        if question.question_name in self.survey.question_names:
-            raise SurveyCreationError(
-                f"""Question name '{question.question_name}' already exists in survey. Existing names are {self.survey.question_names}."""
-            )
-        if index is None:
-            index = len(self.survey.questions)
-
-        if index > len(self.survey.questions):
-            raise SurveyCreationError(
-                f"Index {index} is greater than the number of questions in the survey."
-            )
-        if index < 0:
-            raise SurveyCreationError(f"Index {index} is less than 0.")
-
-        interior_insertion = index != len(self.survey.questions)
-
-        # index = len(self.survey.questions)
-        # TODO: This is a bit ugly because the user
-        # doesn't "know" about _questions - it's generated by the
-        # descriptor.
-        self.survey._questions.insert(index, question)
-
-        if interior_insertion:
-            for question_name, old_index in self.survey._pseudo_indices.items():
-                if old_index >= index:
-                    self.survey._pseudo_indices[question_name] = old_index + 1
-
-        self.survey._pseudo_indices[question.question_name] = index
-
-        ## Re-do question_name to index - this is done automatically
-        # for question_name, old_index in self.survey.question_name_to_index.items():
-        #     if old_index >= index:
-        #         self.survey.question_name_to_index[question_name] = old_index + 1
-
-        ## Need to re-do the rule collection and the indices of the questions
-
-        ## If a rule is before the insertion index and next_q is also before the insertion index, no change needed.
-        ## If the rule is before the insertion index but next_q is after the insertion index, increment the next_q by 1
-        ## If the rule is after the insertion index, increment the current_q by 1 and the next_q by 1
-
-        # using index + 1 presumes there is a next question
-        if interior_insertion:
-            for rule in self.survey.rule_collection:
-                if rule.current_q >= index:
-                    rule.current_q += 1
-                if rule.next_q >= index:
-                    rule.next_q += 1
-
-        # add a new rule
-        self.survey.rule_collection.add_rule(
-            Rule(
-                current_q=index,
-                expression="True",
-                next_q=index + 1,
-                question_name_to_index=self.survey.question_name_to_index,
-                priority=RulePriority.DEFAULT.value,
-            )
-        )
-
-        # a question might be added before the memory plan is created
-        # it's ok because the memory plan will be updated when it is created
-        if hasattr(self.survey, "memory_plan"):
-            self.survey.memory_plan.add_question(question)
-
-        return self.survey
-
-    def delete_question(self, identifier: Union[str, int]) -> "Survey":
-        """
-        Delete a question from the survey.
-
-        :param identifier: The name or index of the question to delete.
-        :return: The updated Survey object.
-
-        >>> from edsl import QuestionMultipleChoice, Survey
-        >>> q1 = QuestionMultipleChoice(question_text="Q1", question_options=["A", "B"], question_name="q1")
-        >>> q2 = QuestionMultipleChoice(question_text="Q2", question_options=["C", "D"], question_name="q2")
-        >>> s = Survey().add_question(q1).add_question(q2)
-        >>> _ = s.delete_question("q1")
-        >>> len(s.questions)
-        1
-        >>> _ = s.delete_question(0)
-        >>> len(s.questions)
-        0
-        """
-        if isinstance(identifier, str):
-            if identifier not in self.survey.question_names:
-                raise SurveyError(
-                    f"Question name '{identifier}' does not exist in the survey."
-                )
-            index = self.survey.question_name_to_index[identifier]
-        elif isinstance(identifier, int):
-            if identifier < 0 or identifier >= len(self.survey.questions):
-                raise SurveyError(f"Index {identifier} is out of range.")
-            index = identifier
-        else:
-            raise SurveyError(
-                "Identifier must be either a string (question name) or an integer (question index)."
-            )
-
-        # Remove the question
-        deleted_question = self.survey._questions.pop(index)
-        del self.survey._pseudo_indices[deleted_question.question_name]
-
-        # Update indices
-        for question_name, old_index in self.survey._pseudo_indices.items():
-            if old_index > index:
-                self.survey._pseudo_indices[question_name] = old_index - 1
-
-        # Update rules
-        from .RuleCollection import RuleCollection
-
-        new_rule_collection = RuleCollection()
-        for rule in self.survey.rule_collection:
-            if rule.current_q == index:
-                continue  # Remove rules associated with the deleted question
-            if rule.current_q > index:
-                rule.current_q -= 1
-            if rule.next_q > index:
-                rule.next_q -= 1
-
-            if rule.next_q == index:
-                if index == len(self.survey.questions):
-                    rule.next_q = EndOfSurvey
-                else:
-                    rule.next_q = index
-
-            new_rule_collection.add_rule(rule)
-        self.survey.rule_collection = new_rule_collection
-
-        # Update memory plan if it exists
-        if hasattr(self.survey, "memory_plan"):
-            self.survey.memory_plan.remove_question(deleted_question.question_name)
-
-        return self.survey
-
-    def add_instruction(
-        self, instruction: Union["Instruction", "ChangeInstruction"]
-    ) -> "Survey":
-        """
-        Add an instruction to the survey.
-
-        :param instruction: The instruction to add to the survey.
-
-        >>> from edsl import Instruction
-        >>> from edsl.surveys.Survey import Survey
-        >>> i = Instruction(text="Pay attention to the following questions.", name="intro")
-        >>> s = Survey().add_instruction(i)
-        >>> s._instruction_names_to_instructions
-        {'intro': Instruction(name="intro", text="Pay attention to the following questions.")}
-        >>> s._pseudo_indices
-        {'intro': -0.5}
-        """
-        import math
-
-        if instruction.name in self.survey._instruction_names_to_instructions:
-            raise SurveyCreationError(
-                f"""Instruction name '{instruction.name}' already exists in survey. Existing names are {self.survey._instruction_names_to_instructions.keys()}."""
-            )
-        self.survey._instruction_names_to_instructions[instruction.name] = instruction
-
-        # was the last thing added an instruction or a question?
-        if self.survey._pseudo_indices.last_item_was_instruction:
-            pseudo_index = (
-                self.survey._pseudo_indices.max_pseudo_index
-                + (
-                    math.ceil(self.survey._pseudo_indices.max_pseudo_index)
-                    - self.survey._pseudo_indices.max_pseudo_index
-                )
-                / 2
-            )
-        else:
-            pseudo_index = self.survey._pseudo_indices.max_pseudo_index + 1.0 / 2.0
-        self.survey._pseudo_indices[instruction.name] = pseudo_index
-
-        return self.survey
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod()