edsl 0.1.32__py3-none-any.whl → 0.1.33__py3-none-any.whl

edsl/jobs/interviews/InterviewTaskBuildingMixin.py

@@ -1,286 +0,0 @@
-"""This module contains the Interview class, which is responsible for conducting an interview asynchronously."""
-
-from __future__ import annotations
-import asyncio
-import time
-import traceback
-from typing import Generator, Union
-
-from edsl import CONFIG
-from edsl.exceptions import InterviewTimeoutError
-
-# from edsl.questions.QuestionBase import QuestionBase
-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.agents.InvigilatorBase import InvigilatorBase
-
-from rich.console import Console
-from rich.traceback import Traceback
-
-TIMEOUT = float(CONFIG.get("EDSL_API_TIMEOUT"))
-
-
-def frame_summary_to_dict(frame):
-    """
-    Convert a FrameSummary object to a dictionary.
-
-    :param frame: A traceback FrameSummary object
-    :return: A dictionary containing the frame's details
-    """
-    return {
-        "filename": frame.filename,
-        "lineno": frame.lineno,
-        "name": frame.name,
-        "line": frame.line,
-    }
-
-
-class InterviewTaskBuildingMixin:
-    def _build_invigilators(
-        self, debug: bool
-    ) -> Generator["InvigilatorBase", None, None]:
-        """Create an invigilator for each question.
-
-        :param debug: whether to use debug mode, in which case `InvigilatorDebug` is used.
-
-        An invigilator is responsible for answering a particular question in the survey.
-        """
-        for question in self.survey.questions:
-            yield self._get_invigilator(question=question, debug=debug)
-
-    def _get_invigilator(self, question: "QuestionBase", debug: bool) -> "Invigilator":
-        """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=debug,
-            survey=self.survey,
-            memory_plan=self.survey.memory_plan,
-            current_answers=self.answers,
-            iteration=self.iteration,
-            cache=self.cache,
-            sidecar_model=self.sidecar_model,
-        )
-        """Return an invigilator for the given question."""
-        return invigilator
-
-    def _build_question_tasks(
-        self,
-        debug: bool,
-        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,
-                debug=debug,
-                iteration=self.iteration,
-            )
-            tasks.append(question_task)
-        return tuple(tasks)  # , invigilators
-
-    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,
-        debug: bool,
-        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(debug)
-
-    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, debug=False)
-        # 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,
-        *,
-        question: "QuestionBase",
-        debug: bool,
-        task=None,
-    ) -> "AgentResponseDict":
-        """Answer a question and records the task.
-
-        This in turn calls the the passed-in agent's async_answer_question method, which returns a response dictionary.
-        Note that is updates answers dictionary with the response.
-        """
-        from edsl.data_transfer_models import AgentResponseDict
-
-        async def _inner():
-            try:
-                invigilator = self._get_invigilator(question, debug=debug)
-
-                if self._skip_this_question(question):
-                    return invigilator.get_failed_task_result()
-
-                response: AgentResponseDict = await self._attempt_to_answer_question(
-                    invigilator, task
-                )
-
-                self._add_answer(response=response, question=question)
-
-                self._cancel_skipped_questions(question)
-                return AgentResponseDict(**response)
-            except Exception as e:
-                raise e
-
-        skip_rety = getattr(self, "skip_retry", False)
-        if not skip_rety:
-            _inner = retry_strategy(_inner)
-
-        return await _inner()
-
-    def _add_answer(
-        self, response: "AgentResponseDict", question: "QuestionBase"
-    ) -> None:
-        """Add the answer to the answers dictionary.
-
-        :param response: the response to the question.
-        :param question: the question that was answered.
-        """
-        self.answers.add_answer(response=response, question=question)
-
-    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, question_name: str, task=None):
-        exception_entry = InterviewExceptionEntry(e)
-        if task:
-            task.task_status = TaskStatus.FAILED
-        self.exceptions.add(question_name, exception_entry)
-
-    async def _attempt_to_answer_question(
-        self, invigilator: "InvigilatorBase", task: asyncio.Task
-    ) -> "AgentResponseDict":
-        """Attempt to answer the question, and handle exceptions.
-
-        :param invigilator: the invigilator that will answer the question.
-        :param task: the task that is being run.
-
-        """
-        try:
-            return await asyncio.wait_for(
-                invigilator.async_answer_question(), timeout=TIMEOUT
-            )
-        except asyncio.TimeoutError as e:
-            self._handle_exception(e, invigilator.question.question_name, task)
-            raise InterviewTimeoutError(f"Task timed out after {TIMEOUT} seconds.")
-        except Exception as e:
-            self._handle_exception(e, invigilator.question.question_name, task)
-            raise e
-
-    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)

edsl/jobs/interviews/retry_management.py

@@ -1,37 +0,0 @@
-from edsl import CONFIG
-
-from tenacity import (
-    retry,
-    wait_exponential,
-    stop_after_attempt,
-    retry_if_exception_type,
-    before_sleep,
-)
-
-EDSL_BACKOFF_START_SEC = float(CONFIG.get("EDSL_BACKOFF_START_SEC"))
-EDSL_MAX_BACKOFF_SEC = float(CONFIG.get("EDSL_MAX_BACKOFF_SEC"))
-EDSL_MAX_ATTEMPTS = int(CONFIG.get("EDSL_MAX_ATTEMPTS"))
-
-
-def print_retry(retry_state, print_to_terminal=True):
-    "Prints details on tenacity retries."
-    attempt_number = retry_state.attempt_number
-    exception = retry_state.outcome.exception()
-    wait_time = retry_state.next_action.sleep
-    if print_to_terminal:
-        print(
-            f"Attempt {attempt_number} failed with exception:" f"{exception}",
-            f"now waiting {wait_time:.2f} seconds before retrying."
-            f"Parameters: start={EDSL_BACKOFF_START_SEC}, max={EDSL_MAX_BACKOFF_SEC}, max_attempts={EDSL_MAX_ATTEMPTS}."
-            "\n\n",
-        )
-
-
-retry_strategy = retry(
-    wait=wait_exponential(
-        multiplier=EDSL_BACKOFF_START_SEC, max=EDSL_MAX_BACKOFF_SEC
-    ),  # Exponential back-off starting at 1s, doubling, maxing out at 60s
-    stop=stop_after_attempt(EDSL_MAX_ATTEMPTS),  # Stop after 5 attempts
-    # retry=retry_if_exception_type(Exception),  # Customize this as per your specific retry-able exception
-    before_sleep=print_retry,  # Use custom print function for retries
-)

edsl/jobs/runners/JobsRunnerStatusMixin.py

@@ -1,333 +0,0 @@
-from __future__ import annotations
-from typing import List, DefaultDict
-import asyncio
-from typing import Type
-from collections import defaultdict
-
-from typing import Literal, List, Type, DefaultDict
-from collections import UserDict, defaultdict
-
-from edsl.jobs.interviews.InterviewStatusDictionary import InterviewStatusDictionary
-from edsl.jobs.tokens.InterviewTokenUsage import InterviewTokenUsage
-from edsl.jobs.tokens.TokenUsage import TokenUsage
-from edsl.enums import get_token_pricing
-from edsl.jobs.tasks.task_status_enum import TaskStatus
-
-InterviewTokenUsageMapping = DefaultDict[str, InterviewTokenUsage]
-
-from edsl.jobs.interviews.InterviewStatistic import InterviewStatistic
-from edsl.jobs.interviews.InterviewStatisticsCollection import (
-    InterviewStatisticsCollection,
-)
-from edsl.jobs.tokens.InterviewTokenUsage import InterviewTokenUsage
-
-
-# return {"cache_status": token_usage_type, "details": details, "cost": f"${token_usage.cost(prices):.5f}"}
-
-from dataclasses import dataclass, asdict
-
-from rich.text import Text
-from rich.box import SIMPLE
-from rich.table import Table
-
-
-@dataclass
-class ModelInfo:
-    model_name: str
-    TPM_limit_k: float
-    RPM_limit_k: float
-    num_tasks_waiting: int
-    token_usage_info: dict
-
-
-@dataclass
-class ModelTokenUsageStats:
-    token_usage_type: str
-    details: List[dict]
-    cost: str
-
-
-class Stats:
-    def elapsed_time(self):
-        InterviewStatistic("elapsed_time", value=elapsed_time, digits=1, units="sec.")
-
-
-class JobsRunnerStatusMixin:
-    # @staticmethod
-    # def status_dict(interviews: List[Type["Interview"]]) -> List[Type[InterviewStatusDictionary]]:
-    #     """
-    #     >>> from edsl.jobs.interviews.Interview import Interview
-    #     >>> interviews = [Interview.example()]
-    #     >>> JobsRunnerStatusMixin().status_dict(interviews)
-    #     [InterviewStatusDictionary({<TaskStatus.NOT_STARTED: 1>: 0, <TaskStatus.WAITING_FOR_DEPENDENCIES: 2>: 0, <TaskStatus.CANCELLED: 3>: 0, <TaskStatus.PARENT_FAILED: 4>: 0, <TaskStatus.WAITING_FOR_REQUEST_CAPACITY: 5>: 0, <TaskStatus.WAITING_FOR_TOKEN_CAPACITY: 6>: 0, <TaskStatus.API_CALL_IN_PROGRESS: 7>: 0, <TaskStatus.SUCCESS: 8>: 0, <TaskStatus.FAILED: 9>: 0, 'number_from_cache': 0})]
-    #     """
-    #     return [interview.interview_status for interview in interviews]
-
-    def _compute_statistic(stat_name: str, completed_tasks, elapsed_time, interviews):
-        stat_definitions = {
-            "elapsed_time": lambda: InterviewStatistic(
-                "elapsed_time", value=elapsed_time, digits=1, units="sec."
-            ),
-            "total_interviews_requested": lambda: InterviewStatistic(
-                "total_interviews_requested", value=len(interviews), units=""
-            ),
-            "completed_interviews": lambda: InterviewStatistic(
-                "completed_interviews", value=len(completed_tasks), units=""
-            ),
-            "percent_complete": lambda: InterviewStatistic(
-                "percent_complete",
-                value=(
-                    len(completed_tasks) / len(interviews) * 100
-                    if len(interviews) > 0
-                    else "NA"
-                ),
-                digits=0,
-                units="%",
-            ),
-            "average_time_per_interview": lambda: InterviewStatistic(
-                "average_time_per_interview",
-                value=elapsed_time / len(completed_tasks) if completed_tasks else "NA",
-                digits=1,
-                units="sec.",
-            ),
-            "task_remaining": lambda: InterviewStatistic(
-                "task_remaining", value=len(interviews) - len(completed_tasks), units=""
-            ),
-            "estimated_time_remaining": lambda: InterviewStatistic(
-                "estimated_time_remaining",
-                value=(
-                    (len(interviews) - len(completed_tasks))
-                    * (elapsed_time / len(completed_tasks))
-                    if len(completed_tasks) > 0
-                    else "NA"
-                ),
-                digits=1,
-                units="sec.",
-            ),
-        }
-        if stat_name not in stat_definitions:
-            raise ValueError(
-                f"Invalid stat_name: {stat_name}. The valid stat_names are: {list(stat_definitions.keys())}"
-            )
-        return stat_definitions[stat_name]()
-
-    @staticmethod
-    def _job_level_info(
-        completed_tasks: List[Type[asyncio.Task]],
-        elapsed_time: float,
-        interviews: List[Type["Interview"]],
-    ) -> InterviewStatisticsCollection:
-        interview_statistics = InterviewStatisticsCollection()
-
-        default_statistics = [
-            "elapsed_time",
-            "total_interviews_requested",
-            "completed_interviews",
-            "percent_complete",
-            "average_time_per_interview",
-            "task_remaining",
-            "estimated_time_remaining",
-        ]
-        for stat_name in default_statistics:
-            interview_statistics.add_stat(
-                JobsRunnerStatusMixin._compute_statistic(
-                    stat_name, completed_tasks, elapsed_time, interviews
-                )
-            )
-
-        return interview_statistics
-
-    @staticmethod
-    def _get_model_queues_info(interviews):
-        models_to_tokens = defaultdict(InterviewTokenUsage)
-        model_to_status = defaultdict(InterviewStatusDictionary)
-        waiting_dict = defaultdict(int)
-
-        for interview in interviews:
-            models_to_tokens[interview.model] += interview.token_usage
-            model_to_status[interview.model] += interview.interview_status
-            waiting_dict[interview.model] += interview.interview_status.waiting
-
-        for model, num_waiting in waiting_dict.items():
-            yield JobsRunnerStatusMixin._get_model_info(
-                model, num_waiting, models_to_tokens
-            )
-
-    @staticmethod
-    def generate_status_summary(
-        completed_tasks: List[Type[asyncio.Task]],
-        elapsed_time: float,
-        interviews: List[Type["Interview"]],
-        include_model_queues=False,
-    ) -> InterviewStatisticsCollection:
-        """Generate a summary of the status of the job runner.
-
-        :param completed_tasks: list of completed tasks
-        :param elapsed_time: time elapsed since the start of the job
-        :param interviews: list of interviews to be conducted
-
-        >>> from edsl.jobs.interviews.Interview import Interview
-        >>> interviews = [Interview.example()]
-        >>> completed_tasks = []
-        >>> elapsed_time = 0
-        >>> JobsRunnerStatusMixin().generate_status_summary(completed_tasks, elapsed_time, interviews)
-        {'Elapsed time': '0.0 sec.', 'Total interviews requested': '1 ', 'Completed interviews': '0 ', 'Percent complete': '0 %', 'Average time per interview': 'NA', 'Task remaining': '1 ', 'Estimated time remaining': 'NA'}
-        """
-
-        interview_status_summary: InterviewStatisticsCollection = (
-            JobsRunnerStatusMixin._job_level_info(
-                completed_tasks=completed_tasks,
-                elapsed_time=elapsed_time,
-                interviews=interviews,
-            )
-        )
-        if include_model_queues:
-            interview_status_summary.model_queues = list(
-                JobsRunnerStatusMixin._get_model_queues_info(interviews)
-            )
-        else:
-            interview_status_summary.model_queues = None
-
-        return interview_status_summary
-
-    @staticmethod
-    def _get_model_info(
-        model: str,
-        num_waiting: int,
-        models_to_tokens: InterviewTokenUsageMapping,
-    ) -> dict:
-        """Get the status of a model.
-
-        :param model: the model name
-        :param num_waiting: the number of tasks waiting for capacity
-        :param models_to_tokens: a mapping of models to token usage
-
-        >>> from edsl.jobs.interviews.Interview import Interview
-        >>> interviews = [Interview.example()]
-        >>> models_to_tokens = defaultdict(InterviewTokenUsage)
-        >>> model = interviews[0].model
-        >>> num_waiting = 0
-        >>> JobsRunnerStatusMixin()._get_model_info(model, num_waiting, models_to_tokens)
-        ModelInfo(model_name='gpt-4-1106-preview', TPM_limit_k=480.0, RPM_limit_k=4.0, num_tasks_waiting=0, token_usage_info=[ModelTokenUsageStats(token_usage_type='new_token_usage', details=[{'type': 'prompt_tokens', 'tokens': 0}, {'type': 'completion_tokens', 'tokens': 0}], cost='$0.00000'), ModelTokenUsageStats(token_usage_type='cached_token_usage', details=[{'type': 'prompt_tokens', 'tokens': 0}, {'type': 'completion_tokens', 'tokens': 0}], cost='$0.00000')])
-        """
-
-        ## TODO: This should probably be a coop method
-        prices = get_token_pricing(model.model)
-
-        token_usage_info = []
-        for token_usage_type in ["new_token_usage", "cached_token_usage"]:
-            token_usage_info.append(
-                JobsRunnerStatusMixin._get_token_usage_info(
-                    token_usage_type, models_to_tokens, model, prices
-                )
-            )
-
-        return ModelInfo(
-            **{
-                "model_name": model.model,
-                "TPM_limit_k": model.TPM / 1000,
-                "RPM_limit_k": model.RPM / 1000,
-                "num_tasks_waiting": num_waiting,
-                "token_usage_info": token_usage_info,
-            }
-        )
-
-    @staticmethod
-    def _get_token_usage_info(
-        token_usage_type: Literal["new_token_usage", "cached_token_usage"],
-        models_to_tokens: InterviewTokenUsageMapping,
-        model: str,
-        prices: "TokenPricing",
-    ) -> ModelTokenUsageStats:
-        """Get the token usage info for a model.
-
-        >>> from edsl.jobs.interviews.Interview import Interview
-        >>> interviews = [Interview.example()]
-        >>> models_to_tokens = defaultdict(InterviewTokenUsage)
-        >>> model = interviews[0].model
-        >>> prices = get_token_pricing(model.model)
-        >>> cache_status = "new_token_usage"
-        >>> JobsRunnerStatusMixin()._get_token_usage_info(cache_status, models_to_tokens, model, prices)
-        ModelTokenUsageStats(token_usage_type='new_token_usage', details=[{'type': 'prompt_tokens', 'tokens': 0}, {'type': 'completion_tokens', 'tokens': 0}], cost='$0.00000')
-
-        """
-        all_token_usage: InterviewTokenUsage = models_to_tokens[model]
-        token_usage: TokenUsage = getattr(all_token_usage, token_usage_type)
-
-        details = [
-            {"type": token_type, "tokens": getattr(token_usage, token_type)}
-            for token_type in ["prompt_tokens", "completion_tokens"]
-        ]
-
-        return ModelTokenUsageStats(
-            token_usage_type=token_usage_type,
-            details=details,
-            cost=f"${token_usage.cost(prices):.5f}",
-        )
-
-    @staticmethod
-    def _add_statistics_to_table(table, status_summary):
-        table.add_column("Statistic", style="dim", no_wrap=True, width=50)
-        table.add_column("Value", width=10)
-
-        for key, value in status_summary.items():
-            if key != "model_queues":
-                table.add_row(key, value)
-
-    @staticmethod
-    def display_status_table(status_summary: InterviewStatisticsCollection) -> "Table":
-        table = Table(
-            title="Job Status",
-            show_header=True,
-            header_style="bold magenta",
-            box=SIMPLE,
-        )
-
-        ### Job-level statistics
-        JobsRunnerStatusMixin._add_statistics_to_table(table, status_summary)
-
-        ## Model-level statistics
-        spacing = " "
-
-        if status_summary.model_queues is not None:
-            table.add_row(Text("Model Queues", style="bold red"), "")
-            for model_info in status_summary.model_queues:
-                model_name = model_info.model_name
-                tpm = f"TPM (k)={model_info.TPM_limit_k}"
-                rpm = f"RPM (k)= {model_info.RPM_limit_k}"
-                pretty_model_name = model_name + ";" + tpm + ";" + rpm
-                table.add_row(Text(pretty_model_name, style="blue"), "")
-                table.add_row(
-                    "Number question tasks waiting for capacity",
-                    str(model_info.num_tasks_waiting),
-                )
-                # Token usage and cost info
-                for token_usage_info in model_info.token_usage_info:
-                    token_usage_type = token_usage_info.token_usage_type
-                    table.add_row(
-                        Text(
-                            spacing + token_usage_type.replace("_", " "), style="bold"
-                        ),
-                        "",
-                    )
-                    for detail in token_usage_info.details:
-                        token_type = detail["type"]
-                        tokens = detail["tokens"]
-                        table.add_row(spacing + f"{token_type}", f"{tokens:,}")
-                    # table.add_row(spacing + "cost", cache_info["cost"])
-
-        return table
-
-    def status_table(self, completed_tasks: List[asyncio.Task], elapsed_time: float):
-        summary_data = JobsRunnerStatusMixin.generate_status_summary(
-            completed_tasks=completed_tasks,
-            elapsed_time=elapsed_time,
-            interviews=self.total_interviews,
-        )
-        return self.display_status_table(summary_data)
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod(optionflags=doctest.ELLIPSIS)

edsl/utilities/gcp_bucket/simple_example.py

@@ -1,9 +0,0 @@
-from edsl.utilities.gcp_bucket.cloud_storage import CloudStorageManager
-
-manager = CloudStorageManager()
-
-# Download Process
-file_name = "GSS2022.dta"  # Name for the downloaded file
-save_name = "test.dta"
-
-manager.download_file(file_name, save_name)