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

edsl/data/Cache.py

@@ -7,13 +7,13 @@ import json
 import os
 import warnings
 from typing import Optional, Union
-import time
+
 from edsl.config import CONFIG
 from edsl.data.CacheEntry import CacheEntry
-
-# from edsl.data.SQLiteDict import SQLiteDict
+from edsl.data.SQLiteDict import SQLiteDict
 from edsl.Base import Base
 from edsl.utilities.utilities import dict_hash
+
 from edsl.utilities.decorators import (
     add_edsl_version,
     remove_edsl_version,
@@ -38,7 +38,7 @@ class Cache(Base):
         self,
         *,
         filename: Optional[str] = None,
-        data: Optional[Union["SQLiteDict", dict]] = None,
+        data: Optional[Union[SQLiteDict, dict]] = None,
         immediate_write: bool = True,
         method=None,
     ):
@@ -104,8 +104,6 @@ class Cache(Base):
 
     def _perform_checks(self):
         """Perform checks on the cache."""
-        from edsl.data.CacheEntry import CacheEntry
-
         if any(not isinstance(value, CacheEntry) for value in self.data.values()):
             raise Exception("Not all values are CacheEntry instances")
         if self.method is not None:
@@ -140,8 +138,6 @@ class Cache(Base):
 
 
         """
-        from edsl.data.CacheEntry import CacheEntry
-
         key = CacheEntry.gen_key(
             model=model,
             parameters=parameters,
@@ -175,7 +171,6 @@ class Cache(Base):
         * If `immediate_write` is True , the key-value pair is added to `self.data`
         * If `immediate_write` is False, the key-value pair is added to `self.new_entries_to_write_later`
         """
-
         entry = CacheEntry(
             model=model,
             parameters=parameters,
@@ -193,14 +188,13 @@ class Cache(Base):
         return key
 
     def add_from_dict(
-        self, new_data: dict[str, "CacheEntry"], write_now: Optional[bool] = True
+        self, new_data: dict[str, CacheEntry], write_now: Optional[bool] = True
     ) -> None:
         """
         Add entries to the cache from a dictionary.
 
         :param write_now: Whether to write to the cache immediately (similar to `immediate_write`).
         """
-
         for key, value in new_data.items():
             if key in self.data:
                 if value != self.data[key]:
@@ -237,8 +231,6 @@ class Cache(Base):
 
         :param write_now: Whether to write to the cache immediately (similar to `immediate_write`).
         """
-        from edsl.data.SQLiteDict import SQLiteDict
-
         db = SQLiteDict(db_path)
         new_data = {}
         for key, value in db.items():
@@ -250,8 +242,6 @@ class Cache(Base):
         """
         Construct a Cache from a SQLite database.
         """
-        from edsl.data.SQLiteDict import SQLiteDict
-
         return cls(data=SQLiteDict(db_path))
 
     @classmethod
@@ -278,8 +268,6 @@ class Cache(Base):
         * If `db_path` is provided, the cache will be stored in an SQLite database.
         """
         # if a file doesn't exist at jsonfile, throw an error
-        from edsl.data.SQLiteDict import SQLiteDict
-
         if not os.path.exists(jsonlfile):
             raise FileNotFoundError(f"File {jsonlfile} not found")
 
@@ -298,8 +286,6 @@ class Cache(Base):
         """
         ## TODO: Check to make sure not over-writing (?)
         ## Should be added to SQLiteDict constructor (?)
-        from edsl.data.SQLiteDict import SQLiteDict
-
         new_data = SQLiteDict(db_path)
         for key, value in self.data.items():
             new_data[key] = value

edsl/data/SQLiteDict.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 import json
+from sqlalchemy import create_engine
+from sqlalchemy.exc import SQLAlchemyError
+from sqlalchemy.orm import sessionmaker
 from typing import Any, Generator, Optional, Union
-
 from edsl.config import CONFIG
 from edsl.data.CacheEntry import CacheEntry
 from edsl.data.orm import Base, Data
@@ -23,16 +25,10 @@ class SQLiteDict:
         >>> import os; os.unlink(temp_db_path)  # Clean up the temp file after the test
 
         """
-        from sqlalchemy.exc import SQLAlchemyError
-        from sqlalchemy.orm import sessionmaker
-        from sqlalchemy import create_engine
-
         self.db_path = db_path or CONFIG.get("EDSL_DATABASE_PATH")
         if not self.db_path.startswith("sqlite:///"):
             self.db_path = f"sqlite:///{self.db_path}"
         try:
-            from edsl.data.orm import Base, Data
-
             self.engine = create_engine(self.db_path, echo=False, future=True)
             Base.metadata.create_all(self.engine)
             self.Session = sessionmaker(bind=self.engine)
@@ -59,8 +55,6 @@ class SQLiteDict:
         if not isinstance(value, CacheEntry):
             raise ValueError(f"Value must be a CacheEntry object (got {type(value)}).")
         with self.Session() as db:
-            from edsl.data.orm import Base, Data
-
             db.merge(Data(key=key, value=json.dumps(value.to_dict())))
             db.commit()
 
@@ -75,8 +69,6 @@ class SQLiteDict:
         True
         """
         with self.Session() as db:
-            from edsl.data.orm import Base, Data
-
             value = db.query(Data).filter_by(key=key).first()
             if not value:
                 raise KeyError(f"Key '{key}' not found.")

edsl/jobs/Answers.py

@@ -8,15 +8,7 @@ class Answers(UserDict):
     """Helper class to hold the answers to a survey."""
 
     def add_answer(self, response, question) -> None:
-        """Add a response to the answers dictionary.
-
-        >>> from edsl import QuestionFreeText
-        >>> q = QuestionFreeText.example()
-        >>> answers = Answers()
-        >>> answers.add_answer({"answer": "yes"}, q)
-        >>> answers[q.question_name]
-        'yes'
-        """
+        """Add a response to the answers dictionary."""
         answer = response.get("answer")
         comment = response.pop("comment", None)
         # record the answer
@@ -50,9 +42,3 @@ class Answers(UserDict):
             table.add_row(attr_name, repr(attr_value))
 
         return table
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod()

edsl/jobs/Jobs.py

@@ -1,15 +1,30 @@
 # """The Jobs class is a collection of agents, scenarios and models and one survey."""
 from __future__ import annotations
+import os
 import warnings
 from itertools import product
 from typing import Optional, Union, Sequence, Generator
-
+from edsl import Model
+from edsl.agents import Agent
+from edsl.agents.AgentList import AgentList
 from edsl.Base import Base
+from edsl.data.Cache import Cache
+from edsl.data.CacheHandler import CacheHandler
+from edsl.results.Dataset import Dataset
 
+from edsl.exceptions.jobs import MissingRemoteInferenceError
 from edsl.exceptions import MissingAPIKeyError
 from edsl.jobs.buckets.BucketCollection import BucketCollection
 from edsl.jobs.interviews.Interview import Interview
+from edsl.language_models import LanguageModel
+from edsl.results import Results
+from edsl.scenarios import Scenario
+from edsl import ScenarioList
+from edsl.surveys import Survey
 from edsl.jobs.runners.JobsRunnerAsyncio import JobsRunnerAsyncio
+
+from edsl.language_models.ModelList import ModelList
+
 from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
 
 
@@ -22,10 +37,10 @@ class Jobs(Base):
 
     def __init__(
         self,
-        survey: "Survey",
-        agents: Optional[list["Agent"]] = None,
-        models: Optional[list["LanguageModel"]] = None,
-        scenarios: Optional[list["Scenario"]] = None,
+        survey: Survey,
+        agents: Optional[list[Agent]] = None,
+        models: Optional[list[LanguageModel]] = None,
+        scenarios: Optional[list[Scenario]] = None,
     ):
         """Initialize a Jobs instance.
 
@@ -35,8 +50,8 @@ class Jobs(Base):
         :param scenarios: a list of scenarios
         """
         self.survey = survey
-        self.agents: "AgentList" = agents
-        self.scenarios: "ScenarioList" = scenarios
+        self.agents: AgentList = agents
+        self.scenarios: ScenarioList = scenarios
         self.models = models
 
         self.__bucket_collection = None
@@ -47,8 +62,6 @@ class Jobs(Base):
 
     @models.setter
     def models(self, value):
-        from edsl import ModelList
-
         if value:
             if not isinstance(value, ModelList):
                 self._models = ModelList(value)
@@ -63,8 +76,6 @@ class Jobs(Base):
 
     @agents.setter
     def agents(self, value):
-        from edsl import AgentList
-
         if value:
             if not isinstance(value, AgentList):
                 self._agents = AgentList(value)
@@ -79,8 +90,6 @@ class Jobs(Base):
 
     @scenarios.setter
     def scenarios(self, value):
-        from edsl import ScenarioList
-
         if value:
             if not isinstance(value, ScenarioList):
                 self._scenarios = ScenarioList(value)
@@ -92,10 +101,10 @@ class Jobs(Base):
     def by(
         self,
         *args: Union[
-            "Agent",
-            "Scenario",
-            "LanguageModel",
-            Sequence[Union["Agent", "Scenario", "LanguageModel"]],
+            Agent,
+            Scenario,
+            LanguageModel,
+            Sequence[Union[Agent, Scenario, LanguageModel]],
         ],
     ) -> Jobs:
         """
@@ -135,7 +144,7 @@ class Jobs(Base):
         setattr(self, objects_key, new_objects)  # update the job
         return self
 
-    def prompts(self) -> "Dataset":
+    def prompts(self) -> Dataset:
         """Return a Dataset of prompts that will be used.
 
 
@@ -151,7 +160,6 @@ class Jobs(Base):
         user_prompts = []
         system_prompts = []
         scenario_indices = []
-        from edsl.results.Dataset import Dataset
 
         for interview_index, interview in enumerate(interviews):
             invigilators = list(interview._build_invigilators(debug=False))
@@ -174,10 +182,7 @@ class Jobs(Base):
 
     @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 import AgentList
 
         if isinstance(object, Agent):
             return AgentList
@@ -213,10 +218,6 @@ class Jobs(Base):
     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
@@ -245,9 +246,6 @@ class Jobs(Base):
     @staticmethod
     def _get_empty_container_object(object):
         from edsl import AgentList
-        from edsl import Agent
-        from edsl import Scenario
-        from edsl import ScenarioList
 
         if isinstance(object, Agent):
             return AgentList([])
@@ -312,12 +310,12 @@ class Jobs(Base):
         with us filling in defaults.
         """
         # if no agents, models, or scenarios are set, set them to defaults
-        from edsl.agents.Agent import Agent
-        from edsl.language_models.registry import Model
-        from edsl.scenarios.Scenario import Scenario
-
         self.agents = self.agents or [Agent()]
         self.models = self.models or [Model()]
+        # if remote, set all the models to remote
+        if hasattr(self, "remote") and self.remote:
+            for model in self.models:
+                model.remote = True
         self.scenarios = self.scenarios or [Scenario()]
         for agent, scenario, model in product(self.agents, self.scenarios, self.models):
             yield Interview(
@@ -331,7 +329,6 @@ class Jobs(Base):
         These buckets are used to track API calls and token usage.
 
         >>> from edsl.jobs import Jobs
-        >>> from edsl import Model
         >>> j = Jobs.example().by(Model(temperature = 1), Model(temperature = 0.5))
         >>> bc = j.create_bucket_collection()
         >>> bc
@@ -371,16 +368,14 @@ class Jobs(Base):
         if self.verbose:
             print(message)
 
-    def _check_parameters(self, strict=False, warn=False) -> None:
+    def _check_parameters(self, strict=False, warn = True) -> None:
         """Check if the parameters in the survey and scenarios are consistent.
 
         >>> from edsl import QuestionFreeText
-        >>> from edsl import Survey
-        >>> from edsl import Scenario
         >>> q = QuestionFreeText(question_text = "{{poo}}", question_name = "ugly_question")
         >>> j = Jobs(survey = Survey(questions=[q]))
         >>> with warnings.catch_warnings(record=True) as w:
-        ...     j._check_parameters(warn = True)
+        ...     j._check_parameters()
         ...     assert len(w) == 1
         ...     assert issubclass(w[-1].category, UserWarning)
         ...     assert "The following parameters are in the survey but not in the scenarios" in str(w[-1].message)
@@ -418,13 +413,15 @@ class Jobs(Base):
         progress_bar: bool = False,
         stop_on_exception: bool = False,
         cache: Union[Cache, bool] = None,
+        remote: bool = (
+            False if os.getenv("DEFAULT_RUN_MODE", "local") == "local" else True
+        ),
         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,
     ) -> Results:
         """
         Runs the Job: conducts Interviews and returns their results.
@@ -434,11 +431,11 @@ class Jobs(Base):
         :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
+        :param remote: run the job remotely
         :param check_api_keys: check if the API keys are valid
         :param batch_mode: run the job in batch mode i.e., no expecation of interaction with the user
         :param verbose: prints messages
         :param remote_cache_description: specifies a description for this group of entries in the remote cache
-        :param remote_inference_description: specifies a description for the remote inference job
         """
         from edsl.coop.coop import Coop
 
@@ -449,50 +446,21 @@ class Jobs(Base):
                 "Batch mode is deprecated. Please update your code to not include 'batch_mode' in the 'run' method."
             )
 
+        self.remote = remote
         self.verbose = verbose
 
         try:
             coop = Coop()
-            user_edsl_settings = coop.edsl_settings
-            remote_cache = user_edsl_settings["remote_caching"]
-            remote_inference = user_edsl_settings["remote_inference"]
+            remote_cache = coop.edsl_settings["remote_caching"]
         except Exception:
             remote_cache = False
-            remote_inference = False
 
-        if remote_inference:
-            self._output("Remote inference activated. Sending job to server...")
-            if remote_cache:
-                self._output(
-                    "Remote caching activated. The remote cache will be used for this job."
-                )
+        if self.remote:
+            ## TODO: This should be a coop check
+            if os.getenv("EXPECTED_PARROT_API_KEY", None) is None:
+                raise MissingRemoteInferenceError()
 
-            remote_job_data = coop.remote_inference_create(
-                self,
-                description=remote_inference_description,
-                status="queued",
-            )
-            self._output("Job sent!")
-            # Create mock results object to store job data
-            results = Results(
-                survey=Survey(),
-                data=[
-                    Result(
-                        agent=Agent.example(),
-                        scenario=Scenario.example(),
-                        model=Model(),
-                        iteration=1,
-                        answer={"info": "Remote job details"},
-                    )
-                ],
-            )
-            results.add_columns_from_dict([remote_job_data])
-            if self.verbose:
-                results.select(["info", "uuid", "status", "version"]).print(
-                    format="rich"
-                )
-            return results
-        else:
+        if not self.remote:
             if check_api_keys:
                 for model in self.models + [Model()]:
                     if not model.has_valid_api_key():
@@ -503,12 +471,8 @@ class Jobs(Base):
 
         # handle cache
         if cache is None:
-            from edsl.data.CacheHandler import CacheHandler
-
             cache = CacheHandler().get_cache()
         if cache is False:
-            from edsl.data.Cache import Cache
-
             cache = Cache()
 
         if not remote_cache:
@@ -660,11 +624,6 @@ class Jobs(Base):
     @remove_edsl_version
     def from_dict(cls, data: dict) -> Jobs:
         """Creates a Jobs instance from a dictionary."""
-        from edsl import Survey
-        from edsl.agents.Agent import Agent
-        from edsl.language_models.LanguageModel import LanguageModel
-        from edsl.scenarios.Scenario import Scenario
-
         return cls(
             survey=Survey.from_dict(data["survey"]),
             agents=[Agent.from_dict(agent) for agent in data["agents"]],
@@ -691,8 +650,7 @@ class Jobs(Base):
         """
         import random
         from edsl.questions import QuestionMultipleChoice
-        from edsl.agents.Agent import Agent
-        from edsl.scenarios.Scenario import Scenario
+        from edsl import Agent
 
         # (status, question, period)
         agent_answers = {
@@ -731,8 +689,6 @@ class Jobs(Base):
             question_options=["Good", "Great", "OK", "Terrible"],
             question_name="how_feeling_yesterday",
         )
-        from edsl import Survey, ScenarioList
-
         base_survey = Survey(questions=[q1, q2])
 
         scenario_list = ScenarioList(

edsl/jobs/buckets/ModelBuckets.py

@@ -1,4 +1,4 @@
-# from edsl.jobs.buckets.TokenBucket import TokenBucket
+from edsl.jobs.buckets.TokenBucket import TokenBucket
 
 
 class ModelBuckets:
@@ -8,7 +8,7 @@ class ModelBuckets:
     A request is one call to the service. The number of tokens required for a request depends on parameters.
     """
 
-    def __init__(self, requests_bucket: "TokenBucket", tokens_bucket: "TokenBucket"):
+    def __init__(self, requests_bucket: TokenBucket, tokens_bucket: TokenBucket):
         """Initialize the model buckets.
 
         The requests bucket captures requests per unit of time.
@@ -28,8 +28,6 @@ class ModelBuckets:
     @classmethod
     def infinity_bucket(cls, model_name: str = "not_specified") -> "ModelBuckets":
         """Create a bucket with infinite capacity and refill rate."""
-        from edsl.jobs.buckets.TokenBucket import TokenBucket
-
         return cls(
             requests_bucket=TokenBucket(
                 bucket_name=model_name,

edsl/jobs/buckets/TokenBucket.py

@@ -1,6 +1,8 @@
 from typing import Union, List, Any
 import asyncio
 import time
+from collections import UserDict
+from matplotlib import pyplot as plt
 
 
 class TokenBucket:
@@ -112,7 +114,6 @@ class TokenBucket:
         times, tokens = zip(*self.get_log())
         start_time = times[0]
         times = [t - start_time for t in times]  # Normalize time to start from 0
-        from matplotlib import pyplot as plt
 
         plt.figure(figsize=(10, 6))
         plt.plot(times, tokens, label="Tokens Available")

edsl/jobs/interviews/Interview.py

@@ -6,9 +6,15 @@ import asyncio
 import time
 from typing import Any, Type, List, Generator, Optional
 
+from edsl.agents import Agent
+from edsl.language_models import LanguageModel
+from edsl.scenarios import Scenario
+from edsl.surveys import Survey
+
 from edsl.jobs.Answers import Answers
 from edsl.surveys.base import EndOfSurvey
 from edsl.jobs.buckets.ModelBuckets import ModelBuckets
+
 from edsl.jobs.tasks.TaskCreators import TaskCreators
 
 from edsl.jobs.interviews.InterviewStatusLog import InterviewStatusLog
@@ -54,9 +60,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

edsl/jobs/interviews/InterviewStatusMixin.py

@@ -17,9 +17,9 @@ class InterviewStatusMixin:
         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
-            )
+            self._task_status_log_dict[
+                task_creator.question.question_name
+            ] = task_creator.status_log
         return self._task_status_log_dict
 
     @property

edsl/jobs/interviews/InterviewTaskBuildingMixin.py

@@ -5,19 +5,17 @@ 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.data_transfer_models import AgentResponseDict
+from edsl.questions.QuestionBase import QuestionBase
 from edsl.surveys.base import EndOfSurvey
 from edsl.jobs.buckets.ModelBuckets import ModelBuckets
 from edsl.jobs.interviews.interview_exception_tracking 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 edsl.agents.InvigilatorBase import InvigilatorBase
 
 TIMEOUT = float(CONFIG.get("EDSL_API_TIMEOUT"))
 
@@ -46,7 +44,6 @@ class InterviewTaskBuildingMixin:
             scenario=self.scenario,
             model=self.model,
             debug=debug,
-            survey=self.survey,
             memory_plan=self.survey.memory_plan,
             current_answers=self.answers,
             iteration=self.iteration,
@@ -152,17 +149,15 @@ class InterviewTaskBuildingMixin:
     async def _answer_question_and_record_task(
         self,
         *,
-        question: "QuestionBase",
+        question: QuestionBase,
         debug: bool,
         task=None,
-    ) -> "AgentResponseDict":
+    ) -> 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
-
         try:
             invigilator = self._get_invigilator(question, debug=debug)
 
@@ -258,11 +253,11 @@ class InterviewTaskBuildingMixin:
         """
         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: 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