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

edsl/conjure/AgentConstructionMixin.py

@@ -99,8 +99,6 @@ class AgentConstructionMixin:
         sample_size: int = None,
         seed: str = "edsl",
         dryrun=False,
-        disable_remote_cache: bool = False,
-        disable_remote_inference: bool = False,
     ) -> Union[Results, None]:
         """Return the results of the survey.
 
@@ -111,7 +109,7 @@ class AgentConstructionMixin:
 
         >>> from edsl.conjure.InputData import InputDataABC
         >>> id = InputDataABC.example()
-        >>> r = id.to_results(disable_remote_cache = True, disable_remote_inference = True)
+        >>> r = id.to_results()
         >>> len(r) == id.num_observations
         True
         """
@@ -127,10 +125,7 @@ class AgentConstructionMixin:
             import time
 
             start = time.time()
-            _ = survey.by(agent_list.sample(DRYRUN_SAMPLE)).run(
-                disable_remote_cache=disable_remote_cache,
-                disable_remote_inference=disable_remote_inference,
-            )
+            _ = survey.by(agent_list.sample(DRYRUN_SAMPLE)).run()
             end = time.time()
             print(f"Time to run {DRYRUN_SAMPLE} agents (s): {round(end - start, 2)}")
             time_per_agent = (end - start) / DRYRUN_SAMPLE
@@ -148,10 +143,7 @@ class AgentConstructionMixin:
                     f"Full sample will take about {round(full_sample_time / 3600, 2)} hours."
                 )
             return None
-        return survey.by(agent_list).run(
-            disable_remote_cache=disable_remote_cache,
-            disable_remote_inference=disable_remote_inference,
-        )
+        return survey.by(agent_list).run()
 
 
 if __name__ == "__main__":

edsl/conversation/Conversation.py

@@ -5,7 +5,7 @@ from typing import Optional, Callable
 from edsl import Agent, QuestionFreeText, Results, AgentList, ScenarioList, Scenario
 from edsl.questions import QuestionBase
 from edsl.results.Result import Result
-from jinja2 import Template
+
 from edsl.data import Cache
 
 from edsl.conversation.next_speaker_utilities import (
@@ -54,9 +54,6 @@ class Conversation:
     """A conversation between a list of agents. The first agent in the list is the first speaker.
     After that, order is determined by the next_speaker function.
     The question asked to each agent is determined by the next_statement_question.
-
-    If the user has passed in a "per_round_message_template", this will be displayed at the beginning of each round.
-    {{ round_message }} must be in the question_text.
     """
 
     def __init__(
@@ -67,62 +64,28 @@ class Conversation:
         next_statement_question: Optional[QuestionBase] = None,
         next_speaker_generator: Optional[Callable] = None,
         verbose: bool = False,
-        per_round_message_template: Optional[str] = None,
         conversation_index: Optional[int] = None,
         cache=None,
-        disable_remote_inference=False,
-        default_model: Optional["LanguageModel"] = None,
     ):
-        self.disable_remote_inference = disable_remote_inference
-        self.per_round_message_template = per_round_message_template
-
         if cache is None:
             self.cache = Cache()
         else:
             self.cache = cache
 
         self.agent_list = agent_list
-
-        from edsl import Model
-
-        for agent in self.agent_list:
-            if not hasattr(agent, "model"):
-                if default_model is not None:
-                    agent.model = default_model
-                else:
-                    agent.model = Model()
-
         self.verbose = verbose
         self.agent_statements = []
         self._conversation_index = conversation_index
+
         self.agent_statements = AgentStatements()
 
         self.max_turns = max_turns
 
         if next_statement_question is None:
-            import textwrap
-
-            base_question = textwrap.dedent(
-                """\
-You are {{ agent_name }}. This is the conversation so far: {{ conversation }}
-{% if round_message is not none %}
-{{ round_message }}
-{% endif %}
-What do you say next?"""
-            )
             self.next_statement_question = QuestionFreeText(
-                question_text=base_question,
+                question_text="You are {{ agent_name }}. This is the converstaion so far: {{ conversation }}. What do you say next?",
                 question_name="dialogue",
             )
-        else:
-            self.next_statement_question = next_statement_question
-            if (
-                per_round_message_template
-                and "{{ round_message }}" not in next_statement_question.question_text
-            ):
-                raise ValueError(
-                    "If you pass in a per_round_message_template, you must include {{ round_message }} in the question_text."
-                )
 
         # Determine how the next speaker is chosen
         if next_speaker_generator is None:
@@ -130,7 +93,6 @@ What do you say next?"""
         else:
             func = next_speaker_generator
 
-        # Choose the next speaker
         self.next_speaker = speaker_closure(
             agent_list=self.agent_list, generator_function=func
         )
@@ -196,32 +158,18 @@ What do you say next?"""
         }
         return Scenario(d)
 
-    async def get_next_statement(self, *, index, speaker, conversation) -> "Result":
-        """Get the next statement from the speaker."""
+    async def get_next_statement(self, *, index, speaker, conversation):
         q = self.next_statement_question
-        # assert q.parameters == {"agent_name", "conversation"}, q.parameters
-        from edsl import Scenario
-
-        if self.per_round_message_template is None:
-            round_message = None
-        else:
-            round_message = Template(self.per_round_message_template).render(
-                {"max_turns": self.max_turns, "current_turn": index}
-            )
-
-        s = Scenario(
-            {
-                "agent_name": speaker.name,
-                "conversation": conversation,
-                "conversation_index": self.conversation_index,
-                "index": index,
-                "round_message": round_message,
-            }
-        )
-        jobs = q.by(s).by(speaker).by(speaker.model)
-        jobs.show_prompts()
-        results = await jobs.run_async(
-            cache=self.cache, disable_remote_inference=self.disable_remote_inference
+        assert q.parameters == {"agent_name", "conversation"}, q.parameters
+        results = await q.run_async(
+            index=index,
+            conversation=conversation,
+            conversation_index=self.conversation_index,
+            agent_name=speaker.name,
+            agent=speaker,
+            just_answer=False,
+            cache=self.cache,
+            model=speaker.model,
         )
         return results[0]
 

edsl/coop/coop.py

@@ -28,18 +28,9 @@ class Coop:
         - Provide a URL directly, or use the default one.
         """
         self.api_key = api_key or os.getenv("EXPECTED_PARROT_API_KEY")
-
         self.url = url or CONFIG.EXPECTED_PARROT_URL
         if self.url.endswith("/"):
             self.url = self.url[:-1]
-        if "chick.expectedparrot" in self.url:
-            self.api_url = "https://chickapi.expectedparrot.com"
-        elif "expectedparrot" in self.url:
-            self.api_url = "https://api.expectedparrot.com"
-        elif "localhost:1234" in self.url:
-            self.api_url = "http://localhost:8000"
-        else:
-            self.api_url = self.url
         self._edsl_version = edsl.__version__
 
     ################
@@ -68,7 +59,7 @@ class Coop:
         """
         Send a request to the server and return the response.
         """
-        url = f"{self.api_url}/{uri}"
+        url = f"{self.url}/{uri}"
         method = method.upper()
         if payload is None:
             timeout = 20
@@ -99,83 +90,18 @@ class Coop:
 
         return response
 
-    def _resolve_server_response(
-        self, response: requests.Response, check_api_key: bool = True
-    ) -> None:
+    def _resolve_server_response(self, response: requests.Response) -> None:
         """
         Check the response from the server and raise errors as appropriate.
         """
         if response.status_code >= 400:
             message = response.json().get("detail")
             # print(response.text)
-            if "The API key you provided is invalid" in message and check_api_key:
-                import secrets
-                from edsl.utilities.utilities import write_api_key_to_env
-
-                edsl_auth_token = secrets.token_urlsafe(16)
-
-                print("Your Expected Parrot API key is invalid.")
-                print(
-                    "\nUse the link below to log in to Expected Parrot so we can automatically update your API key."
-                )
-                self._display_login_url(edsl_auth_token=edsl_auth_token)
-                api_key = self._poll_for_api_key(edsl_auth_token)
-
-                if api_key is None:
-                    print("\nTimed out waiting for login. Please try again.")
-                    return
-
-                write_api_key_to_env(api_key)
-                print("\n✨ API key retrieved and written to .env file.")
-                print("Rerun your code to try again with a valid API key.")
-                return
-
-            elif "Authorization" in message:
+            if "Authorization" in message:
                 print(message)
                 message = "Please provide an Expected Parrot API key."
-
             raise CoopServerResponseError(message)
 
-    def _poll_for_api_key(
-        self, edsl_auth_token: str, timeout: int = 120
-    ) -> Union[str, None]:
-        """
-        Allows the user to retrieve their Expected Parrot API key by logging in with an EDSL auth token.
-
-        :param edsl_auth_token: The EDSL auth token to use for login
-        :param timeout: Maximum time to wait for login, in seconds (default: 120)
-        """
-        import time
-        from datetime import datetime
-
-        start_poll_time = time.time()
-        waiting_for_login = True
-        while waiting_for_login:
-            elapsed_time = time.time() - start_poll_time
-            if elapsed_time > timeout:
-                # Timed out waiting for the user to log in
-                print("\r" + " " * 80 + "\r", end="")
-                return None
-
-            api_key = self._get_api_key(edsl_auth_token)
-            if api_key is not None:
-                print("\r" + " " * 80 + "\r", end="")
-                return api_key
-            else:
-                duration = 5
-                time_checked = datetime.now().strftime("%Y-%m-%d %I:%M:%S %p")
-                frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
-                start_time = time.time()
-                i = 0
-                while time.time() - start_time < duration:
-                    print(
-                        f"\r{frames[i % len(frames)]} Waiting for login. Last checked: {time_checked}",
-                        end="",
-                        flush=True,
-                    )
-                    time.sleep(0.1)
-                    i += 1
-
     def _json_handle_none(self, value: Any) -> Any:
         """
         Handle None values during JSON serialization.
@@ -208,7 +134,7 @@ class Coop:
             response = self._send_server_request(
                 uri="api/v0/edsl-settings", method="GET", timeout=5
             )
-            self._resolve_server_response(response, check_api_key=False)
+            self._resolve_server_response(response)
             return response.json()
         except Timeout:
             return {}
@@ -563,7 +489,6 @@ class Coop:
         description: Optional[str] = None,
         status: RemoteJobStatus = "queued",
         visibility: Optional[VisibilityType] = "unlisted",
-        initial_results_visibility: Optional[VisibilityType] = "unlisted",
         iterations: Optional[int] = 1,
     ) -> dict:
         """
@@ -592,7 +517,6 @@ class Coop:
                 "iterations": iterations,
                 "visibility": visibility,
                 "version": self._edsl_version,
-                "initial_results_visibility": initial_results_visibility,
             },
         )
         self._resolve_server_response(response)
@@ -644,9 +568,7 @@ class Coop:
             "version": data.get("version"),
         }
 
-    def remote_inference_cost(
-        self, input: Union[Jobs, Survey], iterations: int = 1
-    ) -> int:
+    def remote_inference_cost(self, input: Union[Jobs, Survey]) -> int:
         """
         Get the cost of a remote inference job.
 
@@ -671,7 +593,6 @@ class Coop:
                     job.to_dict(),
                     default=self._json_handle_none,
                 ),
-                "iterations": iterations,
             },
         )
         self._resolve_server_response(response)
@@ -694,7 +615,7 @@ class Coop:
     async def remote_async_execute_model_call(
         self, model_dict: dict, user_prompt: str, system_prompt: str
     ) -> dict:
-        url = self.api_url + "/inference/"
+        url = self.url + "/inference/"
         # print("Now using url: ", url)
         data = {
             "model_dict": model_dict,
@@ -715,7 +636,7 @@ class Coop:
         ] = "lime_survey",
         email=None,
     ):
-        url = f"{self.api_url}/api/v0/export_to_{platform}"
+        url = f"{self.url}/api/v0/export_to_{platform}"
         if email:
             data = {"json_string": json.dumps({"survey": survey, "email": email})}
         else:
@@ -740,17 +661,6 @@ class Coop:
         else:
             return {}
 
-    def fetch_models(self) -> dict:
-        """
-        Fetch a dict of available models from Coop.
-
-        Each key in the dict is an inference service, and each value is a list of models from that service.
-        """
-        response = self._send_server_request(uri="api/v0/models", method="GET")
-        self._resolve_server_response(response)
-        data = response.json()
-        return data
-
     def fetch_rate_limit_config_vars(self) -> dict:
         """
         Fetch a dict of rate limit config vars from Coop.
@@ -765,58 +675,14 @@ class Coop:
         data = response.json()
         return data
 
-    def _display_login_url(self, edsl_auth_token: str):
-        """
-        Uses rich.print to display a login URL.
-
-        - We need this function because URL detection with print() does not work alongside animations in VSCode.
-        """
-        from rich import print as rich_print
-
-        url = f"{CONFIG.EXPECTED_PARROT_URL}/login?edsl_auth_token={edsl_auth_token}"
-
-        rich_print(f"[#38bdf8][link={url}]{url}[/link][/#38bdf8]")
-
-    def _get_api_key(self, edsl_auth_token: str):
-        """
-        Given an EDSL auth token, find the corresponding user's API key.
-        """
-
-        response = self._send_server_request(
-            uri="api/v0/get-api-key",
-            method="POST",
-            payload={
-                "edsl_auth_token": edsl_auth_token,
-            },
-        )
-        data = response.json()
-        api_key = data.get("api_key")
-        return api_key
-
-    def login(self):
-        """
-        Starts the EDSL auth token login flow.
-        """
-        import secrets
-        from dotenv import load_dotenv
-        from edsl.utilities.utilities import write_api_key_to_env
-
-        edsl_auth_token = secrets.token_urlsafe(16)
-
-        print(
-            "\nUse the link below to log in to Expected Parrot so we can automatically update your API key."
-        )
-        self._display_login_url(edsl_auth_token=edsl_auth_token)
-        api_key = self._poll_for_api_key(edsl_auth_token)
-
-        if api_key is None:
-            raise Exception("Timed out waiting for login. Please try again.")
-
-        write_api_key_to_env(api_key)
-        print("\n✨ API key retrieved and written to .env file.")
 
-        # Add API key to environment
-        load_dotenv()
+if __name__ == "__main__":
+    sheet_data = fetch_sheet_data()
+    if sheet_data:
+        print(f"Successfully fetched {len(sheet_data)} rows of data.")
+        print("First row:", sheet_data[0])
+    else:
+        print("Failed to fetch sheet data.")
 
 
 def main():

edsl/data/Cache.py

@@ -194,7 +194,7 @@ class Cache(Base):
         >>> c = Cache()
         >>> len(c)
         0
-        >>> results = Question.example("free_text").by(m).run(cache = c, disable_remote_cache = True, disable_remote_inference = True)
+        >>> results = Question.example("free_text").by(m).run(cache = c)
         >>> len(c)
         1
         """

edsl/exceptions/__init__.py

@@ -1,8 +1,8 @@
 from .agents import (
-    #    AgentAttributeLookupCallbackError,
+    AgentAttributeLookupCallbackError,
     AgentCombinationError,
-    #    AgentLacksLLMError,
-    #    AgentRespondedWithBadJSONError,
+    AgentLacksLLMError,
+    AgentRespondedWithBadJSONError,
 )
 from .configuration import (
     InvalidEnvironmentVariableError,
@@ -14,10 +14,6 @@ from .data import (
     DatabaseIntegrityError,
 )
 
-from .scenarios import (
-    ScenarioError,
-)
-
 from .general import MissingAPIKeyError
 
 from .jobs import JobsRunError, InterviewErrorPriorTaskCanceled, InterviewTimeoutError

edsl/exceptions/agents.py

@@ -1,35 +1,37 @@
-from edsl.exceptions.BaseException import BaseException
-
-
-class AgentErrors(BaseException):
-    relevant_doc = "https://docs.expectedparrot.com/en/latest/agents.html"
+class AgentErrors(Exception):
+    pass
 
 
 class AgentDynamicTraitsFunctionError(AgentErrors):
-    relevant_doc = (
-        "https://docs.expectedparrot.com/en/latest/agents.html#dynamic-traits-function"
-    )
-    relevant_notebook = "https://docs.expectedparrot.com/en/latest/notebooks/example_agent_dynamic_traits.html"
+    pass
 
 
 class AgentDirectAnswerFunctionError(AgentErrors):
-    relevant_doc = "https://docs.expectedparrot.com/en/latest/agents.html#agent-direct-answering-methods"
+    pass
+
+
+class AgentAttributeLookupCallbackError(AgentErrors):
+    pass
 
 
 class AgentCombinationError(AgentErrors):
-    relevant_doc = (
-        "https://docs.expectedparrot.com/en/latest/agents.html#combining-agents"
-    )
+    pass
+
+
+class AgentLacksLLMError(AgentErrors):
+    pass
+
+
+class AgentRespondedWithBadJSONError(AgentErrors):
+    pass
 
 
 class AgentNameError(AgentErrors):
-    relevant_doc = "https://docs.expectedparrot.com/en/latest/agents.html#agent-names"
+    pass
 
 
 class AgentTraitKeyError(AgentErrors):
-    relevant_doc = (
-        "https://docs.expectedparrot.com/en/latest/agents.html#constructing-an-agent"
-    )
+    pass
 
 
 class FailedTaskException(Exception):

edsl/exceptions/results.py

@@ -1,29 +1,26 @@
-from edsl.exceptions.BaseException import BaseException
-
-
-class ResultsError(BaseException):
-    relevant_docs = "https://docs.expectedparrot.com/en/latest/results.html"
+class ResultsErrors(Exception):
+    pass
 
 
-class ResultsDeserializationError(ResultsError):
+class ResultsDeserializationError(ResultsErrors):
     pass
 
 
-class ResultsBadMutationstringError(ResultsError):
+class ResultsBadMutationstringError(ResultsErrors):
     pass
 
 
-class ResultsColumnNotFoundError(ResultsError):
+class ResultsColumnNotFoundError(ResultsErrors):
     pass
 
 
-class ResultsInvalidNameError(ResultsError):
+class ResultsInvalidNameError(ResultsErrors):
     pass
 
 
-class ResultsMutateError(ResultsError):
+class ResultsMutateError(ResultsErrors):
     pass
 
 
-class ResultsFilterError(ResultsError):
+class ResultsFilterError(ResultsErrors):
     pass

edsl/exceptions/surveys.py

@@ -1,37 +1,34 @@
-from edsl.exceptions.BaseException import BaseException
-
-
-class SurveyError(BaseException):
-    relevant_doc = "https://docs.expectedparrot.com/en/latest/surveys.html"
+class SurveyErrors(Exception):
+    pass
 
 
-class SurveyCreationError(SurveyError):
+class SurveyCreationError(SurveyErrors):
     pass
 
 
-class SurveyHasNoRulesError(SurveyError):
+class SurveyHasNoRulesError(SurveyErrors):
     pass
 
 
-class SurveyRuleSendsYouBackwardsError(SurveyError):
+class SurveyRuleSendsYouBackwardsError(SurveyErrors):
     pass
 
 
-class SurveyRuleSkipLogicSyntaxError(SurveyError):
+class SurveyRuleSkipLogicSyntaxError(SurveyErrors):
     pass
 
 
-class SurveyRuleReferenceInRuleToUnknownQuestionError(SurveyError):
+class SurveyRuleReferenceInRuleToUnknownQuestionError(SurveyErrors):
     pass
 
 
-class SurveyRuleRefersToFutureStateError(SurveyError):
+class SurveyRuleRefersToFutureStateError(SurveyErrors):
     pass
 
 
-class SurveyRuleCollectionHasNoRulesAtNodeError(SurveyError):
+class SurveyRuleCollectionHasNoRulesAtNodeError(SurveyErrors):
     pass
 
 
-class SurveyRuleCannotEvaluateError(SurveyError):
+class SurveyRuleCannotEvaluateError(SurveyErrors):
     pass

edsl/inference_services/AwsBedrock.py

@@ -28,16 +28,12 @@ class AwsBedrockService(InferenceServiceABC):
         "ai21.j2-ultra",
         "ai21.j2-ultra-v1",
     ]
-    _models_list_cache: List[str] = []
 
     @classmethod
     def available(cls):
         """Fetch available models from AWS Bedrock."""
-
-        region = os.getenv("AWS_REGION", "us-east-1")
-
         if not cls._models_list_cache:
-            client = boto3.client("bedrock", region_name=region)
+            client = boto3.client("bedrock", region_name="us-west-2")
             all_models_ids = [
                 x["modelId"] for x in client.list_foundation_models()["modelSummaries"]
             ]
@@ -84,8 +80,7 @@ class AwsBedrockService(InferenceServiceABC):
                     self.api_token
                 )  # call to check the if env variables are set.
 
-                region = os.getenv("AWS_REGION", "us-east-1")
-                client = boto3.client("bedrock-runtime", region_name=region)
+                client = boto3.client("bedrock-runtime", region_name="us-west-2")
 
                 conversation = [
                     {