edsl 0.1.50__py3-none-any.whl → 0.1.52__py3-none-any.whl

edsl/inference_services/available_model_fetcher.py

@@ -55,7 +55,7 @@ class AvailableModelFetcher:
 
         :param service: Optional[InferenceServiceABC] - If specified, only fetch models for this service.
 
-        >>> from edsl.inference_services.services.open_ai_service import OpenAIService
+        >>> from .services.open_ai_service import OpenAIService
         >>> af = AvailableModelFetcher([OpenAIService()], {})
         >>> af.available(service="openai")
         [LanguageModelInfo(model_name='...', service_name='openai'), ...]
@@ -155,7 +155,7 @@ class AvailableModelFetcher:
         """The service name is the _inference_service_ attribute of the service."""
         if service_name in self._service_map:
             return self._service_map[service_name]
-        from edsl.inference_services.exceptions import InferenceServiceValueError
+        from .exceptions import InferenceServiceValueError
         raise InferenceServiceValueError(f"Service {service_name} not found")
 
     def _get_all_models(self, force_refresh=False) -> List[LanguageModelInfo]:

edsl/inference_services/data_structures.py

@@ -43,7 +43,7 @@ class LanguageModelInfo:
         elif key == 1:
             return self.service_name
         else:
-            from edsl.inference_services.exceptions import InferenceServiceIndexError
+            from .exceptions import InferenceServiceIndexError
             raise InferenceServiceIndexError("Index out of range")
 
     @classmethod
@@ -70,7 +70,7 @@ class AvailableModels(UserList):
         return self.to_dataset().print()
 
     def to_dataset(self):
-        from edsl.scenarios.ScenarioList import ScenarioList
+        from ..scenarios.scenario_list import ScenarioList
 
         models, services = zip(
             *[(model.model_name, model.service_name) for model in self]
@@ -106,14 +106,14 @@ class AvailableModels(UserList):
                 ]
             )
             if len(avm) == 0:
-                from edsl.inference_services.exceptions import InferenceServiceValueError
+                from .exceptions import InferenceServiceValueError
                 raise InferenceServiceValueError(
                     "No models found matching the search pattern: " + pattern
                 )
             else:
                 return avm
         except re.error as e:
-            from edsl.inference_services.exceptions import InferenceServiceValueError
+            from .exceptions import InferenceServiceValueError
             raise InferenceServiceValueError(f"Invalid regular expression pattern: {e}")
 
 
@@ -128,7 +128,7 @@ class ServiceToModelsMapping(UserDict):
     def _validate_service_names(self):
         for service in self.service_names:
             if service not in InferenceServiceLiteral:
-                from edsl.inference_services.exceptions import InferenceServiceValueError
+                from .exceptions import InferenceServiceValueError
                 raise InferenceServiceValueError(f"Invalid service name: {service}")
 
     def model_to_services(self) -> dict:

edsl/inference_services/inference_service_abc.py

@@ -26,7 +26,7 @@ class InferenceServiceABC(ABC):
         ]
         for attr in must_have_attributes:
             if not hasattr(cls, attr):
-                from edsl.inference_services.exceptions import InferenceServiceNotImplementedError
+                from .exceptions import InferenceServiceNotImplementedError
                 raise InferenceServiceNotImplementedError(
                     f"Class {cls.__name__} must have a '{attr}' attribute."
                 )

edsl/inference_services/inference_services_collection.py

@@ -1,7 +1,7 @@
 from collections import defaultdict
 from typing import Optional, Protocol, Dict, List, Tuple, TYPE_CHECKING
 
-from edsl.enums import InferenceServiceLiteral
+from ..enums import InferenceServiceLiteral
 from .inference_service_abc import InferenceServiceABC
 from .available_model_fetcher import AvailableModelFetcher
 from .exceptions import InferenceServiceError

edsl/inference_services/service_availability.py

@@ -42,7 +42,7 @@ class ServiceAvailability:
     @classmethod
     def models_from_coop(cls) -> AvailableModels:
         if not cls._coop_model_list:
-            from edsl.coop.coop import Coop
+            from ..coop.coop import Coop
 
             c = Coop()
             coop_model_list = c.fetch_models()
@@ -74,7 +74,7 @@ class ServiceAvailability:
                 continue
 
         # If we get here, all sources failed
-        from edsl.inference_services.exceptions import InferenceServiceRuntimeError
+        from .exceptions import InferenceServiceRuntimeError
         raise InferenceServiceRuntimeError(
             f"All sources failed to fetch models. Last error: {last_error}"
         )
@@ -93,7 +93,7 @@ class ServiceAvailability:
     @staticmethod
     def _fetch_from_cache(service: "InferenceServiceABC") -> ModelNamesList:
         """Fetch models from local cache."""
-        from edsl.inference_services.models_available_cache import models_available
+        from .models_available_cache import models_available
 
         return models_available.get(service._inference_service_, [])
 

edsl/inference_services/services/azure_ai.py

@@ -46,7 +46,7 @@ class AzureAIService(InferenceServiceABC):
         out = []
         azure_endpoints = os.getenv("AZURE_ENDPOINT_URL_AND_KEY", None)
         if not azure_endpoints:
-            from edsl.inference_services.exceptions import InferenceServiceEnvironmentError
+            from ..exceptions import InferenceServiceEnvironmentError
             raise InferenceServiceEnvironmentError("AZURE_ENDPOINT_URL_AND_KEY is not defined")
         azure_endpoints = azure_endpoints.split(",")
         for data in azure_endpoints:
@@ -135,7 +135,7 @@ class AzureAIService(InferenceServiceABC):
                     api_key = None
 
                 if not api_key:
-                    from edsl.inference_services.exceptions import InferenceServiceEnvironmentError
+                    from ..exceptions import InferenceServiceEnvironmentError
                     raise InferenceServiceEnvironmentError(
                         f"AZURE_ENDPOINT_URL_AND_KEY doesn't have the endpoint:key pair for your model: {model_name}"
                     )
@@ -146,7 +146,7 @@ class AzureAIService(InferenceServiceABC):
                     endpoint = None
 
                 if not endpoint:
-                    from edsl.inference_services.exceptions import InferenceServiceEnvironmentError
+                    from ..exceptions import InferenceServiceEnvironmentError
                     raise InferenceServiceEnvironmentError(
                         f"AZURE_ENDPOINT_URL_AND_KEY doesn't have the endpoint:key pair for your model: {model_name}"
                     )

edsl/inference_services/services/google_service.py

@@ -5,7 +5,7 @@ import google.generativeai as genai
 from google.generativeai.types import GenerationConfig
 from google.api_core.exceptions import InvalidArgument
 
-# from edsl.exceptions.general import MissingAPIKeyError
+# from ...exceptions.general import MissingAPIKeyError
 from ..inference_service_abc import InferenceServiceABC
 from ...language_models import LanguageModel
 

edsl/inference_services/services/test_service.py

@@ -74,7 +74,7 @@ class TestService(InferenceServiceABC):
                         p = 1
 
                     if random.random() < p:
-                        from edsl.inference_services.exceptions import InferenceServiceError
+                        from ..exceptions import InferenceServiceError
                         raise InferenceServiceError("This is a test error")
 
                 if hasattr(self, "func"):

edsl/instructions/change_instruction.py

@@ -1,5 +1,5 @@
 from typing import List, Optional
-from edsl.utilities.remove_edsl_version import remove_edsl_version
+from ..utilities.remove_edsl_version import remove_edsl_version
 
 
 class ChangeInstruction:
@@ -9,11 +9,12 @@ class ChangeInstruction:
         drop: Optional[List[str]] = None,
     ):
         if keep is None and drop is None:
-            from edsl.instructions.exceptions import InstructionValueError
+            from .exceptions import InstructionValueError
             raise InstructionValueError("Keep and drop cannot both be None")
 
         self.keep = keep or []
         self.drop = drop or []
+        self.pseudo_index = 0.0
 
     def include_instruction(self, instruction_name) -> bool:
         return (instruction_name in self.keep) or (instruction_name not in self.drop)
@@ -30,7 +31,7 @@ class ChangeInstruction:
             "drop": self.drop,
         }
         if add_edsl_version:
-            from edsl import __version__
+            from .. import __version__
 
             d["edsl_version"] = __version__
             d["edsl_class_name"] = "ChangeInstruction"
@@ -39,7 +40,7 @@ class ChangeInstruction:
 
     def __hash__(self) -> int:
         """Return a hash of the question."""
-        from edsl.utilities.utilities import dict_hash
+        from ..utilities.utilities import dict_hash
 
         return dict_hash(self.to_dict(add_edsl_version=False))
 

edsl/instructions/instruction.py

@@ -14,6 +14,7 @@ class Instruction(RepresentationMixin):
         self.name = name
         self.text = text
         self.preamble = preamble
+        self.pseudo_index = 0.0
 
     def __str__(self):
         return self.text

edsl/instructions/instruction_collection.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Dict, List, Generator, Union
+from typing import TYPE_CHECKING, Dict, List, Generator, Union, Tuple
 from collections import UserDict
 
 from .instruction import Instruction
@@ -40,13 +40,14 @@ class InstructionCollection(UserDict):
 
     def _entries_before(
         self, question_name
-    ) -> tuple[List[Instruction], List[ChangeInstruction]]:
+    ) -> Tuple[List[Instruction], List[ChangeInstruction]]:
         if question_name not in self.question_names:
-            from edsl.instructions.exceptions import InstructionCollectionError
+            from .exceptions import InstructionCollectionError
             raise InstructionCollectionError(
                 f"Question name not found in the list of questions: got '{question_name}'; list is {self.question_names}"
             )
-        instructions, changes = [], []
+        instructions: List[Instruction] = []
+        changes: List[ChangeInstruction] = []
 
         index = self.question_index(question_name)
         for instruction in self.instruction_names_to_instruction.values():

edsl/instructions/instruction_handler.py

@@ -1,11 +1,13 @@
 from dataclasses import dataclass
 
 
+from typing import Dict, List, Any
+
 @dataclass
 class SeparatedComponents:
-    true_questions: list
-    instruction_names_to_instructions: dict
-    pseudo_indices: dict
+    true_questions: List[Any]
+    instruction_names_to_instructions: Dict[str, Any]
+    pseudo_indices: Dict[str, float]
 
 
 class InstructionHandler:
@@ -13,7 +15,7 @@ class InstructionHandler:
         self.survey = survey
 
     @staticmethod
-    def separate_questions_and_instructions(questions_and_instructions: list) -> tuple:
+    def separate_questions_and_instructions(questions_and_instructions: list) -> SeparatedComponents:
         """
         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.
@@ -48,9 +50,9 @@ class InstructionHandler:
         """
         from .instruction import Instruction
         from .change_instruction import ChangeInstruction
-        from edsl.questions import QuestionBase
+        from ..questions import QuestionBase
 
-        true_questions = []
+        true_questions: List[QuestionBase] = []
         instruction_names_to_instructions = {}
 
         num_change_instructions = 0
@@ -63,7 +65,7 @@ class InstructionHandler:
                     num_change_instructions += 1
                     for prior_instruction in entry.keep + entry.drop:
                         if prior_instruction not in instruction_names_to_instructions:
-                            from edsl.instructions.exceptions import InstructionValueError
+                            from .exceptions import InstructionValueError
                             raise InstructionValueError(
                                 f"ChangeInstruction {entry.name} references instruction {prior_instruction} which does not exist."
                             )
@@ -77,7 +79,7 @@ class InstructionHandler:
                 instructions_run_length = 0
                 true_questions.append(entry)
             else:
-                from edsl.instructions.exceptions import InstructionValueError
+                from .exceptions import InstructionValueError
                 raise InstructionValueError(
                     f"Entry {repr(entry)} is not a QuestionBase or an Instruction."
                 )

edsl/interviews/answering_function.py

@@ -26,7 +26,6 @@ class RetryConfig:
 
 
 class SkipHandler:
-
     def __init__(self, interview: "Interview"):
         self.interview = interview
         self.question_index = self.interview.to_index
@@ -47,7 +46,7 @@ class SkipHandler:
 
     def _current_info_env(self) -> dict[str, Any]:
         """
-        - The current answers are "generated_tokens" and "comment" 
+        - The current answers are "generated_tokens" and "comment"
         - The scenario should have "scenario." added to the keys
         - The agent traits should have "agent." added to the keys
         """
@@ -65,10 +64,14 @@ class SkipHandler:
                 processed_answers[f"{key}.answer"] = value
 
         # Process scenario dictionary
-        processed_scenario = {f"scenario.{k}": v for k, v in self.interview.scenario.items()}
+        processed_scenario = {
+            f"scenario.{k}": v for k, v in self.interview.scenario.items()
+        }
 
         # Process agent traits
-        processed_agent = {f"agent.{k}": v for k, v in self.interview.agent["traits"].items()}
+        processed_agent = {
+            f"agent.{k}": v for k, v in self.interview.agent["traits"].items()
+        }
 
         return processed_answers | processed_scenario | processed_agent
 
@@ -85,21 +88,22 @@ class SkipHandler:
         # )
 
         # Get the index of the next question, which could also be the end of the survey
-        next_question: Union[int, EndOfSurvey] = (
-            self.interview.survey.rule_collection.next_question(
-                q_now=current_question_index,
-                answers=answers,
-            )
+        next_question: Union[
+            int, EndOfSurvey
+        ] = self.interview.survey.rule_collection.next_question(
+            q_now=current_question_index,
+            answers=answers,
         )
 
-
         def cancel_between(start, end):
             """Cancel the tasks for questions between the start and end indices."""
             for i in range(start, end):
-                #print(f"Cancelling task {i}")
-                #self.interview.tasks[i].cancel()
-                #self.interview.tasks[i].set_result("skipped")
-                self.interview.skip_flags[self.interview.survey.questions[i].question_name] = True
+                # print(f"Cancelling task {i}")
+                # self.interview.tasks[i].cancel()
+                # self.interview.tasks[i].set_result("skipped")
+                self.interview.skip_flags[
+                    self.interview.survey.questions[i].question_name
+                ] = True
 
         if (next_question_index := next_question.next_q) == EndOfSurvey:
             cancel_between(
@@ -111,8 +115,6 @@ class SkipHandler:
             cancel_between(current_question_index + 1, next_question_index)
 
 
-
-
 class AnswerQuestionFunctionConstructor:
     """Constructs a function that answers a question and records the answer."""
 
@@ -137,7 +139,6 @@ class AnswerQuestionFunctionConstructor:
     ):
         """Handle an exception that occurred while answering a question."""
 
-
         answers = copy.copy(
             self.interview.answers
         )  # copy to freeze the answers here for logging
@@ -171,7 +172,6 @@ class AnswerQuestionFunctionConstructor:
         question: "QuestionBase",
         task=None,
     ) -> "EDSLResultObjectInput":
-
         from tenacity import (
             RetryError,
             retry,
@@ -196,7 +196,6 @@ class AnswerQuestionFunctionConstructor:
                 return invigilator.get_failed_task_result(
                     failure_reason="Question skipped."
                 )
-
             if self.skip_handler.should_skip(question):
                 return invigilator.get_failed_task_result(
                     failure_reason="Question skipped."
@@ -240,7 +239,6 @@ class AnswerQuestionFunctionConstructor:
                 raise LanguageModelNoResponseError(
                     f"Language model did not return a response for question '{question.question_name}.'"
                 )
-
             if (
                 question.question_name in self.interview.exceptions
                 and had_language_model_no_response_error
@@ -250,7 +248,8 @@ class AnswerQuestionFunctionConstructor:
             return response
 
         try:
-            return await attempt_answer()
+            out = await attempt_answer()
+            return out
         except RetryError as retry_error:
             original_error = retry_error.last_attempt.exception()
             self._handle_exception(

edsl/interviews/exception_tracking.py

@@ -81,6 +81,7 @@ class InterviewExceptionEntry:
             raise_validation_errors=True,
             disable_remote_cache=True,
             disable_remote_inference=True,
+            cache=False,
         )
         return results.task_history.exceptions[0]["how_are_you"][0]
 
@@ -97,8 +98,8 @@ class InterviewExceptionEntry:
         lines.append(f"q = {repr(self.invigilator.question)}")
         lines.append(f"scenario = {repr(self.invigilator.scenario)}")
         lines.append(f"agent = {repr(self.invigilator.agent)}")
-        lines.append(f"m = Model('{self.invigilator.model.model}')")
-        lines.append("results = q.by(m).by(agent).by(scenario).run()")
+        lines.append(f"model = {repr(self.invigilator.model)}")
+        lines.append("results = q.by(model).by(agent).by(scenario).run()")
         code_str = "\n".join(lines)
 
         if run:

edsl/interviews/interview.py

@@ -365,7 +365,7 @@ class Interview:
             bool: True if the interviews are equivalent, False otherwise
             
         Examples:
-            >>> from edsl.interviews import Interview
+            >>> from . import Interview
             >>> i = Interview.example()
             >>> d = i.to_dict()
             >>> i2 = Interview.from_dict(d)

edsl/interviews/interview_status_dictionary.py

@@ -27,7 +27,7 @@ class InterviewStatusDictionary(UserDict):
     ) -> "InterviewStatusDictionary":
         """Adds two InterviewStatusDictionaries together."""
         if not isinstance(other, InterviewStatusDictionary):
-            from edsl.interviews.exceptions import InterviewStatusError
+            from .exceptions import InterviewStatusError
             raise InterviewStatusError(f"Can't add {type(other)} to InterviewStatusDictionary")
         new_dict = {}
         for key in self.keys():

edsl/interviews/interview_task_manager.py

@@ -24,12 +24,13 @@ class InterviewTaskManager:
             for index, question_name in enumerate(self.survey.question_names)
         }
         self._task_status_log_dict = InterviewStatusLog()
+        self.survey_dag = None
 
     def build_question_tasks(
         self, answer_func, token_estimator, model_buckets
     ) -> list[asyncio.Task]:
         """Create tasks for all questions with proper dependencies."""
-        tasks = []
+        tasks: list[asyncio.Task] = []
         for question in self.survey.questions:
             dependencies = self._get_task_dependencies(tasks, question)
             task = self._create_single_task(
@@ -40,14 +41,15 @@ class InterviewTaskManager:
                 model_buckets=model_buckets,
             )
             tasks.append(task)
-        return tuple(tasks)
+        return 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, [])
+        if self.survey_dag is None:
+            self.survey_dag = self.survey.dag(textify=True)
+        parents = self.survey_dag.get(question.question_name, [])
         return [existing_tasks[self.to_index[parent_name]] for parent_name in parents]
 
     def _create_single_task(
@@ -100,4 +102,5 @@ class InterviewTaskManager:
 
 if __name__ == "__main__":
     import doctest
+
     doctest.testmod()

edsl/interviews/request_token_estimator.py

@@ -26,9 +26,10 @@ class RequestTokenEstimator:
                     if isinstance(file, FileStore):
                         file_tokens += file.size * 0.25
             else:
-                from edsl.interviews.exceptions import InterviewTokenError
+                from .exceptions import InterviewTokenError
                 raise InterviewTokenError(f"Prompt is of type {type(prompt)}")
-        return len(combined_text) / 4.0 + file_tokens
+        result: float = len(combined_text) / 4.0 + file_tokens
+        return result
 
 
 

edsl/interviews/statistics.py

@@ -1,5 +1,5 @@
 from collections import UserDict
-from typing import DefaultDict
+from typing import DefaultDict, Union, Optional
 
 from ..tokens import InterviewTokenUsage
 
@@ -43,7 +43,7 @@ class InterviewStatistic(UserDict):
         value: float,
         digits: int = 0,
         units: str = "",
-        pretty_name: str = None,
+        pretty_name: Optional[str] = None,
     ):
         """Create a new InterviewStatistic object."""
         self.name = name

edsl/invigilators/invigilators.py

@@ -6,7 +6,7 @@ from typing import Literal
 
 from ..utilities.decorators import sync_wrapper
 from ..questions.exceptions import QuestionAnswerValidationError
-from ..data_transfer_models import AgentResponseDict, EDSLResultObjectInput
+from ..base.data_transfer_models import AgentResponseDict, EDSLResultObjectInput
 from ..utilities.decorators import jupyter_nb_handler
 
 from .prompt_constructor import PromptConstructor
@@ -24,11 +24,11 @@ if TYPE_CHECKING:
     from ..key_management import KeyLookup
 
 
-
 PromptType = Literal["user_prompt", "system_prompt", "encoded_image", "files_list"]
 
 NA = "Not Applicable"
 
+
 class InvigilatorBase(ABC):
     """An invigiator (someone who administers an exam) is a class that is responsible for administering a question to an agent.
 
@@ -261,13 +261,14 @@ class InvigilatorBase(ABC):
             current_answers=current_answers,
         )
 
+
 class InvigilatorAI(InvigilatorBase):
     """An invigilator that uses an AI model to answer questions."""
 
     def get_prompts(self) -> Dict[PromptType, "Prompt"]:
         """Return the prompts used."""
         return self.prompt_constructor.get_prompts()
-    
+
     def get_captured_variables(self) -> dict:
         """Get the captured variables."""
         return self.prompt_constructor.get_captured_variables()
@@ -280,7 +281,8 @@ class InvigilatorAI(InvigilatorBase):
         }
         if "encoded_image" in prompts:
             params["encoded_image"] = prompts["encoded_image"]
-            from edsl.invigilators.exceptions import InvigilatorNotImplementedError
+            from .exceptions import InvigilatorNotImplementedError
+
             raise InvigilatorNotImplementedError("encoded_image not implemented")
 
         if "files_list" in prompts:
@@ -307,7 +309,8 @@ class InvigilatorAI(InvigilatorBase):
         """
         agent_response_dict: AgentResponseDict = await self.async_get_agent_response()
         self.store_response(agent_response_dict)
-        return self._extract_edsl_result_entry_and_validate(agent_response_dict)
+        out = self._extract_edsl_result_entry_and_validate(agent_response_dict)
+        return out
 
     def _remove_from_cache(self, cache_key) -> None:
         """Remove an entry from the cache."""
@@ -389,6 +392,30 @@ class InvigilatorAI(InvigilatorBase):
         edsl_dict = agent_response_dict.edsl_dict._asdict()
         exception_occurred = None
         validated = False
+
+        if agent_response_dict.model_outputs.cache_used:
+            data = {
+                "answer": agent_response_dict.edsl_dict.answer
+                if type(agent_response_dict.edsl_dict.answer) is str
+                else "",
+                "comment": agent_response_dict.edsl_dict.comment
+                if agent_response_dict.edsl_dict.comment
+                else "",
+                "generated_tokens": agent_response_dict.edsl_dict.generated_tokens,
+                "question_name": self.question.question_name,
+                "prompts": self.get_prompts(),
+                "cached_response": agent_response_dict.model_outputs.cached_response,
+                "raw_model_response": agent_response_dict.model_outputs.response,
+                "cache_used": agent_response_dict.model_outputs.cache_used,
+                "cache_key": agent_response_dict.model_outputs.cache_key,
+                "validated": True,
+                "exception_occurred": exception_occurred,
+                "cost": agent_response_dict.model_outputs.cost,
+            }
+
+            result = EDSLResultObjectInput(**data)
+            return result
+
         try:
             # if the question has jinja parameters, it is easier to make a new question with the parameters
             if self.question.parameters:
@@ -405,7 +432,7 @@ class InvigilatorAI(InvigilatorBase):
                         self.question.question_options = new_question_options
 
                 question_with_validators = self.question.render(
-                    self.scenario | prior_answers_dict | {'agent':self.agent.traits}
+                    self.scenario | prior_answers_dict | {"agent": self.agent.traits}
                 )
                 question_with_validators.use_code = self.question.use_code
             else:
@@ -426,6 +453,7 @@ class InvigilatorAI(InvigilatorBase):
             exception_occurred = non_validation_error
         finally:
             # even if validation failes, we still return the result
+
             data = {
                 "answer": answer,
                 "comment": comment,

edsl/jobs/__init__.py

@@ -1,7 +1,44 @@
+"""
+The jobs module provides tools for running and managing EDSL jobs.
+
+It includes classes for job configuration, execution, pricing estimation,
+and management of concurrent language model API calls.
+"""
+
 from .jobs import Jobs
 from .jobs import RunConfig, RunParameters, RunEnvironment  # noqa: F401
 from .remote_inference import JobsRemoteInferenceHandler  # noqa: F401
 from .jobs_runner_status import JobsRunnerStatusBase  # noqa: F401
+from .exceptions import (
+    JobsErrors,
+    JobsRunError,
+    MissingRemoteInferenceError,
+    InterviewError,
+    InterviewErrorPriorTaskCanceled,
+    InterviewTimeoutError,
+    JobsValueError,
+    JobsCompatibilityError,
+    JobsImplementationError,
+    RemoteInferenceError,
+    JobsTypeError
+)
 
-
-__all__ = ["Jobs"]
+__all__ = [
+    "Jobs",
+    "JobsErrors",
+    "JobsRunError",
+    "MissingRemoteInferenceError",
+    "InterviewError",
+    "InterviewErrorPriorTaskCanceled",
+    "InterviewTimeoutError",
+    "JobsValueError",
+    "JobsCompatibilityError",
+    "JobsImplementationError",
+    "RemoteInferenceError",
+    "JobsTypeError",
+    "JobsRemoteInferenceHandler",
+    "JobsRunnerStatusBase",
+    "RunConfig",
+    "RunParameters",
+    "RunEnvironment"
+]