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

edsl/jobs/FetchInvigilator.py

@@ -1,47 +0,0 @@
-from typing import List, Dict, Any, Optional, TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from edsl.questions.QuestionBase import QuestionBase
-    from edsl.agents.InvigilatorBase import InvigilatorBase
-    from edsl.language_models.key_management.KeyLookup import KeyLookup
-    from edsl.jobs.interviews.Interview import Interview
-
-
-class FetchInvigilator:
-    def __init__(
-        self,
-        interview: "Interview",
-        current_answers: Optional[Dict[str, Any]] = None,
-        key_lookup: Optional["KeyLookup"] = None,
-    ):
-        self.interview = interview
-        if current_answers is None:
-            self.current_answers = self.interview.answers
-        else:
-            self.current_answers = current_answers
-        self.key_lookup = key_lookup
-
-    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.interview.agent.create_invigilator(
-            question=question,
-            scenario=self.interview.scenario,
-            model=self.interview.model,
-            survey=self.interview.survey,
-            memory_plan=self.interview.survey.memory_plan,
-            current_answers=self.current_answers,  # not yet known
-            iteration=self.interview.iteration,
-            cache=self.interview.cache,
-            raise_validation_errors=self.interview.raise_validation_errors,
-            key_lookup=self.key_lookup,
-        )
-        """Return an invigilator for the given question."""
-        return invigilator
-
-    def __call__(self, question):
-        return self.get_invigilator(question)

edsl/jobs/InterviewTaskManager.py

@@ -1,98 +0,0 @@
-from __future__ import annotations
-import asyncio
-from typing import Any, Type, List, Generator, Optional, Union, TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from edsl.questions import QuestionBase
-    from edsl.jobs.tokens.InterviewTokenUsage import InterviewTokenUsage
-    from edsl.jobs.interviews.InterviewStatusDictionary import InterviewStatusDictionary
-    from edsl.jobs.interviews.InterviewStatusLog import InterviewStatusLog
-
-
-class InterviewTaskManager:
-    """Handles creation and management of interview tasks."""
-
-    def __init__(self, survey, iteration=0):
-        from edsl.jobs.tasks.TaskCreators import TaskCreators
-        from edsl.jobs.interviews.InterviewStatusLog import InterviewStatusLog
-
-        self.survey = survey
-        self.iteration = iteration
-        self.task_creators = TaskCreators()
-        self.to_index = {
-            question_name: index
-            for index, question_name in enumerate(self.survey.question_names)
-        }
-        self._task_status_log_dict = InterviewStatusLog()
-
-    def build_question_tasks(
-        self, answer_func, token_estimator, model_buckets
-    ) -> list[asyncio.Task]:
-        """Create tasks for all questions with proper dependencies."""
-        tasks = []
-        for question in self.survey.questions:
-            dependencies = self._get_task_dependencies(tasks, question)
-            task = self._create_single_task(
-                question=question,
-                dependencies=dependencies,
-                answer_func=answer_func,
-                token_estimator=token_estimator,
-                model_buckets=model_buckets,
-            )
-            tasks.append(task)
-        return tuple(tasks)
-
-    def _get_task_dependencies(
-        self, existing_tasks: list[asyncio.Task], question: "QuestionBase"
-    ) -> list[asyncio.Task]:
-        """Get tasks that must be completed before the given question."""
-        dag = self.survey.dag(textify=True)
-        parents = dag.get(question.question_name, [])
-        return [existing_tasks[self.to_index[parent_name]] for parent_name in parents]
-
-    def _create_single_task(
-        self,
-        question: "QuestionBase",
-        dependencies: list[asyncio.Task],
-        answer_func,
-        token_estimator,
-        model_buckets,
-    ) -> asyncio.Task:
-        """Create a single question task with its dependencies."""
-        from edsl.jobs.tasks.QuestionTaskCreator import QuestionTaskCreator
-
-        task_creator = QuestionTaskCreator(
-            question=question,
-            answer_question_func=answer_func,
-            token_estimator=token_estimator,
-            model_buckets=model_buckets,
-            iteration=self.iteration,
-        )
-
-        for dependency in dependencies:
-            task_creator.add_dependency(dependency)
-
-        self.task_creators[question.question_name] = task_creator
-        return task_creator.generate_task()
-
-    @property
-    def task_status_logs(self) -> "InterviewStatusLog":
-        """Return the task status logs for the interview.
-
-        The keys are the question names; the values are the lists of status log changes for each task.
-        """
-        for task_creator in self.task_creators.values():
-            self._task_status_log_dict[
-                task_creator.question.question_name
-            ] = task_creator.status_log
-        return self._task_status_log_dict
-
-    @property
-    def token_usage(self) -> "InterviewTokenUsage":
-        """Determine how many tokens were used for the interview."""
-        return self.task_creators.token_usage
-
-    @property
-    def interview_status(self) -> "InterviewStatusDictionary":
-        """Return a dictionary mapping task status codes to counts."""
-        return self.task_creators.interview_status

edsl/jobs/InterviewsConstructor.py

@@ -1,50 +0,0 @@
-from typing import Generator, TYPE_CHECKING
-from itertools import product
-
-if TYPE_CHECKING:
-    from edsl.jobs.interviews.Interview import Interview
-
-
-class InterviewsConstructor:
-    def __init__(self, jobs: "Jobs", cache: "Cache"):
-        self.jobs = jobs
-        self.cache = cache
-
-    def create_interviews(self) -> Generator["Interview", None, None]:
-        """
-        Generate interviews.
-
-        Note that this sets the agents, model and scenarios if they have not been set. This is a side effect of the method.
-        This is useful because a user can create a job without setting the agents, models, or scenarios, and the job will still run,
-        with us filling in defaults.
-
-        """
-        from edsl.jobs.interviews.Interview import Interview
-
-        agent_index = {
-            hash(agent): index for index, agent in enumerate(self.jobs.agents)
-        }
-        model_index = {
-            hash(model): index for index, model in enumerate(self.jobs.models)
-        }
-        scenario_index = {
-            hash(scenario): index for index, scenario in enumerate(self.jobs.scenarios)
-        }
-
-        for agent, scenario, model in product(
-            self.jobs.agents, self.jobs.scenarios, self.jobs.models
-        ):
-            yield Interview(
-                survey=self.jobs.survey.draw(),
-                agent=agent,
-                scenario=scenario,
-                model=model,
-                cache=self.cache,
-                skip_retry=self.jobs.run_config.parameters.skip_retry,
-                raise_validation_errors=self.jobs.run_config.parameters.raise_validation_errors,
-                indices={
-                    "agent": agent_index[hash(agent)],
-                    "model": model_index[hash(model)],
-                    "scenario": scenario_index[hash(scenario)],
-                },
-            )

edsl/jobs/JobsComponentConstructor.py

@@ -1,189 +0,0 @@
-from typing import Union, Sequence, TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from edsl.agents.Agent import Agent
-    from edsl.language_models.LanguageModel import LanguageModel
-    from edsl.scenarios.Scenario import Scenario
-    from edsl.jobs.Jobs import Jobs
-
-
-class JobsComponentConstructor:
-    "Handles the creation of Agents, Scenarios, and LanguageModels in a job."
-
-    def __init__(self, jobs: "Jobs"):
-        self.jobs = jobs
-
-    def by(
-        self,
-        *args: Union[
-            "Agent",
-            "Scenario",
-            "LanguageModel",
-            Sequence[Union["Agent", "Scenario", "LanguageModel"]],
-        ],
-    ) -> "Jobs":
-        """
-        Add Agents, Scenarios and LanguageModels to a job.
-
-        :param args: objects or a sequence (list, tuple, ...) of objects of the same type
-
-        If no objects of this type exist in the Jobs instance, it stores the new objects as a list in the corresponding attribute.
-        Otherwise, it combines the new objects with existing objects using the object's `__add__` method.
-
-        This 'by' is intended to create a fluent interface.
-
-        >>> from edsl.surveys import Survey
-        >>> from edsl.questions import QuestionFreeText
-        >>> q = QuestionFreeText(question_name="name", question_text="What is your name?")
-        >>> from edsl.jobs import Jobs
-        >>> j = Jobs(survey = Survey(questions=[q]))
-        >>> j
-        Jobs(survey=Survey(...), agents=AgentList([]), models=ModelList([]), scenarios=ScenarioList([]))
-        >>> from edsl import Agent; a = Agent(traits = {"status": "Sad"})
-        >>> j.by(a).agents
-        AgentList([Agent(traits = {'status': 'Sad'})])
-
-
-        Notes:
-        - all objects must implement the 'get_value', 'set_value', and `__add__` methods
-        - agents: traits of new agents are combined with traits of existing agents. New and existing agents should not have overlapping traits, and do not increase the # agents in the instance
-        - scenarios: traits of new scenarios are combined with traits of old existing. New scenarios will overwrite overlapping traits, and do not increase the number of scenarios in the instance
-        - models: new models overwrite old models.
-        """
-        from edsl.results.Dataset import Dataset
-
-        if isinstance(
-            args[0], Dataset
-        ):  # let the user use a Dataset as if it were a ScenarioList
-            args = args[0].to_scenario_list()
-
-        passed_objects = self._turn_args_to_list(
-            args
-        )  # objects can also be passed comma-separated
-
-        current_objects, objects_key = self._get_current_objects_of_this_type(
-            passed_objects[0]
-        )
-
-        if not current_objects:
-            new_objects = passed_objects
-        else:
-            new_objects = self._merge_objects(passed_objects, current_objects)
-
-        setattr(self.jobs, objects_key, new_objects)  # update the job object
-        return self.jobs
-
-    @staticmethod
-    def _turn_args_to_list(args):
-        """Return a list of the first argument if it is a sequence, otherwise returns a list of all the arguments.
-
-        Example:
-
-        >>> JobsComponentConstructor._turn_args_to_list([1,2,3])
-        [1, 2, 3]
-
-        """
-
-        def did_user_pass_a_sequence(args):
-            """Return True if the user passed a sequence, False otherwise.
-
-            Example:
-
-            >>> did_user_pass_a_sequence([1,2,3])
-            True
-
-            >>> did_user_pass_a_sequence(1)
-            False
-            """
-            return len(args) == 1 and isinstance(args[0], Sequence)
-
-        if did_user_pass_a_sequence(args):
-            container_class = JobsComponentConstructor._get_container_class(args[0][0])
-            return container_class(args[0])
-        else:
-            container_class = JobsComponentConstructor._get_container_class(args[0])
-            return container_class(args)
-
-    def _get_current_objects_of_this_type(
-        self, object: Union["Agent", "Scenario", "LanguageModel"]
-    ) -> tuple[list, str]:
-        from edsl.agents.Agent import Agent
-        from edsl.scenarios.Scenario import Scenario
-        from edsl.language_models.LanguageModel import LanguageModel
-
-        """Return the current objects of the same type as the first argument.
-
-        >>> from edsl.jobs import Jobs
-        >>> j = JobsComponentConstructor(Jobs.example())
-        >>> j._get_current_objects_of_this_type(j.agents[0])
-        (AgentList([Agent(traits = {'status': 'Joyful'}), Agent(traits = {'status': 'Sad'})]), 'agents')
-        """
-        class_to_key = {
-            Agent: "agents",
-            Scenario: "scenarios",
-            LanguageModel: "models",
-        }
-        for class_type in class_to_key:
-            if isinstance(object, class_type) or issubclass(
-                object.__class__, class_type
-            ):
-                key = class_to_key[class_type]
-                break
-        else:
-            raise ValueError(
-                f"First argument must be an Agent, Scenario, or LanguageModel, not {object}"
-            )
-        current_objects = getattr(self.jobs, key, None)
-        return current_objects, key
-
-    @staticmethod
-    def _get_empty_container_object(object):
-        from edsl.agents.AgentList import AgentList
-        from edsl.scenarios.ScenarioList import ScenarioList
-
-        return {"Agent": AgentList([]), "Scenario": ScenarioList([])}.get(
-            object.__class__.__name__, []
-        )
-
-    @staticmethod
-    def _merge_objects(passed_objects, current_objects) -> list:
-        """
-        Combine all the existing objects with the new objects.
-
-        For example, if the user passes in 3 agents,
-        and there are 2 existing agents, this will create 6 new agents
-        >>> from edsl.jobs import Jobs
-        >>> JobsComponentConstructor(Jobs(survey = []))._merge_objects([1,2,3], [4,5,6])
-        [5, 6, 7, 6, 7, 8, 7, 8, 9]
-        """
-        new_objects = JobsComponentConstructor._get_empty_container_object(
-            passed_objects[0]
-        )
-        for current_object in current_objects:
-            for new_object in passed_objects:
-                new_objects.append(current_object + new_object)
-        return new_objects
-
-    @staticmethod
-    def _get_container_class(object):
-        from edsl.agents.AgentList import AgentList
-        from edsl.agents.Agent import Agent
-        from edsl.scenarios.Scenario import Scenario
-        from edsl.scenarios.ScenarioList import ScenarioList
-        from edsl.language_models.ModelList import ModelList
-
-        if isinstance(object, Agent):
-            return AgentList
-        elif isinstance(object, Scenario):
-            return ScenarioList
-        elif isinstance(object, ModelList):
-            return ModelList
-        else:
-            return list
-
-
-if __name__ == "__main__":
-    """Run the module's doctests."""
-    import doctest
-
-    doctest.testmod(optionflags=doctest.ELLIPSIS)

edsl/jobs/JobsRemoteInferenceLogger.py

@@ -1,239 +0,0 @@
-import re
-import sys
-import uuid
-from abc import ABC, abstractmethod
-from typing import Optional, Union, Literal, TYPE_CHECKING, List, Dict
-from datetime import datetime
-from dataclasses import dataclass
-from edsl.exceptions.coop import CoopServerResponseError
-
-from edsl.jobs.jobs_status_enums import JobsStatus
-
-if TYPE_CHECKING:
-    from edsl.results.Results import Results
-
-
-@dataclass
-class LogMessage:
-    text: str
-    status: str
-    timestamp: datetime
-    status: JobsStatus
-
-
-@dataclass
-class JobsInfo:
-    job_uuid: str = None
-    progress_bar_url: str = None
-    error_report_url: str = None
-    results_uuid: str = None
-    results_url: str = None
-
-    pretty_names = {
-        "job_uuid": "Job UUID",
-        "progress_bar_url": "Progress Bar URL",
-        "error_report_url": "Error Report URL",
-        "results_uuid": "Results UUID",
-        "results_url": "Results URL",
-    }
-
-
-class JobLogger(ABC):
-    def __init__(self, verbose: bool = False):
-        self.verbose = verbose
-        self.jobs_info = JobsInfo()
-
-    def add_info(
-        self,
-        information_type: Literal[
-            "job_uuid",
-            "progress_bar_url",
-            "error_report_url",
-            "results_uuid",
-            "results_url",
-        ],
-        value: str,
-    ):
-        """Add information to the logger
-
-        >>> j = StdOutJobLogger()
-        >>> j.add_info("job_uuid", "1234")
-        >>> j.jobs_info.job_uuid
-        '1234'
-        """
-        if information_type not in self.jobs_info.__annotations__:
-            raise ValueError(f"Information type {information_type} not supported")
-        setattr(self.jobs_info, information_type, value)
-
-    @abstractmethod
-    def update(self, message: str, status: str = "running"):
-        pass
-
-
-class HTMLTableJobLogger(JobLogger):
-    def __init__(self, verbose=True, **kwargs):
-        from IPython.display import display, HTML
-
-        super().__init__(verbose=verbose)
-        self.display_handle = display(HTML(""), display_id=True)
-        self.current_message = None
-        self.log_id = str(uuid.uuid4())
-        self.is_expanded = True
-        self.spinner_chars = ["◐", "◓", "◑", "◒"]  # Rotating spinner characters
-        self.spinner_idx = 0
-
-    def _get_table_row(self, key: str, value: str) -> str:
-        """Generate a table row with key-value pair"""
-        return f"""
-            <tr>
-                <td style="padding: 8px; border: 1px solid #ddd; font-weight: bold;">{key}</td>
-                <td style="padding: 8px; border: 1px solid #ddd;">{value if value else 'None'}</td>
-            </tr>
-        """
-
-    def _linkify(self, text: str) -> str:
-        """Convert URLs in text to clickable links"""
-        url_pattern = r'(https?://[^\s<>"]+|www\.[^\s<>"]+)'
-        return re.sub(
-            url_pattern,
-            r'<a href="\1" target="_blank" style="color: #3b82f6; text-decoration: underline;">\1</a>',
-            text,
-        )
-
-    def _get_spinner(self, status: JobsStatus) -> str:
-        """Get the current spinner frame if status is running"""
-        if status == JobsStatus.RUNNING:
-            spinner = self.spinner_chars[self.spinner_idx]
-            self.spinner_idx = (self.spinner_idx + 1) % len(self.spinner_chars)
-            return f'<span style="margin-right: 8px;">{spinner}</span>'
-        elif status == JobsStatus.COMPLETED:
-            return '<span style="margin-right: 8px; color: #22c55e;">✓</span>'
-        elif status == JobsStatus.FAILED:
-            return '<span style="margin-right: 8px; color: #ef4444;">✗</span>'
-        return ""
-
-    def _get_html(self, status: JobsStatus = JobsStatus.RUNNING) -> str:
-        """Generate the complete HTML display"""
-        # Generate table rows for each JobsInfo field
-        info_rows = ""
-        for field, _ in self.jobs_info.__annotations__.items():
-            if field != "pretty_names":  # Skip the pretty_names dictionary
-                value = getattr(self.jobs_info, field)
-                value = self._linkify(str(value)) if value else None
-                pretty_name = self.jobs_info.pretty_names.get(
-                    field, field.replace("_", " ").title()
-                )
-                info_rows += self._get_table_row(pretty_name, value)
-
-        # Add current message section with spinner
-        message_html = ""
-        if self.current_message:
-            spinner = self._get_spinner(status)
-            message_html = f"""
-                <div style="margin-top: 10px; padding: 8px; background-color: #f8f9fa; border: 1px solid #ddd; border-radius: 4px;">
-                    {spinner}<strong>Current Status:</strong> {self._linkify(self.current_message)}
-                </div>
-            """
-
-        display_style = "block" if self.is_expanded else "none"
-        arrow = "▼" if self.is_expanded else "▶"
-
-        return f"""
-            <div style="font-family: system-ui; max-width: 800px; margin: 10px 0;">
-                <div onclick="document.getElementById('content-{self.log_id}').style.display = document.getElementById('content-{self.log_id}').style.display === 'none' ? 'block' : 'none';
-                             document.getElementById('arrow-{self.log_id}').innerHTML = document.getElementById('content-{self.log_id}').style.display === 'none' ? '▶' : '▼';"
-                     style="padding: 10px; background: #f5f5f5; border: 1px solid #ddd; border-radius: 4px; cursor: pointer;">
-                    <span id="arrow-{self.log_id}">{arrow}</span> Job Status ({datetime.now().strftime('%Y-%m-%d %H:%M:%S')})
-                </div>
-                <div id="content-{self.log_id}" style="display: {display_style};">
-                    <table style="width: 100%; border-collapse: collapse; background: white; border: 1px solid #ddd;">
-                        {info_rows}
-                    </table>
-                    {message_html}
-                </div>
-            </div>
-        """
-
-    def update(self, message: str, status: JobsStatus = JobsStatus.RUNNING):
-        """Update the display with new message and current JobsInfo state"""
-        from IPython.display import HTML
-
-        self.current_message = message
-        if self.verbose:
-            self.display_handle.update(HTML(self._get_html(status)))
-        else:
-            return None
-
-
-class StdOutJobLogger(JobLogger):
-    def __init__(self, verbose=True, **kwargs):
-        super().__init__(verbose=verbose)  # Properly call parent's __init__
-        self.messages: List[LogMessage] = []
-
-    def update(self, message: str, status: JobsStatus = JobsStatus.RUNNING):
-        log_msg = LogMessage(text=message, status=status, timestamp=datetime.now())
-        self.messages.append(log_msg)
-        if self.verbose:
-            sys.stdout.write(f"│ {message}\n")
-            sys.stdout.flush()
-        else:
-            return None
-
-
-class JupyterJobLogger(JobLogger):
-    def __init__(self, verbose=True, **kwargs):
-        from IPython.display import display, HTML
-
-        super().__init__(verbose=verbose)
-        self.messages = []
-        self.log_id = str(uuid.uuid4())
-        self.is_expanded = True
-        self.display_handle = display(HTML(""), display_id=True)
-
-    def _linkify(self, text):
-        url_pattern = r'(https?://[^\s<>"]+|www\.[^\s<>"]+)'
-        return re.sub(
-            url_pattern,
-            r'<a href="\1" target="_blank" style="color: #3b82f6; text-decoration: underline;">\1</a>',
-            text,
-        )
-
-    def _get_html(self):
-        messages_html = "\n".join(
-            [
-                f'<div style="border-left: 3px solid {msg["color"]}; padding: 5px 10px; margin: 5px 0;">{self._linkify(msg["text"])}</div>'
-                for msg in self.messages
-            ]
-        )
-
-        display_style = "block" if self.is_expanded else "none"
-        arrow = "▼" if self.is_expanded else "▶"
-
-        return f"""
-            <div style="border: 1px solid #ccc; margin: 10px 0; max-width: 800px;">
-                <div onclick="document.getElementById('content-{self.log_id}').style.display = document.getElementById('content-{self.log_id}').style.display === 'none' ? 'block' : 'none';
-                             document.getElementById('arrow-{self.log_id}').innerHTML = document.getElementById('content-{self.log_id}').style.display === 'none' ? '▶' : '▼';"
-                     style="padding: 10px; background: #f5f5f5; cursor: pointer;">
-                    <span id="arrow-{self.log_id}">{arrow}</span> Remote Job Log ({datetime.now().strftime('%Y-%m-%d %H:%M:%S')})
-                </div>
-                <div id="content-{self.log_id}" style="padding: 10px; display: {display_style};">
-                    {messages_html}
-                </div>
-            </div>
-        """
-
-    def update(self, message, status: JobsStatus = JobsStatus.RUNNING):
-        from IPython.display import HTML
-
-        colors = {"running": "#3b82f6", "completed": "#22c55e", "failed": "#ef4444"}
-        self.messages.append({"text": message, "color": colors.get(status, "#666")})
-        if self.verbose:
-            self.display_handle.update(HTML(self._get_html()))
-        else:
-            return None
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod()

edsl/jobs/RequestTokenEstimator.py

@@ -1,30 +0,0 @@
-from edsl.jobs.FetchInvigilator import FetchInvigilator
-
-
-class RequestTokenEstimator:
-    """Estimate the number of tokens that will be required to run the focal task."""
-
-    def __init__(self, interview):
-        self.interview = interview
-
-    def __call__(self, question) -> float:
-        """Estimate the number of tokens that will be required to run the focal task."""
-        from edsl.scenarios.FileStore import FileStore
-
-        invigilator = FetchInvigilator(self.interview)(question=question)
-
-        # TODO: There should be a way to get a more accurate estimate.
-        combined_text = ""
-        file_tokens = 0
-        for prompt in invigilator.get_prompts().values():
-            if hasattr(prompt, "text"):
-                combined_text += prompt.text
-            elif isinstance(prompt, str):
-                combined_text += prompt
-            elif isinstance(prompt, list):
-                for file in prompt:
-                    if isinstance(file, FileStore):
-                        file_tokens += file.size * 0.25
-            else:
-                raise ValueError(f"Prompt is of type {type(prompt)}")
-        return len(combined_text) / 4.0 + file_tokens