edsl 0.1.43__py3-none-any.whl → 0.1.45__py3-none-any.whl

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
@@ -192,7 +190,7 @@ class Coop(CoopFunctionsMixin):
                 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 install --upgrade edsl`"
+                    "Please upgrade your EDSL version to access our latest features. Open your terminal and run `pip install --upgrade edsl`"
                 )
 
         if response.status_code >= 400:
@@ -214,7 +212,7 @@ class Coop(CoopFunctionsMixin):
                 print("Your Expected Parrot API key is invalid.")
                 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.",
+                    link_description="\n🔗 Use the link below to log in to your account and automatically update your API key.",
                 )
                 api_key = self._poll_for_api_key(edsl_auth_token)
 
@@ -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,41 @@ class Coop(CoopFunctionsMixin):
             "usd": response_json.get("cost_in_usd"),
         }
 
+    ################
+    # PROJECTS
+    ################
+    def create_project(
+        self,
+        survey: Survey,
+        project_name: str = "Project",
+        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"),
+            "admin_url": f"{self.url}/home/projects/{response_json.get('uuid')}",
+            "respondent_url": f"{self.url}/respond/{response_json.get('uuid')}",
+        }
+
     ################
     # DUNDER METHODS
     ################
@@ -995,15 +1028,28 @@ class Coop(CoopFunctionsMixin):
         - We need this function because URL detection with print() does not work alongside animations in VSCode.
         """
         from rich import print as rich_print
+        from rich.console import Console
+
+        console = Console()
 
         url = f"{CONFIG.EXPECTED_PARROT_URL}/login?edsl_auth_token={edsl_auth_token}"
 
-        if link_description:
-            rich_print(
-                f"{link_description}\n    [#38bdf8][link={url}]{url}[/link][/#38bdf8]"
-            )
+        if console.is_terminal:
+            # Running in a standard terminal, show the full URL
+            if link_description:
+                rich_print("{link_description}\n[#38bdf8][link={url}]{url}[/link][/#38bdf8]")
+            else:
+                rich_print(f"[#38bdf8][link={url}]{url}[/link][/#38bdf8]")
         else:
-            rich_print(f"    [#38bdf8][link={url}]{url}[/link][/#38bdf8]")
+            # Running in an interactive environment (e.g., Jupyter Notebook), hide the URL
+            if link_description:
+                rich_print(f"{link_description}\n[#38bdf8][link={url}][underline]Log in and automatically store key[/underline][/link][/#38bdf8]")
+            else:
+                rich_print(f"[#38bdf8][link={url}][underline]Log in and automatically store key[/underline][/link][/#38bdf8]")
+
+
+
+
 
     def _get_api_key(self, edsl_auth_token: str):
         """

edsl/enums.py

@@ -67,6 +67,7 @@ class InferenceServiceType(EnumWithChecks):
     TOGETHER = "together"
     PERPLEXITY = "perplexity"
     DEEPSEEK = "deepseek"
+    XAI = "xai"
 
 
 # unavoidable violation of the DRY principle but it is necessary
@@ -86,6 +87,7 @@ InferenceServiceLiteral = Literal[
     "together",
     "perplexity",
     "deepseek",
+    "xai",
 ]
 
 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.XAI.value: "XAI_API_KEY",
 }
 
 

edsl/inference_services/AnthropicService.py

@@ -17,9 +17,10 @@ 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):
-
         import requests
 
         if api_key is None:
@@ -92,13 +93,16 @@ class AnthropicService(InferenceServiceABC):
                 # breakpoint()
                 client = AsyncAnthropic(api_key=self.api_token)
 
-                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,
-                )
+                try:
+                    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,
+                    )
+                except Exception as e:
+                    return {"message": str(e)}
                 return response.model_dump()
 
         LLM.__name__ = model_class_name

edsl/inference_services/AvailableModelFetcher.py

@@ -69,6 +69,8 @@ class AvailableModelFetcher:
 
         Returns a list of [model, service_name, index] entries.
         """
+        if service == "azure":
+            force_refresh = True  # Azure models are listed inside the .env AZURE_ENDPOINT_URL_AND_KEY variable
 
         if service:  # they passed a specific service
             matching_models, _ = self.get_available_models_by_service(

edsl/inference_services/AwsBedrock.py

@@ -110,8 +110,7 @@ class AwsBedrockService(InferenceServiceABC):
                     )
                     return response
                 except (ClientError, Exception) as e:
-                    print(e)
-                    return {"error": str(e)}
+                    return {"message": str(e)}
 
         LLM.__name__ = model_class_name
 

edsl/inference_services/AzureAI.py

@@ -179,15 +179,18 @@ class AzureAIService(InferenceServiceABC):
                         api_version=api_version,
                         api_key=api_key,
                     )
-                    response = await client.chat.completions.create(
-                        model=model_name,
-                        messages=[
-                            {
-                                "role": "user",
-                                "content": user_prompt,  # Your question can go here
-                            },
-                        ],
-                    )
+                    try:
+                        response = await client.chat.completions.create(
+                            model=model_name,
+                            messages=[
+                                {
+                                    "role": "user",
+                                    "content": user_prompt,  # Your question can go here
+                                },
+                            ],
+                        )
+                    except Exception as e:
+                        return {"message": str(e)}
                     return response.model_dump()
 
             # @staticmethod

edsl/inference_services/GoogleService.py

@@ -39,6 +39,10 @@ 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 = []
@@ -130,9 +134,12 @@ class GoogleService(InferenceServiceABC):
                     )
                     combined_prompt.append(gen_ai_file)
 
-                response = await self.generative_model.generate_content_async(
-                    combined_prompt, generation_config=generation_config
-                )
+                try:
+                    response = await self.generative_model.generate_content_async(
+                        combined_prompt, generation_config=generation_config
+                    )
+                except Exception as e:
+                    return {"message": str(e)}
                 return response.to_dict()
 
         LLM.__name__ = model_name

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/inference_services/InferenceServicesCollection.py

@@ -104,8 +104,9 @@ class InferenceServicesCollection:
     def available(
         self,
         service: Optional[str] = None,
+        force_refresh: bool = False,
     ) -> List[Tuple[str, str, int]]:
-        return self.availability_fetcher.available(service)
+        return self.availability_fetcher.available(service, force_refresh=force_refresh)
 
     def reset_cache(self) -> None:
         self.availability_fetcher.reset_cache()
@@ -120,7 +121,6 @@ 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

edsl/inference_services/MistralAIService.py

@@ -111,8 +111,7 @@ class MistralAIService(InferenceServiceABC):
                         ],
                     )
                 except Exception as e:
-                    raise LanguageModelBadResponseError(f"Error with Mistral API: {e}")
-
+                    return {"message": str(e)}
                 return res.model_dump()
 
         LLM.__name__ = model_class_name

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()
@@ -206,8 +207,10 @@ class OpenAIService(InferenceServiceABC):
                     {"role": "user", "content": content},
                 ]
                 if (
-                    system_prompt == "" and self.omit_system_prompt_if_empty
-                ) or "o1" in self.model:
+                    (system_prompt == "" and self.omit_system_prompt_if_empty)
+                    or "o1" in self.model
+                    or "o3" in self.model
+                ):
                     messages = messages[1:]
 
                 params = {
@@ -221,14 +224,17 @@ class OpenAIService(InferenceServiceABC):
                     "logprobs": self.logprobs,
                     "top_logprobs": self.top_logprobs if self.logprobs else None,
                 }
-                if "o1" in self.model:
+                if "o1" in self.model or "o3" in self.model:
                     params.pop("max_tokens")
                     params["max_completion_tokens"] = self.max_tokens
                     params["temperature"] = 1
                 try:
                     response = await client.chat.completions.create(**params)
                 except Exception as e:
-                    print(e)
+                    #breakpoint()
+                    #print(e)
+                    #raise e
+                    return {'message': str(e)}
                 return response.model_dump()
 
         LLM.__name__ = "LanguageModel"

edsl/inference_services/PerplexityService.py

@@ -152,7 +152,8 @@ class PerplexityService(OpenAIService):
                 try:
                     response = await client.chat.completions.create(**params)
                 except Exception as e:
-                    print(e, flush=True)
+                    return {"message": str(e)}
+
                 return response.model_dump()
 
         LLM.__name__ = "LanguageModel"

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/inference_services/XAIService.py

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

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.XAIService import XAIService
 
 try:
     from edsl.inference_services.MistralAIService import MistralAIService
@@ -35,6 +36,7 @@ services = [
     TogetherAIService,
     PerplexityService,
     DeepSeekService,
+    XAIService,
 ]
 
 if mistral_available:

edsl/jobs/Jobs.py

@@ -364,6 +364,15 @@ class Jobs(Base):
             self, cache=self.run_config.environment.cache
         ).create_interviews()
 
+    def show_flow(self, filename: Optional[str] = None) -> None:
+        """Show the flow of the survey."""
+        from edsl.surveys.SurveyFlowVisualization import SurveyFlowVisualization
+        if self.scenarios: 
+            scenario = self.scenarios[0]
+        else:
+            scenario = None
+        SurveyFlowVisualization(self.survey, scenario=scenario, agent=None).show_flow(filename=filename)
+
     def interviews(self) -> list[Interview]:
         """
         Return a list of :class:`edsl.jobs.interviews.Interview` objects.

edsl/jobs/JobsChecks.py

@@ -24,14 +24,14 @@ class JobsChecks:
 
     def get_missing_api_keys(self) -> set:
         """
-        Returns a list of the api keys that a user needs to run this job, but does not currently have in their .env file.
+        Returns a list of the API keys that a user needs to run this job, but does not currently have in their .env file.
         """
         missing_api_keys = set()
 
         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,20 @@ class JobsChecks:
 
         edsl_auth_token = secrets.token_urlsafe(16)
 
-        print("You're missing some of the API keys needed to run this job:")
+        print("\nThe following keys are needed to run this survey: \n")
         for api_key in missing_api_keys:
-            print(f"     🔑 {api_key}")
+            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 for language models or use an Expected Parrot key to access all available models.
+            \nClick the link below to create an account and run your survey with your Expected Parrot key:
+            """
         )
-        print("Remote inference allows you to run jobs on our server.")
-
+    
         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:",
-        )
-
-        print(
-            "\nOnce you log in, we will automatically retrieve your Expected Parrot API key and continue your job remotely."
+            # link_description="",
         )
 
         api_key = coop._poll_for_api_key(edsl_auth_token)
@@ -159,8 +157,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(f"    {path_to_env}")
+        print(f"\n✨ Your Expected Parrot key has been stored at the following path: {path_to_env}\n")
 
         # Retrieve API key so we can continue running the job
         load_dotenv()

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/jobs/async_interview_runner.py

@@ -7,6 +7,8 @@ from edsl.data_transfer_models import EDSLResultObjectInput
 
 from edsl.results.Result import Result
 from edsl.jobs.interviews.Interview import Interview
+from edsl.config import Config
+config = Config()
 
 if TYPE_CHECKING:
     from edsl.jobs.Jobs import Jobs
@@ -23,7 +25,7 @@ from edsl.jobs.data_structures import RunConfig
 
 
 class AsyncInterviewRunner:
-    MAX_CONCURRENT = 5
+    MAX_CONCURRENT = int(config.EDSL_MAX_CONCURRENT_TASKS)
 
     def __init__(self, jobs: "Jobs", run_config: RunConfig):
         self.jobs = jobs

edsl/jobs/check_survey_scenario_compatibility.py

@@ -72,11 +72,11 @@ class CheckSurveyScenarioCompatibility:
                 if warn:
                     warnings.warn(message)
 
-        if self.scenarios.has_jinja_braces:
-            warnings.warn(
-                "The scenarios have Jinja braces ({{ and }}). Converting to '<<' and '>>'. If you want a different conversion, use the convert_jinja_braces method first to modify the scenario."
-            )
-            self.scenarios = self.scenarios._convert_jinja_braces()
+        # if self.scenarios.has_jinja_braces:
+        #     warnings.warn(
+        #         "The scenarios have Jinja braces ({{ and }}). Converting to '<<' and '>>'. If you want a different conversion, use the convert_jinja_braces method first to modify the scenario."
+        #     )
+        #     self.scenarios = self.scenarios._convert_jinja_braces()
 
 
 if __name__ == "__main__":

edsl/jobs/interviews/InterviewExceptionEntry.py

@@ -166,6 +166,9 @@ class InterviewExceptionEntry:
         >>> entry = InterviewExceptionEntry.example()
         >>> _ = entry.to_dict()
         """
+        import json
+        from edsl.exceptions.questions import QuestionAnswerValidationError
+
         invigilator = (
             self.invigilator.to_dict() if self.invigilator is not None else None
         )
@@ -174,7 +177,16 @@ class InterviewExceptionEntry:
             "time": self.time,
             "traceback": self.traceback,
             "invigilator": invigilator,
+            "additional_data": {},
         }
+
+        if isinstance(self.exception, QuestionAnswerValidationError):
+            d["additional_data"]["edsl_response"] = json.dumps(self.exception.data)
+            d["additional_data"]["validating_model"] = json.dumps(
+                self.exception.model.model_json_schema()
+            )
+            d["additional_data"]["error_message"] = str(self.exception.message)
+
         return d
 
     @classmethod

edsl/jobs/tasks/TaskHistory.py

@@ -419,7 +419,7 @@ class TaskHistory(RepresentationMixin):
         filename: Optional[str] = None,
         return_link=False,
         css=None,
-        cta="\nClick to open the report in a new tab\n",
+        cta="<br><span style='font-size: 18px; font-weight: medium-bold; text-decoration: underline;'>Click to open the report in a new tab</span><br><br>",
         open_in_browser=False,
     ):
         """Return an HTML report."""

edsl/language_models/LanguageModel.py

@@ -394,7 +394,6 @@ class LanguageModel(
             from edsl.config import CONFIG
 
             TIMEOUT = float(CONFIG.get("EDSL_API_TIMEOUT"))
-
             response = await asyncio.wait_for(f(**params), timeout=TIMEOUT)
             new_cache_key = cache.store(
                 **cache_call_params, response=response
@@ -518,7 +517,9 @@ class LanguageModel(
         """
         from edsl.language_models.model import get_model_class
 
-        model_class = get_model_class(data["model"])
+        model_class = get_model_class(
+            data["model"], service_name=data.get("inference_service", None)
+        )
         return model_class(**data)
 
     def __repr__(self) -> str:
@@ -574,7 +575,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/language_models/PriceManager.py

@@ -30,19 +30,22 @@ class PriceManager:
         except Exception as e:
             print(f"Error fetching prices: {str(e)}")
 
-    def get_price(self, inference_service: str, model: str) -> Optional[Dict]:
+    def get_price(self, inference_service: str, model: str) -> Dict:
         """
         Get the price information for a specific service and model combination.
+        If no specific price is found, returns a fallback price.
 
         Args:
             inference_service (str): The name of the inference service
             model (str): The model identifier
 
         Returns:
-            Optional[Dict]: Price information if found, None otherwise
+            Dict: Price information (either actual or fallback prices)
         """
         key = (inference_service, model)
-        return self._price_lookup.get(key)
+        return self._price_lookup.get(key) or self._get_fallback_price(
+            inference_service
+        )
 
     def get_all_prices(self) -> Dict[Tuple[str, str], Dict]:
         """
@@ -53,6 +56,45 @@ class PriceManager:
         """
         return self._price_lookup.copy()
 
+    def _get_fallback_price(self, inference_service: str) -> Dict:
+        """
+        Get fallback prices for a service.
+        - First fallback: The highest input and output prices for that service from the price lookup.
+        - Second fallback: $1.00 per million tokens (for both input and output).
+
+        Args:
+            inference_service (str): The inference service name
+
+        Returns:
+            Dict: Price information
+        """
+        service_prices = [
+            prices
+            for (service, _), prices in self._price_lookup.items()
+            if service == inference_service
+        ]
+
+        input_tokens_per_usd = [
+            float(p["input"]["one_usd_buys"]) for p in service_prices if "input" in p
+        ]
+        if input_tokens_per_usd:
+            min_input_tokens = min(input_tokens_per_usd)
+        else:
+            min_input_tokens = 1_000_000
+
+        output_tokens_per_usd = [
+            float(p["output"]["one_usd_buys"]) for p in service_prices if "output" in p
+        ]
+        if output_tokens_per_usd:
+            min_output_tokens = min(output_tokens_per_usd)
+        else:
+            min_output_tokens = 1_000_000
+
+        return {
+            "input": {"one_usd_buys": min_input_tokens},
+            "output": {"one_usd_buys": min_output_tokens},
+        }
+
     def calculate_cost(
         self,
         inference_service: str,
@@ -75,8 +117,6 @@ class PriceManager:
             Union[float, str]: Total cost if calculation successful, error message string if not
         """
         relevant_prices = self.get_price(inference_service, model)
-        if relevant_prices is None:
-            return f"Could not find price for model {model} in the price lookup."
 
         # Extract token counts
         try: