edsl 0.1.37.dev5__py3-none-any.whl → 0.1.38__py3-none-any.whl

edsl/coop/coop.py

@@ -28,11 +28,23 @@ class Coop:
         - Provide a URL directly, or use the default one.
         """
         self.api_key = api_key or os.getenv("EXPECTED_PARROT_API_KEY")
+
         self.url = url or CONFIG.EXPECTED_PARROT_URL
         if self.url.endswith("/"):
             self.url = self.url[:-1]
+        if "chick.expectedparrot" in self.url:
+            self.api_url = "https://chickapi.expectedparrot.com"
+        elif "expectedparrot" in self.url:
+            self.api_url = "https://api.expectedparrot.com"
+        elif "localhost:1234" in self.url:
+            self.api_url = "http://localhost:8000"
+        else:
+            self.api_url = self.url
         self._edsl_version = edsl.__version__
 
+    def get_progress_bar_url(self):
+        return f"{CONFIG.EXPECTED_PARROT_URL}"
+
     ################
     # BASIC METHODS
     ################
@@ -59,7 +71,7 @@ class Coop:
         """
         Send a request to the server and return the response.
         """
-        url = f"{self.url}/{uri}"
+        url = f"{self.api_url}/{uri}"
         method = method.upper()
         if payload is None:
             timeout = 20
@@ -90,12 +102,57 @@ class Coop:
 
         return response
 
+    def _get_latest_stable_version(self, version: str) -> str:
+        """
+        Extract the latest stable PyPI version from a version string.
+
+        Examples:
+        - Decrement the patch number of a dev version: "0.1.38.dev1" -> "0.1.37"
+        - Return a stable version as is: "0.1.37" -> "0.1.37"
+        """
+        if "dev" not in version:
+            return version
+        else:
+            # For 0.1.38.dev1, split into ["0", "1", "38", "dev1"]
+            major, minor, patch = version.split(".")[:3]
+
+            current_patch = int(patch)
+            latest_patch = current_patch - 1
+            return f"{major}.{minor}.{latest_patch}"
+
+    def _user_version_is_outdated(
+        self, user_version_str: str, server_version_str: str
+    ) -> bool:
+        """
+        Check if the user's EDSL version is outdated compared to the server's.
+        """
+        server_stable_version_str = self._get_latest_stable_version(server_version_str)
+        user_stable_version_str = self._get_latest_stable_version(user_version_str)
+
+        # Turn the version strings into tuples of ints for comparison
+        user_stable_version = tuple(map(int, user_stable_version_str.split(".")))
+        server_stable_version = tuple(map(int, server_stable_version_str.split(".")))
+
+        return user_stable_version < server_stable_version
+
     def _resolve_server_response(
         self, response: requests.Response, check_api_key: bool = True
     ) -> None:
         """
         Check the response from the server and raise errors as appropriate.
         """
+        # Get EDSL version from header
+        server_edsl_version = response.headers.get("X-EDSL-Version")
+
+        if server_edsl_version:
+            if self._user_version_is_outdated(
+                user_version_str=self._edsl_version,
+                server_version_str=server_edsl_version,
+            ):
+                print(
+                    "Please upgrade your EDSL version to access our latest features. To upgrade, open your terminal and run `pip upgrade edsl`"
+                )
+
         if response.status_code >= 400:
             message = response.json().get("detail")
             # print(response.text)
@@ -568,7 +625,7 @@ class Coop:
 
         >>> job = Jobs.example()
         >>> coop.remote_inference_create(job=job, description="My job")
-        {'uuid': '9f8484ee-b407-40e4-9652-4133a7236c9c', 'description': 'My job', 'status': 'queued', 'visibility': 'unlisted', 'version': '0.1.29.dev4'}
+        {'uuid': '9f8484ee-b407-40e4-9652-4133a7236c9c', 'description': 'My job', 'status': 'queued', 'iterations': None, 'visibility': 'unlisted', 'version': '0.1.38.dev1'}
         """
         response = self._send_server_request(
             uri="api/v0/remote-inference",
@@ -609,7 +666,7 @@ class Coop:
         :param results_uuid: The UUID of the results associated with the EDSL job.
 
         >>> coop.remote_inference_get("9f8484ee-b407-40e4-9652-4133a7236c9c")
-        {'jobs_uuid': '9f8484ee-b407-40e4-9652-4133a7236c9c', 'results_uuid': 'dd708234-31bf-4fe1-8747-6e232625e026', 'results_url': 'https://www.expectedparrot.com/content/dd708234-31bf-4fe1-8747-6e232625e026', 'status': 'completed', 'reason': None, 'price': 16, 'version': '0.1.29.dev4'}
+        {'job_uuid': '9f8484ee-b407-40e4-9652-4133a7236c9c', 'results_uuid': 'dd708234-31bf-4fe1-8747-6e232625e026', 'results_url': 'https://www.expectedparrot.com/content/dd708234-31bf-4fe1-8747-6e232625e026', 'latest_error_report_uuid': None, 'latest_error_report_url': None, 'status': 'completed', 'reason': None, 'credits_consumed': 0.35, 'version': '0.1.38.dev1'}
         """
         if job_uuid is None and results_uuid is None:
             raise ValueError("Either job_uuid or results_uuid must be provided.")
@@ -625,10 +682,28 @@ class Coop:
         )
         self._resolve_server_response(response)
         data = response.json()
+
+        results_uuid = data.get("results_uuid")
+        latest_error_report_uuid = data.get("latest_error_report_uuid")
+
+        if results_uuid is None:
+            results_url = None
+        else:
+            results_url = f"{self.url}/content/{results_uuid}"
+
+        if latest_error_report_uuid is None:
+            latest_error_report_url = None
+        else:
+            latest_error_report_url = (
+                f"{self.url}/home/remote-inference/error/{latest_error_report_uuid}"
+            )
+
         return {
             "job_uuid": data.get("job_uuid"),
-            "results_uuid": data.get("results_uuid"),
-            "results_url": f"{self.url}/content/{data.get('results_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"),
@@ -645,7 +720,7 @@ class Coop:
 
         >>> job = Jobs.example()
         >>> coop.remote_inference_cost(input=job)
-        16
+        {'credits': 0.77, 'usd': 0.0076950000000000005}
         """
         if isinstance(input, Jobs):
             job = input
@@ -685,7 +760,7 @@ class Coop:
     async def remote_async_execute_model_call(
         self, model_dict: dict, user_prompt: str, system_prompt: str
     ) -> dict:
-        url = self.url + "/inference/"
+        url = self.api_url + "/inference/"
         # print("Now using url: ", url)
         data = {
             "model_dict": model_dict,
@@ -706,7 +781,7 @@ class Coop:
         ] = "lime_survey",
         email=None,
     ):
-        url = f"{self.url}/api/v0/export_to_{platform}"
+        url = f"{self.api_url}/api/v0/export_to_{platform}"
         if email:
             data = {"json_string": json.dumps({"survey": survey, "email": email})}
         else:
@@ -725,11 +800,15 @@ class Coop:
 
         from edsl.config import CONFIG
 
-        if bool(CONFIG.get("EDSL_FETCH_TOKEN_PRICES")):
+        if CONFIG.get("EDSL_FETCH_TOKEN_PRICES") == "True":
             price_fetcher = PriceFetcher()
             return price_fetcher.fetch_prices()
-        else:
+        elif CONFIG.get("EDSL_FETCH_TOKEN_PRICES") == "False":
             return {}
+        else:
+            raise ValueError(
+                "Invalid EDSL_FETCH_TOKEN_PRICES value---should be 'True' or 'False'."
+            )
 
     def fetch_models(self) -> dict:
         """
@@ -810,15 +889,6 @@ class Coop:
         load_dotenv()
 
 
-if __name__ == "__main__":
-    sheet_data = fetch_sheet_data()
-    if sheet_data:
-        print(f"Successfully fetched {len(sheet_data)} rows of data.")
-        print("First row:", sheet_data[0])
-    else:
-        print("Failed to fetch sheet data.")
-
-
 def main():
     """
     A simple example for the coop client

edsl/data/Cache.py

@@ -11,7 +11,8 @@ 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 add_edsl_version, remove_edsl_version
+from edsl.utilities.decorators import remove_edsl_version
+from edsl.exceptions.cache import CacheError
 
 
 class Cache(Base):
@@ -26,6 +27,8 @@ class Cache(Base):
     :param method: The method of storage to use for the cache.
     """
 
+    __documentation__ = "https://docs.expectedparrot.com/en/latest/data.html"
+
     data = {}
 
     def __init__(
@@ -58,7 +61,7 @@ class Cache(Base):
 
         self.filename = filename
         if filename and data:
-            raise ValueError("Cannot provide both filename and data")
+            raise CacheError("Cannot provide both filename and data")
         if filename is None and data is None:
             data = {}
         if data is not None:
@@ -76,7 +79,7 @@ class Cache(Base):
                 if os.path.exists(filename):
                     self.add_from_sqlite(filename)
             else:
-                raise ValueError("Invalid file extension. Must be .jsonl or .db")
+                raise CacheError("Invalid file extension. Must be .jsonl or .db")
 
         self._perform_checks()
 
@@ -116,7 +119,7 @@ class Cache(Base):
         from edsl.data.CacheEntry import CacheEntry
 
         if any(not isinstance(value, CacheEntry) for value in self.data.values()):
-            raise Exception("Not all values are CacheEntry instances")
+            raise CacheError("Not all values are CacheEntry instances")
         if self.method is not None:
             warnings.warn("Argument `method` is deprecated", DeprecationWarning)
 
@@ -227,9 +230,9 @@ class Cache(Base):
         for key, value in new_data.items():
             if key in self.data:
                 if value != self.data[key]:
-                    raise Exception("Mismatch in values")
+                    raise CacheError("Mismatch in values")
             if not isinstance(value, CacheEntry):
-                raise Exception(f"Wrong type - the observed type is {type(value)}")
+                raise CacheError(f"Wrong type - the observed type is {type(value)}")
 
         self.new_entries.update(new_data)
         if write_now:
@@ -338,7 +341,7 @@ class Cache(Base):
         elif filename.endswith(".db"):
             self.write_sqlite_db(filename)
         else:
-            raise ValueError("Invalid file extension. Must be .jsonl or .db")
+            raise CacheError("Invalid file extension. Must be .jsonl or .db")
 
     def write_jsonl(self, filename: str) -> None:
         """
@@ -396,20 +399,45 @@ class Cache(Base):
     ####################
     def __hash__(self):
         """Return the hash of the Cache."""
-        return dict_hash(self._to_dict())
+        return dict_hash(self.to_dict(add_edsl_version=False))
+
+    def to_dict(self, add_edsl_version=True) -> dict:
+        d = {k: v.to_dict() for k, v in self.data.items()}
+        if add_edsl_version:
+            from edsl import __version__
 
-    def _to_dict(self) -> dict:
-        return {k: v.to_dict() for k, v in self.data.items()}
+            d["edsl_version"] = __version__
+            d["edsl_class_name"] = "Cache"
 
-    @add_edsl_version
-    def to_dict(self) -> dict:
-        """Return the Cache as a dictionary."""
-        return self._to_dict()
+        return d
+
+    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
+        # 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,
+        tablefmt: Optional[str] = None,
+        pretty_labels: Optional[dict] = None,
+    ) -> str:
+        return self.to_dataset().table(
+            *fields, tablefmt=tablefmt, pretty_labels=pretty_labels
+        )
+
+    def select(self, *fields):
+        return self.to_dataset().select(*fields)
+
+    def tree(self, node_list: Optional[list[str]] = None):
+        return self.to_scenario_list().tree(node_list)
 
-        return data_to_html(self.to_dict())
+    def to_dataset(self):
+        return self.to_scenario_list().to_dataset()
 
     @classmethod
     @remove_edsl_version
@@ -438,7 +466,7 @@ class Cache(Base):
         Combine two caches.
         """
         if not isinstance(other, Cache):
-            raise ValueError("Can only add two caches together")
+            raise CacheError("Can only add two caches together")
         self.data.update(other.data)
         return self
 

edsl/data/CacheEntry.py

@@ -96,9 +96,14 @@ class CacheEntry:
         """
         Returns an HTML representation of a CacheEntry.
         """
-        from edsl.utilities.utilities import data_to_html
-
-        return data_to_html(self.to_dict())
+        # 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>"
 
     def keys(self):
         return list(self.to_dict().keys())

edsl/data/RemoteCacheSync.py

@@ -76,22 +76,3 @@ class RemoteCacheSync:
         self._output(
             f"There are {len(self.cache.keys()):,} entries in the local cache."
         )
-
-
-# # Usage example
-# def run_job(self, n, progress_bar, cache, stop_on_exception, sidecar_model, print_exceptions, raise_validation_errors, use_remote_cache=True):
-#     with RemoteCacheSync(self.coop, cache, self._output, remote_cache=use_remote_cache):
-#         self._output("Running job...")
-#         results = self._run_local(
-#             n=n,
-#             progress_bar=progress_bar,
-#             cache=cache,
-#             stop_on_exception=stop_on_exception,
-#             sidecar_model=sidecar_model,
-#             print_exceptions=print_exceptions,
-#             raise_validation_errors=raise_validation_errors,
-#         )
-#         self._output("Job completed!")
-
-#     results.cache = cache.new_entries_cache()
-#     return results

edsl/enums.py

@@ -64,6 +64,7 @@ class InferenceServiceType(EnumWithChecks):
     OLLAMA = "ollama"
     MISTRAL = "mistral"
     TOGETHER = "together"
+    PERPLEXITY = "perplexity"
 
 
 service_to_api_keyname = {
@@ -78,6 +79,7 @@ service_to_api_keyname = {
     InferenceServiceType.BEDROCK.value: ["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY"],
     InferenceServiceType.MISTRAL.value: "MISTRAL_API_KEY",
     InferenceServiceType.TOGETHER.value: "TOGETHER_API_KEY",
+    InferenceServiceType.PERPLEXITY.value: "PERPLEXITY_API_KEY",
 }
 
 

edsl/exceptions/agents.py

@@ -1,6 +1,10 @@
 from edsl.exceptions.BaseException import BaseException
 
 
+class AgentListError(BaseException):
+    relevant_doc = "https://docs.expectedparrot.com/en/latest/agents.html#agent-lists"
+
+
 class AgentErrors(BaseException):
     relevant_doc = "https://docs.expectedparrot.com/en/latest/agents.html"
 

edsl/exceptions/cache.py

@@ -0,0 +1,5 @@
+from edsl.exceptions.BaseException import BaseException
+
+
+class CacheError(BaseException):
+    relevant_doc = "https://docs.expectedparrot.com/en/latest/agents.html#agent-lists"

edsl/inference_services/GoogleService.py

@@ -8,6 +8,7 @@ from google.api_core.exceptions import InvalidArgument
 from edsl.exceptions import MissingAPIKeyError
 from edsl.language_models.LanguageModel import LanguageModel
 from edsl.inference_services.InferenceServiceABC import InferenceServiceABC
+from edsl.coop import Coop
 
 safety_settings = [
     {
@@ -79,22 +80,8 @@ class GoogleService(InferenceServiceABC):
             api_token = None
             model = None
 
-            @classmethod
-            def initialize(cls):
-                if cls.api_token is None:
-                    cls.api_token = os.getenv("GOOGLE_API_KEY")
-                    if not cls.api_token:
-                        raise MissingAPIKeyError(
-                            "GOOGLE_API_KEY environment variable is not set"
-                        )
-                    genai.configure(api_key=cls.api_token)
-                    cls.generative_model = genai.GenerativeModel(
-                        cls._model_, safety_settings=safety_settings
-                    )
-
             def __init__(self, *args, **kwargs):
                 super().__init__(*args, **kwargs)
-                self.initialize()
 
             def get_generation_config(self) -> GenerationConfig:
                 return GenerationConfig(
@@ -116,6 +103,7 @@ class GoogleService(InferenceServiceABC):
                 if files_list is None:
                     files_list = []
 
+                genai.configure(api_key=self.api_token)
                 if (
                     system_prompt is not None
                     and system_prompt != ""
@@ -133,7 +121,11 @@ class GoogleService(InferenceServiceABC):
                         )
                         print("Will add system_prompt to user_prompt")
                         user_prompt = f"{system_prompt}\n{user_prompt}"
-
+                else:
+                    self.generative_model = genai.GenerativeModel(
+                        self._model_,
+                        safety_settings=safety_settings,
+                    )
                 combined_prompt = [user_prompt]
                 for file in files_list:
                     if "google" not in file.external_locations:

edsl/inference_services/PerplexityService.py

@@ -0,0 +1,163 @@
+import aiohttp
+import json
+import requests
+from typing import Any, List, Optional
+from edsl.inference_services.rate_limits_cache import rate_limits
+
+# from edsl.inference_services.InferenceServiceABC import InferenceServiceABC
+from edsl.language_models import LanguageModel
+
+from edsl.inference_services.OpenAIService import OpenAIService
+
+
+class PerplexityService(OpenAIService):
+    """Perplexity service class."""
+
+    _inference_service_ = "perplexity"
+    _env_key_name_ = "PERPLEXITY_API_KEY"
+    _base_url_ = "https://api.perplexity.ai"
+    _models_list_cache: List[str] = []
+    # default perplexity parameters
+    _parameters_ = {
+        "temperature": 0.5,
+        "max_tokens": 1000,
+        "top_p": 1,
+        "logprobs": False,
+        "top_logprobs": 3,
+    }
+
+    @classmethod
+    def available(cls) -> List[str]:
+        return [
+            "llama-3.1-sonar-huge-128k-online",
+            "llama-3.1-sonar-large-128k-online",
+            "llama-3.1-sonar-small-128k-online",
+        ]
+
+    @classmethod
+    def create_model(
+        cls, model_name="llama-3.1-sonar-large-128k-online", model_class_name=None
+    ) -> LanguageModel:
+        if model_class_name is None:
+            model_class_name = cls.to_class_name(model_name)
+
+        class LLM(LanguageModel):
+            """
+            Child class of LanguageModel for interacting with Perplexity models
+            """
+
+            key_sequence = cls.key_sequence
+            usage_sequence = cls.usage_sequence
+            input_token_name = cls.input_token_name
+            output_token_name = cls.output_token_name
+
+            _rpm = cls.get_rpm(cls)
+            _tpm = cls.get_tpm(cls)
+
+            _inference_service_ = cls._inference_service_
+            _model_ = model_name
+
+            _parameters_ = {
+                "temperature": 0.5,
+                "max_tokens": 1000,
+                "top_p": 1,
+                "frequency_penalty": 1,
+                "presence_penalty": 0,
+                # "logprobs": False, # Enable this returns 'Neither or both of logprobs and top_logprobs must be set.
+                # "top_logprobs": 3,
+            }
+
+            def sync_client(self):
+                return cls.sync_client()
+
+            def async_client(self):
+                return cls.async_client()
+
+            @classmethod
+            def available(cls) -> list[str]:
+                return cls.sync_client().models.list()
+
+            def get_headers(self) -> dict[str, Any]:
+                client = self.sync_client()
+                response = client.chat.completions.with_raw_response.create(
+                    messages=[
+                        {
+                            "role": "user",
+                            "content": "Say this is a test",
+                        }
+                    ],
+                    model=self.model,
+                )
+                return dict(response.headers)
+
+            def get_rate_limits(self) -> dict[str, Any]:
+                try:
+                    if "openai" in rate_limits:
+                        headers = rate_limits["openai"]
+
+                    else:
+                        headers = self.get_headers()
+
+                except Exception as e:
+                    return {
+                        "rpm": 10_000,
+                        "tpm": 2_000_000,
+                    }
+                else:
+                    return {
+                        "rpm": int(headers["x-ratelimit-limit-requests"]),
+                        "tpm": int(headers["x-ratelimit-limit-tokens"]),
+                    }
+
+            async def async_execute_model_call(
+                self,
+                user_prompt: str,
+                system_prompt: str = "",
+                files_list: Optional[List["Files"]] = None,
+                invigilator: Optional[
+                    "InvigilatorAI"
+                ] = None,  # TBD - can eventually be used for function-calling
+            ) -> 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}"
+                            },
+                        }
+                    )
+                else:
+                    content = user_prompt
+                client = self.async_client()
+
+                messages = [
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": content},
+                ]
+                if system_prompt == "" and self.omit_system_prompt_if_empty:
+                    messages = messages[1:]
+
+                params = {
+                    "model": self.model,
+                    "messages": messages,
+                    "temperature": self.temperature,
+                    "max_tokens": self.max_tokens,
+                    "top_p": self.top_p,
+                    "frequency_penalty": self.frequency_penalty,
+                    "presence_penalty": self.presence_penalty,
+                    # "logprobs": self.logprobs,
+                    # "top_logprobs": self.top_logprobs if self.logprobs else None,
+                }
+                try:
+                    response = await client.chat.completions.create(**params)
+                except Exception as e:
+                    print(e, flush=True)
+                return response.model_dump()
+
+        LLM.__name__ = "LanguageModel"
+
+        return LLM

edsl/inference_services/registry.py

@@ -12,6 +12,7 @@ from edsl.inference_services.AzureAI import AzureAIService
 from edsl.inference_services.OllamaService import OllamaService
 from edsl.inference_services.TestService import TestService
 from edsl.inference_services.TogetherAIService import TogetherAIService
+from edsl.inference_services.PerplexityService import PerplexityService
 
 try:
     from edsl.inference_services.MistralAIService import MistralAIService
@@ -31,6 +32,7 @@ services = [
     OllamaService,
     TestService,
     TogetherAIService,
+    PerplexityService,
 ]
 
 if mistral_available: