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

edsl/coop/coop.py

@@ -287,19 +287,25 @@ class Coop(CoopFunctionsMixin):
         if value is None:
             return "null"
 
+    @staticmethod
+    def _is_url(url_or_uuid: Union[str, UUID]) -> bool:
+        return "http://" in str(url_or_uuid) or "https://" in str(url_or_uuid)
+
     def _resolve_uuid_or_alias(
-        self, uuid: Union[str, UUID] = None, url: str = None
+        self, url_or_uuid: Union[str, UUID]
     ) -> tuple[Optional[str], Optional[str], Optional[str]]:
         """
         Resolve the uuid or alias information from a uuid or a url.
         Returns a tuple of (uuid, owner_username, alias)
-        - For content/<uuid> URLs: returns (uuid, None, None)
-        - For content/<username>/<alias> URLs: returns (None, username, alias)
+        - For content/uuid URLs: returns (uuid, None, None)
+        - For content/username/alias URLs: returns (None, username, alias)
         """
-        if not url and not uuid:
+        if not url_or_uuid:
             raise CoopNoUUIDError("No uuid or url provided for the object.")
 
-        if not uuid and url:
+        if self._is_url(url_or_uuid):
+            url = str(url_or_uuid)
+
             parts = (
                 url.replace("http://", "")
                 .replace("https://", "")
@@ -326,7 +332,8 @@ class Coop(CoopFunctionsMixin):
                     f"Invalid URL format. The URL must end with /content/<uuid> or /content/<username>/<alias>: {url}"
                 )
 
-        return str(uuid), None, None
+        uuid = str(url_or_uuid)
+        return uuid, None, None
 
     @property
     def edsl_settings(self) -> dict:
@@ -348,6 +355,15 @@ class Coop(CoopFunctionsMixin):
     ################
     # Objects
     ################
+    def _get_alias_url(self, owner_username: str, alias: str) -> Union[str, None]:
+        """
+        Get the URL of an object by its owner username and alias.
+        """
+        if owner_username and alias:
+            return f"{self.url}/content/{owner_username}/{alias}"
+        else:
+            return None
+
     def create(
         self,
         object: EDSLObject,
@@ -368,7 +384,9 @@ class Coop(CoopFunctionsMixin):
                 "json_string": json.dumps(
                     object.to_dict(),
                     default=self._json_handle_none,
-                ),
+                )
+                if object_type != "scenario"
+                else "",
                 "object_type": object_type,
                 "visibility": visibility,
                 "version": self._edsl_version,
@@ -376,19 +394,38 @@ class Coop(CoopFunctionsMixin):
         )
         self._resolve_server_response(response)
         response_json = response.json()
+
+        if object_type == "scenario":
+            json_data = json.dumps(
+                object.to_dict(),
+                default=self._json_handle_none,
+            )
+            headers = {"Content-Type": "application/json"}
+            if response_json.get("upload_signed_url"):
+                signed_url = response_json.get("upload_signed_url")
+            else:
+                raise Exception("No signed url provided received")
+
+            response = requests.put(
+                signed_url, data=json_data.encode(), headers=headers
+            )
+        owner_username = response_json.get("owner_username")
+        object_alias = response_json.get("alias")
+
         return {
             "description": response_json.get("description"),
             "object_type": object_type,
             "url": f"{self.url}/content/{response_json.get('uuid')}",
+            "alias_url": self._get_alias_url(owner_username, object_alias),
             "uuid": response_json.get("uuid"),
             "version": self._edsl_version,
             "visibility": response_json.get("visibility"),
+            "upload_signed_url": response_json.get("upload_signed_url", None),
         }
 
     def get(
         self,
-        uuid: Union[str, UUID] = None,
-        url: str = None,
+        url_or_uuid: Union[str, UUID],
         expected_object_type: Optional[ObjectType] = None,
     ) -> EDSLObject:
         """
@@ -396,13 +433,13 @@ class Coop(CoopFunctionsMixin):
         - If the object's visibility is private, the user must be the owner.
         - Optionally, check if the retrieved object is of a certain type.
 
-        :param uuid: the uuid of the object either in str or UUID format.
-        :param url: the url of the object (can be content/uuid or content/username/alias format).
-        :param expected_object_type: the expected type of the object.
+        :param url_or_uuid: The UUID or URL of the object.
+            URLs can be in the form content/uuid or content/username/alias.
+        :param expected_object_type: The expected type of the object.
 
         :return: the object instance.
         """
-        obj_uuid, owner_username, alias = self._resolve_uuid_or_alias(uuid, url)
+        obj_uuid, owner_username, alias = self._resolve_uuid_or_alias(url_or_uuid)
 
         if obj_uuid:
             response = self._send_server_request(
@@ -419,6 +456,10 @@ class Coop(CoopFunctionsMixin):
 
         self._resolve_server_response(response)
         json_string = response.json().get("json_string")
+        if "load_from:" in json_string[0:12]:
+            load_link = json_string.split("load_from:")[1]
+            object_data = requests.get(load_link)
+            json_string = object_data.text
         object_type = response.json().get("object_type")
         if expected_object_type and object_type != expected_object_type:
             raise Exception(f"Expected {expected_object_type=} but got {object_type=}")
@@ -437,28 +478,51 @@ class Coop(CoopFunctionsMixin):
             params={"type": object_type},
         )
         self._resolve_server_response(response)
-        objects = [
-            {
-                "object": edsl_class.from_dict(json.loads(o.get("json_string"))),
+        objects = []
+        for o in response.json():
+            json_string = o.get("json_string")
+            ## check if load from bucket needed.
+            if "load_from:" in json_string[0:12]:
+                load_link = json_string.split("load_from:")[1]
+                object_data = requests.get(load_link)
+                json_string = object_data.text
+
+            json_string = json.loads(json_string)
+            object = {
+                "object": edsl_class.from_dict(json_string),
                 "uuid": o.get("uuid"),
                 "version": o.get("version"),
                 "description": o.get("description"),
                 "visibility": o.get("visibility"),
                 "url": f"{self.url}/content/{o.get('uuid')}",
+                "alias_url": self._get_alias_url(
+                    o.get("owner_username"), o.get("alias")
+                ),
             }
-            for o in response.json()
-        ]
+            objects.append(object)
+
         return objects
 
-    def delete(self, uuid: Union[str, UUID] = None, url: str = None) -> dict:
+    def delete(self, url_or_uuid: Union[str, UUID]) -> dict:
         """
         Delete an object from the server.
+
+        :param url_or_uuid: The UUID or URL of the object.
+            URLs can be in the form content/uuid or content/username/alias.
         """
-        obj_uuid, _, _ = self._resolve_uuid_or_alias(uuid, url)
+        obj_uuid, owner_username, alias = self._resolve_uuid_or_alias(url_or_uuid)
+
+        if obj_uuid:
+            uri = "api/v0/object"
+            params = {"uuid": obj_uuid}
+        else:
+            uri = "api/v0/object/alias"
+            params = {"owner_username": owner_username, "alias": alias}
+
         response = self._send_server_request(
-            uri=f"api/v0/object",
+            uri=uri,
             method="DELETE",
-            params={"uuid": obj_uuid},
+            params=params,
         )
 
         self._resolve_server_response(response)
@@ -466,8 +530,7 @@ class Coop(CoopFunctionsMixin):
 
     def patch(
         self,
-        uuid: Union[str, UUID] = None,
-        url: str = None,
+        url_or_uuid: Union[str, UUID],
         description: Optional[str] = None,
         alias: Optional[str] = None,
         value: Optional[EDSLObject] = None,
@@ -475,15 +538,35 @@ class Coop(CoopFunctionsMixin):
     ) -> dict:
         """
         Change the attributes of an uploaded object
-        - Only supports visibility for now
-        """
-        if description is None and visibility is None and value is None:
+
+        :param url_or_uuid: The UUID or URL of the object.
+            URLs can be in the form content/uuid or content/username/alias.
+        :param description: Optional new description
+        :param alias: Optional new alias
+        :param value: Optional new object value
+        :param visibility: Optional new visibility setting
+        """
+        if (
+            description is None
+            and visibility is None
+            and value is None
+            and alias is None
+        ):
             raise Exception("Nothing to patch.")
-        obj_uuid, _, _ = self._resolve_uuid_or_alias(uuid, url)
+
+        obj_uuid, owner_username, obj_alias = self._resolve_uuid_or_alias(url_or_uuid)
+
+        if obj_uuid:
+            uri = "api/v0/object"
+            params = {"uuid": obj_uuid}
+        else:
+            uri = "api/v0/object/alias"
+            params = {"owner_username": owner_username, "alias": obj_alias}
+
         response = self._send_server_request(
-            uri=f"api/v0/object",
+            uri=uri,
             method="PATCH",
-            params={"uuid": obj_uuid},
+            params=params,
             payload={
                 "description": description,
                 "alias": alias,
@@ -504,90 +587,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 +734,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 +745,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 +756,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 +764,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 +782,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 +822,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 +832,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 +854,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 +883,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 +1179,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):
         """
@@ -1126,27 +1270,25 @@ def main():
     ##############
     # .. create and manipulate an object through the Coop client
     response = coop.create(QuestionMultipleChoice.example())
-    coop.get(uuid=response.get("uuid"))
-    coop.get(uuid=response.get("uuid"), expected_object_type="question")
-    coop.get(url=response.get("url"))
+    coop.get(response.get("uuid"))
+    coop.get(response.get("uuid"), expected_object_type="question")
+    coop.get(response.get("url"))
     coop.create(QuestionMultipleChoice.example())
     coop.get_all("question")
-    coop.patch(uuid=response.get("uuid"), visibility="private")
-    coop.patch(uuid=response.get("uuid"), description="hey")
-    coop.patch(uuid=response.get("uuid"), value=QuestionFreeText.example())
-    # coop.patch(uuid=response.get("uuid"), value=Survey.example()) - should throw error
-    coop.get(uuid=response.get("uuid"))
-    coop.delete(uuid=response.get("uuid"))
+    coop.patch(response.get("uuid"), visibility="private")
+    coop.patch(response.get("uuid"), description="hey")
+    coop.patch(response.get("uuid"), value=QuestionFreeText.example())
+    # coop.patch(response.get("uuid"), value=Survey.example()) - should throw error
+    coop.get(response.get("uuid"))
+    coop.delete(response.get("uuid"))
 
     # .. create and manipulate an object through the class
     response = QuestionMultipleChoice.example().push()
-    QuestionMultipleChoice.pull(uuid=response.get("uuid"))
-    QuestionMultipleChoice.pull(url=response.get("url"))
-    QuestionMultipleChoice.patch(uuid=response.get("uuid"), visibility="private")
-    QuestionMultipleChoice.patch(uuid=response.get("uuid"), description="hey")
-    QuestionMultipleChoice.patch(
-        uuid=response.get("uuid"), value=QuestionFreeText.example()
-    )
+    QuestionMultipleChoice.pull(response.get("uuid"))
+    QuestionMultipleChoice.pull(response.get("url"))
+    QuestionMultipleChoice.patch(response.get("uuid"), visibility="private")
+    QuestionMultipleChoice.patch(response.get("uuid"), description="hey")
+    QuestionMultipleChoice.patch(response.get("uuid"), value=QuestionFreeText.example())
     QuestionMultipleChoice.pull(response.get("uuid"))
     QuestionMultipleChoice.delete(response.get("uuid"))
 
@@ -1169,7 +1311,7 @@ def main():
         # 1. Delete existing objects
         existing_objects = coop.get_all(object_type)
         for item in existing_objects:
-            coop.delete(uuid=item.get("uuid"))
+            coop.delete(item.get("uuid"))
         # 2. Create new objects
         example = cls.example()
         response_1 = coop.create(example)
@@ -1183,45 +1325,45 @@ def main():
         assert len(objects) == 4
         # 4. Try to retrieve an item that does not exist
         try:
-            coop.get(uuid=uuid4())
+            coop.get(uuid4())
         except Exception as e:
             print(e)
         # 5. Try to retrieve all test objects by their uuids
         for response in [response_1, response_2, response_3, response_4]:
-            coop.get(uuid=response.get("uuid"))
+            coop.get(response.get("uuid"))
         # 6. Change visibility of all objects
         for item in objects:
-            coop.patch(uuid=item.get("uuid"), visibility="private")
+            coop.patch(item.get("uuid"), visibility="private")
         # 6. Change description of all objects
         for item in objects:
-            coop.patch(uuid=item.get("uuid"), description="hey")
+            coop.patch(item.get("uuid"), description="hey")
         # 7. Delete all objects
         for item in objects:
-            coop.delete(uuid=item.get("uuid"))
+            coop.delete(item.get("uuid"))
         assert len(coop.get_all(object_type)) == 0
 
     ##############
     # 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
@@ -1230,4 +1372,4 @@ def main():
     coop.remote_inference_cost(job)
     job_coop_object = coop.remote_inference_create(job)
     job_coop_results = coop.remote_inference_get(job_coop_object.get("uuid"))
-    coop.get(uuid=job_coop_results.get("results_uuid"))
+    coop.get(job_coop_results.get("results_uuid"))