edsl 0.1.38.dev4__py3-none-any.whl → 0.1.39__py3-none-any.whl

edsl/data/CacheEntry.py

@@ -5,8 +5,12 @@ import hashlib
 from typing import Optional
 from uuid import uuid4
 
+from edsl.utilities.decorators import remove_edsl_version
 
-class CacheEntry:
+from edsl.Base import RepresentationMixin
+
+
+class CacheEntry(RepresentationMixin):
     """
     A Class to represent a cache entry.
     """
@@ -78,11 +82,11 @@ class CacheEntry:
         d = {k: value for k, value in self.__dict__.items() if k in self.key_fields}
         return self.gen_key(**d)
 
-    def to_dict(self) -> dict:
+    def to_dict(self, add_edsl_version=True) -> dict:
         """
         Returns a dictionary representation of a CacheEntry.
         """
-        return {
+        d = {
             "model": self.model,
             "parameters": self.parameters,
             "system_prompt": self.system_prompt,
@@ -91,19 +95,12 @@ class CacheEntry:
             "iteration": self.iteration,
             "timestamp": self.timestamp,
         }
+        # if add_edsl_version:
+        #     from edsl import __version__
 
-    def _repr_html_(self) -> str:
-        """
-        Returns an HTML representation of a CacheEntry.
-        """
-        # from edsl.utilities.utilities import data_to_html
-        # return data_to_html(self.to_dict())
-        d = self.to_dict()
-        data = [[k, v] for k, v in d.items()]
-        from tabulate import tabulate
-
-        table = str(tabulate(data, headers=["keys", "values"], tablefmt="html"))
-        return f"<pre>{table}</pre>"
+        #     d["edsl_version"] = __version__
+        #     d["edsl_class_name"] = self.__class__.__name__
+        return d
 
     def keys(self):
         return list(self.to_dict().keys())

edsl/data/CacheHandler.py

@@ -3,19 +3,19 @@ import ast
 import json
 import os
 import shutil
-import sqlite3
-from edsl.config import CONFIG
-from edsl.data.Cache import Cache
-from edsl.data.CacheEntry import CacheEntry
-from edsl.data.SQLiteDict import SQLiteDict
+from typing import TYPE_CHECKING
 
-from edsl.config import CONFIG
+if TYPE_CHECKING:
+    from edsl.data.Cache import Cache
+    from edsl.data.CacheEntry import CacheEntry
 
 
-def set_session_cache(cache: Cache) -> None:
+def set_session_cache(cache: "Cache") -> None:
     """
     Set the session cache.
     """
+    from edsl.config import CONFIG
+
     CONFIG.EDSL_SESSION_CACHE = cache
 
 
@@ -23,6 +23,8 @@ def unset_session_cache() -> None:
     """
     Unset the session cache.
     """
+    from edsl.config import CONFIG
+
     if hasattr(CONFIG, "EDSL_SESSION_CACHE"):
         del CONFIG.EDSL_SESSION_CACHE
 
@@ -32,7 +34,11 @@ class CacheHandler:
     This CacheHandler figures out what caches are available and does migrations, as needed.
     """
 
-    CACHE_PATH = CONFIG.get("EDSL_DATABASE_PATH")
+    @property
+    def CACHE_PATH(self):
+        from edsl.config import CONFIG
+
+        return CONFIG.get("EDSL_DATABASE_PATH")
 
     def __init__(self, test: bool = False):
         self.test = test
@@ -52,16 +58,22 @@ class CacheHandler:
             if notify:
                 print(f"Created cache directory: {dir_path}")
 
-    def gen_cache(self) -> Cache:
+    def gen_cache(self) -> "Cache":
         """
         Generate a Cache object.
         """
+        from edsl.data.Cache import Cache
+
         if self.test:
             return Cache(data={})
 
+        from edsl.config import CONFIG
+
         if hasattr(CONFIG, "EDSL_SESSION_CACHE"):
             return CONFIG.EDSL_SESSION_CACHE
 
+        from edsl.data.SQLiteDict import SQLiteDict
+
         cache = Cache(data=SQLiteDict(self.CACHE_PATH))
         return cache
 
@@ -76,6 +88,8 @@ class CacheHandler:
         if not os.path.exists(os.path.join(os.getcwd(), path)):
             return old_data
         try:
+            import sqlite3
+
             conn = sqlite3.connect(path)
             with conn:
                 cur = conn.cursor()
@@ -108,6 +122,8 @@ class CacheHandler:
         entry_dict["user_prompt"] = entry_dict.pop("prompt")
         parameters = entry_dict["parameters"]
         entry_dict["parameters"] = ast.literal_eval(parameters)
+        from edsl.data.CacheEntry import CacheEntry
+
         entry = CacheEntry(**entry_dict)
         return entry
 
@@ -117,7 +133,7 @@ class CacheHandler:
     ###############
     # NOT IN USE
     ###############
-    def from_sqlite(uri="new_edsl_cache.db") -> dict[str, CacheEntry]:
+    def from_sqlite(uri="new_edsl_cache.db") -> dict[str, "CacheEntry"]:
         """
         Read in a new-style sqlite cache and return a dictionary of dictionaries.
         """
@@ -131,7 +147,7 @@ class CacheHandler:
                 newdata[entry.key] = entry
         return newdata
 
-    def from_jsonl(filename="edsl_cache.jsonl") -> dict[str, CacheEntry]:
+    def from_jsonl(filename="edsl_cache.jsonl") -> dict[str, "CacheEntry"]:
         """Read in a jsonl file and return a dictionary of CacheEntry objects."""
         with open(filename, "a+") as f:
             f.seek(0)
@@ -146,4 +162,7 @@ class CacheHandler:
 
 
 if __name__ == "__main__":
-    ch = CacheHandler()
+    # ch = CacheHandler()
+    import doctest
+
+    doctest.testmod()

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/__init__.py

@@ -1,4 +1,5 @@
-from edsl.data.CacheEntry import CacheEntry
-from edsl.data.SQLiteDict import SQLiteDict
+# from edsl.data.CacheEntry import CacheEntry
+# from edsl.data.SQLiteDict import SQLiteDict
 from edsl.data.Cache import Cache
-from edsl.data.CacheHandler import CacheHandler
+
+# from edsl.data.CacheHandler import CacheHandler

edsl/data_transfer_models.py

@@ -1,6 +1,5 @@
 from typing import NamedTuple, Dict, List, Optional, Any
 from dataclasses import dataclass, fields
-import reprlib
 
 
 class ModelInputs(NamedTuple):
@@ -56,6 +55,8 @@ class ImageInfo:
     encoded_image: str
 
     def __repr__(self):
+        import reprlib
+
         reprlib_instance = reprlib.Repr()
         reprlib_instance.maxstring = 30  # Limit the string length for the encoded image
 

edsl/enums.py

@@ -1,6 +1,7 @@
 """Enums for the different types of questions, language models, and inference services."""
 
 from enum import Enum
+from typing import Literal
 
 
 class EnumWithChecks(Enum):
@@ -67,6 +68,32 @@ class InferenceServiceType(EnumWithChecks):
     PERPLEXITY = "perplexity"
 
 
+# unavoidable violation of the DRY principle but it is necessary
+# checked w/ a unit test to make sure consistent with services in enums.py
+InferenceServiceLiteral = Literal[
+    "bedrock",
+    "deep_infra",
+    "replicate",
+    "openai",
+    "google",
+    "test",
+    "anthropic",
+    "groq",
+    "azure",
+    "ollama",
+    "mistral",
+    "together",
+    "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",
     InferenceServiceType.DEEP_INFRA.value: "DEEP_INFRA_API_KEY",

edsl/exceptions/__init__.py

@@ -1,54 +1,54 @@
-from .agents import (
-    #    AgentAttributeLookupCallbackError,
-    AgentCombinationError,
-    #    AgentLacksLLMError,
-    #    AgentRespondedWithBadJSONError,
-)
-from .configuration import (
-    InvalidEnvironmentVariableError,
-    MissingEnvironmentVariableError,
-)
-from .data import (
-    DatabaseConnectionError,
-    DatabaseCRUDError,
-    DatabaseIntegrityError,
-)
+# from .agents import (
+#     #    AgentAttributeLookupCallbackError,
+#     AgentCombinationError,
+#     #    AgentLacksLLMError,
+#     #    AgentRespondedWithBadJSONError,
+# )
+# from .configuration import (
+#     InvalidEnvironmentVariableError,
+#     MissingEnvironmentVariableError,
+# )
+# from .data import (
+#     DatabaseConnectionError,
+#     DatabaseCRUDError,
+#     DatabaseIntegrityError,
+# )
 
-from .scenarios import (
-    ScenarioError,
-)
+# from .scenarios import (
+#     ScenarioError,
+# )
 
-from .general import MissingAPIKeyError
+# from .general import MissingAPIKeyError
 
-from .jobs import JobsRunError, InterviewErrorPriorTaskCanceled, InterviewTimeoutError
+# from .jobs import JobsRunError, InterviewErrorPriorTaskCanceled, InterviewTimeoutError
 
-from .language_models import (
-    LanguageModelResponseNotJSONError,
-    LanguageModelMissingAttributeError,
-    LanguageModelAttributeTypeError,
-    LanguageModelDoNotAddError,
-)
-from .questions import (
-    QuestionAnswerValidationError,
-    QuestionAttributeMissing,
-    QuestionCreationValidationError,
-    QuestionResponseValidationError,
-    QuestionSerializationError,
-    QuestionScenarioRenderError,
-)
-from .results import (
-    ResultsBadMutationstringError,
-    ResultsColumnNotFoundError,
-    ResultsInvalidNameError,
-    ResultsMutateError,
-)
-from .surveys import (
-    SurveyCreationError,
-    SurveyHasNoRulesError,
-    SurveyRuleCannotEvaluateError,
-    SurveyRuleCollectionHasNoRulesAtNodeError,
-    SurveyRuleReferenceInRuleToUnknownQuestionError,
-    SurveyRuleRefersToFutureStateError,
-    SurveyRuleSendsYouBackwardsError,
-    SurveyRuleSkipLogicSyntaxError,
-)
+# from .language_models import (
+#     LanguageModelResponseNotJSONError,
+#     LanguageModelMissingAttributeError,
+#     LanguageModelAttributeTypeError,
+#     LanguageModelDoNotAddError,
+# )
+# from .questions import (
+#     QuestionAnswerValidationError,
+#     QuestionAttributeMissing,
+#     QuestionCreationValidationError,
+#     QuestionResponseValidationError,
+#     QuestionSerializationError,
+#     QuestionScenarioRenderError,
+# )
+# from .results import (
+#     ResultsBadMutationstringError,
+#     ResultsColumnNotFoundError,
+#     ResultsInvalidNameError,
+#     ResultsMutateError,
+# )
+# from .surveys import (
+#     SurveyCreationError,
+#     SurveyHasNoRulesError,
+#     SurveyRuleCannotEvaluateError,
+#     SurveyRuleCollectionHasNoRulesAtNodeError,
+#     SurveyRuleReferenceInRuleToUnknownQuestionError,
+#     SurveyRuleRefersToFutureStateError,
+#     SurveyRuleSendsYouBackwardsError,
+#     SurveyRuleSkipLogicSyntaxError,
+# )

edsl/exceptions/agents.py

@@ -1,6 +1,18 @@
 from edsl.exceptions.BaseException import BaseException
 
 
+# from edsl.utilities.utilities import is_notebook
+
+# from IPython.core.error import UsageError
+
+# class AgentListErrorAlternative(UsageError):
+#     def __init__(self, message):
+#         super().__init__(message)
+
+import sys
+from edsl.utilities.is_notebook import is_notebook
+
+
 class AgentListError(BaseException):
     relevant_doc = "https://docs.expectedparrot.com/en/latest/agents.html#agent-lists"
 

edsl/exceptions/inference_services.py

@@ -0,0 +1,5 @@
+from edsl.exceptions.BaseException import BaseException
+
+
+class InferenceServiceError(BaseException):
+    relevant_doc = "https://docs.expectedparrot.com/"

edsl/exceptions/questions.py

@@ -1,6 +1,6 @@
 from typing import Any, SupportsIndex
-from jinja2 import Template
 import json
+from pydantic import ValidationError
 
 
 class QuestionErrors(Exception):
@@ -20,17 +20,35 @@ class QuestionAnswerValidationError(QuestionErrors):
     For example, if the question is a multiple choice question, the answer should be drawn from the list of options provided.
     """
 
-    def __init__(self, message="Invalid answer.", data=None, model=None):
+    def __init__(
+        self,
+        message="Invalid answer.",
+        pydantic_error: ValidationError = None,
+        data: dict = None,
+        model=None,
+    ):
         self.message = message
+        self.pydantic_error = pydantic_error
         self.data = data
         self.model = model
         super().__init__(self.message)
 
     def __str__(self):
-        return f"""{repr(self)} 
-        Data being validated: {self.data} 
-        Pydnantic Model: {self.model}.
-        Reported error: {self.message}."""
+        if isinstance(self.message, ValidationError):
+            # If it's a ValidationError, just return the core error message
+            return str(self.message)
+        elif hasattr(self.message, "errors"):
+            # Handle the case where it's already been converted to a string but has errors
+            error_list = self.message.errors()
+            if error_list:
+                return str(error_list[0].get("msg", "Unknown error"))
+        return str(self.message)
+
+    # def __str__(self):
+    #     return f"""{repr(self)}
+    #     Data being validated: {self.data}
+    #     Pydnantic Model: {self.model}.
+    #     Reported error: {self.message}."""
 
     def to_html_dict(self):
         return {

edsl/exceptions/scenarios.py

@@ -1,6 +1,13 @@
 import re
 import textwrap
 
+# from IPython.core.error import UsageError
+
+
+class AgentListError(Exception):
+    def __init__(self, message):
+        super().__init__(message)
+
 
 class ScenarioError(Exception):
     documentation = "https://docs.expectedparrot.com/en/latest/scenarios.html#module-edsl.scenarios.Scenario"