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

edsl/data/Cache.py

@@ -6,9 +6,11 @@ from __future__ import annotations
 import json
 import os
 import warnings
-from typing import Optional, Union, TYPE_CHECKING
+from typing import Optional, Union
 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
 
@@ -81,6 +83,10 @@ 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.")
@@ -287,8 +293,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(path)
+        db_path = os.path.join(os.path.dirname(path), "data.db")
+        return cls.from_sqlite_db(db_path=db_path)
 
     @classmethod
     def from_jsonl(cls, jsonlfile: str, db_path: Optional[str] = None) -> Cache:
@@ -362,32 +368,12 @@ class Cache(Base):
             scenarios.append(s)
         return ScenarioList(scenarios)
 
-    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)
-
+    ####################
+    # 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?
     @classmethod
     def from_url(cls, db_path=None) -> Cache:
         """
@@ -413,6 +399,9 @@ 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,6 +67,8 @@ 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,166 +1,71 @@
-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
-    """
-
+class RemoteCacheSync:
     def __init__(
-        self,
-        coop: "Coop",
-        cache: "Cache",
-        output_func: Callable,
-        remote_cache: bool = True,
-        remote_cache_description: str = "",
+        self, coop, cache, output_func, remote_cache=True, remote_cache_description=""
     ):
-        """
-        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_enabled = remote_cache
+        self.remote_cache = remote_cache
+        self.old_entry_keys = []
+        self.new_cache_entries = []
         self.remote_cache_description = remote_cache_description
-        self.initial_cache_keys = []
 
-    def __enter__(self) -> "RemoteCacheSync":
-        if self.remote_cache_enabled:
+    def __enter__(self):
+        if self.remote_cache:
             self._sync_from_remote()
-            self.initial_cache_keys = list(self.cache.keys())
+            self.old_entry_keys = list(self.cache.keys())
         return self
 
     def __exit__(self, exc_type, exc_value, traceback):
-        if self.remote_cache_enabled:
+        if self.remote_cache:
             self._sync_to_remote()
         return False  # Propagate exceptions
 
-    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", []),
+    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", []
         )
+        missing_entry_count = len(client_missing_cacheentries)
 
-    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:
+        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:
             self._output("No new entries to add to local cache.")
-            return
 
-        self._output(
-            f"Updating local cache with {missing_count:,} new "
-            f"{'entry' if missing_count == 1 else 'entries'} from remote..."
+    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.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:
+        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._output(
-                f"Updating remote cache with {upload_count:,} new "
-                f"{'entry' if upload_count == 1 else 'entries'}..."
+                f"Updating remote cache with {new_entry_count:,} new "
+                f"{'entry' if new_entry_count == 1 else 'entries'}..."
             )
-
             self.coop.remote_cache_create_many(
-                entries_to_upload,
+                server_missing_cacheentries,
                 visibility="private",
                 description=self.remote_cache_description,
             )
@@ -171,16 +76,3 @@ class RemoteCacheSync(AbstractContextManager):
         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/enums.py

@@ -86,13 +86,6 @@ 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,27 +11,21 @@ class AnthropicService(InferenceServiceABC):
 
     _inference_service_ = "anthropic"
     _env_key_name_ = "ANTHROPIC_API_KEY"
-    key_sequence = ["content", 0, "text"]
+    key_sequence = ["content", 0, "text"]  # ["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):
-        return cls.get_model_list()
+        # TODO - replace with an API call
+        return [
+            "claude-3-5-sonnet-20240620",
+            "claude-3-opus-20240229",
+            "claude-3-sonnet-20240229",
+            "claude-3-haiku-20240307",
+        ]
 
     @classmethod
     def create_model(
@@ -68,36 +62,20 @@ class AnthropicService(InferenceServiceABC):
                 system_prompt: str = "",
                 files_list: Optional[List["Files"]] = None,
             ) -> dict[str, Any]:
-                """Calls the Anthropic API and returns the API response."""
+                """Calls the OpenAI API and returns the API response."""
 
-                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)
+                api_key = os.environ.get("ANTHROPIC_API_KEY")
+                client = AsyncAnthropic(api_key=api_key)
 
                 response = await client.messages.create(
                     model=model_name,
                     max_tokens=self.max_tokens,
                     temperature=self.temperature,
-                    system=system_prompt,  # note that the Anthropic API uses "system" parameter rather than put it in the message
-                    messages=messages,
+                    system=system_prompt,
+                    messages=[
+                        #                        {"role": "system", "content": system_prompt},
+                        {"role": "user", "content": user_prompt},
+                    ],
                 )
                 return response.model_dump()
 

edsl/inference_services/AvailableModelFetcher.py

@@ -133,12 +133,6 @@ 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(
@@ -183,7 +177,7 @@ class AvailableModelFetcher:
                         )
 
                 except Exception as exc:
-                    print(f"Service query failed for service {service_name}: {exc}")
+                    print(f"Service query failed: {exc}")
                     continue
 
         return AvailableModels(all_models)

edsl/inference_services/GoogleService.py

@@ -40,17 +40,13 @@ class GoogleService(InferenceServiceABC):
     model_exclude_list = []
 
     @classmethod
-    def get_model_list(cls):
+    def available(cls) -> List[str]:
         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,12 +71,7 @@ class ModelResolver:
                 self._models_to_services[model_name] = service
                 return service
 
-        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")
-                                    """
-        )
+        raise InferenceServiceError(f"Model {model_name} not found in any services")
 
 
 class InferenceServicesCollection:
@@ -98,9 +93,6 @@ 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,
@@ -120,15 +112,7 @@ class InferenceServicesCollection:
     def create_model_factory(
         self, model_name: str, service_name: Optional[InferenceServiceLiteral] = None
     ) -> "LanguageModel":
-
-        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")
-
+        service = self.resolver.resolve_model(model_name, service_name)
         return service.create_model(model_name)
 
 

edsl/inference_services/OpenAIService.py

@@ -1,8 +1,7 @@
 from __future__ import annotations
-from typing import Any, List, Optional, Dict, NewType
+from typing import Any, List, Optional
 import os
 
-
 import openai
 
 from edsl.inference_services.InferenceServiceABC import InferenceServiceABC
@@ -12,8 +11,6 @@ from edsl.utilities.utilities import fix_partial_correct_response
 
 from edsl.config import CONFIG
 
-APIToken = NewType("APIToken", str)
-
 
 class OpenAIService(InferenceServiceABC):
     """OpenAI service class."""
@@ -25,43 +22,35 @@ class OpenAIService(InferenceServiceABC):
     _sync_client_ = openai.OpenAI
     _async_client_ = openai.AsyncOpenAI
 
-    _sync_client_instances: Dict[APIToken, openai.OpenAI] = {}
-    _async_client_instances: Dict[APIToken, openai.AsyncOpenAI] = {}
+    _sync_client_instance = None
+    _async_client_instance = None
 
     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 that use the OpenAI api key have to create their own instances of the clients
-        cls._sync_client_instances = {}
-        cls._async_client_instances = {}
+        # so subclasses have to create their own instances of the clients
+        cls._sync_client_instance = None
+        cls._async_client_instance = None
 
     @classmethod
-    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_,
+    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_
             )
-            cls._sync_client_instances[api_key] = client
-        client = cls._sync_client_instances[api_key]
-        return client
+        return cls._sync_client_instance
 
     @classmethod
-    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_,
+    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_
             )
-            cls._async_client_instances[api_key] = client
-        client = cls._async_client_instances[api_key]
-        return client
+        return cls._async_client_instance
 
     model_exclude_list = [
         "whisper-1",
@@ -83,24 +72,20 @@ class OpenAIService(InferenceServiceABC):
     _models_list_cache: List[str] = []
 
     @classmethod
-    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()
+    def get_model_list(cls):
+        raw_list = cls.sync_client().models.list()
         if hasattr(raw_list, "data"):
             return raw_list.data
         else:
             return raw_list
 
     @classmethod
-    def available(cls, api_token=None) -> List[str]:
-        if api_token is None:
-            api_token = os.getenv(cls._env_key_name_)
+    def available(cls) -> List[str]:
         if not cls._models_list_cache:
             try:
                 cls._models_list_cache = [
                     m.id
-                    for m in cls.get_model_list(api_key=api_token)
+                    for m in cls.get_model_list()
                     if m.id not in cls.model_exclude_list
                 ]
             except Exception as e:
@@ -135,10 +120,10 @@ class OpenAIService(InferenceServiceABC):
             }
 
             def sync_client(self):
-                return cls.sync_client(api_key=self.api_token)
+                return cls.sync_client()
 
             def async_client(self):
-                return cls.async_client(api_key=self.api_token)
+                return cls.async_client()
 
             @classmethod
             def available(cls) -> list[str]:
@@ -187,16 +172,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}]
-                    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}"
-                                },
-                            }
-                        )
+                    content.append(
+                        {
+                            "type": "image_url",
+                            "image_url": {
+                                "url": f"data:image/jpeg;base64,{encoded_image}"
+                            },
+                        }
+                    )
                 else:
                     content = user_prompt
                 client = self.async_client()

edsl/inference_services/TestService.py

@@ -51,7 +51,6 @@ class TestService(InferenceServiceABC):
             @property
             def _canned_response(self):
                 if hasattr(self, "canned_response"):
-
                     return self.canned_response
                 else:
                     return "Hello, world"
@@ -64,6 +63,9 @@ class TestService(InferenceServiceABC):
                 files_list: Optional[List["File"]] = None,
             ) -> dict[str, Any]:
                 await asyncio.sleep(0.1)
+                # return {"message": """{"answer": "Hello, world"}"""}
+
+                # breakpoint()
 
                 if hasattr(self, "throw_exception") and self.throw_exception:
                     if hasattr(self, "exception_probability"):