edsl 0.1.44__py3-none-any.whl → 0.1.46__py3-none-any.whl

edsl/agents/QuestionTemplateReplacementsBuilder.py

@@ -4,19 +4,53 @@ from typing import Any, Set, TYPE_CHECKING
 if TYPE_CHECKING:
     from edsl.agents.PromptConstructor import PromptConstructor
     from edsl.scenarios.Scenario import Scenario
+    from edsl.questions.QuestionBase import QuestionBase
+    from edsl.agents.Agent import Agent
 
 
 class QuestionTemplateReplacementsBuilder:
-    def __init__(self, prompt_constructor: "PromptConstructor"):
-        self.prompt_constructor = prompt_constructor
+
+    @classmethod
+    def from_prompt_constructor(cls, prompt_constructor: "PromptConstructor"):
+        scenario = prompt_constructor.scenario
+        question = prompt_constructor.question
+        prior_answers_dict = prompt_constructor.prior_answers_dict()
+        agent = prompt_constructor.agent
+
+        return cls(scenario, question, prior_answers_dict, agent)
+
+    def __init__(
+        self,
+        scenario: "Scenario",
+        question: "QuestionBase",
+        prior_answers_dict: dict,
+        agent: "Agent",
+    ):
+        self.scenario = scenario
+        self.question = question
+        self.prior_answers_dict = prior_answers_dict
+        self.agent = agent
 
     def question_file_keys(self):
-        question_text = self.prompt_constructor.question.question_text
-        file_keys = self._find_file_keys(self.prompt_constructor.scenario)
+        """
+        >>> from edsl import QuestionMultipleChoice, Scenario
+        >>> q = QuestionMultipleChoice(question_text="Do you like school?", question_name = "q0", question_options = ["yes", "no"])
+        >>> qtrb = QuestionTemplateReplacementsBuilder(scenario = {"file1": "file1"}, question = q, prior_answers_dict = {'q0': 'q0'}, agent = "agent")
+        >>> qtrb.question_file_keys()
+        []
+        >>> from edsl import FileStore
+        >>> fs = FileStore.example()
+        >>> q = QuestionMultipleChoice(question_text="What do you think of this file: {{ file1 }}", question_name = "q0", question_options = ["good", "bad"])
+        >>> qtrb = QuestionTemplateReplacementsBuilder(scenario = Scenario({"file1": fs}), question = q, prior_answers_dict = {'q0': 'q0'}, agent = "agent")
+        >>> qtrb.question_file_keys()
+        ['file1']
+        """
+        question_text = self.question.question_text
+        file_keys = self._find_file_keys(self.scenario)
         return self._extract_file_keys_from_question_text(question_text, file_keys)
 
     def scenario_file_keys(self):
-        return self._find_file_keys(self.prompt_constructor.scenario)
+        return self._find_file_keys(self.scenario)
 
     def get_jinja2_variables(template_str: str) -> Set[str]:
         """
@@ -88,17 +122,29 @@ class QuestionTemplateReplacementsBuilder:
                 question_file_keys.append(var)
         return question_file_keys
 
-    def _scenario_replacements(self) -> dict[str, Any]:
+    def _scenario_replacements(
+        self, replacement_string: str = "<see file {key}>"
+    ) -> dict[str, Any]:
+        """
+        >>> from edsl import Scenario
+        >>> from edsl import QuestionFreeText; 
+        >>> q = QuestionFreeText(question_text = "How are you {{ scenario.friend }}?", question_name = "test")
+        >>> s = Scenario({'friend':'john'}) 
+        >>> q.by(s).prompts().select('user_prompt')
+        Dataset([{'user_prompt': [Prompt(text=\"""How are you john?\""")]}])
+        """
         # File references dictionary
-        file_refs = {key: f"<see file {key}>" for key in self.scenario_file_keys()}
+        file_refs = {
+            key: replacement_string.format(key=key) for key in self.scenario_file_keys()
+        }
 
         # Scenario items excluding file keys
         scenario_items = {
-            k: v
-            for k, v in self.prompt_constructor.scenario.items()
-            if k not in self.scenario_file_keys()
+            k: v for k, v in self.scenario.items() if k not in self.scenario_file_keys()
         }
-        return {**file_refs, **scenario_items}
+        scenario_items_with_prefix = {'scenario': scenario_items}
+        
+        return {**file_refs, **scenario_items, **scenario_items_with_prefix}
 
     @staticmethod
     def _question_data_replacements(
@@ -119,14 +165,31 @@ class QuestionTemplateReplacementsBuilder:
         return {**question_settings, **question_data}
 
     def build_replacement_dict(self, question_data: dict) -> dict[str, Any]:
-        """Builds a dictionary of replacement values for rendering a prompt by combining multiple data sources."""
+        """Builds a dictionary of replacement values for rendering a prompt by combining multiple data sources.
+
+
+        >>> from edsl import QuestionMultipleChoice, Scenario
+        >>> q = QuestionMultipleChoice(question_text="Do you like school?", question_name = "q0", question_options = ["yes", "no"])
+        >>> qtrb = QuestionTemplateReplacementsBuilder(scenario = {"file1": "file1"}, question = q, prior_answers_dict = {'q0': 'q0'}, agent = "agent")
+        >>> qtrb.question_file_keys()
+        []
+        >>> from edsl import FileStore
+        >>> fs = FileStore.example()
+        >>> s = Scenario({"file1": fs, "first_name": "John"})
+        >>> q = QuestionMultipleChoice(question_text="What do you think of this file: {{ file1 }}, {{ first_name}}", question_name = "q0", question_options = ["good", "bad"])
+        >>> qtrb = QuestionTemplateReplacementsBuilder(scenario = s, question = q, prior_answers_dict = {'q0': 'q0'}, agent = "agent")
+        >>> qtrb.build_replacement_dict(q.data)
+        {'file1': '<see file file1>', 'first_name': 'John', 'scenario': {'first_name': 'John'}, 'use_code': False, 'include_comment': True, 'question_name': 'q0', 'question_text': 'What do you think of this file: {{ file1 }}, {{ first_name}}', 'question_options': ['good', 'bad'], 'q0': 'q0', 'agent': 'agent'}
+
+
+        """
         rpl = {}
         rpl["scenario"] = self._scenario_replacements()
-        rpl["question"] = self._question_data_replacements(
-            self.prompt_constructor.question, question_data
-        )
-        rpl["prior_answers"] = self.prompt_constructor.prior_answers_dict()
-        rpl["agent"] = {"agent": self.prompt_constructor.agent}
+        rpl["question"] = self._question_data_replacements(self.question, question_data)
+        # rpl["prior_answers"] = self.prompt_constructor.prior_answers_dict()
+        rpl["prior_answers"] = self.prior_answers_dict
+        # rpl["agent"] = {"agent": self.prompt_constructor.agent}
+        rpl["agent"] = {"agent": self.agent}
 
         # Combine all dictionaries using dict.update() for clarity
         replacement_dict = {}

edsl/agents/question_option_processor.py

@@ -8,8 +8,16 @@ class QuestionOptionProcessor:
     These can be provided directly, as a template string, or fetched from prior answers or the scenario.
     """
 
-    def __init__(self, prompt_constructor):
-        self.prompt_constructor = prompt_constructor
+    @classmethod
+    def from_prompt_constructor(cls, prompt_constructor):
+        scenario = prompt_constructor.scenario
+        prior_answers_dict = prompt_constructor.prior_answers_dict()
+
+        return cls(scenario, prior_answers_dict)
+
+    def __init__(self, scenario: 'Scenario', prior_answers_dict: dict):
+        self.scenario = scenario 
+        self.prior_answers_dict = prior_answers_dict
 
     @staticmethod
     def _get_default_options() -> list:
@@ -109,7 +117,8 @@ class QuestionOptionProcessor:
         >>> mpc = MockPromptConstructor()
         >>> from edsl import Scenario
         >>> mpc.scenario = Scenario({"options": ["Option 1", "Option 2"]})
-        >>> processor = QuestionOptionProcessor(mpc)
+        >>> mpc.prior_answers_dict = lambda: {'q0': 'q0'}
+        >>> processor = QuestionOptionProcessor.from_prompt_constructor(mpc)
 
         The basic case where options are directly provided:
 
@@ -130,7 +139,7 @@ class QuestionOptionProcessor:
         >>> q0 = MockQuestion()
         >>> q0.answer = ["Option 1", "Option 2"]
         >>> mpc.prior_answers_dict = lambda: {'q0': q0}
-        >>> processor = QuestionOptionProcessor(mpc)
+        >>> processor = QuestionOptionProcessor.from_prompt_constructor(mpc)
         >>> question_data = {"question_options": "{{ q0 }}"}
         >>> processor.get_question_options(question_data)
         ['Option 1', 'Option 2']
@@ -151,14 +160,14 @@ class QuestionOptionProcessor:
 
         # Try getting options from scenario
         scenario_options = self._get_options_from_scenario(
-            self.prompt_constructor.scenario, option_key
+            self.scenario, option_key
         )
         if scenario_options:
             return scenario_options
 
         # Try getting options from prior answers
         prior_answer_options = self._get_options_from_prior_answers(
-            self.prompt_constructor.prior_answers_dict(), option_key
+            self.prior_answers_dict, option_key
         )
         if prior_answer_options:
             return prior_answer_options

edsl/coop/CoopFunctionsMixin.py

@@ -4,10 +4,9 @@ class CoopFunctionsMixin:
 
         s = Scenario({"existing_names": existing_names})
         q = QuestionList(
-            question_text="""The following colum names are already in use: {{ existing_names }} 
-                         Please provide new names for the columns.
-                         They should be short, one or two words, and unique. They should be valid Python idenifiers. 
-                         No spaces - use underscores instead. 
+            question_text="""The following column names are already in use: {{ existing_names }} 
+                         Please provide new column names.
+                         They should be short (one or two words) and unique valid Python idenifiers (i.e., use underscores instead of spaces). 
                          """,
             question_name="better_names",
         )

edsl/coop/coop.py

@@ -190,7 +190,7 @@ class Coop(CoopFunctionsMixin):
                 server_version_str=server_edsl_version,
             ):
                 print(
-                    "Please upgrade your EDSL version to access our latest features. To upgrade, open your terminal and run `pip install --upgrade edsl`"
+                    "Please upgrade your EDSL version to access our latest features. Open your terminal and run `pip install --upgrade edsl`"
                 )
 
         if response.status_code >= 400:
@@ -212,7 +212,7 @@ class Coop(CoopFunctionsMixin):
                 print("Your Expected Parrot API key is invalid.")
                 self._display_login_url(
                     edsl_auth_token=edsl_auth_token,
-                    link_description="\n🔗 Use the link below to log in to Expected Parrot so we can automatically update your API key.",
+                    link_description="\n🔗 Use the link below to log in to your account and automatically update your API key.",
                 )
                 api_key = self._poll_for_api_key(edsl_auth_token)
 
@@ -504,90 +504,146 @@ class Coop(CoopFunctionsMixin):
     ################
     # Remote Cache
     ################
-    def remote_cache_create(
+    # def remote_cache_create(
+    #     self,
+    #     cache_entry: CacheEntry,
+    #     visibility: VisibilityType = "private",
+    #     description: Optional[str] = None,
+    # ) -> dict:
+    #     """
+    #     Create a single remote cache entry.
+    #     If an entry with the same key already exists in the database, update it instead.
+
+    #     :param cache_entry: The cache entry to send to the server.
+    #     :param visibility: The visibility of the cache entry.
+    #     :param optional description: A description for this entry in the remote cache.
+
+    #     >>> entry = CacheEntry.example()
+    #     >>> coop.remote_cache_create(cache_entry=entry)
+    #     {'status': 'success', 'created_entry_count': 1, 'updated_entry_count': 0}
+    #     """
+    #     response = self._send_server_request(
+    #         uri="api/v0/remote-cache",
+    #         method="POST",
+    #         payload={
+    #             "json_string": json.dumps(cache_entry.to_dict()),
+    #             "version": self._edsl_version,
+    #             "visibility": visibility,
+    #             "description": description,
+    #         },
+    #     )
+    #     self._resolve_server_response(response)
+    #     response_json = response.json()
+    #     created_entry_count = response_json.get("created_entry_count", 0)
+    #     if created_entry_count > 0:
+    #         self.remote_cache_create_log(
+    #             response,
+    #             description="Upload new cache entries to server",
+    #             cache_entry_count=created_entry_count,
+    #         )
+    #     return response.json()
+
+    # def remote_cache_create_many(
+    #     self,
+    #     cache_entries: list[CacheEntry],
+    #     visibility: VisibilityType = "private",
+    #     description: Optional[str] = None,
+    # ) -> dict:
+    #     """
+    #     Create many remote cache entries.
+    #     If an entry with the same key already exists in the database, update it instead.
+
+    #     :param cache_entries: The list of cache entries to send to the server.
+    #     :param visibility: The visibility of the cache entries.
+    #     :param optional description: A description for these entries in the remote cache.
+
+    #     >>> entries = [CacheEntry.example(randomize=True) for _ in range(10)]
+    #     >>> coop.remote_cache_create_many(cache_entries=entries)
+    #     {'status': 'success', 'created_entry_count': 10, 'updated_entry_count': 0}
+    #     """
+    #     payload = [
+    #         {
+    #             "json_string": json.dumps(c.to_dict()),
+    #             "version": self._edsl_version,
+    #             "visibility": visibility,
+    #             "description": description,
+    #         }
+    #         for c in cache_entries
+    #     ]
+    #     response = self._send_server_request(
+    #         uri="api/v0/remote-cache/many",
+    #         method="POST",
+    #         payload=payload,
+    #         timeout=40,
+    #     )
+    #     self._resolve_server_response(response)
+    #     response_json = response.json()
+    #     created_entry_count = response_json.get("created_entry_count", 0)
+    #     if created_entry_count > 0:
+    #         self.remote_cache_create_log(
+    #             response,
+    #             description="Upload new cache entries to server",
+    #             cache_entry_count=created_entry_count,
+    #         )
+    #     return response.json()
+
+    def remote_cache_get(
         self,
-        cache_entry: CacheEntry,
-        visibility: VisibilityType = "private",
-        description: Optional[str] = None,
-    ) -> dict:
+        job_uuid: Optional[Union[str, UUID]] = None,
+    ) -> list[CacheEntry]:
         """
-        Create a single remote cache entry.
-        If an entry with the same key already exists in the database, update it instead.
+        Get all remote cache entries.
 
-        :param cache_entry: The cache entry to send to the server.
-        :param visibility: The visibility of the cache entry.
-        :param optional description: A description for this entry in the remote cache.
+        :param optional select_keys: Only return CacheEntry objects with these keys.
 
-        >>> entry = CacheEntry.example()
-        >>> coop.remote_cache_create(cache_entry=entry)
-        {'status': 'success', 'created_entry_count': 1, 'updated_entry_count': 0}
+        >>> coop.remote_cache_get(job_uuid="...")
+        [CacheEntry(...), CacheEntry(...), ...]
         """
+        if job_uuid is None:
+            raise ValueError("Must provide a job_uuid.")
         response = self._send_server_request(
-            uri="api/v0/remote-cache",
+            uri="api/v0/remote-cache/get-many-by-job",
             method="POST",
             payload={
-                "json_string": json.dumps(cache_entry.to_dict()),
-                "version": self._edsl_version,
-                "visibility": visibility,
-                "description": description,
+                "job_uuid": str(job_uuid),
             },
+            timeout=40,
         )
         self._resolve_server_response(response)
-        response_json = response.json()
-        created_entry_count = response_json.get("created_entry_count", 0)
-        if created_entry_count > 0:
-            self.remote_cache_create_log(
-                response,
-                description="Upload new cache entries to server",
-                cache_entry_count=created_entry_count,
-            )
-        return response.json()
+        return [
+            CacheEntry.from_dict(json.loads(v.get("json_string")))
+            for v in response.json()
+        ]
 
-    def remote_cache_create_many(
+    def remote_cache_get_by_key(
         self,
-        cache_entries: list[CacheEntry],
-        visibility: VisibilityType = "private",
-        description: Optional[str] = None,
-    ) -> dict:
+        select_keys: Optional[list[str]] = None,
+    ) -> list[CacheEntry]:
         """
-        Create many remote cache entries.
-        If an entry with the same key already exists in the database, update it instead.
+        Get all remote cache entries.
 
-        :param cache_entries: The list of cache entries to send to the server.
-        :param visibility: The visibility of the cache entries.
-        :param optional description: A description for these entries in the remote cache.
+        :param optional select_keys: Only return CacheEntry objects with these keys.
 
-        >>> entries = [CacheEntry.example(randomize=True) for _ in range(10)]
-        >>> coop.remote_cache_create_many(cache_entries=entries)
-        {'status': 'success', 'created_entry_count': 10, 'updated_entry_count': 0}
+        >>> coop.remote_cache_get_by_key(selected_keys=["..."])
+        [CacheEntry(...), CacheEntry(...), ...]
         """
-        payload = [
-            {
-                "json_string": json.dumps(c.to_dict()),
-                "version": self._edsl_version,
-                "visibility": visibility,
-                "description": description,
-            }
-            for c in cache_entries
-        ]
+        if select_keys is None or len(select_keys) == 0:
+            raise ValueError("Must provide a non-empty list of select_keys.")
         response = self._send_server_request(
-            uri="api/v0/remote-cache/many",
+            uri="api/v0/remote-cache/get-many-by-key",
             method="POST",
-            payload=payload,
+            payload={
+                "selected_keys": select_keys,
+            },
             timeout=40,
         )
         self._resolve_server_response(response)
-        response_json = response.json()
-        created_entry_count = response_json.get("created_entry_count", 0)
-        if created_entry_count > 0:
-            self.remote_cache_create_log(
-                response,
-                description="Upload new cache entries to server",
-                cache_entry_count=created_entry_count,
-            )
-        return response.json()
+        return [
+            CacheEntry.from_dict(json.loads(v.get("json_string")))
+            for v in response.json()
+        ]
 
-    def remote_cache_get(
+    def legacy_remote_cache_get(
         self,
         exclude_keys: Optional[list[str]] = None,
         select_keys: Optional[list[str]] = None,
@@ -595,9 +651,10 @@ class Coop(CoopFunctionsMixin):
         """
         Get all remote cache entries.
 
+        :param optional select_keys: Only return CacheEntry objects with these keys.
         :param optional exclude_keys: Exclude CacheEntry objects with these keys.
 
-        >>> coop.remote_cache_get()
+        >>> coop.legacy_remote_cache_get()
         [CacheEntry(...), CacheEntry(...), ...]
         """
         if exclude_keys is None:
@@ -605,9 +662,9 @@ class Coop(CoopFunctionsMixin):
         if select_keys is None:
             select_keys = []
         response = self._send_server_request(
-            uri="api/v0/remote-cache/get-many",
+            uri="api/v0/remote-cache/legacy/get-many",
             method="POST",
-            payload={"keys": exclude_keys, "selected_keys": select_keys},
+            payload={"exclude_keys": exclude_keys, "selected_keys": select_keys},
             timeout=40,
         )
         self._resolve_server_response(response)
@@ -616,7 +673,7 @@ class Coop(CoopFunctionsMixin):
             for v in response.json()
         ]
 
-    def remote_cache_get_diff(
+    def legacy_remote_cache_get_diff(
         self,
         client_cacheentry_keys: list[str],
     ) -> dict:
@@ -624,7 +681,7 @@ class Coop(CoopFunctionsMixin):
         Get the difference between local and remote cache entries for a user.
         """
         response = self._send_server_request(
-            uri="api/v0/remote-cache/get-diff",
+            uri="api/v0/remote-cache/legacy/get-diff",
             method="POST",
             payload={"keys": client_cacheentry_keys},
             timeout=40,
@@ -642,38 +699,38 @@ class Coop(CoopFunctionsMixin):
         }
         downloaded_entry_count = len(response_dict["client_missing_cacheentries"])
         if downloaded_entry_count > 0:
-            self.remote_cache_create_log(
+            self.legacy_remote_cache_create_log(
                 response,
                 description="Download missing cache entries to client",
                 cache_entry_count=downloaded_entry_count,
             )
         return response_dict
 
-    def remote_cache_clear(self) -> dict:
+    def legacy_remote_cache_clear(self) -> dict:
         """
         Clear all remote cache entries.
 
         >>> entries = [CacheEntry.example(randomize=True) for _ in range(10)]
-        >>> coop.remote_cache_create_many(cache_entries=entries)
-        >>> coop.remote_cache_clear()
+        >>> coop.legacy_remote_cache_create_many(cache_entries=entries)
+        >>> coop.legacy_remote_cache_clear()
         {'status': 'success', 'deleted_entry_count': 10}
         """
         response = self._send_server_request(
-            uri="api/v0/remote-cache/delete-all",
+            uri="api/v0/remote-cache/legacy/delete-all",
             method="DELETE",
         )
         self._resolve_server_response(response)
         response_json = response.json()
         deleted_entry_count = response_json.get("deleted_entry_count", 0)
         if deleted_entry_count > 0:
-            self.remote_cache_create_log(
+            self.legacy_remote_cache_create_log(
                 response,
                 description="Clear cache entries",
                 cache_entry_count=deleted_entry_count,
             )
         return response.json()
 
-    def remote_cache_create_log(
+    def legacy_remote_cache_create_log(
         self, response: requests.Response, description: str, cache_entry_count: int
     ) -> Union[dict, None]:
         """
@@ -682,7 +739,7 @@ class Coop(CoopFunctionsMixin):
         """
         if 200 <= response.status_code < 300:
             log_response = self._send_server_request(
-                uri="api/v0/remote-cache-log",
+                uri="api/v0/remote-cache-log/legacy",
                 method="POST",
                 payload={
                     "description": description,
@@ -692,15 +749,15 @@ class Coop(CoopFunctionsMixin):
             self._resolve_server_response(log_response)
             return response.json()
 
-    def remote_cache_clear_log(self) -> dict:
+    def legacy_remote_cache_clear_log(self) -> dict:
         """
         Clear all remote cache log entries.
 
-        >>> coop.remote_cache_clear_log()
+        >>> coop.legacy_remote_cache_clear_log()
         {'status': 'success'}
         """
         response = self._send_server_request(
-            uri="api/v0/remote-cache-log/delete-all",
+            uri="api/v0/remote-cache-log/legacy/delete-all",
             method="DELETE",
         )
         self._resolve_server_response(response)
@@ -714,6 +771,7 @@ class Coop(CoopFunctionsMixin):
         visibility: Optional[VisibilityType] = "unlisted",
         initial_results_visibility: Optional[VisibilityType] = "unlisted",
         iterations: Optional[int] = 1,
+        fresh: Optional[bool] = False,
     ) -> RemoteInferenceCreationInfo:
         """
         Send a remote inference job to the server.
@@ -742,6 +800,7 @@ class Coop(CoopFunctionsMixin):
                 "visibility": visibility,
                 "version": self._edsl_version,
                 "initial_results_visibility": initial_results_visibility,
+                "fresh": fresh,
             },
         )
         self._resolve_server_response(response)
@@ -870,7 +929,7 @@ class Coop(CoopFunctionsMixin):
     def create_project(
         self,
         survey: Survey,
-        project_name: str,
+        project_name: str = "Project",
         survey_description: Optional[str] = None,
         survey_alias: Optional[str] = None,
         survey_visibility: Optional[VisibilityType] = "unlisted",
@@ -895,7 +954,8 @@ class Coop(CoopFunctionsMixin):
         return {
             "name": response_json.get("project_name"),
             "uuid": response_json.get("uuid"),
-            "url": f"{self.url}/home/projects/{response_json.get('uuid')}",
+            "admin_url": f"{self.url}/home/projects/{response_json.get('uuid')}",
+            "respondent_url": f"{self.url}/respond/{response_json.get('uuid')}",
         }
 
     ################
@@ -1027,15 +1087,30 @@ class Coop(CoopFunctionsMixin):
         - We need this function because URL detection with print() does not work alongside animations in VSCode.
         """
         from rich import print as rich_print
+        from rich.console import Console
+
+        console = Console()
 
         url = f"{CONFIG.EXPECTED_PARROT_URL}/login?edsl_auth_token={edsl_auth_token}"
 
-        if link_description:
-            rich_print(
-                f"{link_description}\n    [#38bdf8][link={url}]{url}[/link][/#38bdf8]"
-            )
+        if console.is_terminal:
+            # Running in a standard terminal, show the full URL
+            if link_description:
+                rich_print(
+                    "{link_description}\n[#38bdf8][link={url}]{url}[/link][/#38bdf8]"
+                )
+            else:
+                rich_print(f"[#38bdf8][link={url}]{url}[/link][/#38bdf8]")
         else:
-            rich_print(f"    [#38bdf8][link={url}]{url}[/link][/#38bdf8]")
+            # Running in an interactive environment (e.g., Jupyter Notebook), hide the URL
+            if link_description:
+                rich_print(
+                    f"{link_description}\n[#38bdf8][link={url}][underline]Log in and automatically store key[/underline][/link][/#38bdf8]"
+                )
+            else:
+                rich_print(
+                    f"[#38bdf8][link={url}][underline]Log in and automatically store key[/underline][/link][/#38bdf8]"
+                )
 
     def _get_api_key(self, edsl_auth_token: str):
         """
@@ -1190,24 +1265,24 @@ def main():
     # C. Remote Cache
     ##############
     # clear
-    coop.remote_cache_clear()
-    assert coop.remote_cache_get() == []
+    coop.legacy_remote_cache_clear()
+    assert coop.legacy_remote_cache_get() == []
     # create one remote cache entry
     cache_entry = CacheEntry.example()
     cache_entry.to_dict()
-    coop.remote_cache_create(cache_entry)
+    # coop.remote_cache_create(cache_entry)
     # create many remote cache entries
     cache_entries = [CacheEntry.example(randomize=True) for _ in range(10)]
-    coop.remote_cache_create_many(cache_entries)
+    # coop.remote_cache_create_many(cache_entries)
     # get all remote cache entries
-    coop.remote_cache_get()
-    coop.remote_cache_get(exclude_keys=[])
-    coop.remote_cache_get(exclude_keys=["a"])
+    coop.legacy_remote_cache_get()
+    coop.legacy_remote_cache_get(exclude_keys=[])
+    coop.legacy_remote_cache_get(exclude_keys=["a"])
     exclude_keys = [cache_entry.key for cache_entry in cache_entries]
-    coop.remote_cache_get(exclude_keys)
+    coop.legacy_remote_cache_get(exclude_keys)
     # clear
-    coop.remote_cache_clear()
-    coop.remote_cache_get()
+    coop.legacy_remote_cache_clear()
+    coop.legacy_remote_cache_get()
 
     ##############
     # D. Remote Inference