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

edsl/jobs/Jobs.py

@@ -156,7 +156,11 @@ class Jobs(Base):
         from edsl.results.Dataset import Dataset
 
         for interview_index, interview in enumerate(interviews):
-            invigilators = list(interview._build_invigilators(debug=False))
+            invigilators = [
+                interview._get_invigilator(question)
+                for question in self.survey.questions
+            ]
+            # list(interview._build_invigilators(debug=False))
             for _, invigilator in enumerate(invigilators):
                 prompts = invigilator.get_prompts()
                 user_prompts.append(prompts["user_prompt"])
@@ -344,6 +348,7 @@ class Jobs(Base):
                 scenario=scenario,
                 model=model,
                 skip_retry=self.skip_retry,
+                raise_validation_errors=self.raise_validation_errors,
             )
 
     def create_bucket_collection(self) -> BucketCollection:
@@ -461,27 +466,31 @@ class Jobs(Base):
             return False
         return self._skip_retry
 
+    @property
+    def raise_validation_errors(self):
+        if not hasattr(self, "_raise_validation_errors"):
+            return False
+        return self._raise_validation_errors
+
     def run(
         self,
         n: int = 1,
-        debug: bool = False,
         progress_bar: bool = False,
         stop_on_exception: bool = False,
         cache: Union[Cache, bool] = None,
         check_api_keys: bool = False,
         sidecar_model: Optional[LanguageModel] = None,
-        batch_mode: Optional[bool] = None,
         verbose: bool = False,
         print_exceptions=True,
         remote_cache_description: Optional[str] = None,
         remote_inference_description: Optional[str] = None,
         skip_retry: bool = False,
+        raise_validation_errors: bool = False,
     ) -> Results:
         """
         Runs the Job: conducts Interviews and returns their results.
 
         :param n: how many times to run each interview
-        :param debug: prints debug messages
         :param progress_bar: shows a progress bar
         :param stop_on_exception: stops the job if an exception is raised
         :param cache: a cache object to store results
@@ -495,11 +504,7 @@ class Jobs(Base):
 
         self._check_parameters()
         self._skip_retry = skip_retry
-
-        if batch_mode is not None:
-            raise NotImplementedError(
-                "Batch mode is deprecated. Please update your code to not include 'batch_mode' in the 'run' method."
-            )
+        self._raise_validation_errors = raise_validation_errors
 
         self.verbose = verbose
 
@@ -587,7 +592,7 @@ class Jobs(Base):
                         )
 
         # handle cache
-        if cache is None:
+        if cache is None or cache is True:
             from edsl.data.CacheHandler import CacheHandler
 
             cache = CacheHandler().get_cache()
@@ -599,12 +604,12 @@ class Jobs(Base):
         if not remote_cache:
             results = self._run_local(
                 n=n,
-                debug=debug,
                 progress_bar=progress_bar,
                 cache=cache,
                 stop_on_exception=stop_on_exception,
                 sidecar_model=sidecar_model,
                 print_exceptions=print_exceptions,
+                raise_validation_errors=raise_validation_errors,
             )
 
             results.cache = cache.new_entries_cache()
@@ -643,12 +648,12 @@ class Jobs(Base):
             self._output("Running job...")
             results = self._run_local(
                 n=n,
-                debug=debug,
                 progress_bar=progress_bar,
                 cache=cache,
                 stop_on_exception=stop_on_exception,
                 sidecar_model=sidecar_model,
                 print_exceptions=print_exceptions,
+                raise_validation_errors=raise_validation_errors,
             )
             self._output("Job completed!")
 
@@ -883,7 +888,7 @@ def main():
 
     job = Jobs.example()
     len(job) == 8
-    results = job.run(debug=True, cache=Cache())
+    results = job.run(cache=Cache())
     len(results) == 8
     results
 

edsl/jobs/buckets/TokenBucket.py

@@ -82,23 +82,30 @@ class TokenBucket:
         >>> bucket.refill()
         >>> bucket.tokens > 0
         True
-
         """
+        """Refill the bucket with new tokens based on elapsed time."""
         now = time.monotonic()
+        # print(f"Time is now: {now}; Last refill time: {self.last_refill}")
         elapsed = now - self.last_refill
+        # print("Elapsed time: ", elapsed)
         refill_amount = elapsed * self.refill_rate
         self.tokens = min(self.capacity, self.tokens + refill_amount)
         self.last_refill = now
 
+        if self.tokens < self.capacity:
+            pass
+            # print(f"Refilled. Current tokens: {self.tokens:.4f}")
+            # print(f"Elapsed time: {elapsed:.4f} seconds")
+            # print(f"Refill amount: {refill_amount:.4f}")
+
         self.log.append((now, self.tokens))
 
     def wait_time(self, requested_tokens: Union[float, int]) -> float:
         """Calculate the time to wait for the requested number of tokens."""
-        now = time.monotonic()
-        elapsed = now - self.last_refill
-        refill_amount = elapsed * self.refill_rate
-        available_tokens = min(self.capacity, self.tokens + refill_amount)
-        return max(0, requested_tokens - available_tokens) / self.refill_rate
+        # self.refill()  # Update the current token count
+        if self.tokens >= requested_tokens:
+            return 0
+        return (requested_tokens - self.tokens) / self.refill_rate
 
     async def get_tokens(
         self, amount: Union[int, float] = 1, cheat_bucket_capacity=True
@@ -123,22 +130,40 @@ class TokenBucket:
         ...
         ValueError: Requested amount exceeds bucket capacity. Bucket capacity: 10, requested amount: 11. As the bucket never overflows, the requested amount will never be available.
         >>> asyncio.run(bucket.get_tokens(11, cheat_bucket_capacity=True))
+        >>> bucket.capacity
+        12.100000000000001
         """
-        if amount > self.capacity:
+        if amount >= self.capacity:
             if not cheat_bucket_capacity:
                 msg = f"Requested amount exceeds bucket capacity. Bucket capacity: {self.capacity}, requested amount: {amount}. As the bucket never overflows, the requested amount will never be available."
                 raise ValueError(msg)
             else:
-                self.tokens = 0  # clear the bucket but let it go through
-                return
-
-        while self.tokens < amount:
-            self.refill()
-            await asyncio.sleep(0.01)  # Sleep briefly to prevent busy waiting
-        self.tokens -= amount
+                # self.tokens = 0  # clear the bucket but let it go through
+                # print(
+                #    f"""The requested amount, {amount}, exceeds the current bucket capacity of {self.capacity}.Increasing bucket capacity to {amount} * 1.10 accommodate the requested amount."""
+                # )
+                self.capacity = amount * 1.10
+                self._old_capacity = self.capacity
+
+        start_time = time.monotonic()
+        while True:
+            self.refill()  # Refill based on elapsed time
+            if self.tokens >= amount:
+                self.tokens -= amount
+                break
+
+            wait_time = self.wait_time(amount)
+            # print(f"Waiting for {wait_time:.4f} seconds")
+            if wait_time > 0:
+                # print(f"Waiting for {wait_time:.4f} seconds")
+                await asyncio.sleep(wait_time)
+
+        # total_elapsed = time.monotonic() - start_time
+        # print(f"Total time to acquire tokens: {total_elapsed:.4f} seconds")
 
         now = time.monotonic()
         self.log.append((now, self.tokens))
+        return None
 
     def get_log(self) -> list[tuple]:
         return self.log

edsl/jobs/interviews/Interview.py

@@ -1,50 +1,68 @@
 """This module contains the Interview class, which is responsible for conducting an interview asynchronously."""
 
 from __future__ import annotations
-import traceback
 import asyncio
-import time
-from typing import Any, Type, List, Generator, Optional
+from typing import Any, Type, List, Generator, Optional, Union
 
-from edsl.jobs.Answers import Answers
+from edsl import CONFIG
 from edsl.surveys.base import EndOfSurvey
+from edsl.exceptions import QuestionAnswerValidationError
+from edsl.exceptions import InterviewTimeoutError
+from edsl.data_transfer_models import AgentResponseDict, EDSLResultObjectInput
+
 from edsl.jobs.buckets.ModelBuckets import ModelBuckets
+from edsl.jobs.Answers import Answers
+from edsl.jobs.tasks.QuestionTaskCreator import QuestionTaskCreator
 from edsl.jobs.tasks.TaskCreators import TaskCreators
-
 from edsl.jobs.interviews.InterviewStatusLog import InterviewStatusLog
 from edsl.jobs.interviews.interview_exception_tracking import (
     InterviewExceptionCollection,
 )
 from edsl.jobs.interviews.InterviewExceptionEntry import InterviewExceptionEntry
 from edsl.jobs.interviews.retry_management import retry_strategy
-from edsl.jobs.interviews.InterviewTaskBuildingMixin import InterviewTaskBuildingMixin
 from edsl.jobs.interviews.InterviewStatusMixin import InterviewStatusMixin
 
-import asyncio
+from edsl.surveys.base import EndOfSurvey
+from edsl.jobs.buckets.ModelBuckets import ModelBuckets
+from edsl.jobs.interviews.InterviewExceptionEntry import InterviewExceptionEntry
+from edsl.jobs.interviews.retry_management import retry_strategy
+from edsl.jobs.tasks.task_status_enum import TaskStatus
+from edsl.jobs.tasks.QuestionTaskCreator import QuestionTaskCreator
+
+from edsl.exceptions import QuestionAnswerValidationError
+
+from edsl import Agent, Survey, Scenario, Cache
+from edsl.language_models import LanguageModel
+from edsl.questions import QuestionBase
+from edsl.agents.InvigilatorBase import InvigilatorBase
+
+from edsl.exceptions.language_models import LanguageModelNoResponseError
 
 
-def run_async(coro):
-    return asyncio.run(coro)
+class RetryableLanguageModelNoResponseError(LanguageModelNoResponseError):
+    pass
 
 
-class Interview(InterviewStatusMixin, InterviewTaskBuildingMixin):
+class Interview(InterviewStatusMixin):
     """
     An 'interview' is one agent answering one survey, with one language model, for a given scenario.
 
     The main method is `async_conduct_interview`, which conducts the interview asynchronously.
+    Most of the class is dedicated to creating the tasks for each question in the survey, and then running them.
     """
 
     def __init__(
         self,
-        agent: "Agent",
-        survey: "Survey",
-        scenario: "Scenario",
+        agent: Agent,
+        survey: Survey,
+        scenario: Scenario,
         model: Type["LanguageModel"],
         debug: Optional[bool] = False,
         iteration: int = 0,
         cache: Optional["Cache"] = None,
         sidecar_model: Optional["LanguageModel"] = None,
-        skip_retry=False,
+        skip_retry: bool = False,
+        raise_validation_errors: bool = True,
     ):
         """Initialize the Interview instance.
 
@@ -79,9 +97,9 @@ class Interview(InterviewStatusMixin, InterviewTaskBuildingMixin):
         self.debug = debug
         self.iteration = iteration
         self.cache = cache
-        self.answers: dict[
-            str, str
-        ] = Answers()  # will get filled in as interview progresses
+        self.answers: dict[str, str] = (
+            Answers()
+        )  # will get filled in as interview progresses
         self.sidecar_model = sidecar_model
 
         # Trackers
@@ -89,6 +107,7 @@ class Interview(InterviewStatusMixin, InterviewTaskBuildingMixin):
         self.exceptions = InterviewExceptionCollection()
         self._task_status_log_dict = InterviewStatusLog()
         self.skip_retry = skip_retry
+        self.raise_validation_errors = raise_validation_errors
 
         # dictionary mapping question names to their index in the survey.
         self.to_index = {
@@ -96,6 +115,9 @@ class Interview(InterviewStatusMixin, InterviewTaskBuildingMixin):
             for index, question_name in enumerate(self.survey.question_names)
         }
 
+        self.failed_questions = []
+
+    # region: Serialization
     def _to_dict(self, include_exceptions=False) -> dict[str, Any]:
         """Return a dictionary representation of the Interview instance.
         This is just for hashing purposes.
@@ -120,13 +142,247 @@ class Interview(InterviewStatusMixin, InterviewTaskBuildingMixin):
 
         return dict_hash(self._to_dict())
 
-    async def async_conduct_interview(
+    # endregion
+
+    # region: Creating tasks
+    @property
+    def dag(self) -> "DAG":
+        """Return the directed acyclic graph for the survey.
+
+        The DAG, or directed acyclic graph, is a dictionary that maps question names to their dependencies.
+        It is used to determine the order in which questions should be answered.
+        This reflects both agent 'memory' considerations and 'skip' logic.
+        The 'textify' parameter is set to True, so that the question names are returned as strings rather than integer indices.
+
+        >>> i = Interview.example()
+        >>> i.dag == {'q2': {'q0'}, 'q1': {'q0'}}
+        True
+        """
+        return self.survey.dag(textify=True)
+
+    def _build_question_tasks(
+        self,
+        model_buckets: ModelBuckets,
+    ) -> list[asyncio.Task]:
+        """Create a task for each question, with dependencies on the questions that must be answered before this one can be answered.
+
+        :param debug: whether to use debug mode, in which case `InvigilatorDebug` is used.
+        :param model_buckets: the model buckets used to track and control usage rates.
+        """
+        tasks = []
+        for question in self.survey.questions:
+            tasks_that_must_be_completed_before = list(
+                self._get_tasks_that_must_be_completed_before(
+                    tasks=tasks, question=question
+                )
+            )
+            question_task = self._create_question_task(
+                question=question,
+                tasks_that_must_be_completed_before=tasks_that_must_be_completed_before,
+                model_buckets=model_buckets,
+                iteration=self.iteration,
+            )
+            tasks.append(question_task)
+        return tuple(tasks)
+
+    def _get_tasks_that_must_be_completed_before(
+        self, *, tasks: list[asyncio.Task], question: "QuestionBase"
+    ) -> Generator[asyncio.Task, None, None]:
+        """Return the tasks that must be completed before the given question can be answered.
+
+        :param tasks: a list of tasks that have been created so far.
+        :param question: the question for which we are determining dependencies.
+
+        If a question has no dependencies, this will be an empty list, [].
+        """
+        parents_of_focal_question = self.dag.get(question.question_name, [])
+        for parent_question_name in parents_of_focal_question:
+            yield tasks[self.to_index[parent_question_name]]
+
+    def _create_question_task(
+        self,
+        *,
+        question: QuestionBase,
+        tasks_that_must_be_completed_before: list[asyncio.Task],
+        model_buckets: ModelBuckets,
+        iteration: int = 0,
+    ) -> asyncio.Task:
+        """Create a task that depends on the passed-in dependencies that are awaited before the task is run.
+
+        :param question: the question to be answered. This is the question we are creating a task for.
+        :param tasks_that_must_be_completed_before: the tasks that must be completed before the focal task is run.
+        :param model_buckets: the model buckets used to track and control usage rates.
+        :param debug: whether to use debug mode, in which case `InvigilatorDebug` is used.
+        :param iteration: the iteration number for the interview.
+
+        The task is created by a `QuestionTaskCreator`, which is responsible for creating the task and managing its dependencies.
+        It is passed a reference to the function that will be called to answer the question.
+        It is passed a list "tasks_that_must_be_completed_before" that are awaited before the task is run.
+        These are added as a dependency to the focal task.
+        """
+        task_creator = QuestionTaskCreator(
+            question=question,
+            answer_question_func=self._answer_question_and_record_task,
+            token_estimator=self._get_estimated_request_tokens,
+            model_buckets=model_buckets,
+            iteration=iteration,
+        )
+        for task in tasks_that_must_be_completed_before:
+            task_creator.add_dependency(task)
+
+        self.task_creators.update(
+            {question.question_name: task_creator}
+        )  # track this task creator
+        return task_creator.generate_task()
+
+    def _get_estimated_request_tokens(self, question) -> float:
+        """Estimate the number of tokens that will be required to run the focal task."""
+        invigilator = self._get_invigilator(question=question)
+        # TODO: There should be a way to get a more accurate estimate.
+        combined_text = ""
+        for prompt in invigilator.get_prompts().values():
+            if hasattr(prompt, "text"):
+                combined_text += prompt.text
+            elif isinstance(prompt, str):
+                combined_text += prompt
+            else:
+                raise ValueError(f"Prompt is of type {type(prompt)}")
+        return len(combined_text) / 4.0
+
+    async def _answer_question_and_record_task(
         self,
         *,
-        model_buckets: ModelBuckets = None,
-        debug: bool = False,
+        question: "QuestionBase",
+        task=None,
+    ) -> "AgentResponseDict":
+        """Answer a question and records the task."""
+
+        invigilator = self._get_invigilator(question)
+
+        if self._skip_this_question(question):
+            response = invigilator.get_failed_task_result(
+                failure_reason="Question skipped."
+            )
+
+        try:
+            response: EDSLResultObjectInput = await invigilator.async_answer_question()
+            if response.validated:
+                self.answers.add_answer(response=response, question=question)
+                self._cancel_skipped_questions(question)
+            else:
+                if (
+                    hasattr(response, "exception_occurred")
+                    and response.exception_occurred
+                ):
+                    raise response.exception_occurred
+
+        except QuestionAnswerValidationError as e:
+            # there's a response, but it couldn't be validated
+            self._handle_exception(e, invigilator, task)
+
+        except asyncio.TimeoutError as e:
+            # the API timed-out - this is recorded but as a response isn't generated, the LanguageModelNoResponseError will also be raised
+            self._handle_exception(e, invigilator, task)
+
+        except Exception as e:
+            # there was some other exception
+            self._handle_exception(e, invigilator, task)
+
+        if "response" not in locals():
+
+            raise LanguageModelNoResponseError(
+                f"Language model did not return a response for question '{question.question_name}.'"
+            )
+
+        return response
+
+    def _get_invigilator(self, question: QuestionBase) -> InvigilatorBase:
+        """Return an invigilator for the given question.
+
+        :param question: the question to be answered
+        :param debug: whether to use debug mode, in which case `InvigilatorDebug` is used.
+        """
+        invigilator = self.agent.create_invigilator(
+            question=question,
+            scenario=self.scenario,
+            model=self.model,
+            debug=False,
+            survey=self.survey,
+            memory_plan=self.survey.memory_plan,
+            current_answers=self.answers,
+            iteration=self.iteration,
+            cache=self.cache,
+            sidecar_model=self.sidecar_model,
+            raise_validation_errors=self.raise_validation_errors,
+        )
+        """Return an invigilator for the given question."""
+        return invigilator
+
+    def _skip_this_question(self, current_question: "QuestionBase") -> bool:
+        """Determine if the current question should be skipped.
+
+        :param current_question: the question to be answered.
+        """
+        current_question_index = self.to_index[current_question.question_name]
+
+        answers = self.answers | self.scenario | self.agent["traits"]
+        skip = self.survey.rule_collection.skip_question_before_running(
+            current_question_index, answers
+        )
+        return skip
+
+    def _handle_exception(
+        self, e: Exception, invigilator: "InvigilatorBase", task=None
+    ):
+        exception_entry = InterviewExceptionEntry(
+            exception=e,
+            invigilator=invigilator,
+        )
+        if task:
+            task.task_status = TaskStatus.FAILED
+        self.exceptions.add(invigilator.question.question_name, exception_entry)
+
+    def _cancel_skipped_questions(self, current_question: QuestionBase) -> None:
+        """Cancel the tasks for questions that are skipped.
+
+        :param current_question: the question that was just answered.
+
+        It first determines the next question, given the current question and the current answers.
+        If the next question is the end of the survey, it cancels all remaining tasks.
+        If the next question is after the current question, it cancels all tasks between the current question and the next question.
+        """
+        current_question_index: int = self.to_index[current_question.question_name]
+
+        next_question: Union[int, EndOfSurvey] = (
+            self.survey.rule_collection.next_question(
+                q_now=current_question_index,
+                answers=self.answers | self.scenario | self.agent["traits"],
+            )
+        )
+
+        next_question_index = next_question.next_q
+
+        def cancel_between(start, end):
+            """Cancel the tasks between the start and end indices."""
+            for i in range(start, end):
+                self.tasks[i].cancel()
+
+        if next_question_index == EndOfSurvey:
+            cancel_between(current_question_index + 1, len(self.survey.questions))
+            return
+
+        if next_question_index > (current_question_index + 1):
+            cancel_between(current_question_index + 1, next_question_index)
+
+    # endregion
+
+    # region: Conducting the interview
+    async def async_conduct_interview(
+        self,
+        model_buckets: Optional[ModelBuckets] = None,
         stop_on_exception: bool = False,
         sidecar_model: Optional["LanguageModel"] = None,
+        raise_validation_errors: bool = True,
     ) -> tuple["Answers", List[dict[str, Any]]]:
         """
         Conduct an Interview asynchronously.
@@ -146,19 +402,6 @@ class Interview(InterviewStatusMixin, InterviewTaskBuildingMixin):
 
         >>> i = Interview.example(throw_exception = True)
         >>> result, _ = asyncio.run(i.async_conduct_interview())
-        Attempt 1 failed with exception:This is a test error now waiting 1.00 seconds before retrying.Parameters: start=1.0, max=60.0, max_attempts=5.
-        <BLANKLINE>
-        <BLANKLINE>
-        Attempt 2 failed with exception:This is a test error now waiting 2.00 seconds before retrying.Parameters: start=1.0, max=60.0, max_attempts=5.
-        <BLANKLINE>
-        <BLANKLINE>
-        Attempt 3 failed with exception:This is a test error now waiting 4.00 seconds before retrying.Parameters: start=1.0, max=60.0, max_attempts=5.
-        <BLANKLINE>
-        <BLANKLINE>
-        Attempt 4 failed with exception:This is a test error now waiting 8.00 seconds before retrying.Parameters: start=1.0, max=60.0, max_attempts=5.
-        <BLANKLINE>
-        <BLANKLINE>
-
         >>> i.exceptions
         {'q0': ...
         >>> i = Interview.example()
@@ -173,21 +416,22 @@ class Interview(InterviewStatusMixin, InterviewTaskBuildingMixin):
         if model_buckets is None or hasattr(self.agent, "answer_question_directly"):
             model_buckets = ModelBuckets.infinity_bucket()
 
-        ## build the tasks using the InterviewTaskBuildingMixin
         ## This is the key part---it creates a task for each question,
         ## with dependencies on the questions that must be answered before this one can be answered.
-        self.tasks = self._build_question_tasks(
-            debug=debug, model_buckets=model_buckets
-        )
+        self.tasks = self._build_question_tasks(model_buckets=model_buckets)
 
         ## 'Invigilators' are used to administer the survey
-        self.invigilators = list(self._build_invigilators(debug=debug))
-        # await the tasks being conducted
+        self.invigilators = [
+            self._get_invigilator(question) for question in self.survey.questions
+        ]
         await asyncio.gather(*self.tasks, return_exceptions=not stop_on_exception)
         self.answers.replace_missing_answers_with_none(self.survey)
         valid_results = list(self._extract_valid_results())
         return self.answers, valid_results
 
+    # endregion
+
+    # region: Extracting results and recording errors
     def _extract_valid_results(self) -> Generator["Answers", None, None]:
         """Extract the valid results from the list of results.
 
@@ -200,8 +444,6 @@ class Interview(InterviewStatusMixin, InterviewTaskBuildingMixin):
         >>> results = list(i._extract_valid_results())
         >>> len(results) == len(i.survey)
         True
-        >>> type(results[0])
-        <class 'edsl.data_transfer_models.AgentResponseDict'>
         """
         assert len(self.tasks) == len(self.invigilators)
 
@@ -212,46 +454,24 @@ class Interview(InterviewStatusMixin, InterviewTaskBuildingMixin):
             try:
                 result = task.result()
             except asyncio.CancelledError as e:  # task was cancelled
-                result = invigilator.get_failed_task_result()
+                result = invigilator.get_failed_task_result(
+                    failure_reason="Task was cancelled."
+                )
             except Exception as e:  # any other kind of exception in the task
-                result = invigilator.get_failed_task_result()
-                self._record_exception(task, e)
-            yield result
+                result = invigilator.get_failed_task_result(
+                    failure_reason=f"Task failed with exception: {str(e)}."
+                )
+                exception_entry = InterviewExceptionEntry(
+                    exception=e,
+                    invigilator=invigilator,
+                )
+                self.exceptions.add(task.get_name(), exception_entry)
 
-    def _record_exception(self, task, exception: Exception) -> None:
-        """Record an exception in the Interview instance.
-
-        It records the exception in the Interview instance, with the task name and the exception entry.
-
-        >>> i = Interview.example()
-        >>> result, _ = asyncio.run(i.async_conduct_interview())
-        >>> i.exceptions
-        {}
-        >>> i._record_exception(i.tasks[0], Exception("An exception occurred."))
-        >>> i.exceptions
-        {'q0': ...
-        """
-        exception_entry = InterviewExceptionEntry(exception)
-        self.exceptions.add(task.get_name(), exception_entry)
-
-    @property
-    def dag(self) -> "DAG":
-        """Return the directed acyclic graph for the survey.
-
-        The DAG, or directed acyclic graph, is a dictionary that maps question names to their dependencies.
-        It is used to determine the order in which questions should be answered.
-        This reflects both agent 'memory' considerations and 'skip' logic.
-        The 'textify' parameter is set to True, so that the question names are returned as strings rather than integer indices.
+            yield result
 
-        >>> i = Interview.example()
-        >>> i.dag == {'q2': {'q0'}, 'q1': {'q0'}}
-        True
-        """
-        return self.survey.dag(textify=True)
+    # endregion
 
-    #######################
-    # Dunder methods
-    #######################
+    # region: Magic methods
     def __repr__(self) -> str:
         """Return a string representation of the Interview instance."""
         return f"Interview(agent = {repr(self.agent)}, survey = {repr(self.survey)}, scenario = {repr(self.scenario)}, model = {repr(self.model)})"