edsl 0.1.38.dev4__py3-none-any.whl → 0.1.39__py3-none-any.whl

edsl/surveys/Survey.py

@@ -2,43 +2,93 @@
 
 from __future__ import annotations
 import re
-import tempfile
-import requests
-
-from typing import Any, Generator, Optional, Union, List, Literal, Callable
+import random
+
+from typing import (
+    Any,
+    Generator,
+    Optional,
+    Union,
+    List,
+    Literal,
+    Callable,
+    TYPE_CHECKING,
+)
 from uuid import uuid4
 from edsl.Base import Base
-from edsl.exceptions import SurveyCreationError, SurveyHasNoRulesError
+from edsl.exceptions.surveys import SurveyCreationError, SurveyHasNoRulesError
 from edsl.exceptions.surveys import SurveyError
+from collections import UserDict
 
-from edsl.questions.QuestionBase import QuestionBase
-from edsl.surveys.base import RulePriority, EndOfSurvey
-from edsl.surveys.DAG import DAG
-from edsl.surveys.descriptors import QuestionsDescriptor
-from edsl.surveys.MemoryPlan import MemoryPlan
-from edsl.surveys.Rule import Rule
-from edsl.surveys.RuleCollection import RuleCollection
-from edsl.surveys.SurveyExportMixin import SurveyExportMixin
-from edsl.surveys.SurveyFlowVisualizationMixin import SurveyFlowVisualizationMixin
-from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
 
-from edsl.agents.Agent import Agent
+class PseudoIndices(UserDict):
+    @property
+    def max_pseudo_index(self) -> float:
+        """Return the maximum pseudo index in the survey.
+        >>> Survey.example()._pseudo_indices.max_pseudo_index
+        2
+        """
+        if len(self) == 0:
+            return -1
+        return max(self.values())
+
+    @property
+    def last_item_was_instruction(self) -> bool:
+        """Return whether the last item added to the survey was an instruction.
+
+        This is used to determine the pseudo-index of the next item added to the survey.
+
+        Example:
+
+        >>> s = Survey.example()
+        >>> s._pseudo_indices.last_item_was_instruction
+        False
+        >>> from edsl.surveys.instructions.Instruction import Instruction
+        >>> s = s.add_instruction(Instruction(text="Pay attention to the following questions.", name="intro"))
+        >>> s._pseudo_indices.last_item_was_instruction
+        True
+        """
+        return isinstance(self.max_pseudo_index, float)
+
+
+if TYPE_CHECKING:
+    from edsl.questions.QuestionBase import QuestionBase
+    from edsl.agents.Agent import Agent
+    from edsl.surveys.DAG import DAG
+    from edsl.language_models.LanguageModel import LanguageModel
+    from edsl.scenarios.Scenario import Scenario
+    from edsl.data.Cache import Cache
+
+    # This is a hack to get around the fact that TypeAlias is not available in typing until Python 3.10
+    try:
+        from typing import TypeAlias
+    except ImportError:
+        from typing import _GenericAlias as TypeAlias
+
+    QuestionType: TypeAlias = Union[QuestionBase, Instruction, ChangeInstruction]
+    QuestionGroupType: TypeAlias = dict[str, tuple[int, int]]
+
+
+from edsl.utilities.remove_edsl_version import remove_edsl_version
 
 from edsl.surveys.instructions.InstructionCollection import InstructionCollection
 from edsl.surveys.instructions.Instruction import Instruction
 from edsl.surveys.instructions.ChangeInstruction import ChangeInstruction
 
-
-class ValidatedString(str):
-    def __new__(cls, content):
-        if "<>" in content:
-            raise SurveyCreationError(
-                "The expression contains '<>', which is not allowed. You probably mean '!='."
-            )
-        return super().__new__(cls, content)
+from edsl.surveys.base import EndOfSurvey
+from edsl.surveys.descriptors import QuestionsDescriptor
+from edsl.surveys.MemoryPlan import MemoryPlan
+from edsl.surveys.RuleCollection import RuleCollection
+from edsl.surveys.SurveyExportMixin import SurveyExportMixin
+from edsl.surveys.SurveyFlowVisualization import SurveyFlowVisualization
+from edsl.surveys.InstructionHandler import InstructionHandler
+from edsl.surveys.EditSurvey import EditSurvey
+from edsl.surveys.Simulator import Simulator
+from edsl.surveys.MemoryManagement import MemoryManagement
+from edsl.surveys.RuleManager import RuleManager
 
 
-class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
+class Survey(SurveyExportMixin, Base):
     """A collection of questions that supports skip logic."""
 
     __documentation__ = """https://docs.expectedparrot.com/en/latest/surveys.html"""
@@ -61,13 +111,12 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
 
     def __init__(
         self,
-        questions: Optional[
-            list[Union[QuestionBase, Instruction, ChangeInstruction]]
-        ] = None,
-        memory_plan: Optional[MemoryPlan] = None,
-        rule_collection: Optional[RuleCollection] = None,
-        question_groups: Optional[dict[str, tuple[int, int]]] = None,
+        questions: Optional[List["QuestionType"]] = None,
+        memory_plan: Optional["MemoryPlan"] = None,
+        rule_collection: Optional["RuleCollection"] = None,
+        question_groups: Optional["QuestionGroupType"] = None,
         name: Optional[str] = None,
+        questions_to_randomize: Optional[List[str]] = None,
     ):
         """Create a new survey.
 
@@ -89,11 +138,7 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
 
         self.raw_passed_questions = questions
 
-        (
-            true_questions,
-            instruction_names_to_instructions,
-            self.pseudo_indices,
-        ) = self._separate_questions_and_instructions(questions or [])
+        true_questions = self._process_raw_questions(self.raw_passed_questions)
 
         self.rule_collection = RuleCollection(
             num_questions=len(true_questions) if true_questions else None
@@ -101,8 +146,9 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
         # the RuleCollection needs to be present while we add the questions; we might override this later
         # if a rule_collection is provided. This allows us to serialize the survey with the rule_collection.
 
+        # this is where the Questions constructor is called.
         self.questions = true_questions
-        self.instruction_names_to_instructions = instruction_names_to_instructions
+        # self.instruction_names_to_instructions = instruction_names_to_instructions
 
         self.memory_plan = memory_plan or MemoryPlan(self)
         if question_groups is not None:
@@ -110,7 +156,7 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
         else:
             self.question_groups = {}
 
-        # if a rule collection is provided, use it instead
+        # if a rule collection is provided, use it instead of the constructed one
         if rule_collection is not None:
             self.rule_collection = rule_collection
 
@@ -119,97 +165,58 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
 
             warnings.warn("name parameter to a survey is deprecated.")
 
-    # region: Suvry instruction handling
+        if questions_to_randomize is not None:
+            self.questions_to_randomize = questions_to_randomize
+        else:
+            self.questions_to_randomize = []
+
+        self._seed = None
+
+    def draw(self) -> "Survey":
+        """Return a new survey with a randomly selected permutation of the options."""
+        if self._seed is None:  # only set once
+            self._seed = hash(self)
+            random.seed(self._seed)
+
+        if len(self.questions_to_randomize) == 0:
+            return self
+
+        new_questions = []
+        for question in self.questions:
+            if question.question_name in self.questions_to_randomize:
+                new_questions.append(question.draw())
+            else:
+                new_questions.append(question.duplicate())
+
+        d = self.to_dict()
+        d["questions"] = [q.to_dict() for q in new_questions]
+        return Survey.from_dict(d)
+
+    def _process_raw_questions(self, questions: Optional[List["QuestionType"]]) -> list:
+        """Process the raw questions passed to the survey."""
+        handler = InstructionHandler(self)
+        components = handler.separate_questions_and_instructions(questions or [])
+        self._instruction_names_to_instructions = (
+            components.instruction_names_to_instructions
+        )
+        self._pseudo_indices = PseudoIndices(components.pseudo_indices)
+        return components.true_questions
+
+    # region: Survey instruction handling
     @property
-    def relevant_instructions_dict(self) -> InstructionCollection:
+    def _relevant_instructions_dict(self) -> InstructionCollection:
         """Return a dictionary with keys as question names and values as instructions that are relevant to the question.
 
         >>> s = Survey.example(include_instructions=True)
-        >>> s.relevant_instructions_dict
+        >>> s._relevant_instructions_dict
         {'q0': [Instruction(name="attention", text="Please pay attention!")], 'q1': [Instruction(name="attention", text="Please pay attention!")], 'q2': [Instruction(name="attention", text="Please pay attention!")]}
 
         """
         return InstructionCollection(
-            self.instruction_names_to_instructions, self.questions
+            self._instruction_names_to_instructions, self.questions
         )
 
-    @staticmethod
-    def _separate_questions_and_instructions(questions_and_instructions: list) -> tuple:
-        """
-        The 'pseudo_indices' attribute is a dictionary that maps question names to pseudo-indices
-        that are used to order questions and instructions in the survey.
-        Only questions get real indices; instructions get pseudo-indices.
-        However, the order of the pseudo-indices is the same as the order questions and instructions are added to the survey.
-
-        We don't have to know how many instructions there are to calculate the pseudo-indices because they are
-        calculated by the inverse of one minus the sum of 1/2^n for n in the number of instructions run so far.
-
-        >>> from edsl import Instruction
-        >>> i = Instruction(text = "Pay attention to the following questions.", name = "intro")
-        >>> i2 = Instruction(text = "How are you feeling today?", name = "followon_intro")
-        >>> from edsl import QuestionFreeText; q1 = QuestionFreeText.example()
-        >>> from edsl import QuestionMultipleChoice; q2 = QuestionMultipleChoice.example()
-        >>> s = Survey([q1, i, i2, q2])
-        >>> len(s.instruction_names_to_instructions)
-        2
-        >>> s.pseudo_indices
-        {'how_are_you': 0, 'intro': 0.5, 'followon_intro': 0.75, 'how_feeling': 1}
-
-        >>> from edsl import ChangeInstruction
-        >>> q3 = QuestionFreeText(question_text = "What is your favorite color?", question_name = "color")
-        >>> i_change = ChangeInstruction(drop = ["intro"])
-        >>> s = Survey([q1, i, q2, i_change, q3])
-        >>> [i.name for i in s.relevant_instructions(q1)]
-        []
-        >>> [i.name for i in s.relevant_instructions(q2)]
-        ['intro']
-        >>> [i.name for i in s.relevant_instructions(q3)]
-        []
-
-        >>> i_change = ChangeInstruction(keep = ["poop"], drop = [])
-        >>> s = Survey([q1, i, q2, i_change])
-        Traceback (most recent call last):
-        ...
-        ValueError: ChangeInstruction change_instruction_0 references instruction poop which does not exist.
-        """
-        from edsl.surveys.instructions.Instruction import Instruction
-        from edsl.surveys.instructions.ChangeInstruction import ChangeInstruction
-
-        true_questions = []
-        instruction_names_to_instructions = {}
-
-        num_change_instructions = 0
-        pseudo_indices = {}
-        instructions_run_length = 0
-        for entry in questions_and_instructions:
-            if isinstance(entry, Instruction) or isinstance(entry, ChangeInstruction):
-                if isinstance(entry, ChangeInstruction):
-                    entry.add_name(num_change_instructions)
-                    num_change_instructions += 1
-                    for prior_instruction in entry.keep + entry.drop:
-                        if prior_instruction not in instruction_names_to_instructions:
-                            raise ValueError(
-                                f"ChangeInstruction {entry.name} references instruction {prior_instruction} which does not exist."
-                            )
-                instructions_run_length += 1
-                delta = 1 - 1.0 / (2.0**instructions_run_length)
-                pseudo_index = (len(true_questions) - 1) + delta
-                entry.pseudo_index = pseudo_index
-                instruction_names_to_instructions[entry.name] = entry
-            elif isinstance(entry, QuestionBase):
-                pseudo_index = len(true_questions)
-                instructions_run_length = 0
-                true_questions.append(entry)
-            else:
-                raise ValueError(
-                    f"Entry {repr(entry)} is not a QuestionBase or an Instruction."
-                )
-
-            pseudo_indices[entry.name] = pseudo_index
-
-        return true_questions, instruction_names_to_instructions, pseudo_indices
-
-    def relevant_instructions(self, question) -> dict:
+    def _relevant_instructions(self, question: QuestionBase) -> dict:
         """This should be a dictionry with keys as question names and values as instructions that are relevant to the question.
 
         :param question: The question to get the relevant instructions for.
@@ -217,38 +224,13 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
         # Did the instruction come before the question and was it not modified by a change instruction?
 
         """
-        return self.relevant_instructions_dict[question]
-
-    @property
-    def max_pseudo_index(self) -> float:
-        """Return the maximum pseudo index in the survey.
-
-        Example:
-
-        >>> s = Survey.example()
-        >>> s.max_pseudo_index
-        2
-        """
-        if len(self.pseudo_indices) == 0:
-            return -1
-        return max(self.pseudo_indices.values())
-
-    @property
-    def last_item_was_instruction(self) -> bool:
-        """Return whether the last item added to the survey was an instruction.
-        This is used to determine the pseudo-index of the next item added to the survey.
-
-        Example:
+        return InstructionCollection(
+            self._instruction_names_to_instructions, self.questions
+        )[question]
 
-        >>> s = Survey.example()
-        >>> s.last_item_was_instruction
-        False
-        >>> from edsl.surveys.instructions.Instruction import Instruction
-        >>> s = s.add_instruction(Instruction(text="Pay attention to the following questions.", name="intro"))
-        >>> s.last_item_was_instruction
-        True
-        """
-        return isinstance(self.max_pseudo_index, float)
+    def show_flow(self, filename: Optional[str] = None) -> None:
+        """Show the flow of the survey."""
+        SurveyFlowVisualization(self).show_flow(filename=filename)
 
     def add_instruction(
         self, instruction: Union["Instruction", "ChangeInstruction"]
@@ -261,101 +243,21 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
         >>> from edsl import Instruction
         >>> i = Instruction(text="Pay attention to the following questions.", name="intro")
         >>> s = Survey().add_instruction(i)
-        >>> s.instruction_names_to_instructions
+        >>> s._instruction_names_to_instructions
         {'intro': Instruction(name="intro", text="Pay attention to the following questions.")}
-        >>> s.pseudo_indices
+        >>> s._pseudo_indices
         {'intro': -0.5}
         """
-        import math
-
-        if instruction.name in self.instruction_names_to_instructions:
-            raise SurveyCreationError(
-                f"""Instruction name '{instruction.name}' already exists in survey. Existing names are {self.instruction_names_to_instructions.keys()}."""
-            )
-        self.instruction_names_to_instructions[instruction.name] = instruction
-
-        # was the last thing added an instruction or a question?
-        if self.last_item_was_instruction:
-            pseudo_index = (
-                self.max_pseudo_index
-                + (math.ceil(self.max_pseudo_index) - self.max_pseudo_index) / 2
-            )
-        else:
-            pseudo_index = self.max_pseudo_index + 1.0 / 2.0
-        self.pseudo_indices[instruction.name] = pseudo_index
-
-        return self
+        return EditSurvey(self).add_instruction(instruction)
 
     # endregion
-
-    # region: Simulation methods
-
     @classmethod
-    def random_survey(self):
-        """Create a random survey."""
-        from edsl.questions import QuestionMultipleChoice, QuestionFreeText
-        from random import choice
-
-        num_questions = 10
-        questions = []
-        for i in range(num_questions):
-            if choice([True, False]):
-                q = QuestionMultipleChoice(
-                    question_text="nothing",
-                    question_name="q_" + str(i),
-                    question_options=list(range(3)),
-                )
-                questions.append(q)
-            else:
-                questions.append(
-                    QuestionFreeText(
-                        question_text="nothing", question_name="q_" + str(i)
-                    )
-                )
-        s = Survey(questions)
-        start_index = choice(range(num_questions - 1))
-        end_index = choice(range(start_index + 1, 10))
-        s = s.add_rule(f"q_{start_index}", "True", f"q_{end_index}")
-        question_to_delete = choice(range(num_questions))
-        s.delete_question(f"q_{question_to_delete}")
-        return s
+    def random_survey(cls):
+        return Simulator.random_survey()
 
     def simulate(self) -> dict:
         """Simulate the survey and return the answers."""
-        i = self.gen_path_through_survey()
-        q = next(i)
-        num_passes = 0
-        while True:
-            num_passes += 1
-            try:
-                answer = q._simulate_answer()
-                q = i.send({q.question_name: answer["answer"]})
-            except StopIteration:
-                break
-
-            if num_passes > 100:
-                print("Too many passes.")
-                raise Exception("Too many passes.")
-        return self.answers
-
-    def create_agent(self) -> "Agent":
-        """Create an agent from the simulated answers."""
-        answers_dict = self.simulate()
-
-        def construct_answer_dict_function(traits: dict) -> Callable:
-            def func(self, question: "QuestionBase", scenario=None):
-                return traits.get(question.question_name, None)
-
-            return func
-
-        return Agent(traits=answers_dict).add_direct_question_answering_method(
-            construct_answer_dict_function(answers_dict)
-        )
-
-    def simulate_results(self) -> "Results":
-        """Simulate the survey and return the results."""
-        a = self.create_agent()
-        return self.by([a]).run()
+        return Simulator(self).simulate()
 
     # endregion
 
@@ -391,26 +293,19 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
                 )
             return self.question_name_to_index[question_name]
 
-    def get(self, question_name: str) -> QuestionBase:
+    def _get_question_by_name(self, question_name: str) -> QuestionBase:
         """
         Return the question object given the question name.
 
         :param question_name: The name of the question to get.
 
         >>> s = Survey.example()
-        >>> s.get_question("q0")
+        >>> s._get_question_by_name("q0")
         Question('multiple_choice', question_name = \"""q0\""", question_text = \"""Do you like school?\""", question_options = ['yes', 'no'])
         """
         if question_name not in self.question_name_to_index:
             raise SurveyError(f"Question name {question_name} not found in survey.")
-        index = self.question_name_to_index[question_name]
-        return self._questions[index]
-
-    def get_question(self, question_name: str) -> QuestionBase:
-        """Return the question object given the question name."""
-        # import warnings
-        # warnings.warn("survey.get_question is deprecated. Use subscript operator instead.")
-        return self.get(question_name)
+        return self._questions[self.question_name_to_index[question_name]]
 
     def question_names_to_questions(self) -> dict:
         """Return a dictionary mapping question names to question attributes."""
@@ -443,12 +338,6 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
     # endregion
 
     # region: serialization methods
-    def __hash__(self) -> int:
-        """Return a hash of the question."""
-        from edsl.utilities.utilities import dict_hash
-
-        return dict_hash(self.to_dict(add_edsl_version=False))
-
     def to_dict(self, add_edsl_version=True) -> dict[str, Any]:
         """Serialize the Survey object to a dictionary.
 
@@ -456,10 +345,12 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
         >>> s.to_dict(add_edsl_version = False).keys()
         dict_keys(['questions', 'memory_plan', 'rule_collection', 'question_groups'])
         """
-        return {
+        from edsl import __version__
+
+        d = {
             "questions": [
                 q.to_dict(add_edsl_version=add_edsl_version)
-                for q in self.recombined_questions_and_instructions()
+                for q in self._recombined_questions_and_instructions()
             ],
             "memory_plan": self.memory_plan.to_dict(add_edsl_version=add_edsl_version),
             "rule_collection": self.rule_collection.to_dict(
@@ -467,6 +358,13 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
             ),
             "question_groups": self.question_groups,
         }
+        if self.questions_to_randomize != []:
+            d["questions_to_randomize"] = self.questions_to_randomize
+
+        if add_edsl_version:
+            d["edsl_version"] = __version__
+            d["edsl_class_name"] = "Survey"
+        return d
 
     @classmethod
     @remove_edsl_version
@@ -489,6 +387,8 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
         """
 
         def get_class(pass_dict):
+            from edsl.questions.QuestionBase import QuestionBase
+
             if (class_name := pass_dict.get("edsl_class_name")) == "QuestionBase":
                 return QuestionBase
             elif class_name == "Instruction":
@@ -508,11 +408,16 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
             get_class(q_dict).from_dict(q_dict) for q_dict in data["questions"]
         ]
         memory_plan = MemoryPlan.from_dict(data["memory_plan"])
+        if "questions_to_randomize" in data:
+            questions_to_randomize = data["questions_to_randomize"]
+        else:
+            questions_to_randomize = None
         survey = cls(
             questions=questions,
             memory_plan=memory_plan,
             rule_collection=RuleCollection.from_dict(data["rule_collection"]),
             question_groups=data["question_groups"],
+            questions_to_randomize=questions_to_randomize,
         )
         return survey
 
@@ -600,27 +505,16 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
 
         return Survey(questions=self.questions + other.questions)
 
-    def move_question(self, identifier: Union[str, int], new_index: int):
-        if isinstance(identifier, str):
-            if identifier not in self.question_names:
-                raise SurveyError(
-                    f"Question name '{identifier}' does not exist in the survey."
-                )
-            index = self.question_name_to_index[identifier]
-        elif isinstance(identifier, int):
-            if identifier < 0 or identifier >= len(self.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._questions[index]
-
-        new_survey = self.delete_question(index)
-        new_survey.add_question(moving_question, new_index)
-        return new_survey
+    def move_question(self, identifier: Union[str, int], new_index: int) -> Survey:
+        """
+        >>> from edsl import QuestionMultipleChoice, Survey
+        >>> s = Survey.example()
+        >>> s.question_names
+        ['q0', 'q1', 'q2']
+        >>> s.move_question("q0", 2).question_names
+        ['q1', 'q2', 'q0']
+        """
+        return EditSurvey(self).move_question(identifier, new_index)
 
     def delete_question(self, identifier: Union[str, int]) -> Survey:
         """
@@ -640,54 +534,7 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
         >>> len(s.questions)
         0
         """
-        if isinstance(identifier, str):
-            if identifier not in self.question_names:
-                raise SurveyError(
-                    f"Question name '{identifier}' does not exist in the survey."
-                )
-            index = self.question_name_to_index[identifier]
-        elif isinstance(identifier, int):
-            if identifier < 0 or identifier >= len(self.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._questions.pop(index)
-        del self.pseudo_indices[deleted_question.question_name]
-
-        # Update indices
-        for question_name, old_index in self.pseudo_indices.items():
-            if old_index > index:
-                self.pseudo_indices[question_name] = old_index - 1
-
-        # Update rules
-        new_rule_collection = RuleCollection()
-        for rule in self.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.questions):
-                    rule.next_q = EndOfSurvey
-                else:
-                    rule.next_q = index
-
-            new_rule_collection.add_rule(rule)
-        self.rule_collection = new_rule_collection
-
-        # Update memory plan if it exists
-        if hasattr(self, "memory_plan"):
-            self.memory_plan.remove_question(deleted_question.question_name)
-
-        return self
+        return EditSurvey(self).delete_question(identifier)
 
     def add_question(
         self, question: QuestionBase, index: Optional[int] = None
@@ -711,81 +558,17 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
         edsl.exceptions.surveys.SurveyCreationError: Question name 'q0' already exists in survey. Existing names are ['q0'].
         ...
         """
-        if question.question_name in self.question_names:
-            raise SurveyCreationError(
-                f"""Question name '{question.question_name}' already exists in survey. Existing names are {self.question_names}."""
-            )
-        if index is None:
-            index = len(self.questions)
+        return EditSurvey(self).add_question(question, index)
 
-        if index > len(self.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.questions)
-
-        # index = len(self.questions)
-        # TODO: This is a bit ugly because the user
-        # doesn't "know" about _questions - it's generated by the
-        # descriptor.
-        self._questions.insert(index, question)
-
-        if interior_insertion:
-            for question_name, old_index in self.pseudo_indices.items():
-                if old_index >= index:
-                    self.pseudo_indices[question_name] = old_index + 1
-
-        self.pseudo_indices[question.question_name] = index
-
-        ## Re-do question_name to index - this is done automatically
-        # for question_name, old_index in self.question_name_to_index.items():
-        #     if old_index >= index:
-        #         self.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.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.rule_collection.add_rule(
-            Rule(
-                current_q=index,
-                expression="True",
-                next_q=index + 1,
-                question_name_to_index=self.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, "memory_plan"):
-            self.memory_plan.add_question(question)
-
-        return self
-
-    def recombined_questions_and_instructions(
+    def _recombined_questions_and_instructions(
         self,
     ) -> list[Union[QuestionBase, "Instruction"]]:
         """Return a list of questions and instructions sorted by pseudo index."""
         questions_and_instructions = self._questions + list(
-            self.instruction_names_to_instructions.values()
+            self._instruction_names_to_instructions.values()
         )
         return sorted(
-            questions_and_instructions, key=lambda x: self.pseudo_indices[x.name]
+            questions_and_instructions, key=lambda x: self._pseudo_indices[x.name]
         )
 
     # endregion
@@ -797,7 +580,7 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
         >>> s = Survey.example().set_full_memory_mode()
 
         """
-        self._set_memory_plan(lambda i: self.question_names[:i])
+        MemoryManagement(self)._set_memory_plan(lambda i: self.question_names[:i])
         return self
 
     def set_lagged_memory(self, lags: int) -> Survey:
@@ -805,10 +588,12 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
 
         The agent should remember the answers to the questions in the survey from the previous lags.
         """
-        self._set_memory_plan(lambda i: self.question_names[max(0, i - lags) : i])
+        MemoryManagement(self)._set_memory_plan(
+            lambda i: self.question_names[max(0, i - lags) : i]
+        )
         return self
 
-    def _set_memory_plan(self, prior_questions_func: Callable):
+    def _set_memory_plan(self, prior_questions_func: Callable) -> None:
         """Set memory plan based on a provided function determining prior questions.
 
         :param prior_questions_func: A function that takes the index of the current question and returns a list of prior questions to remember.
@@ -817,11 +602,7 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
         >>> s._set_memory_plan(lambda i: s.question_names[:i])
 
         """
-        for i, question_name in enumerate(self.question_names):
-            self.memory_plan.add_memory_collection(
-                focal_question=question_name,
-                prior_questions=prior_questions_func(i),
-            )
+        MemoryManagement(self)._set_memory_plan(prior_questions_func)
 
     def add_targeted_memory(
         self,
@@ -841,20 +622,10 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
 
         The agent should also remember the answers to prior_questions listed in prior_questions.
         """
-        focal_question_name = self.question_names[
-            self._get_question_index(focal_question)
-        ]
-        prior_question_name = self.question_names[
-            self._get_question_index(prior_question)
-        ]
-
-        self.memory_plan.add_single_memory(
-            focal_question=focal_question_name,
-            prior_question=prior_question_name,
+        return MemoryManagement(self).add_targeted_memory(
+            focal_question, prior_question
         )
 
-        return self
-
     def add_memory_collection(
         self,
         focal_question: Union[QuestionBase, str],
@@ -873,23 +644,9 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
         >>> s.memory_plan
         {'q2': Memory(prior_questions=['q0', 'q1'])}
         """
-        focal_question_name = self.question_names[
-            self._get_question_index(focal_question)
-        ]
-
-        prior_question_names = [
-            self.question_names[self._get_question_index(prior_question)]
-            for prior_question in prior_questions
-        ]
-
-        self.memory_plan.add_memory_collection(
-            focal_question=focal_question_name, prior_questions=prior_question_names
+        return MemoryManagement(self).add_memory_collection(
+            focal_question, prior_questions
         )
-        return self
-
-    # endregion
-    # endregion
-    # endregion
 
     # region: Question groups
     def add_question_group(
@@ -984,16 +741,9 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
 
         >>> s = Survey.example()
         >>> s.show_rules()
-        ┏━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━━━━┓
-        ┃ current_q ┃ expression  ┃ next_q ┃ priority ┃ before_rule ┃
-        ┡━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━━━━┩
-        │ 0         │ True        │ 1      │ -1       │ False       │
-        │ 0         │ q0 == 'yes' │ 2      │ 0        │ False       │
-        │ 1         │ True        │ 2      │ -1       │ False       │
-        │ 2         │ True        │ 3      │ -1       │ False       │
-        └───────────┴─────────────┴────────┴──────────┴─────────────┘
+        Dataset([{'current_q': [0, 0, 1, 2]}, {'expression': ['True', "q0 == 'yes'", 'True', 'True']}, {'next_q': [1, 2, 2, 3]}, {'priority': [-1, 0, -1, -1]}, {'before_rule': [False, False, False, False]}])
         """
-        self.rule_collection.show_rules()
+        return self.rule_collection.show_rules()
 
     def add_stop_rule(
         self, question: Union[QuestionBase, str], expression: str
@@ -1023,41 +773,15 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
         edsl.exceptions.surveys.SurveyCreationError: The expression contains '<>', which is not allowed. You probably mean '!='.
         ...
         """
-        expression = ValidatedString(expression)
-        prior_question_appears = False
-        for prior_question in self.questions:
-            if prior_question.question_name in expression:
-                prior_question_appears = True
-
-        if not prior_question_appears:
-            import warnings
-
-            warnings.warn(
-                f"The expression {expression} does not contain any prior question names. This is probably a mistake."
-            )
-        self.add_rule(question, expression, EndOfSurvey)
-        return self
+        return RuleManager(self).add_stop_rule(question, expression)
 
     def clear_non_default_rules(self) -> Survey:
         """Remove all non-default rules from the survey.
 
         >>> Survey.example().show_rules()
-        ┏━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━━━━┓
-        ┃ current_q ┃ expression  ┃ next_q ┃ priority ┃ before_rule ┃
-        ┡━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━━━━┩
-        │ 0         │ True        │ 1      │ -1       │ False       │
-        │ 0         │ q0 == 'yes' │ 2      │ 0        │ False       │
-        │ 1         │ True        │ 2      │ -1       │ False       │
-        │ 2         │ True        │ 3      │ -1       │ False       │
-        └───────────┴─────────────┴────────┴──────────┴─────────────┘
+        Dataset([{'current_q': [0, 0, 1, 2]}, {'expression': ['True', "q0 == 'yes'", 'True', 'True']}, {'next_q': [1, 2, 2, 3]}, {'priority': [-1, 0, -1, -1]}, {'before_rule': [False, False, False, False]}])
         >>> Survey.example().clear_non_default_rules().show_rules()
-        ┏━━━━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━━━━┓
-        ┃ current_q ┃ expression ┃ next_q ┃ priority ┃ before_rule ┃
-        ┡━━━━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━━━━┩
-        │ 0         │ True       │ 1      │ -1       │ False       │
-        │ 1         │ True       │ 2      │ -1       │ False       │
-        │ 2         │ True       │ 3      │ -1       │ False       │
-        └───────────┴────────────┴────────┴──────────┴─────────────┘
+        Dataset([{'current_q': [0, 1, 2]}, {'expression': ['True', 'True', 'True']}, {'next_q': [1, 2, 3]}, {'priority': [-1, -1, -1]}, {'before_rule': [False, False, False]}])
         """
         s = Survey()
         for question in self.questions:
@@ -1088,38 +812,9 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
 
         """
         question_index = self._get_question_index(question)
-        self._add_rule(question, expression, question_index + 1, before_rule=True)
-        return self
-
-    def _get_new_rule_priority(
-        self, question_index: int, before_rule: bool = False
-    ) -> int:
-        """Return the priority for the new rule.
-
-        :param question_index: The index of the question to add the rule to.
-        :param before_rule: Whether the rule is evaluated before the question is answered.
-
-        >>> s = Survey.example()
-        >>> s._get_new_rule_priority(0)
-        1
-        """
-        current_priorities = [
-            rule.priority
-            for rule in self.rule_collection.applicable_rules(
-                question_index, before_rule
-            )
-        ]
-        if len(current_priorities) == 0:
-            return RulePriority.DEFAULT.value + 1
-
-        max_priority = max(current_priorities)
-        # newer rules take priority over older rules
-        new_priority = (
-            RulePriority.DEFAULT.value
-            if len(current_priorities) == 0
-            else max_priority + 1
+        return RuleManager(self).add_rule(
+            question, expression, question_index + 1, before_rule=True
         )
-        return new_priority
 
     def add_rule(
         self,
@@ -1143,52 +838,10 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
         'q2'
 
         """
-        return self._add_rule(
+        return RuleManager(self).add_rule(
             question, expression, next_question, before_rule=before_rule
         )
 
-    def _add_rule(
-        self,
-        question: Union[QuestionBase, str],
-        expression: str,
-        next_question: Union[QuestionBase, str, int],
-        before_rule: bool = False,
-    ) -> Survey:
-        """
-        Add a rule to a Question of the Survey with the appropriate priority.
-
-        :param question: The question to add the rule to.
-        :param expression: The expression to evaluate.
-        :param next_question: The next question to go to if the rule is true.
-        :param before_rule: Whether the rule is evaluated before the question is answered.
-
-
-        - The last rule added for the question will have the highest priority.
-        - If there are no rules, the rule added gets priority -1.
-        """
-        question_index = self._get_question_index(question)
-
-        # Might not have the name of the next question yet
-        if isinstance(next_question, int):
-            next_question_index = next_question
-        else:
-            next_question_index = self._get_question_index(next_question)
-
-        new_priority = self._get_new_rule_priority(question_index, before_rule)
-
-        self.rule_collection.add_rule(
-            Rule(
-                current_q=question_index,
-                expression=expression,
-                next_q=next_question_index,
-                question_name_to_index=self.question_name_to_index,
-                priority=new_priority,
-                before_rule=before_rule,
-            )
-        )
-
-        return self
-
     # endregion
 
     # region: Forward methods
@@ -1199,22 +852,26 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
 
         This takes the survey and adds an Agent and a Scenario via 'by' which converts to a Jobs object:
 
-        >>> s = Survey.example(); from edsl import Agent; from edsl import Scenario
+        >>> s = Survey.example(); from edsl.agents import Agent; from edsl import Scenario
         >>> s.by(Agent.example()).by(Scenario.example())
         Jobs(...)
         """
         from edsl.jobs.Jobs import Jobs
 
-        job = Jobs(survey=self)
-        return job.by(*args)
+        return Jobs(survey=self).by(*args)
 
     def to_jobs(self):
-        """Convert the survey to a Jobs object."""
+        """Convert the survey to a Jobs object.
+        >>> s = Survey.example()
+        >>> s.to_jobs()
+        Jobs(...)
+        """
         from edsl.jobs.Jobs import Jobs
 
         return Jobs(survey=self)
 
     def show_prompts(self):
+        """Show the prompts for the survey."""
         return self.to_jobs().show_prompts()
 
     # endregion
@@ -1226,6 +883,7 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
         model=None,
         agent=None,
         cache=None,
+        verbose=False,
         disable_remote_cache: bool = False,
         disable_remote_inference: bool = False,
         **kwargs,
@@ -1241,19 +899,21 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
         >>> s(period = "evening", cache = False, disable_remote_cache = True, disable_remote_inference = True).select("answer.q0").first()
         'no'
         """
-        job = self.get_job(model, agent, **kwargs)
-        return job.run(
+
+        return self.get_job(model, agent, **kwargs).run(
             cache=cache,
+            verbose=verbose,
             disable_remote_cache=disable_remote_cache,
             disable_remote_inference=disable_remote_inference,
         )
 
     async def run_async(
         self,
-        model: Optional["Model"] = None,
+        model: Optional["LanguageModel"] = None,
         agent: Optional["Agent"] = None,
         cache: Optional["Cache"] = None,
         disable_remote_inference: bool = False,
+        disable_remote_cache: bool = False,
         **kwargs,
     ):
         """Run the survey with default model, taking the required survey as arguments.
@@ -1263,7 +923,7 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
         >>> def f(scenario, agent_traits): return "yes" if scenario["period"] == "morning" else "no"
         >>> q = QuestionFunctional(question_name = "q0", func = f)
         >>> s = Survey([q])
-        >>> async def test_run_async(): result = await s.run_async(period="morning", disable_remote_inference = True); print(result.select("answer.q0").first())
+        >>> async def test_run_async(): result = await s.run_async(period="morning", disable_remote_inference = True, disable_remote_cache=True); print(result.select("answer.q0").first())
         >>> asyncio.run(test_run_async())
         yes
         >>> import asyncio
@@ -1271,20 +931,23 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
         >>> def f(scenario, agent_traits): return "yes" if scenario["period"] == "morning" else "no"
         >>> q = QuestionFunctional(question_name = "q0", func = f)
         >>> s = Survey([q])
-        >>> async def test_run_async(): result = await s.run_async(period="evening", disable_remote_inference = True); print(result.select("answer.q0").first())
-        >>> asyncio.run(test_run_async())
+        >>> async def test_run_async(): result = await s.run_async(period="evening", disable_remote_inference = True, disable_remote_cache = True); print(result.select("answer.q0").first())
+        >>> results = asyncio.run(test_run_async())
         no
         """
         # TODO: temp fix by creating a cache
         if cache is None:
             from edsl.data import Cache
-
             c = Cache()
         else:
             c = cache
-        jobs: "Jobs" = self.get_job(model=model, agent=agent, **kwargs)
+
+        
+
+        jobs: "Jobs" = self.get_job(model=model, agent=agent, **kwargs).using(c)
         return await jobs.run_async(
-            cache=c, disable_remote_inference=disable_remote_inference
+            disable_remote_inference=disable_remote_inference,
+            disable_remote_cache=disable_remote_cache,
         )
 
     def run(self, *args, **kwargs) -> "Results":
@@ -1302,9 +965,30 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
 
         return Jobs(survey=self).run(*args, **kwargs)
 
+    def using(self, obj: Union["Cache", "KeyLookup", "BucketCollection"]) -> "Jobs":
+        """Turn the survey into a Job and appends the arguments to the Job."""
+        from edsl.jobs.Jobs import Jobs
+
+        return Jobs(survey=self).using(obj)
+
+    def duplicate(self):
+        """Duplicate the survey.
+
+        >>> s = Survey.example()
+        >>> s2 = s.duplicate()
+        >>> s == s2
+        True
+        >>> s is s2
+        False
+
+        """
+        return Survey.from_dict(self.to_dict())
+
     # region: Survey flow
     def next_question(
-        self, current_question: Union[str, QuestionBase], answers: dict
+        self,
+        current_question: Optional[Union[str, QuestionBase]] = None,
+        answers: Optional[dict] = None,
     ) -> Union[QuestionBase, EndOfSurvey.__class__]:
         """
         Return the next question in a survey.
@@ -1323,8 +1007,11 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
         'q1'
 
         """
+        if current_question is None:
+            return self.questions[0]
+
         if isinstance(current_question, str):
-            current_question = self.get_question(current_question)
+            current_question = self._get_question_by_name(current_question)
 
         question_index = self.question_name_to_index[current_question.question_name]
         next_question_object = self.rule_collection.next_question(
@@ -1354,14 +1041,7 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
 
         >>> s = Survey.example()
         >>> s.show_rules()
-        ┏━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━━━━┓
-        ┃ current_q ┃ expression  ┃ next_q ┃ priority ┃ before_rule ┃
-        ┡━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━━━━┩
-        │ 0         │ True        │ 1      │ -1       │ False       │
-        │ 0         │ q0 == 'yes' │ 2      │ 0        │ False       │
-        │ 1         │ True        │ 2      │ -1       │ False       │
-        │ 2         │ True        │ 3      │ -1       │ False       │
-        └───────────┴─────────────┴────────┴──────────┴─────────────┘
+        Dataset([{'current_q': [0, 0, 1, 2]}, {'expression': ['True', "q0 == 'yes'", 'True', 'True']}, {'next_q': [1, 2, 2, 3]}, {'priority': [-1, 0, -1, -1]}, {'before_rule': [False, False, False, False]}])
 
         Note that q0 has a rule that if the answer is 'yes', the next question is q2. If the answer is 'no', the next question is q1.
 
@@ -1390,7 +1070,6 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
             question = self.next_question(question, self.answers)
 
         while not question == EndOfSurvey:
-            # breakpoint()
             answer = yield question
             self.answers.update(answer)
             # print(f"Answers: {self.answers}")
@@ -1399,69 +1078,6 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
 
     # endregion
 
-    # regions: DAG construction
-    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:
-
-        >>> s = Survey.example()
-        >>> d = s.dag()
-        >>> d
-        {1: {0}, 2: {0}}
-        >>> 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
-
-    @property
-    def piping_dag(self) -> DAG:
-        """Figures out the DAG of piping dependencies.
-
-        >>> 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])
-        >>> 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 dag(self, textify: bool = False) -> DAG:
         """Return the DAG of the survey, which reflects both skip-logic and memory.
 
@@ -1473,14 +1089,9 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
         {1: {0}, 2: {0}}
 
         """
-        memory_dag = self.memory_plan.dag
-        rule_dag = self.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
+        from edsl.surveys.ConstructDAG import ConstructDAG
+
+        return ConstructDAG(self).dag(textify)
 
     ###################
     # DUNDER METHODS
@@ -1509,77 +1120,18 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
         elif isinstance(index, str):
             return getattr(self, index)
 
-    def _diff(self, other):
-        """Used for debugging. Print out the differences between two surveys."""
-        from rich import print
-
-        for key, value in self.to_dict().items():
-            if value != other.to_dict()[key]:
-                print(f"Key: {key}")
-                print("\n")
-                print(f"Self: {value}")
-                print("\n")
-                print(f"Other: {other.to_dict()[key]}")
-                print("\n\n")
-
-    def __eq__(self, other) -> bool:
-        """Return True if the two surveys have the same to_dict.
-
-        :param other: The other survey to compare to.
-
-        >>> s = Survey.example()
-        >>> s == s
-        True
-
-        >>> s == "poop"
-        False
-
-        """
-        if not isinstance(other, Survey):
-            return False
-        return self.to_dict() == other.to_dict()
-
-    @classmethod
-    def from_qsf(
-        cls, qsf_file: Optional[str] = None, url: Optional[str] = None
-    ) -> Survey:
-        """Create a Survey object from a Qualtrics QSF file."""
+    # def _diff(self, other):
+    #     """Used for debugging. Print out the differences between two surveys."""
+    #     from rich import print
 
-        if url and qsf_file:
-            raise ValueError("Only one of url or qsf_file can be provided.")
-
-        if (not url) and (not qsf_file):
-            raise ValueError("Either url or qsf_file must be provided.")
-
-        if url:
-            response = requests.get(url)
-            response.raise_for_status()  # Ensure the request was successful
-
-            # Save the Excel file to a temporary file
-            with tempfile.NamedTemporaryFile(suffix=".qsf", delete=False) as temp_file:
-                temp_file.write(response.content)
-                qsf_file = temp_file.name
-
-        from edsl.surveys.SurveyQualtricsImport import SurveyQualtricsImport
-
-        so = SurveyQualtricsImport(qsf_file)
-        return so.create_survey()
-
-    # region: Display methods
-    def print(self):
-        """Print the survey in a rich format.
-
-        >>> s = Survey.example()
-        >>> s.print()
-        {
-          "questions": [
-          ...
-        }
-        """
-        from rich import print_json
-        import json
-
-        print_json(json.dumps(self.to_dict()))
+    #     for key, value in self.to_dict().items():
+    #         if value != other.to_dict()[key]:
+    #             print(f"Key: {key}")
+    #             print("\n")
+    #             print(f"Self: {value}")
+    #             print("\n")
+    #             print(f"Other: {other.to_dict()[key]}")
+    #             print("\n\n")
 
     def __repr__(self) -> str:
         """Return a string representation of the survey."""
@@ -1587,60 +1139,20 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
         # questions_string = ", ".join([repr(q) for q in self._questions])
         questions_string = ", ".join([repr(q) for q in self.raw_passed_questions or []])
         # question_names_string = ", ".join([repr(name) for name in self.question_names])
-        return f"Survey(questions=[{questions_string}], memory_plan={self.memory_plan}, rule_collection={self.rule_collection}, question_groups={self.question_groups})"
+        return f"Survey(questions=[{questions_string}], memory_plan={self.memory_plan}, rule_collection={self.rule_collection}, question_groups={self.question_groups}, questions_to_randomize={self.questions_to_randomize})"
 
     def _summary(self) -> dict:
         return {
-            "EDSL Class": "Survey",
-            "Number of Questions": len(self),
-            "Question Names": self.question_names,
+            "# questions": len(self),
+            "question_name list": self.question_names,
         }
 
-    def _repr_html_(self) -> str:
-        footer = f"<a href={self.__documentation__}>(docs)</a>"
-        return str(self.summary(format="html")) + footer
-
     def tree(self, node_list: Optional[List[str]] = None):
         return self.to_scenario_list().tree(node_list=node_list)
 
     def table(self, *fields, tablefmt=None) -> Table:
         return self.to_scenario_list().to_dataset().table(*fields, tablefmt=tablefmt)
 
-    def rich_print(self) -> Table:
-        """Print the survey in a rich format.
-
-        >>> t = Survey.example().rich_print()
-        >>> print(t) # doctest: +SKIP
-        ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
-        ┃ Questions                                                                                          ┃
-        ┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
-        │ ┏━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━┓                                │
-        │ ┃ Question Name ┃ Question Type   ┃ Question Text       ┃ Options ┃                                │
-        │ ┡━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━┩                                │
-        │ │ q0            │ multiple_choice │ Do you like school? │ yes, no │                                │
-        │ └───────────────┴─────────────────┴─────────────────────┴─────────┘                                │
-        │ ┏━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓              │
-        │ ┃ Question Name ┃ Question Type   ┃ Question Text ┃ Options                         ┃              │
-        │ ┡━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩              │
-        │ │ q1            │ multiple_choice │ Why not?      │ killer bees in cafeteria, other │              │
-        │ └───────────────┴─────────────────┴───────────────┴─────────────────────────────────┘              │
-        │ ┏━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓ │
-        │ ┃ Question Name ┃ Question Type   ┃ Question Text ┃ Options                                      ┃ │
-        │ ┡━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩ │
-        │ │ q2            │ multiple_choice │ Why?          │ **lack*** of killer bees in cafeteria, other │ │
-        │ └───────────────┴─────────────────┴───────────────┴──────────────────────────────────────────────┘ │
-        └────────────────────────────────────────────────────────────────────────────────────────────────────┘
-        """
-        from rich.table import Table
-
-        table = Table(show_header=True, header_style="bold magenta")
-        table.add_column("Questions", style="dim")
-
-        for question in self._questions:
-            table.add_row(question.rich_print())
-
-        return table
-
     # endregion
 
     def codebook(self) -> dict[str, str]:
@@ -1655,37 +1167,6 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
             codebook[question.question_name] = question.question_text
         return codebook
 
-    # region: Export methods
-    def to_csv(self, filename: str = None):
-        """Export the survey to a CSV file.
-
-        :param filename: The name of the file to save the CSV to.
-
-        >>> s = Survey.example()
-        >>> s.to_csv() # doctest: +SKIP
-           index question_name        question_text                                question_options    question_type
-        0      0            q0  Do you like school?                                       [yes, no]  multiple_choice
-        1      1            q1             Why not?               [killer bees in cafeteria, other]  multiple_choice
-        2      2            q2                 Why?  [**lack*** of killer bees in cafeteria, other]  multiple_choice
-        """
-        raw_data = []
-        for index, question in enumerate(self._questions):
-            d = {"index": index}
-            question_dict = question.to_dict()
-            _ = question_dict.pop("edsl_version")
-            _ = question_dict.pop("edsl_class_name")
-            d.update(question_dict)
-            raw_data.append(d)
-        from pandas import DataFrame
-
-        df = DataFrame(raw_data)
-        if filename:
-            df.to_csv(filename, index=False)
-        else:
-            return df
-
-    # endregion
-
     @classmethod
     def example(
         cls,
@@ -1744,7 +1225,7 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
 
     def get_job(self, model=None, agent=None, **kwargs):
         if model is None:
-            from edsl import Model
+            from edsl.language_models.model import Model
 
             model = Model()
 
@@ -1753,7 +1234,7 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
         s = Scenario(kwargs)
 
         if not agent:
-            from edsl import Agent
+            from edsl.agents.Agent import Agent
 
             agent = Agent()
 
@@ -1765,26 +1246,24 @@ def main():
 
     def example_survey():
         """Return an example survey."""
-        from edsl.questions.QuestionMultipleChoice import QuestionMultipleChoice
-        from edsl.surveys.Survey import Survey
+        from edsl import QuestionMultipleChoice, QuestionList, QuestionNumerical, Survey
 
         q0 = QuestionMultipleChoice(
-            question_text="Do you like school?",
-            question_options=["yes", "no"],
             question_name="q0",
+            question_text="What is the capital of France?",
+            question_options=["London", "Paris", "Rome", "Boston", "I don't know"]
         )
-        q1 = QuestionMultipleChoice(
-            question_text="Why not?",
-            question_options=["killer bees in cafeteria", "other"],
+        q1 = QuestionList(
             question_name="q1",
+            question_text="Name some cities in France.",
+            max_list_items = 5
         )
-        q2 = QuestionMultipleChoice(
-            question_text="Why?",
-            question_options=["**lack*** of killer bees in cafeteria", "other"],
+        q2 = QuestionNumerical(
             question_name="q2",
+            question_text="What is the population of {{ q0.answer }}?"
         )
         s = Survey(questions=[q0, q1, q2])
-        s = s.add_rule(q0, "q0 == 'yes'", q2)
+        s = s.add_rule(q0, "q0 == 'Paris'", q2)
         return s
 
     s = example_survey()