edsl 0.1.43__tar.gz → 0.1.44__tar.gz

{edsl-0.1.43 → edsl-0.1.44}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: edsl
-Version: 0.1.43
+Version: 0.1.44
 Summary: Create and analyze LLM-based surveys
 Home-page: https://www.expectedparrot.com/
 License: MIT

{edsl-0.1.43 → edsl-0.1.44}/edsl/Base.py

@@ -64,17 +64,26 @@ class PersistenceMixin:
     @classmethod
     def pull(
         cls,
-        uuid: Optional[Union[str, UUID]] = None,
-        url: Optional[str] = None,
-        expected_parrot_url: Optional[str] = None,
+        url_or_uuid: Optional[Union[str, UUID]] = None,
+        #expected_parrot_url: Optional[str] = None,
     ):
-        """Pull the object from coop."""
+        """Pull the object from coop.
+        
+        Args:
+            url_or_uuid: Either a UUID string or a URL pointing to the object
+            expected_parrot_url: Optional URL for the Parrot server
+        """
         from edsl.coop import Coop
         from edsl.coop.utils import ObjectRegistry
 
         object_type = ObjectRegistry.get_object_type_by_edsl_class(cls)
-        coop = Coop(url=expected_parrot_url)
-        return coop.get(uuid, url, object_type)
+        coop = Coop()
+
+        # Determine if input is URL or UUID
+        if url_or_uuid and ("http://" in str(url_or_uuid) or "https://" in str(url_or_uuid)):
+            return coop.get(url=url_or_uuid, expected_object_type=object_type)
+        else:
+            return coop.get(uuid=url_or_uuid, expected_object_type=object_type)
 
     @classmethod
     def delete(cls, uuid: Optional[Union[str, UUID]] = None, url: Optional[str] = None):

edsl-0.1.44/edsl/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.1.44"

{edsl-0.1.43 → edsl-0.1.44}/edsl/coop/coop.py

@@ -4,10 +4,8 @@ import requests
 
 from typing import Any, Optional, Union, Literal, TypedDict
 from uuid import UUID
-from collections import UserDict, defaultdict
 
 import edsl
-from pathlib import Path
 
 from edsl.config import CONFIG
 from edsl.data.CacheEntry import CacheEntry
@@ -340,7 +338,7 @@ class Coop(CoopFunctionsMixin):
 
         try:
             response = self._send_server_request(
-                uri="api/v0/edsl-settings", method="GET", timeout=5
+                uri="api/v0/edsl-settings", method="GET", timeout=20
             )
             self._resolve_server_response(response, check_api_key=False)
             return response.json()
@@ -866,6 +864,40 @@ class Coop(CoopFunctionsMixin):
             "usd": response_json.get("cost_in_usd"),
         }
 
+    ################
+    # PROJECTS
+    ################
+    def create_project(
+        self,
+        survey: Survey,
+        project_name: str,
+        survey_description: Optional[str] = None,
+        survey_alias: Optional[str] = None,
+        survey_visibility: Optional[VisibilityType] = "unlisted",
+    ):
+        """
+        Create a survey object on Coop, then create a project from the survey.
+        """
+        survey_details = self.create(
+            object=survey,
+            description=survey_description,
+            alias=survey_alias,
+            visibility=survey_visibility,
+        )
+        survey_uuid = survey_details.get("uuid")
+        response = self._send_server_request(
+            uri=f"api/v0/projects/create-from-survey",
+            method="POST",
+            payload={"project_name": project_name, "survey_uuid": str(survey_uuid)},
+        )
+        self._resolve_server_response(response)
+        response_json = response.json()
+        return {
+            "name": response_json.get("project_name"),
+            "uuid": response_json.get("uuid"),
+            "url": f"{self.url}/home/projects/{response_json.get('uuid')}",
+        }
+
     ################
     # DUNDER METHODS
     ################

{edsl-0.1.43 → edsl-0.1.44}/edsl/enums.py

@@ -67,6 +67,7 @@ class InferenceServiceType(EnumWithChecks):
     TOGETHER = "together"
     PERPLEXITY = "perplexity"
     DEEPSEEK = "deepseek"
+    GROK = "grok"
 
 
 # unavoidable violation of the DRY principle but it is necessary
@@ -86,6 +87,7 @@ InferenceServiceLiteral = Literal[
     "together",
     "perplexity",
     "deepseek",
+    "grok",
 ]
 
 available_models_urls = {
@@ -108,7 +110,8 @@ service_to_api_keyname = {
     InferenceServiceType.MISTRAL.value: "MISTRAL_API_KEY",
     InferenceServiceType.TOGETHER.value: "TOGETHER_API_KEY",
     InferenceServiceType.PERPLEXITY.value: "PERPLEXITY_API_KEY",
-    InferenceServiceType.DEEPSEEK.value: "DEEPSEEK_API_KEY"
+    InferenceServiceType.DEEPSEEK.value: "DEEPSEEK_API_KEY",
+    InferenceServiceType.GROK.value: "XAI_API_KEY",
 }
 
 

{edsl-0.1.43 → edsl-0.1.44}/edsl/inference_services/AnthropicService.py

@@ -17,6 +17,8 @@ class AnthropicService(InferenceServiceABC):
     output_token_name = "output_tokens"
     model_exclude_list = []
 
+    available_models_url = 'https://docs.anthropic.com/en/docs/about-claude/models'
+
     @classmethod
     def get_model_list(cls, api_key: str = None):
 

{edsl-0.1.43 → edsl-0.1.44}/edsl/inference_services/GoogleService.py

@@ -39,6 +39,8 @@ class GoogleService(InferenceServiceABC):
 
     model_exclude_list = []
 
+    available_models_url = 'https://cloud.google.com/vertex-ai/generative-ai/docs/learn/models'
+
     @classmethod
     def get_model_list(cls):
         model_list = []

edsl-0.1.44/edsl/inference_services/GrokService.py

@@ -0,0 +1,11 @@
+from typing import Any, List
+from edsl.inference_services.OpenAIService import OpenAIService
+
+
+class GrokService(OpenAIService):
+    """Openai service class."""
+
+    _inference_service_ = "grok"
+    _env_key_name_ = "XAI_API_KEY"
+    _base_url_ = "https://api.x.ai/v1"
+    _models_list_cache: List[str] = []

{edsl-0.1.43 → edsl-0.1.44}/edsl/inference_services/InferenceServiceABC.py

@@ -23,6 +23,7 @@ class InferenceServiceABC(ABC):
             "usage_sequence",
             "input_token_name",
             "output_token_name",
+            #"available_models_url",
         ]
         for attr in must_have_attributes:
             if not hasattr(cls, attr):

{edsl-0.1.43 → edsl-0.1.44}/edsl/inference_services/OpenAIService.py

@@ -84,6 +84,7 @@ class OpenAIService(InferenceServiceABC):
 
     @classmethod
     def get_model_list(cls, api_key=None):
+        # breakpoint()
         if api_key is None:
             api_key = os.getenv(cls._env_key_name_)
         raw_list = cls.sync_client(api_key).models.list()

{edsl-0.1.43 → edsl-0.1.44}/edsl/inference_services/TestService.py

@@ -28,6 +28,7 @@ class TestService(InferenceServiceABC):
     model_exclude_list = []
     input_token_name = "prompt_tokens"
     output_token_name = "completion_tokens"
+    available_models_url = None
 
     @classmethod
     def available(cls) -> list[str]:

{edsl-0.1.43 → edsl-0.1.44}/edsl/inference_services/registry.py

@@ -14,6 +14,7 @@ from edsl.inference_services.TestService import TestService
 from edsl.inference_services.TogetherAIService import TogetherAIService
 from edsl.inference_services.PerplexityService import PerplexityService
 from edsl.inference_services.DeepSeekService import DeepSeekService
+from edsl.inference_services.GrokService import GrokService
 
 try:
     from edsl.inference_services.MistralAIService import MistralAIService
@@ -35,6 +36,7 @@ services = [
     TogetherAIService,
     PerplexityService,
     DeepSeekService,
+    GrokService,
 ]
 
 if mistral_available:

{edsl-0.1.43 → edsl-0.1.44}/edsl/jobs/JobsChecks.py

@@ -31,7 +31,7 @@ class JobsChecks:
         from edsl.language_models.model import Model
         from edsl.enums import service_to_api_keyname
 
-        for model in self.jobs.models + [Model()]:
+        for model in self.jobs.models: # + [Model()]:
             if not model.has_valid_api_key():
                 key_name = service_to_api_keyname.get(
                     model._inference_service_, "NOT FOUND"
@@ -134,22 +134,22 @@ class JobsChecks:
 
         edsl_auth_token = secrets.token_urlsafe(16)
 
-        print("You're missing some of the API keys needed to run this job:")
+        print("API keys are required to run surveys with language models. The following keys are needed to run this survey: ")
         for api_key in missing_api_keys:
             print(f"     🔑 {api_key}")
         print(
-            "\nYou can either add the missing keys to your .env file, or use remote inference."
+            "\nYou can provide your own keys or use an Expected Parrot key to access all available models."
         )
-        print("Remote inference allows you to run jobs on our server.")
+        print("Please see the documentation page to learn about options for managing keys: https://docs.expectedparrot.com/en/latest/api_keys.html")
 
         coop = Coop()
         coop._display_login_url(
             edsl_auth_token=edsl_auth_token,
-            link_description="\n🚀 To use remote inference, sign up at the following link:",
+            link_description="\n➡️ Click the link below to create an account and get an Expected Parrot key:\n",
         )
 
         print(
-            "\nOnce you log in, we will automatically retrieve your Expected Parrot API key and continue your job remotely."
+            "\nOnce you log in, your key will be stored on your computer and your survey will start running at the Expected Parrot server."
         )
 
         api_key = coop._poll_for_api_key(edsl_auth_token)
@@ -159,7 +159,7 @@ class JobsChecks:
             return
 
         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("\n✨ Your key has been stored at the following path: ")
         print(f"    {path_to_env}")
 
         # Retrieve API key so we can continue running the job

{edsl-0.1.43 → edsl-0.1.44}/edsl/jobs/JobsPrompts.py

@@ -200,10 +200,10 @@ class JobsPrompts:
             import warnings
 
             warnings.warn(
-                "Price data could not be retrieved. Using default estimates for input and output token prices. Input: $0.15 / 1M tokens; Output: $0.60 / 1M tokens"
+                "Price data could not be retrieved. Using default estimates for input and output token prices. Input: $1.00 / 1M tokens; Output: $1.00 / 1M tokens"
             )
-            input_price_per_token = 0.00000015  # $0.15 / 1M tokens
-            output_price_per_token = 0.00000060  # $0.60 / 1M tokens
+            input_price_per_token = 0.000001  # $1.00 / 1M tokens
+            output_price_per_token = 0.000001  # $1.00 / 1M tokens
 
         # Compute the number of characters (double if the question involves piping)
         user_prompt_chars = len(str(user_prompt)) * get_piping_multiplier(

{edsl-0.1.43 → edsl-0.1.44}/edsl/language_models/LanguageModel.py

@@ -518,7 +518,11 @@ class LanguageModel(
         """
         from edsl.language_models.model import get_model_class
 
-        model_class = get_model_class(data["model"])
+        # breakpoint()
+
+        model_class = get_model_class(
+            data["model"], service_name=data.get("inference_service", None)
+        )
         return model_class(**data)
 
     def __repr__(self) -> str:
@@ -574,7 +578,6 @@ class LanguageModel(
             return Model(skip_api_key_check=True)
 
     def from_cache(self, cache: "Cache") -> LanguageModel:
-
         from copy import deepcopy
         from types import MethodType
         from edsl import Cache

{edsl-0.1.43 → edsl-0.1.44}/edsl/language_models/model.py

@@ -1,6 +1,6 @@
 import textwrap
 from random import random
-from typing import Optional, TYPE_CHECKING, List
+from typing import Optional, TYPE_CHECKING, List, Callable
 
 from edsl.utilities.PrettyList import PrettyList
 from edsl.config import CONFIG
@@ -11,17 +11,21 @@ from edsl.inference_services.InferenceServicesCollection import (
 from edsl.inference_services.data_structures import AvailableModels
 from edsl.inference_services.InferenceServiceABC import InferenceServiceABC
 from edsl.enums import InferenceServiceLiteral
+from edsl.exceptions.inference_services import InferenceServiceError
 
 if TYPE_CHECKING:
     from edsl.results.Dataset import Dataset
 
 
-def get_model_class(model_name, registry: Optional[InferenceServicesCollection] = None):
+def get_model_class(model_name, registry: Optional[InferenceServicesCollection] = None, service_name: Optional[InferenceServiceLiteral] = None):
     from edsl.inference_services.registry import default
 
     registry = registry or default
-    factory = registry.create_model_factory(model_name)
-    return factory
+    try:
+        factory = registry.create_model_factory(model_name, service_name=service_name)
+        return factory
+    except (InferenceServiceError, Exception) as e:
+        return Model._handle_model_error(model_name, e)
 
 
 class Meta(type):
@@ -58,6 +62,33 @@ class Model(metaclass=Meta):
         """Set a new registry"""
         cls._registry = registry
 
+    @classmethod
+    def _handle_model_error(cls, model_name: str, error: Exception):
+        """Handle errors from model creation and execution with notebook-aware behavior."""
+        if isinstance(error, InferenceServiceError):
+            services = [s._inference_service_ for s in cls.get_registry().services]
+            message = (
+                f"Model '{model_name}' not found in any services.\n"
+                "It is likely that our registry is just out of date.\n"
+                "Simply adding the service name to your model call should fix this.\n"
+                f"Available services are: {services}\n"
+                f"To specify a model with a service, use:\n"
+                f'Model("{model_name}", service_name="<service_name>")'
+            )
+        else:
+            message = f"An error occurred: {str(error)}"
+
+        # Check if we're in a notebook environment
+        try:
+            get_ipython()
+            print(message)
+            return None
+        except NameError:
+            # Not in a notebook, raise the exception
+            if isinstance(error, InferenceServiceError):
+                raise InferenceServiceError(message)
+            raise error
+
     def __new__(
         cls,
         model_name: Optional[str] = None,
@@ -69,9 +100,7 @@ class Model(metaclass=Meta):
         "Instantiate a new language model."
         # Map index to the respective subclass
         if model_name is None:
-            model_name = (
-                cls.default_model
-            )  # when model_name is None, use the default model, set in the config file
+            model_name = cls.default_model
 
         if registry is not None:
             cls.set_registry(registry)
@@ -79,10 +108,13 @@ class Model(metaclass=Meta):
         if isinstance(model_name, int):  # can refer to a model by index
             model_name = cls.available(name_only=True)[model_name]
 
-        factory = cls.get_registry().create_model_factory(
-            model_name, service_name=service_name
-        )
-        return factory(*args, **kwargs)
+        try:
+            factory = cls.get_registry().create_model_factory(
+                model_name, service_name=service_name
+            )
+            return factory(*args, **kwargs)
+        except (InferenceServiceError, Exception) as e:
+            return cls._handle_model_error(model_name, e)
 
     @classmethod
     def add_model(cls, service_name, model_name) -> None:

{edsl-0.1.43 → edsl-0.1.44}/edsl/results/Results.py

@@ -1326,7 +1326,7 @@ class Results(UserList, Mixins, Base):
         except Exception as e:
             raise ResultsError(f"Failed to fetch remote results: {str(e)}")
 
-    def fetch(self, polling_interval: float = 1.0) -> Results:
+    def fetch(self, polling_interval: [float, int] = 1.0) -> Results:
         """
         Polls the server for job completion and updates this Results instance with the completed data.
         
@@ -1346,6 +1346,7 @@ class Results(UserList, Mixins, Base):
             remote_job_data = JobsRemoteInferenceHandler.check_status(self.job_info.job_uuid)
             
             while remote_job_data.get("status") not in ["completed", "failed"]:
+                print("Waiting for remote job to complete...")
                 import time
                 time.sleep(polling_interval)
                 remote_job_data = JobsRemoteInferenceHandler.check_status(self.job_info.job_uuid)

{edsl-0.1.43 → edsl-0.1.44}/edsl/scenarios/FileStore.py

@@ -9,7 +9,8 @@ from edsl.scenarios.Scenario import Scenario
 from edsl.utilities.remove_edsl_version import remove_edsl_version
 
 from edsl.scenarios.file_methods import FileMethods
-
+from typing import Union
+from uuid import UUID
 
 class FileStore(Scenario):
     __documentation__ = "https://docs.expectedparrot.com/en/latest/filestore.html"
@@ -262,7 +263,12 @@ class FileStore(Scenario):
         # raise TypeError("No text method found for this file type.")
 
     def push(
-        self, description: Optional[str] = None, visibility: str = "unlisted"
+        self, 
+        description: Optional[str] = None, 
+        alias: Optional[str] = None,
+        visibility: Optional[str] = "unlisted",
+        expected_parrot_url: Optional[str] = None,
+
     ) -> dict:
         """
         Push the object to Coop.
@@ -272,17 +278,22 @@ class FileStore(Scenario):
         scenario_version = Scenario.from_dict(self.to_dict())
         if description is None:
             description = "File: " + self.path
-        info = scenario_version.push(description=description, visibility=visibility)
+        info = scenario_version.push(description=description, visibility=visibility, expected_parrot_url=expected_parrot_url, alias=alias)
         return info
 
     @classmethod
-    def pull(cls, uuid: str, expected_parrot_url: Optional[str] = None) -> "FileStore":
+    def pull(cls, url_or_uuid: Union[str, UUID]) -> "FileStore":
         """
-        :param uuid: The UUID of the object to pull.
-        :param expected_parrot_url: The URL of the Parrot server to use.
-        :return: The object pulled from the Parrot server.
+        Pull a FileStore object from Coop.
+        
+        Args:
+            url_or_uuid: Either a UUID string or a URL pointing to the object
+            expected_parrot_url: Optional URL for the Parrot server
+        
+        Returns:
+            FileStore: The pulled FileStore object
         """
-        scenario_version = Scenario.pull(uuid, expected_parrot_url=expected_parrot_url)
+        scenario_version = Scenario.pull(url_or_uuid)
         return cls.from_dict(scenario_version.to_dict())
 
     @classmethod

{edsl-0.1.43 → edsl-0.1.44}/edsl/surveys/Survey.py

@@ -942,12 +942,11 @@ class Survey(SurveyExportMixin, Base):
         # TODO: temp fix by creating a cache
         if cache is None:
             from edsl.data import Cache
+
             c = Cache()
         else:
             c = cache
 
-        
-
         jobs: "Jobs" = self.get_job(model=model, agent=agent, **kwargs).using(c)
         return await jobs.run_async(
             disable_remote_inference=disable_remote_inference,
@@ -1244,6 +1243,28 @@ class Survey(SurveyExportMixin, Base):
 
         return self.by(s).by(agent).by(model)
 
+    ###################
+    # COOP METHODS
+    ###################
+    def humanize(
+        self,
+        project_name: str,
+        survey_description: Optional[str] = None,
+        survey_alias: Optional[str] = None,
+        survey_visibility: Optional["VisibilityType"] = "unlisted",
+    ):
+        """
+        Create a survey object on Coop.
+        Then, create a project on Coop so you can share the survey with humans.
+        """
+        from edsl.coop import Coop
+
+        c = Coop()
+        project_details = c.create_project(
+            self, project_name, survey_description, survey_alias, survey_visibility
+        )
+        return project_details
+
 
 def main():
     """Run the example survey."""
@@ -1255,16 +1276,16 @@ def main():
         q0 = QuestionMultipleChoice(
             question_name="q0",
             question_text="What is the capital of France?",
-            question_options=["London", "Paris", "Rome", "Boston", "I don't know"]
+            question_options=["London", "Paris", "Rome", "Boston", "I don't know"],
         )
         q1 = QuestionList(
             question_name="q1",
             question_text="Name some cities in France.",
-            max_list_items = 5
+            max_list_items=5,
         )
         q2 = QuestionNumerical(
             question_name="q2",
-            question_text="What is the population of {{ q0.answer }}?"
+            question_text="What is the population of {{ q0.answer }}?",
         )
         s = Survey(questions=[q0, q1, q2])
         s = s.add_rule(q0, "q0 == 'Paris'", q2)
@@ -1281,4 +1302,4 @@ if __name__ == "__main__":
     import doctest
 
     # doctest.testmod(optionflags=doctest.ELLIPSIS | doctest.SKIP)
-    doctest.testmod(optionflags=doctest.ELLIPSIS)
+    doctest.testmod(optionflags=doctest.ELLIPSIS)

{edsl-0.1.43 → edsl-0.1.44}/pyproject.toml

@@ -13,7 +13,7 @@ keywords = [ "LLM", "social science", "surveys", "user research",]
 license = "MIT"
 name = "edsl"
 readme = "README.md"
-version = "0.1.43"
+version = "0.1.44"
 
 [tool.poetry.dependencies]
 python = ">=3.9.1,<3.13"

edsl-0.1.43/edsl/__version__.py

@@ -1 +0,0 @@
-__version__ = "0.1.43"