edsl 0.1.27.dev2__py3-none-any.whl → 0.1.28__py3-none-any.whl

edsl/coop/coop.py

@@ -106,7 +106,8 @@ class Coop:
     def create(
         self,
         object: EDSLObject,
-        visibility: VisibilityType = "unlisted",
+        description: Optional[str] = None,
+        visibility: Optional[VisibilityType] = "unlisted",
     ) -> dict:
         """
         Create an EDSL object in the Coop server.
@@ -117,6 +118,7 @@ class Coop:
             uri=f"api/v0/object",
             method="POST",
             payload={
+                "description": description,
                 "object_type": object_type,
                 "json_string": json.dumps(
                     object.to_dict(),
@@ -131,8 +133,9 @@ class Coop:
         return {
             "uuid": response_json.get("uuid"),
             "version": self._edsl_version,
+            "description": response_json.get("description"),
             "visibility": response_json.get("visibility"),
-            "url": f"{self.url}/explore/{object_page}/{response_json.get('uuid')}",
+            "url": f"{self.url}/content/{response_json.get('uuid')}",
         }
 
     def get(
@@ -140,6 +143,7 @@ class Coop:
         object_type: ObjectType = None,
         uuid: Union[str, UUID] = None,
         url: str = None,
+        exec_profile=None,
     ) -> EDSLObject:
         """
         Retrieve an EDSL object either by object type & UUID, or by its url.
@@ -156,25 +160,37 @@ class Coop:
         elif not object_type and not uuid:
             raise Exception("Provide either object_type & UUID, or a url.")
         edsl_class = ObjectRegistry.object_type_to_edsl_class.get(object_type)
+        import time
+
+        start = time.time()
         response = self._send_server_request(
             uri=f"api/v0/object",
             method="GET",
             params={"type": object_type, "uuid": uuid},
         )
+        end = time.time()
+        if exec_profile:
+            print("Download exec time = ", end - start)
         self._resolve_server_response(response)
         json_string = response.json().get("json_string")
-        return edsl_class.from_dict(json.loads(json_string))
+        start = time.time()
+        res_object = edsl_class.from_dict(json.loads(json_string))
+        end = time.time()
+        if exec_profile:
+            print("Creating object exec time = ", end - start)
+        return res_object
 
     def _get_base(
         self,
         cls: EDSLObject,
         uuid: Union[str, UUID],
+        exec_profile=None,
     ) -> EDSLObject:
         """
         Used by the Base class to offer a get functionality.
         """
         object_type = ObjectRegistry.get_object_type_by_edsl_class(cls)
-        return self.get(object_type, uuid)
+        return self.get(object_type, uuid, exec_profile=exec_profile)
 
     def get_all(self, object_type: ObjectType) -> list[EDSLObject]:
         """
@@ -193,6 +209,7 @@ class Coop:
                 "object": edsl_class.from_dict(json.loads(o.get("json_string"))),
                 "uuid": o.get("uuid"),
                 "version": o.get("version"),
+                "description": o.get("description"),
                 "visibility": o.get("visibility"),
                 "url": f"{self.url}/explore/{object_page}/{o.get('uuid')}",
             }
@@ -227,17 +244,36 @@ class Coop:
         self,
         object_type: ObjectType,
         uuid: Union[str, UUID],
-        visibility: VisibilityType,
+        description: Optional[str] = None,
+        value: Optional[EDSLObject] = None,
+        visibility: Optional[VisibilityType] = None,
     ) -> 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:
+            raise Exception("Nothing to patch.")
+        if value is not None:
+            value_type = ObjectRegistry.get_object_type_by_edsl_class(value)
+            if value_type != object_type:
+                raise Exception(f"Object type mismatch: {object_type=} {value_type=}")
         response = self._send_server_request(
             uri=f"api/v0/object",
             method="PATCH",
             params={"type": object_type, "uuid": uuid},
-            payload={"visibility": visibility},
+            payload={
+                "description": description,
+                "json_string": (
+                    json.dumps(
+                        value.to_dict(),
+                        default=self._json_handle_none,
+                    )
+                    if value
+                    else None
+                ),
+                "visibility": visibility,
+            },
         )
         self._resolve_server_response(response)
         return response.json()
@@ -246,13 +282,15 @@ class Coop:
         self,
         cls: EDSLObject,
         uuid: Union[str, UUID],
-        visibility: VisibilityType,
+        description: Optional[str] = None,
+        value: Optional[EDSLObject] = None,
+        visibility: Optional[VisibilityType] = None,
     ) -> dict:
         """
         Used by the Base class to offer a patch functionality.
         """
         object_type = ObjectRegistry.get_object_type_by_edsl_class(cls)
-        return self.patch(object_type, uuid, visibility)
+        return self.patch(object_type, uuid, description, value, visibility)
 
     ################
     # Remote Cache
@@ -261,9 +299,19 @@ class Coop:
         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",
@@ -272,24 +320,44 @@ class Coop:
                 "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
         ]
@@ -299,6 +367,14 @@ class Coop:
             payload=payload,
         )
         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(
@@ -307,7 +383,11 @@ class Coop:
     ) -> list[CacheEntry]:
         """
         Get all remote cache entries.
-        - optional exclude_keys: exclude CacheEntry objects with these keys.
+
+        :param optional exclude_keys: Exclude CacheEntry objects with these keys.
+
+        >>> coop.remote_cache_get()
+        [CacheEntry(...), CacheEntry(...), ...]
         """
         if exclude_keys is None:
             exclude_keys = []
@@ -322,15 +402,93 @@ class Coop:
             for v in response.json()
         ]
 
+    def remote_cache_get_diff(
+        self,
+        client_cacheentry_keys: list[str],
+    ) -> dict:
+        """
+        Get the difference between local and remote cache entries for a user.
+        """
+        response = self._send_server_request(
+            uri="api/v0/remote-cache/get-diff",
+            method="POST",
+            payload={"keys": client_cacheentry_keys},
+        )
+        self._resolve_server_response(response)
+        response_json = response.json()
+        response_dict = {
+            "client_missing_cacheentries": [
+                CacheEntry.from_dict(json.loads(c.get("json_string")))
+                for c in response_json.get("client_missing_cacheentries", [])
+            ],
+            "server_missing_cacheentry_keys": response_json.get(
+                "server_missing_cacheentry_keys", []
+            ),
+        }
+        downloaded_entry_count = len(response_dict["client_missing_cacheentries"])
+        if downloaded_entry_count > 0:
+            self.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:
         """
         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()
+        {'status': 'success', 'deleted_entry_count': 10}
         """
         response = self._send_server_request(
             uri="api/v0/remote-cache/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(
+                response,
+                description="Clear cache entries",
+                cache_entry_count=deleted_entry_count,
+            )
+        return response.json()
+
+    def remote_cache_create_log(
+        self, response: requests.Response, description: str, cache_entry_count: int
+    ) -> Union[dict, None]:
+        """
+        If a remote cache action has been completed successfully,
+        log the action.
+        """
+        if 200 <= response.status_code < 300:
+            log_response = self._send_server_request(
+                uri="api/v0/remote-cache-log",
+                method="POST",
+                payload={
+                    "description": description,
+                    "cache_entry_count": cache_entry_count,
+                },
+            )
+            self._resolve_server_response(log_response)
+            return response.json()
+
+    def remote_cache_clear_log(self) -> dict:
+        """
+        Clear all remote cache log entries.
+
+        >>> coop.remote_cache_clear_log()
+        {'status': 'success'}
+        """
+        response = self._send_server_request(
+            uri="api/v0/remote-cache-log/delete-all",
+            method="DELETE",
+        )
+        self._resolve_server_response(response)
         return response.json()
 
     ################
@@ -438,7 +596,7 @@ if __name__ == "__main__":
         Agent,
         AgentList,
         Cache,
-        Jobs,
+        Notebook,
         QuestionMultipleChoice,
         Results,
         Scenario,
@@ -450,7 +608,7 @@ if __name__ == "__main__":
         ("agent", Agent),
         ("agent_list", AgentList),
         ("cache", Cache),
-        ("job", Jobs),
+        ("notebook", Notebook),
         ("question", QuestionMultipleChoice),
         ("results", Results),
         ("scenario", Scenario),
@@ -469,7 +627,9 @@ if __name__ == "__main__":
         response_1 = coop.create(example)
         response_2 = coop.create(cls.example(), visibility="private")
         response_3 = coop.create(cls.example(), visibility="public")
-        response_4 = coop.create(cls.example(), visibility="unlisted")
+        response_4 = coop.create(
+            cls.example(), visibility="unlisted", description="hey"
+        )
         # 3. Retrieve all objects
         objects = coop.get_all(object_type)
         assert len(objects) == 4
@@ -486,14 +646,33 @@ if __name__ == "__main__":
             coop.patch(
                 object_type=object_type, uuid=item.get("uuid"), visibility="private"
             )
+        # 6. Change description of all objects
+        for item in objects:
+            coop.patch(
+                object_type=object_type, uuid=item.get("uuid"), description="hey"
+            )
         # 7. Delete all objects
         for item in objects:
             coop.delete(object_type=object_type, uuid=item.get("uuid"))
         assert len(coop.get_all(object_type)) == 0
 
+    # a simple example
+    from edsl import Coop, QuestionMultipleChoice, QuestionFreeText
+
+    coop = Coop(api_key="b")
     response = QuestionMultipleChoice.example().push()
     QuestionMultipleChoice.pull(response.get("uuid"))
     coop.patch(object_type="question", uuid=response.get("uuid"), visibility="public")
+    coop.patch(
+        object_type="question",
+        uuid=response.get("uuid"),
+        description="crazy new description",
+    )
+    coop.patch(
+        object_type="question",
+        uuid=response.get("uuid"),
+        value=QuestionFreeText.example(),
+    )
     coop.delete(object_type="question", uuid=response.get("uuid"))
 
     ##############

edsl/coop/utils.py

@@ -1,5 +1,15 @@
-from edsl import Agent, AgentList, Cache, Jobs, Results, Scenario, ScenarioList, Survey
-from edsl.notebooks import Notebook
+from edsl import (
+    Agent,
+    AgentList,
+    Cache,
+    Jobs,
+    Notebook,
+    Results,
+    Scenario,
+    ScenarioList,
+    Survey,
+    Study,
+)
 from edsl.questions import QuestionBase
 from typing import Literal, Type, Union
 
@@ -14,6 +24,7 @@ EDSLObject = Union[
     Scenario,
     ScenarioList,
     Survey,
+    Study,
 ]
 
 ObjectType = Literal[
@@ -27,6 +38,7 @@ ObjectType = Literal[
     "scenario",
     "scenario_list",
     "survey",
+    "study",
 ]
 
 ObjectPage = Literal[
@@ -40,6 +52,7 @@ ObjectPage = Literal[
     "scenarios",
     "scenariolists",
     "surveys",
+    "studies",
 ]
 
 VisibilityType = Literal[
@@ -105,6 +118,11 @@ class ObjectRegistry:
             "edsl_class": Survey,
             "object_page": "surveys",
         },
+        {
+            "object_type": "study",
+            "edsl_class": Study,
+            "object_page": "studies",
+        },
     ]
     object_type_to_edsl_class = {o["object_type"]: o["edsl_class"] for o in objects}
     edsl_class_to_object_type = {

edsl/data/Cache.py

@@ -12,6 +12,7 @@ from edsl.config import CONFIG
 from edsl.data.CacheEntry import CacheEntry
 from edsl.data.SQLiteDict import SQLiteDict
 from edsl.Base import Base
+from edsl.utilities.utilities import dict_hash
 
 from edsl.utilities.decorators import (
     add_edsl_version,
@@ -24,7 +25,6 @@ class Cache(Base):
     A class that represents a cache of responses from a language model.
 
     :param data: The data to initialize the cache with.
-    :param remote: Whether to sync the Cache with the server.
     :param immediate_write: Whether to write to the cache immediately after storing a new entry.
 
     Deprecated:
@@ -37,24 +37,51 @@ class Cache(Base):
     def __init__(
         self,
         *,
+        filename: Optional[str] = None,
         data: Optional[Union[SQLiteDict, dict]] = None,
-        remote: bool = False,
         immediate_write: bool = True,
         method=None,
     ):
         """
         Create two dictionaries to store the cache data.
 
+        :param filename: The name of the file to read/write the cache from/to.
+        :param data: The data to initialize the cache with.
+        :param immediate_write: Whether to write to the cache immediately after storing a new entry.
+        :param method: The method of storage to use for the cache.
+
         """
-        self.data = data or {}
+
         # self.data_at_init = data or {}
         self.fetched_data = {}
-        self.remote = remote
         self.immediate_write = immediate_write
         self.method = method
         self.new_entries = {}
         self.new_entries_to_write_later = {}
         self.coop = None
+
+        self.filename = filename
+        if filename and data:
+            raise ValueError("Cannot provide both filename and data")
+        if filename is None and data is None:
+            data = {}
+        if data is not None:
+            self.data = data
+        if filename is not None:
+            self.data = {}
+            if filename.endswith(".jsonl"):
+                if os.path.exists(filename):
+                    self.add_from_jsonl(filename)
+                else:
+                    print(
+                        f"File {filename} not found, but will write to this location."
+                    )
+            elif filename.endswith(".db"):
+                if os.path.exists(filename):
+                    self.add_from_sqlite(filename)
+            else:
+                raise ValueError("Invalid file extension. Must be .jsonl or .db")
+
         self._perform_checks()
 
     def rich_print(sefl):
@@ -81,10 +108,6 @@ class Cache(Base):
             raise Exception("Not all values are CacheEntry instances")
         if self.method is not None:
             warnings.warn("Argument `method` is deprecated", DeprecationWarning)
-        if self.remote:
-            from edsl.coop import Coop
-
-            self.coop = Coop()
 
     ####################
     # READ/WRITE
@@ -267,6 +290,19 @@ class Cache(Base):
         for key, value in self.data.items():
             new_data[key] = value
 
+    def write(self, filename: Optional[str] = None) -> None:
+        """
+        Write the cache to a file at the specified location.
+        """
+        if filename is None:
+            filename = self.filename
+        if filename.endswith(".jsonl"):
+            self.write_jsonl(filename)
+        elif filename.endswith(".db"):
+            self.write_sqlite_db(filename)
+        else:
+            raise ValueError("Invalid file extension. Must be .jsonl or .db")
+
     def write_jsonl(self, filename: str) -> None:
         """
         Write the cache to a JSONL file.
@@ -295,11 +331,6 @@ class Cache(Base):
         """
         Run when a context is entered.
         """
-        if self.remote:
-            print("Syncing local and remote caches")
-            exclude_keys = list(self.data.keys())
-            cache_entries = self.coop.get_cache_entries(exclude_keys)
-            self.add_from_dict({c.key: c for c in cache_entries}, write_now=True)
         return self
 
     def __exit__(self, exc_type, exc_value, traceback):
@@ -308,16 +339,21 @@ class Cache(Base):
         """
         for key, entry in self.new_entries_to_write_later.items():
             self.data[key] = entry
-        if self.remote:
-            _ = self.coop.create_cache_entries(cache_dict=self.new_entries)
 
     ####################
     # DUNDER / USEFUL
     ####################
+    def __hash__(self):
+        """Return the hash of the Cache."""
+        return dict_hash(self._to_dict())
+
+    def _to_dict(self) -> dict:
+        return {k: v.to_dict() for k, v in self.data.items()}
+
     @add_edsl_version
     def to_dict(self) -> dict:
         """Return the Cache as a dictionary."""
-        return {k: v.to_dict() for k, v in self.data.items()}
+        return self._to_dict()
 
     def _repr_html_(self):
         from edsl.utilities.utilities import data_to_html
@@ -359,7 +395,9 @@ class Cache(Base):
         """
         Return a string representation of the Cache object.
         """
-        return f"Cache(data = {repr(self.data)}, immediate_write={self.immediate_write}, remote={self.remote})"
+        return (
+            f"Cache(data = {repr(self.data)}, immediate_write={self.immediate_write})"
+        )
 
     ####################
     # EXAMPLES

edsl/data/CacheHandler.py

@@ -9,22 +9,22 @@ from edsl.data.Cache import Cache
 from edsl.data.CacheEntry import CacheEntry
 from edsl.data.SQLiteDict import SQLiteDict
 
+from edsl.config import CONFIG
+
 
 def set_session_cache(cache: Cache) -> None:
     """
     Set the session cache.
     """
-    print("All calls to 'run' will now use this cache by default.")
-    global _CACHE
-    _CACHE = cache
+    CONFIG.EDSL_SESSION_CACHE = cache
 
 
 def unset_session_cache() -> None:
     """
     Unset the session cache.
     """
-    global _CACHE
-    _CACHE = None
+    if hasattr(CONFIG, "EDSL_SESSION_CACHE"):
+        del CONFIG.EDSL_SESSION_CACHE
 
 
 class CacheHandler:
@@ -49,7 +49,9 @@ class CacheHandler:
         dir_path = os.path.dirname(path)
         if dir_path and not os.path.exists(dir_path):
             os.makedirs(dir_path)
-            print(f"Created cache directory: {dir_path}")
+            import warnings
+
+            warnings.warn(f"Created cache directory: {dir_path}")
 
     def gen_cache(self) -> Cache:
         """
@@ -58,9 +60,8 @@ class CacheHandler:
         if self.test:
             return Cache(data={})
 
-        if "_CACHE" in globals() and _CACHE is not None:
-            # print("Using globally-set cache.")
-            return _CACHE
+        if hasattr(CONFIG, "EDSL_SESSION_CACHE"):
+            return CONFIG.EDSL_SESSION_CACHE
 
         cache = Cache(data=SQLiteDict(self.CACHE_PATH))
         return cache

edsl/inference_services/AnthropicService.py

@@ -16,6 +16,7 @@ class AnthropicService(InferenceServiceABC):
     def available(cls):
         # TODO - replace with an API call
         return [
+            "claude-3-5-sonnet-20240620",
             "claude-3-opus-20240229",
             "claude-3-sonnet-20240229",
             "claude-3-haiku-20240307",