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

edsl/study/__init__.py

@@ -1,4 +1,4 @@
-from edsl.study.ObjectEntry import ObjectEntry
-from edsl.study.ProofOfWork import ProofOfWork
-from edsl.study.SnapShot import SnapShot
-from edsl.study.Study import Study
+from edsl.study.ObjectEntry import ObjectEntry
+from edsl.study.ProofOfWork import ProofOfWork
+from edsl.study.SnapShot import SnapShot
+from edsl.study.Study import Study

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

edsl/surveys/DAG.py

@@ -1,148 +1,148 @@
-"""Directed Acyclic Graph (DAG) class."""
-
-from collections import UserDict
-from graphlib import TopologicalSorter
-
-
-class DAG(UserDict):
-    """Class for creating a Directed Acyclic Graph (DAG) from a dictionary."""
-
-    def __init__(self, data: dict):
-        """Initialize the DAG class."""
-        super().__init__(data)
-        self.reverse_mapping = self._create_reverse_mapping()
-        self.validate_no_cycles()
-
-    def _create_reverse_mapping(self):
-        """
-        Create a reverse mapping of the DAG, where the keys are the children and the values are the parents.
-
-        Example usage:
-
-        .. code-block:: python
-
-            data = {"a": ["b", "c"], "b": ["d"], "c": [], "d": []}
-            dag = DAG(data)
-            dag._create_reverse_mapping()
-            {'b': {'a'}, 'c': {'a'}, 'd': {'b'}}
-
-        """
-        rev_map = {}
-        for key, values in self.items():
-            for value in values:
-                rev_map.setdefault(value, set()).add(key)
-        return rev_map
-
-    def get_all_children(self, key):
-        """Get all children of a node in the DAG."""
-        children = set()
-
-        def dfs(node):
-            for child in self.reverse_mapping.get(node, []):
-                if child not in children:
-                    children.add(child)
-                    dfs(child)
-
-        dfs(key)
-        return children
-
-    def topologically_sorted_nodes(self):
-        """
-        Return a sequence of the DAG.
-
-        Example usage:
-
-        .. code-block:: python
-
-            data = {"a": ["b", "c"], "b": ["d"], "c": [], "d": []}
-            dag = DAG(data)
-            dag.topologically_sorted_nodes() == ['c', 'd', 'b', 'a']
-            True
-
-        """
-        return list(TopologicalSorter(self).static_order())
-
-    def __add__(self, other_dag):
-        """Combine two DAGs."""
-        d = {}
-        combined_keys = set(self.keys()).union(set(other_dag.keys()))
-        for key in combined_keys:
-            d[key] = self.get(key, set({})).union(other_dag.get(key, set({})))
-        return DAG(d)
-        # if textify:
-        #     return DAG(self.textify(d))
-        # else:
-        #     return DAG(d)
-
-    def remove_node(self, node: int) -> None:
-        """Remove a node and all its connections from the DAG."""
-        self.pop(node, None)
-        for connections in self.values():
-            connections.discard(node)
-        # Adjust remaining nodes if necessary
-        self._adjust_nodes_after_removal(node)
-
-    def _adjust_nodes_after_removal(self, removed_node: int) -> None:
-        """Adjust node indices after a node is removed."""
-        new_dag = {}
-        for node, connections in self.items():
-            new_node = node if node < removed_node else node - 1
-            new_connections = {c if c < removed_node else c - 1 for c in connections}
-            new_dag[new_node] = new_connections
-        self.clear()
-        self.update(new_dag)
-
-    @classmethod
-    def example(cls):
-        """Return an example of the `DAG`."""
-        data = {"a": ["b", "c"], "b": ["d"], "c": [], "d": []}
-        return cls(data)
-
-    def detect_cycles(self):
-        """
-        Detect cycles in the DAG using depth-first search.
-
-        :return: A list of cycles if any are found, otherwise an empty list.
-        """
-        visited = set()
-        path = []
-        cycles = []
-
-        def dfs(node):
-            if node in path:
-                cycle = path[path.index(node) :]
-                cycles.append(cycle + [node])
-                return
-
-            if node in visited:
-                return
-
-            visited.add(node)
-            path.append(node)
-
-            for child in self.get(node, []):
-                dfs(child)
-
-            path.pop()
-
-        for node in self:
-            if node not in visited:
-                dfs(node)
-
-        return cycles
-
-    def validate_no_cycles(self):
-        """
-        Validate that the DAG does not contain any cycles.
-
-        :raises ValueError: If cycles are detected in the DAG.
-        """
-        cycles = self.detect_cycles()
-        if cycles:
-            raise ValueError(f"Cycles detected in the DAG: {cycles}")
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod()
+"""Directed Acyclic Graph (DAG) class."""
+
+from collections import UserDict
+from graphlib import TopologicalSorter
+
+
+class DAG(UserDict):
+    """Class for creating a Directed Acyclic Graph (DAG) from a dictionary."""
+
+    def __init__(self, data: dict):
+        """Initialize the DAG class."""
+        super().__init__(data)
+        self.reverse_mapping = self._create_reverse_mapping()
+        self.validate_no_cycles()
+
+    def _create_reverse_mapping(self):
+        """
+        Create a reverse mapping of the DAG, where the keys are the children and the values are the parents.
+
+        Example usage:
+
+        .. code-block:: python
+
+            data = {"a": ["b", "c"], "b": ["d"], "c": [], "d": []}
+            dag = DAG(data)
+            dag._create_reverse_mapping()
+            {'b': {'a'}, 'c': {'a'}, 'd': {'b'}}
+
+        """
+        rev_map = {}
+        for key, values in self.items():
+            for value in values:
+                rev_map.setdefault(value, set()).add(key)
+        return rev_map
+
+    def get_all_children(self, key):
+        """Get all children of a node in the DAG."""
+        children = set()
+
+        def dfs(node):
+            for child in self.reverse_mapping.get(node, []):
+                if child not in children:
+                    children.add(child)
+                    dfs(child)
+
+        dfs(key)
+        return children
+
+    def topologically_sorted_nodes(self):
+        """
+        Return a sequence of the DAG.
+
+        Example usage:
+
+        .. code-block:: python
+
+            data = {"a": ["b", "c"], "b": ["d"], "c": [], "d": []}
+            dag = DAG(data)
+            dag.topologically_sorted_nodes() == ['c', 'd', 'b', 'a']
+            True
+
+        """
+        return list(TopologicalSorter(self).static_order())
+
+    def __add__(self, other_dag):
+        """Combine two DAGs."""
+        d = {}
+        combined_keys = set(self.keys()).union(set(other_dag.keys()))
+        for key in combined_keys:
+            d[key] = self.get(key, set({})).union(other_dag.get(key, set({})))
+        return DAG(d)
+        # if textify:
+        #     return DAG(self.textify(d))
+        # else:
+        #     return DAG(d)
+
+    def remove_node(self, node: int) -> None:
+        """Remove a node and all its connections from the DAG."""
+        self.pop(node, None)
+        for connections in self.values():
+            connections.discard(node)
+        # Adjust remaining nodes if necessary
+        self._adjust_nodes_after_removal(node)
+
+    def _adjust_nodes_after_removal(self, removed_node: int) -> None:
+        """Adjust node indices after a node is removed."""
+        new_dag = {}
+        for node, connections in self.items():
+            new_node = node if node < removed_node else node - 1
+            new_connections = {c if c < removed_node else c - 1 for c in connections}
+            new_dag[new_node] = new_connections
+        self.clear()
+        self.update(new_dag)
+
+    @classmethod
+    def example(cls):
+        """Return an example of the `DAG`."""
+        data = {"a": ["b", "c"], "b": ["d"], "c": [], "d": []}
+        return cls(data)
+
+    def detect_cycles(self):
+        """
+        Detect cycles in the DAG using depth-first search.
+
+        :return: A list of cycles if any are found, otherwise an empty list.
+        """
+        visited = set()
+        path = []
+        cycles = []
+
+        def dfs(node):
+            if node in path:
+                cycle = path[path.index(node) :]
+                cycles.append(cycle + [node])
+                return
+
+            if node in visited:
+                return
+
+            visited.add(node)
+            path.append(node)
+
+            for child in self.get(node, []):
+                dfs(child)
+
+            path.pop()
+
+        for node in self:
+            if node not in visited:
+                dfs(node)
+
+        return cycles
+
+    def validate_no_cycles(self):
+        """
+        Validate that the DAG does not contain any cycles.
+
+        :raises ValueError: If cycles are detected in the DAG.
+        """
+        cycles = self.detect_cycles()
+        if cycles:
+            raise ValueError(f"Cycles detected in the DAG: {cycles}")
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

edsl/surveys/EditSurvey.py

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