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

edsl/coop/coop.py

@@ -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)
@@ -1037,19 +1096,21 @@ class Coop(CoopFunctionsMixin):
         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]")
+                rich_print(
+                    "{link_description}\n[#38bdf8][link={url}]{url}[/link][/#38bdf8]"
+                )
             else:
                 rich_print(f"[#38bdf8][link={url}]{url}[/link][/#38bdf8]")
         else:
             # 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]")
+                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]")
-
-
-
-
+                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):
         """
@@ -1204,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

edsl/data/RemoteCacheSync.py

@@ -100,7 +100,7 @@ class RemoteCacheSync(AbstractContextManager):
 
     def _get_cache_difference(self) -> CacheDifference:
         """Retrieves differences between local and remote caches."""
-        diff = self.coop.remote_cache_get_diff(self.cache.keys())
+        diff = self.coop.legacy_remote_cache_get_diff(self.cache.keys())
         return CacheDifference(
             client_missing_entries=diff.get("client_missing_cacheentries", []),
             server_missing_keys=diff.get("server_missing_cacheentry_keys", []),
@@ -112,7 +112,7 @@ class RemoteCacheSync(AbstractContextManager):
         missing_count = len(diff.client_missing_entries)
 
         if missing_count == 0:
-        #     self._output("No new entries to add to local cache.")
+            #     self._output("No new entries to add to local cache.")
             return
 
         # self._output(
@@ -154,22 +154,23 @@ class RemoteCacheSync(AbstractContextManager):
         upload_count = len(entries_to_upload)
 
         if upload_count > 0:
+            pass
             # self._output(
             #     f"Updating remote cache with {upload_count:,} new "
             #     f"{'entry' if upload_count == 1 else 'entries'}..."
             # )
 
-            self.coop.remote_cache_create_many(
-                entries_to_upload,
-                visibility="private",
-                description=self.remote_cache_description,
-            )
+            # self.coop.remote_cache_create_many(
+            #     entries_to_upload,
+            #     visibility="private",
+            #     description=self.remote_cache_description,
+            # )
             # self._output("Remote cache updated!")
         # else:
-            # self._output("No new entries to add to remote cache.")
+        # self._output("No new entries to add to remote cache.")
 
         # self._output(
-            # f"There are {len(self.cache.keys()):,} entries in the local cache."
+        # f"There are {len(self.cache.keys()):,} entries in the local cache."
         # )
 
 

edsl/inference_services/AvailableModelFetcher.py

@@ -69,7 +69,7 @@ class AvailableModelFetcher:
 
         Returns a list of [model, service_name, index] entries.
         """
-        if service == "azure":
+        if service == "azure" or service == "bedrock":
             force_refresh = True  # Azure models are listed inside the .env AZURE_ENDPOINT_URL_AND_KEY variable
 
         if service:  # they passed a specific service

edsl/jobs/AnswerQuestionFunctionConstructor.py

@@ -66,10 +66,14 @@ class SkipHandler:
             )
         )
 
+
         def cancel_between(start, end):
             """Cancel the tasks for questions between the start and end indices."""
             for i in range(start, end):
-                self.interview.tasks[i].cancel()
+                #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(
@@ -80,6 +84,8 @@ class SkipHandler:
         if next_question_index > (current_question_index + 1):
             cancel_between(current_question_index + 1, next_question_index)
 
+        
+
 
 class AnswerQuestionFunctionConstructor:
     """Constructs a function that answers a question and records the answer."""
@@ -161,6 +167,11 @@ class AnswerQuestionFunctionConstructor:
         async def attempt_answer():
             invigilator = self.invigilator_fetcher(question)
 
+            if self.interview.skip_flags.get(question.question_name, False):
+                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."

edsl/jobs/Jobs.py

@@ -277,7 +277,7 @@ class Jobs(Base):
 
         return JobsComponentConstructor(self).by(*args)
 
-    def prompts(self) -> "Dataset":
+    def prompts(self, iterations=1) -> "Dataset":
         """Return a Dataset of prompts that will be used.
 
 
@@ -285,7 +285,7 @@ class Jobs(Base):
         >>> Jobs.example().prompts()
         Dataset(...)
         """
-        return JobsPrompts(self).prompts()
+        return JobsPrompts(self).prompts(iterations=iterations)
 
     def show_prompts(self, all: bool = False) -> None:
         """Print the prompts."""
@@ -418,11 +418,9 @@ class Jobs(Base):
         BucketCollection(...)
         """
         bc = BucketCollection.from_models(self.models)
-        
+
         if self.run_config.environment.key_lookup is not None:
-            bc.update_from_key_lookup(
-                self.run_config.environment.key_lookup
-            )
+            bc.update_from_key_lookup(self.run_config.environment.key_lookup)
         return bc
 
     def html(self):
@@ -484,25 +482,24 @@ class Jobs(Base):
     def _start_remote_inference_job(
         self, job_handler: Optional[JobsRemoteInferenceHandler] = None
     ) -> Union["Results", None]:
-
         if job_handler is None:
             job_handler = self._create_remote_inference_handler()
-            
+
         job_info = job_handler.create_remote_inference_job(
-                iterations=self.run_config.parameters.n,
-                remote_inference_description=self.run_config.parameters.remote_inference_description,
-                remote_inference_results_visibility=self.run_config.parameters.remote_inference_results_visibility,
+            iterations=self.run_config.parameters.n,
+            remote_inference_description=self.run_config.parameters.remote_inference_description,
+            remote_inference_results_visibility=self.run_config.parameters.remote_inference_results_visibility,
+            fresh=self.run_config.parameters.fresh,
         )
         return job_info
-    
-    def _create_remote_inference_handler(self) -> JobsRemoteInferenceHandler:
 
+    def _create_remote_inference_handler(self) -> JobsRemoteInferenceHandler:
         from edsl.jobs.JobsRemoteInferenceHandler import JobsRemoteInferenceHandler
-        
+
         return JobsRemoteInferenceHandler(
             self, verbose=self.run_config.parameters.verbose
         )
-        
+
     def _remote_results(
         self,
         config: RunConfig,
@@ -516,7 +513,8 @@ class Jobs(Base):
         if jh.use_remote_inference(self.run_config.parameters.disable_remote_inference):
             job_info: RemoteJobInfo = self._start_remote_inference_job(jh)
             if background:
-                from edsl.results.Results import Results 
+                from edsl.results.Results import Results
+
                 results = Results.from_job_info(job_info)
                 return results
             else:
@@ -603,7 +601,7 @@ class Jobs(Base):
         # first try to run the job remotely
         if (results := self._remote_results(config)) is not None:
             return results
-        
+
         self._check_if_local_keys_ok()
 
         if config.environment.bucket_collection is None: