edsl 0.1.39.dev2__py3-none-any.whl → 0.1.39.dev4__py3-none-any.whl

edsl/data/Cache.py

@@ -6,11 +6,9 @@ from __future__ import annotations
 import json
 import os
 import warnings
-from typing import Optional, Union
+from typing import Optional, Union, TYPE_CHECKING
 from edsl.Base import Base
 
-
-# from edsl.utilities.decorators import remove_edsl_version
 from edsl.utilities.remove_edsl_version import remove_edsl_version
 from edsl.exceptions.cache import CacheError
 
@@ -83,10 +81,6 @@ class Cache(Base):
 
         self._perform_checks()
 
-    # def rich_print(sefl):
-    #     pass
-    #     # raise NotImplementedError("This method is not implemented yet.")
-
     def code(sefl):
         pass
         # raise NotImplementedError("This method is not implemented yet.")
@@ -293,8 +287,8 @@ class Cache(Base):
 
         CACHE_PATH = CONFIG.get("EDSL_DATABASE_PATH")
         path = CACHE_PATH.replace("sqlite:///", "")
-        db_path = os.path.join(os.path.dirname(path), "data.db")
-        return cls.from_sqlite_db(db_path=db_path)
+        # db_path = os.path.join(os.path.dirname(path), "data.db")
+        return cls.from_sqlite_db(path)
 
     @classmethod
     def from_jsonl(cls, jsonlfile: str, db_path: Optional[str] = None) -> Cache:
@@ -368,12 +362,32 @@ class Cache(Base):
             scenarios.append(s)
         return ScenarioList(scenarios)
 
-    ####################
-    # REMOTE
-    ####################
-    # TODO: Make this work
-    # - Need to decide whether the cache belongs to a user and what can be shared
-    # - I.e., some cache entries? all or nothing?
+    def __floordiv__(self, other: "Cache") -> "Cache":
+        """
+        Return a new Cache containing entries that are in self but not in other.
+        Uses // operator as alternative to subtraction.
+
+        :param other: Another Cache object to compare against
+        :return: A new Cache object containing unique entries
+
+        >>> from edsl.data.CacheEntry import CacheEntry
+        >>> ce1 = CacheEntry.example(randomize = True)
+        >>> ce2 = CacheEntry.example(randomize = True)
+        >>> ce2 = CacheEntry.example(randomize = True)
+        >>> c1 = Cache(data={ce1.key: ce1, ce2.key: ce2})
+        >>> c2 = Cache(data={ce1.key: ce1})
+        >>> c3 = c1 // c2
+        >>> len(c3)
+        1
+        >>> c3.data[ce2.key] == ce2
+        True
+        """
+        if not isinstance(other, Cache):
+            raise CacheError("Can only compare two caches")
+
+        diff_data = {k: v for k, v in self.data.items() if k not in other.data}
+        return Cache(data=diff_data, immediate_write=self.immediate_write)
+
     @classmethod
     def from_url(cls, db_path=None) -> Cache:
         """
@@ -399,9 +413,6 @@ class Cache(Base):
         if self.filename:
             self.write(self.filename)
 
-    ####################
-    # DUNDER / USEFUL
-    ####################
     def __hash__(self):
         """Return the hash of the Cache."""
         from edsl.utilities.utilities import dict_hash

edsl/data/CacheHandler.py

@@ -67,8 +67,6 @@ class CacheHandler:
         if self.test:
             return Cache(data={})
 
-        # if self.CACHE_PATH is not None:
-        #    return self.CACHE_PATH
         from edsl.config import CONFIG
 
         if hasattr(CONFIG, "EDSL_SESSION_CACHE"):

edsl/data/RemoteCacheSync.py

@@ -1,71 +1,166 @@
-class RemoteCacheSync:
+from typing import List, Dict, Any, Optional, TYPE_CHECKING, Callable
+from dataclasses import dataclass
+from contextlib import AbstractContextManager
+from collections import UserList
+
+if TYPE_CHECKING:
+    from .Cache import Cache
+    from edsl.coop.coop import Coop
+    from .CacheEntry import CacheEntry
+
+from logging import Logger
+
+
+class CacheKeyList(UserList):
+    def __init__(self, data: List[str]):
+        super().__init__(data)
+        self.data = data
+
+    def __repr__(self):
+        import reprlib
+
+        keys_repr = reprlib.repr(self.data)
+        return f"CacheKeyList({keys_repr})"
+
+
+class CacheEntriesList(UserList):
+    def __init__(self, data: List["CacheEntry"]):
+        super().__init__(data)
+        self.data = data
+
+    def __repr__(self):
+        import reprlib
+
+        entries_repr = reprlib.repr(self.data)
+        return f"CacheEntries({entries_repr})"
+
+    def to_cache(self) -> "Cache":
+        from edsl.data.Cache import Cache
+
+        return Cache({entry.key: entry for entry in self.data})
+
+
+@dataclass
+class CacheDifference:
+    client_missing_entries: CacheEntriesList
+    server_missing_keys: List[str]
+
+    def __repr__(self):
+        """Returns a string representation of the CacheDifference object."""
+        import reprlib
+
+        missing_entries_repr = reprlib.repr(self.client_missing_entries)
+        missing_keys_repr = reprlib.repr(self.server_missing_keys)
+        return f"CacheDifference(client_missing_entries={missing_entries_repr}, server_missing_keys={missing_keys_repr})"
+
+
+class RemoteCacheSync(AbstractContextManager):
+    """Synchronizes a local cache with a remote cache.
+
+    Handles bidirectional synchronization:
+    - Downloads missing entries from remote to local cache
+    - Uploads new local entries to remote cache
+    """
+
     def __init__(
-        self, coop, cache, output_func, remote_cache=True, remote_cache_description=""
+        self,
+        coop: "Coop",
+        cache: "Cache",
+        output_func: Callable,
+        remote_cache: bool = True,
+        remote_cache_description: str = "",
     ):
+        """
+        Initializes a RemoteCacheSync object.
+
+        :param coop: Coop object for interacting with the remote cache
+        :param cache: Cache object for local cache
+        :param output_func: Function for outputting messages
+        :param remote_cache: Whether to enable remote cache synchronization
+        :param remote_cache_description: Description for remote cache entries
+
+        """
         self.coop = coop
         self.cache = cache
         self._output = output_func
-        self.remote_cache = remote_cache
-        self.old_entry_keys = []
-        self.new_cache_entries = []
+        self.remote_cache_enabled = remote_cache
         self.remote_cache_description = remote_cache_description
+        self.initial_cache_keys = []
 
-    def __enter__(self):
-        if self.remote_cache:
+    def __enter__(self) -> "RemoteCacheSync":
+        if self.remote_cache_enabled:
             self._sync_from_remote()
-            self.old_entry_keys = list(self.cache.keys())
+            self.initial_cache_keys = list(self.cache.keys())
         return self
 
     def __exit__(self, exc_type, exc_value, traceback):
-        if self.remote_cache:
+        if self.remote_cache_enabled:
             self._sync_to_remote()
         return False  # Propagate exceptions
 
-    def _sync_from_remote(self):
-        cache_difference = self.coop.remote_cache_get_diff(self.cache.keys())
-        client_missing_cacheentries = cache_difference.get(
-            "client_missing_cacheentries", []
+    def _get_cache_difference(self) -> CacheDifference:
+        """Retrieves differences between local and remote caches."""
+        diff = self.coop.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", []),
         )
-        missing_entry_count = len(client_missing_cacheentries)
 
-        if missing_entry_count > 0:
-            self._output(
-                f"Updating local cache with {missing_entry_count:,} new "
-                f"{'entry' if missing_entry_count == 1 else 'entries'} from remote..."
-            )
-            self.cache.add_from_dict(
-                {entry.key: entry for entry in client_missing_cacheentries}
-            )
-            self._output("Local cache updated!")
-        else:
+    def _sync_from_remote(self) -> None:
+        """Downloads missing entries from remote cache to local cache."""
+        diff: CacheDifference = self._get_cache_difference()
+        missing_count = len(diff.client_missing_entries)
+
+        if missing_count == 0:
             self._output("No new entries to add to local cache.")
+            return
 
-    def _sync_to_remote(self):
-        cache_difference = self.coop.remote_cache_get_diff(self.cache.keys())
-        server_missing_cacheentry_keys = cache_difference.get(
-            "server_missing_cacheentry_keys", []
+        self._output(
+            f"Updating local cache with {missing_count:,} new "
+            f"{'entry' if missing_count == 1 else 'entries'} from remote..."
         )
-        server_missing_cacheentries = [
-            entry
-            for key in server_missing_cacheentry_keys
-            if (entry := self.cache.data.get(key)) is not None
-        ]
-
-        new_cache_entries = [
-            entry
-            for entry in self.cache.values()
-            if entry.key not in self.old_entry_keys
-        ]
-        server_missing_cacheentries.extend(new_cache_entries)
-        new_entry_count = len(server_missing_cacheentries)
-
-        if new_entry_count > 0:
+
+        self.cache.add_from_dict(
+            {entry.key: entry for entry in diff.client_missing_entries}
+        )
+        self._output("Local cache updated!")
+
+    def _get_entries_to_upload(self, diff: CacheDifference) -> CacheEntriesList:
+        """Determines which entries need to be uploaded to remote cache."""
+        # Get entries for keys missing from server
+        server_missing_entries = CacheEntriesList(
+            [
+                entry
+                for key in diff.server_missing_keys
+                if (entry := self.cache.data.get(key)) is not None
+            ]
+        )
+
+        # Get newly added entries since sync started
+        new_entries = CacheEntriesList(
+            [
+                entry
+                for entry in self.cache.values()
+                if entry.key not in self.initial_cache_keys
+            ]
+        )
+
+        return server_missing_entries + new_entries
+
+    def _sync_to_remote(self) -> None:
+        """Uploads new local entries to remote cache."""
+        diff: CacheDifference = self._get_cache_difference()
+        entries_to_upload: CacheEntriesList = self._get_entries_to_upload(diff)
+        upload_count = len(entries_to_upload)
+
+        if upload_count > 0:
             self._output(
-                f"Updating remote cache with {new_entry_count:,} new "
-                f"{'entry' if new_entry_count == 1 else 'entries'}..."
+                f"Updating remote cache with {upload_count:,} new "
+                f"{'entry' if upload_count == 1 else 'entries'}..."
             )
+
             self.coop.remote_cache_create_many(
-                server_missing_cacheentries,
+                entries_to_upload,
                 visibility="private",
                 description=self.remote_cache_description,
             )
@@ -76,3 +171,16 @@ class RemoteCacheSync:
         self._output(
             f"There are {len(self.cache.keys()):,} entries in the local cache."
         )
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()
+
+    from edsl.coop.coop import Coop
+    from edsl.data.Cache import Cache
+    from edsl.data.CacheEntry import CacheEntry
+
+    r = RemoteCacheSync(Coop(), Cache(), print)
+    diff = r._get_cache_difference()

edsl/data/hack.py

@@ -0,0 +1,10 @@
+from edsl.data.CacheEntry import CacheEntry
+
+first = 0
+for i in range(0,1000000):
+    if i == 0:
+        first = CacheEntry.example().key
+    if first != "55ce2e13d38aa7fb6ec848053285edb4":
+        print(first)
+    print(CacheEntry.example().__dict__)
+    break

edsl/enums.py

@@ -86,6 +86,13 @@ InferenceServiceLiteral = Literal[
     "perplexity",
 ]
 
+available_models_urls = {
+    "anthropic": "https://docs.anthropic.com/en/docs/about-claude/models",
+    "openai": "https://platform.openai.com/docs/models/gp",
+    "groq": "https://console.groq.com/docs/models",
+    "google": "https://cloud.google.com/vertex-ai/generative-ai/docs/learn/models",
+}
+
 
 service_to_api_keyname = {
     InferenceServiceType.BEDROCK.value: "TBD",

edsl/inference_services/AnthropicService.py

@@ -11,21 +11,27 @@ class AnthropicService(InferenceServiceABC):
 
     _inference_service_ = "anthropic"
     _env_key_name_ = "ANTHROPIC_API_KEY"
-    key_sequence = ["content", 0, "text"]  # ["content"][0]["text"]
+    key_sequence = ["content", 0, "text"]
     usage_sequence = ["usage"]
     input_token_name = "input_tokens"
     output_token_name = "output_tokens"
     model_exclude_list = []
 
+    @classmethod
+    def get_model_list(cls, api_key: str = None):
+
+        import requests
+
+        if api_key is None:
+            api_key = os.environ.get("ANTHROPIC_API_KEY")
+        headers = {"x-api-key": api_key, "anthropic-version": "2023-06-01"}
+        response = requests.get("https://api.anthropic.com/v1/models", headers=headers)
+        model_names = [m["id"] for m in response.json()["data"]]
+        return model_names
+
     @classmethod
     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",
-        ]
+        return cls.get_model_list()
 
     @classmethod
     def create_model(
@@ -62,20 +68,36 @@ class AnthropicService(InferenceServiceABC):
                 system_prompt: str = "",
                 files_list: Optional[List["Files"]] = None,
             ) -> dict[str, Any]:
-                """Calls the OpenAI API and returns the API response."""
+                """Calls the Anthropic API and returns the API response."""
 
-                api_key = os.environ.get("ANTHROPIC_API_KEY")
-                client = AsyncAnthropic(api_key=api_key)
+                messages = [
+                    {
+                        "role": "user",
+                        "content": [{"type": "text", "text": user_prompt}],
+                    }
+                ]
+                if files_list:
+                    for file_entry in files_list:
+                        encoded_image = file_entry.base64_string
+                        messages[0]["content"].append(
+                            {
+                                "type": "image",
+                                "source": {
+                                    "type": "base64",
+                                    "media_type": file_entry.mime_type,
+                                    "data": encoded_image,
+                                },
+                            }
+                        )
+                # breakpoint()
+                client = AsyncAnthropic(api_key=self.api_token)
 
                 response = await client.messages.create(
                     model=model_name,
                     max_tokens=self.max_tokens,
                     temperature=self.temperature,
-                    system=system_prompt,
-                    messages=[
-                        #                        {"role": "system", "content": system_prompt},
-                        {"role": "user", "content": user_prompt},
-                    ],
+                    system=system_prompt,  # note that the Anthropic API uses "system" parameter rather than put it in the message
+                    messages=messages,
                 )
                 return response.model_dump()
 

edsl/inference_services/AvailableModelFetcher.py

@@ -133,6 +133,12 @@ class AvailableModelFetcher:
         )
         service_name = service._inference_service_
 
+        if not service_models:
+            import warnings
+
+            warnings.warn(f"No models found for service {service_name}")
+            return [], service_name
+
         models_list = AvailableModels(
             [
                 LanguageModelInfo(
@@ -177,7 +183,7 @@ class AvailableModelFetcher:
                         )
 
                 except Exception as exc:
-                    print(f"Service query failed: {exc}")
+                    print(f"Service query failed for service {service_name}: {exc}")
                     continue
 
         return AvailableModels(all_models)

edsl/inference_services/GoogleService.py

@@ -40,13 +40,17 @@ class GoogleService(InferenceServiceABC):
     model_exclude_list = []
 
     @classmethod
-    def available(cls) -> List[str]:
+    def get_model_list(cls):
         model_list = []
         for m in genai.list_models():
             if "generateContent" in m.supported_generation_methods:
                 model_list.append(m.name.split("/")[-1])
         return model_list
 
+    @classmethod
+    def available(cls) -> List[str]:
+        return cls.get_model_list()
+
     @classmethod
     def create_model(
         cls, model_name: str = "gemini-pro", model_class_name=None

edsl/inference_services/InferenceServicesCollection.py

@@ -71,7 +71,12 @@ class ModelResolver:
                 self._models_to_services[model_name] = service
                 return service
 
-        raise InferenceServiceError(f"Model {model_name} not found in any services")
+        raise InferenceServiceError(
+            f"""Model {model_name} not found in any services. 
+                                    If you know the service that has this model, use the service_name parameter directly.
+                                    E.g., Model("gpt-4o", service_name="openai")
+                                    """
+        )
 
 
 class InferenceServicesCollection:
@@ -93,6 +98,9 @@ class InferenceServicesCollection:
         if service_name not in cls.added_models:
             cls.added_models[service_name].append(model_name)
 
+    def service_names_to_classes(self) -> Dict[str, InferenceServiceABC]:
+        return {service._inference_service_: service for service in self.services}
+
     def available(
         self,
         service: Optional[str] = None,
@@ -112,7 +120,15 @@ class InferenceServicesCollection:
     def create_model_factory(
         self, model_name: str, service_name: Optional[InferenceServiceLiteral] = None
     ) -> "LanguageModel":
-        service = self.resolver.resolve_model(model_name, service_name)
+
+        if service_name is None:  # we try to find the right service
+            service = self.resolver.resolve_model(model_name, service_name)
+        else:  # if they passed a service, we'll use that
+            service = self.service_names_to_classes().get(service_name)
+
+        if not service:  # but if we can't find it, we'll raise an error
+            raise InferenceServiceError(f"Service {service_name} not found")
+
         return service.create_model(model_name)
 
 

edsl/inference_services/OpenAIService.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
-from typing import Any, List, Optional
+from typing import Any, List, Optional, Dict, NewType
 import os
 
+
 import openai
 
 from edsl.inference_services.InferenceServiceABC import InferenceServiceABC
@@ -11,6 +12,8 @@ from edsl.utilities.utilities import fix_partial_correct_response
 
 from edsl.config import CONFIG
 
+APIToken = NewType("APIToken", str)
+
 
 class OpenAIService(InferenceServiceABC):
     """OpenAI service class."""
@@ -22,35 +25,43 @@ class OpenAIService(InferenceServiceABC):
     _sync_client_ = openai.OpenAI
     _async_client_ = openai.AsyncOpenAI
 
-    _sync_client_instance = None
-    _async_client_instance = None
+    _sync_client_instances: Dict[APIToken, openai.OpenAI] = {}
+    _async_client_instances: Dict[APIToken, openai.AsyncOpenAI] = {}
 
     key_sequence = ["choices", 0, "message", "content"]
     usage_sequence = ["usage"]
     input_token_name = "prompt_tokens"
     output_token_name = "completion_tokens"
 
+    available_models_url = "https://platform.openai.com/docs/models/gp"
+
     def __init_subclass__(cls, **kwargs):
         super().__init_subclass__(**kwargs)
-        # so subclasses have to create their own instances of the clients
-        cls._sync_client_instance = None
-        cls._async_client_instance = None
+        # so subclasses that use the OpenAI api key have to create their own instances of the clients
+        cls._sync_client_instances = {}
+        cls._async_client_instances = {}
 
     @classmethod
-    def sync_client(cls):
-        if cls._sync_client_instance is None:
-            cls._sync_client_instance = cls._sync_client_(
-                api_key=os.getenv(cls._env_key_name_), base_url=cls._base_url_
+    def sync_client(cls, api_key):
+        if api_key not in cls._sync_client_instances:
+            client = cls._sync_client_(
+                api_key=api_key,
+                base_url=cls._base_url_,
             )
-        return cls._sync_client_instance
+            cls._sync_client_instances[api_key] = client
+        client = cls._sync_client_instances[api_key]
+        return client
 
     @classmethod
-    def async_client(cls):
-        if cls._async_client_instance is None:
-            cls._async_client_instance = cls._async_client_(
-                api_key=os.getenv(cls._env_key_name_), base_url=cls._base_url_
+    def async_client(cls, api_key):
+        if api_key not in cls._async_client_instances:
+            client = cls._async_client_(
+                api_key=api_key,
+                base_url=cls._base_url_,
             )
-        return cls._async_client_instance
+            cls._async_client_instances[api_key] = client
+        client = cls._async_client_instances[api_key]
+        return client
 
     model_exclude_list = [
         "whisper-1",
@@ -72,20 +83,24 @@ class OpenAIService(InferenceServiceABC):
     _models_list_cache: List[str] = []
 
     @classmethod
-    def get_model_list(cls):
-        raw_list = cls.sync_client().models.list()
+    def get_model_list(cls, api_key=None):
+        if api_key is None:
+            api_key = os.getenv(cls._env_key_name_)
+        raw_list = cls.sync_client(api_key).models.list()
         if hasattr(raw_list, "data"):
             return raw_list.data
         else:
             return raw_list
 
     @classmethod
-    def available(cls) -> List[str]:
+    def available(cls, api_token=None) -> List[str]:
+        if api_token is None:
+            api_token = os.getenv(cls._env_key_name_)
         if not cls._models_list_cache:
             try:
                 cls._models_list_cache = [
                     m.id
-                    for m in cls.get_model_list()
+                    for m in cls.get_model_list(api_key=api_token)
                     if m.id not in cls.model_exclude_list
                 ]
             except Exception as e:
@@ -120,10 +135,10 @@ class OpenAIService(InferenceServiceABC):
             }
 
             def sync_client(self):
-                return cls.sync_client()
+                return cls.sync_client(api_key=self.api_token)
 
             def async_client(self):
-                return cls.async_client()
+                return cls.async_client(api_key=self.api_token)
 
             @classmethod
             def available(cls) -> list[str]:
@@ -172,16 +187,16 @@ class OpenAIService(InferenceServiceABC):
             ) -> dict[str, Any]:
                 """Calls the OpenAI API and returns the API response."""
                 if files_list:
-                    encoded_image = files_list[0].base64_string
                     content = [{"type": "text", "text": user_prompt}]
-                    content.append(
-                        {
-                            "type": "image_url",
-                            "image_url": {
-                                "url": f"data:image/jpeg;base64,{encoded_image}"
-                            },
-                        }
-                    )
+                    for file_entry in files_list:
+                        content.append(
+                            {
+                                "type": "image_url",
+                                "image_url": {
+                                    "url": f"data:{file_entry.mime_type};base64,{file_entry.base64_string}"
+                                },
+                            }
+                        )
                 else:
                     content = user_prompt
                 client = self.async_client()