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

edsl/coop/PriceFetcher.py

@@ -18,7 +18,7 @@ class PriceFetcher:
 
         import os
         import requests
-        from edsl import CONFIG
+        from edsl.config import CONFIG
 
         try:
             # Fetch the pricing data

edsl/coop/coop.py

@@ -1,11 +1,19 @@
 import aiohttp
 import json
-import os
 import requests
-from typing import Any, Optional, Union, Literal
+
+from typing import Any, Optional, Union, Literal, TypedDict
 from uuid import UUID
+from collections import UserDict, defaultdict
+
 import edsl
-from edsl import CONFIG, CacheEntry, Jobs, Survey
+from pathlib import Path
+
+from edsl.config import CONFIG
+from edsl.data.CacheEntry import CacheEntry
+from edsl.jobs.Jobs import Jobs
+from edsl.surveys.Survey import Survey
+
 from edsl.exceptions.coop import CoopNoUUIDError, CoopServerResponseError
 from edsl.coop.utils import (
     EDSLObject,
@@ -15,19 +23,48 @@ from edsl.coop.utils import (
     VisibilityType,
 )
 
+from edsl.coop.CoopFunctionsMixin import CoopFunctionsMixin
+from edsl.coop.ExpectedParrotKeyHandler import ExpectedParrotKeyHandler
+
+from edsl.inference_services.data_structures import ServiceToModelsMapping
+
+
+class RemoteInferenceResponse(TypedDict):
+    job_uuid: str
+    results_uuid: str
+    results_url: str
+    latest_error_report_uuid: str
+    latest_error_report_url: str
+    status: str
+    reason: str
+    credits_consumed: float
+    version: str
+
+
+class RemoteInferenceCreationInfo(TypedDict):
+    uuid: str
+    description: str
+    status: str
+    iterations: int
+    visibility: str
+    version: str
 
-class Coop:
+
+class Coop(CoopFunctionsMixin):
     """
     Client for the Expected Parrot API.
     """
 
-    def __init__(self, api_key: str = None, url: str = None) -> None:
+    def __init__(
+        self, api_key: Optional[str] = None, url: Optional[str] = None
+    ) -> None:
         """
         Initialize the client.
         - Provide an API key directly, or through an env variable.
         - Provide a URL directly, or use the default one.
         """
-        self.api_key = api_key or os.getenv("EXPECTED_PARROT_API_KEY")
+        self.ep_key_handler = ExpectedParrotKeyHandler()
+        self.api_key = api_key or self.ep_key_handler.get_ep_api_key()
 
         self.url = url or CONFIG.EXPECTED_PARROT_URL
         if self.url.endswith("/"):
@@ -163,19 +200,27 @@ class Coop:
                 edsl_auth_token = secrets.token_urlsafe(16)
 
                 print("Your Expected Parrot API key is invalid.")
-                print(
-                    "\nUse the link below to log in to Expected Parrot so we can automatically update your API key."
+                self._display_login_url(
+                    edsl_auth_token=edsl_auth_token,
+                    link_description="\n🔗 Use the link below to log in to Expected Parrot so we can automatically update your API key.",
                 )
-                self._display_login_url(edsl_auth_token=edsl_auth_token)
                 api_key = self._poll_for_api_key(edsl_auth_token)
 
                 if api_key is None:
                     print("\nTimed out waiting for login. Please try again.")
                     return
 
-                write_api_key_to_env(api_key)
-                print("\n✨ API key retrieved and written to .env file.")
-                print("Rerun your code to try again with a valid API key.")
+                print("\n✨ API key retrieved.")
+
+                if stored_in_user_space := self.ep_key_handler.ask_to_store(api_key):
+                    pass
+                else:
+                    path_to_env = write_api_key_to_env(api_key)
+                    print(
+                        "\n✨ API key retrieved and written to .env file at the following path:"
+                    )
+                    print(f"    {path_to_env}")
+                    print("Rerun your code to try again with a valid API key.")
                 return
 
             elif "Authorization" in message:
@@ -268,6 +313,7 @@ class Coop:
         self,
         object: EDSLObject,
         description: Optional[str] = None,
+        alias: Optional[str] = None,
         visibility: Optional[VisibilityType] = "unlisted",
     ) -> dict:
         """
@@ -279,6 +325,7 @@ class Coop:
             method="POST",
             payload={
                 "description": description,
+                "alias": alias,
                 "json_string": json.dumps(
                     object.to_dict(),
                     default=self._json_handle_none,
@@ -373,6 +420,7 @@ class Coop:
         uuid: Union[str, UUID] = None,
         url: str = None,
         description: Optional[str] = None,
+        alias: Optional[str] = None,
         value: Optional[EDSLObject] = None,
         visibility: Optional[VisibilityType] = None,
     ) -> dict:
@@ -389,6 +437,7 @@ class Coop:
             params={"uuid": uuid},
             payload={
                 "description": description,
+                "alias": alias,
                 "json_string": (
                     json.dumps(
                         value.to_dict(),
@@ -613,7 +662,7 @@ class Coop:
         visibility: Optional[VisibilityType] = "unlisted",
         initial_results_visibility: Optional[VisibilityType] = "unlisted",
         iterations: Optional[int] = 1,
-    ) -> dict:
+    ) -> RemoteInferenceCreationInfo:
         """
         Send a remote inference job to the server.
 
@@ -645,18 +694,21 @@ class Coop:
         )
         self._resolve_server_response(response)
         response_json = response.json()
-        return {
-            "uuid": response_json.get("job_uuid"),
-            "description": response_json.get("description"),
-            "status": response_json.get("status"),
-            "iterations": response_json.get("iterations"),
-            "visibility": response_json.get("visibility"),
-            "version": self._edsl_version,
-        }
+
+        return RemoteInferenceCreationInfo(
+            **{
+                "uuid": response_json.get("job_uuid"),
+                "description": response_json.get("description"),
+                "status": response_json.get("status"),
+                "iterations": response_json.get("iterations"),
+                "visibility": response_json.get("visibility"),
+                "version": self._edsl_version,
+            }
+        )
 
     def remote_inference_get(
         self, job_uuid: Optional[str] = None, results_uuid: Optional[str] = None
-    ) -> dict:
+    ) -> RemoteInferenceResponse:
         """
         Get the details of a remote inference job.
         You can pass either the job uuid or the results uuid as a parameter.
@@ -698,17 +750,19 @@ class Coop:
                 f"{self.url}/home/remote-inference/error/{latest_error_report_uuid}"
             )
 
-        return {
-            "job_uuid": data.get("job_uuid"),
-            "results_uuid": results_uuid,
-            "results_url": results_url,
-            "latest_error_report_uuid": latest_error_report_uuid,
-            "latest_error_report_url": latest_error_report_url,
-            "status": data.get("status"),
-            "reason": data.get("reason"),
-            "credits_consumed": data.get("price"),
-            "version": data.get("version"),
-        }
+        return RemoteInferenceResponse(
+            **{
+                "job_uuid": data.get("job_uuid"),
+                "results_uuid": results_uuid,
+                "results_url": results_url,
+                "latest_error_report_uuid": latest_error_report_uuid,
+                "latest_error_report_url": latest_error_report_url,
+                "status": data.get("status"),
+                "reason": data.get("reason"),
+                "credits_consumed": data.get("price"),
+                "version": data.get("version"),
+            }
+        )
 
     def remote_inference_cost(
         self, input: Union[Jobs, Survey], iterations: int = 1
@@ -810,7 +864,7 @@ class Coop:
                 "Invalid EDSL_FETCH_TOKEN_PRICES value---should be 'True' or 'False'."
             )
 
-    def fetch_models(self) -> dict:
+    def fetch_models(self) -> ServiceToModelsMapping:
         """
         Fetch a dict of available models from Coop.
 
@@ -819,7 +873,7 @@ class Coop:
         response = self._send_server_request(uri="api/v0/models", method="GET")
         self._resolve_server_response(response)
         data = response.json()
-        return data
+        return ServiceToModelsMapping(data)
 
     def fetch_rate_limit_config_vars(self) -> dict:
         """
@@ -835,7 +889,9 @@ class Coop:
         data = response.json()
         return data
 
-    def _display_login_url(self, edsl_auth_token: str):
+    def _display_login_url(
+        self, edsl_auth_token: str, link_description: Optional[str] = None
+    ):
         """
         Uses rich.print to display a login URL.
 
@@ -845,7 +901,12 @@ class Coop:
 
         url = f"{CONFIG.EXPECTED_PARROT_URL}/login?edsl_auth_token={edsl_auth_token}"
 
-        rich_print(f"[#38bdf8][link={url}]{url}[/link][/#38bdf8]")
+        if link_description:
+            rich_print(
+                f"{link_description}\n    [#38bdf8][link={url}]{url}[/link][/#38bdf8]"
+            )
+        else:
+            rich_print(f"    [#38bdf8][link={url}]{url}[/link][/#38bdf8]")
 
     def _get_api_key(self, edsl_auth_token: str):
         """
@@ -873,17 +934,18 @@ class Coop:
 
         edsl_auth_token = secrets.token_urlsafe(16)
 
-        print(
-            "\nUse the link below to log in to Expected Parrot so we can automatically update your API key."
+        self._display_login_url(
+            edsl_auth_token=edsl_auth_token,
+            link_description="\n🔗 Use the link below to log in to Expected Parrot so we can automatically update your API key.",
         )
-        self._display_login_url(edsl_auth_token=edsl_auth_token)
         api_key = self._poll_for_api_key(edsl_auth_token)
 
         if api_key is None:
             raise Exception("Timed out waiting for login. Please try again.")
 
-        write_api_key_to_env(api_key)
-        print("\n✨ API key retrieved and written to .env file.")
+        path_to_env = write_api_key_to_env(api_key)
+        print("\n✨ API key retrieved and written to .env file at the following path:")
+        print(f"    {path_to_env}")
 
         # Add API key to environment
         load_dotenv()

edsl/coop/utils.py

@@ -1,19 +1,19 @@
-from edsl import (
-    Agent,
-    AgentList,
-    Cache,
-    ModelList,
-    Notebook,
-    Results,
-    Scenario,
-    ScenarioList,
-    Survey,
-    Study,
-)
-from edsl.language_models import LanguageModel
-from edsl.questions import QuestionBase
 from typing import Literal, Optional, Type, Union
 
+from edsl.agents.Agent import Agent
+from edsl.agents.AgentList import AgentList
+from edsl.data.Cache import Cache
+from edsl.language_models.ModelList import ModelList
+from edsl.notebooks.Notebook import Notebook
+from edsl.results.Results import Results
+from edsl.scenarios.Scenario import Scenario
+from edsl.scenarios.ScenarioList import ScenarioList
+from edsl.surveys.Survey import Survey
+from edsl.study.Study import Study
+
+from edsl.language_models.LanguageModel import LanguageModel
+from edsl.questions.QuestionBase import QuestionBase
+
 EDSLObject = Union[
     Agent,
     AgentList,

edsl/data/Cache.py

@@ -6,12 +6,12 @@ from __future__ import annotations
 import json
 import os
 import warnings
-import copy
 from typing import Optional, Union
 from edsl.Base import Base
-from edsl.data.CacheEntry import CacheEntry
-from edsl.utilities.utilities import dict_hash
-from edsl.utilities.decorators import remove_edsl_version
+
+
+# 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,9 +83,9 @@ class Cache(Base):
 
         self._perform_checks()
 
-    def rich_print(sefl):
-        pass
-        # raise NotImplementedError("This method is not implemented yet.")
+    # def rich_print(sefl):
+    #     pass
+    #     # raise NotImplementedError("This method is not implemented yet.")
 
     def code(sefl):
         pass
@@ -201,6 +201,7 @@ class Cache(Base):
         >>> len(c)
         1
         """
+        from edsl.data.CacheEntry import CacheEntry
 
         entry = CacheEntry(
             model=model,
@@ -226,6 +227,7 @@ class Cache(Base):
 
         :param write_now: Whether to write to the cache immediately (similar to `immediate_write`).
         """
+        from edsl.data.CacheEntry import CacheEntry
 
         for key, value in new_data.items():
             if key in self.data:
@@ -246,6 +248,8 @@ class Cache(Base):
 
         :param write_now: Whether to write to the cache immediately (similar to `immediate_write`).
         """
+        from edsl.data.CacheEntry import CacheEntry
+
         with open(filename, "a+") as f:
             f.seek(0)
             lines = f.readlines()
@@ -353,7 +357,8 @@ class Cache(Base):
                 f.write(json.dumps({key: value.to_dict()}) + "\n")
 
     def to_scenario_list(self):
-        from edsl import ScenarioList, Scenario
+        from edsl.scenarios.ScenarioList import ScenarioList
+        from edsl.scenarios.Scenario import Scenario
 
         scenarios = []
         for key, value in self.data.items():
@@ -399,6 +404,8 @@ class Cache(Base):
     ####################
     def __hash__(self):
         """Return the hash of the Cache."""
+        from edsl.utilities.utilities import dict_hash
+
         return dict_hash(self.to_dict(add_edsl_version=False))
 
     def to_dict(self, add_edsl_version=True) -> dict:
@@ -414,12 +421,6 @@ class Cache(Base):
     def _summary(self):
         return {"EDSL Class": "Cache", "Number of entries": len(self.data)}
 
-    def _repr_html_(self):
-        # from edsl.utilities.utilities import data_to_html
-        # return data_to_html(self.to_dict())
-        footer = f"<a href={self.__documentation__}>(docs)</a>"
-        return str(self.summary(format="html")) + footer
-
     def table(
         self,
         *fields,
@@ -443,6 +444,8 @@ class Cache(Base):
     @remove_edsl_version
     def from_dict(cls, data) -> Cache:
         """Construct a Cache from a dictionary."""
+        from edsl.data.CacheEntry import CacheEntry
+
         newdata = {k: CacheEntry.from_dict(v) for k, v in data.items()}
         return cls(data=newdata)
 
@@ -485,6 +488,8 @@ class Cache(Base):
         """
         Create an example input for a 'fetch' operation.
         """
+        from edsl.data.CacheEntry import CacheEntry
+
         return CacheEntry.fetch_input_example()
 
     def to_html(self):
@@ -541,6 +546,8 @@ class Cache(Base):
 
         :param randomize: If True, uses CacheEntry's randomize method.
         """
+        from edsl.data.CacheEntry import CacheEntry
+
         return cls(
             data={
                 CacheEntry.example(randomize).key: CacheEntry.example(),

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,24 @@ 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={})
 
+        # if self.CACHE_PATH is not None:
+        #    return self.CACHE_PATH
+        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 +90,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 +124,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 +135,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 +149,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 +164,7 @@ class CacheHandler:
 
 
 if __name__ == "__main__":
-    ch = CacheHandler()
+    # ch = CacheHandler()
+    import doctest
+
+    doctest.testmod()

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,25 @@ 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",
+]
+
+
 service_to_api_keyname = {
     InferenceServiceType.BEDROCK.value: "TBD",
     InferenceServiceType.DEEP_INFRA.value: "DEEP_INFRA_API_KEY",