edsl 0.1.47__py3-none-any.whl → 0.1.49__py3-none-any.whl

edsl/config.py

@@ -1,177 +1,5 @@
-"""This module provides a Config class that loads environment variables from a .env file and sets them as class attributes."""
+"""Config module wrapper for backward compatibility.
 
-import os
-import platformdirs
-from dotenv import load_dotenv, find_dotenv
-from edsl.exceptions.configuration import (
-    InvalidEnvironmentVariableError,
-    MissingEnvironmentVariableError,
-)
-
-cache_dir = platformdirs.user_cache_dir("edsl")
-os.makedirs(cache_dir, exist_ok=True)
-
-# valid values for EDSL_RUN_MODE
-EDSL_RUN_MODES = [
-    "development",
-    "development-testrun",
-    "production",
-]
-
-# `default` is used to impute values only in "production" mode
-# `info` gives a brief description of the env var
-CONFIG_MAP = {
-    "EDSL_RUN_MODE": {
-        "default": "production",
-        "info": "This config var determines the run mode of the application.",
-    },
-    "EDSL_API_TIMEOUT": {
-        "default": "60",
-        "info": "This config var determines the maximum number of seconds to wait for an API call to return.",
-    },
-    "EDSL_BACKOFF_START_SEC": {
-        "default": "1",
-        "info": "This config var determines the number of seconds to wait before retrying a failed API call.",
-    },
-    "EDSL_BACKOFF_MAX_SEC": {
-        "default": "60",
-        "info": "This config var determines the maximum number of seconds to wait before retrying a failed API call.",
-    },
-    "EDSL_DATABASE_PATH": {
-        # "default": f"sqlite:///{os.path.join(os.getcwd(), '.edsl_cache/data.db')}",
-        "default": f"sqlite:///{os.path.join(platformdirs.user_cache_dir('edsl'), 'lm_model_calls.db')}",
-        "info": "This config var determines the path to the cache file.",
-    },
-    "EDSL_DEFAULT_MODEL": {
-        "default": "gpt-4o",
-        "info": "This config var holds the default model that will be used if a model is not explicitly passed.",
-    },
-    "EDSL_FETCH_TOKEN_PRICES": {
-        "default": "True",
-        "info": "This config var determines whether to fetch prices for tokens used in remote inference",
-    },
-    "EDSL_MAX_ATTEMPTS": {
-        "default": "5",
-        "info": "This config var determines the maximum number of times to retry a failed API call.",
-    },
-    "EDSL_SERVICE_RPM_BASELINE": {
-        "default": "100",
-        "info": "This config var holds the maximum number of requests per minute. Model-specific values provided in env vars such as EDSL_SERVICE_RPM_OPENAI will override this. value for the corresponding model",
-    },
-    "EDSL_SERVICE_TPM_BASELINE": {
-        "default": "2000000",
-        "info": "This config var holds the maximum number of tokens per minute for all models. Model-specific values provided in env vars such as EDSL_SERVICE_TPM_OPENAI will override this value for the corresponding model.",
-    },
-    "EXPECTED_PARROT_URL": {
-        "default": "https://www.expectedparrot.com",
-        "info": "This config var holds the URL of the Expected Parrot API.",
-    },
-    "EDSL_MAX_CONCURRENT_TASKS": {
-        "default": "500",
-        "info": "This config var determines the maximum number of concurrent tasks that can be run by the async job-runner",
-    },
-    "EDSL_OPEN_EXCEPTION_REPORT_URL": {
-        "default": "False",
-        "info": "This config var determines whether to open the exception report URL in the browser",
-    },
-    "EDSL_REMOTE_TOKEN_BUCKET_URL": {
-        "default": "None",
-        "info": "This config var holds the URL of the remote token bucket server.",
-    },
-}
-
-
-class Config:
-    """A class that loads environment variables from a .env file and sets them as class attributes."""
-
-    def __init__(self):
-        """Initialize the Config class."""
-        self._set_run_mode()
-        self._load_dotenv()
-        self._set_env_vars()
-
-    def show_path_to_dot_env(self):
-        print(find_dotenv(usecwd=True))
-
-    def _set_run_mode(self) -> None:
-        """
-        Sets EDSL_RUN_MODE as a class attribute.
-        """
-        run_mode = os.getenv("EDSL_RUN_MODE")
-        default = CONFIG_MAP.get("EDSL_RUN_MODE").get("default")
-        if run_mode is None:
-            run_mode = default
-        if run_mode not in EDSL_RUN_MODES:
-            raise InvalidEnvironmentVariableError(
-                f"Value `{run_mode}` is not allowed for EDSL_RUN_MODE."
-            )
-        self.EDSL_RUN_MODE = run_mode
-
-    def _load_dotenv(self) -> None:
-        """
-        Loads the .env
-        - The .env will override existing env vars **unless** EDSL_RUN_MODE=="development-testrun"
-        """
-
-        if self.EDSL_RUN_MODE == "development-testrun":
-            override = False
-        else:
-            override = True
-        _ = load_dotenv(dotenv_path=find_dotenv(usecwd=True), override=override)
-
-    def __contains__(self, env_var: str) -> bool:
-        """
-        Checks if an env var is set as a class attribute.
-        """
-        return env_var in self.__dict__
-
-    def _set_env_vars(self) -> None:
-        """
-        Sets env vars as class attributes.
-        - EDSL_RUN_MODE is not set my this method, but by _set_run_mode
-        - If an env var is not set and has a default value in the CONFIG_MAP, sets it to the default value.
-        """
-        # for each env var in the CONFIG_MAP
-        for env_var, config in CONFIG_MAP.items():
-            # EDSL_RUN_MODE is already set by _set_run_mode
-            if env_var == "EDSL_RUN_MODE":
-                continue
-            value = os.getenv(env_var)
-            default_value = config.get("default")
-            # if an env var exists, set it as a class attribute
-            if value:
-                setattr(self, env_var, value)
-            # otherwise, if EDSL_RUN_MODE == "production" set it to its default value
-            elif self.EDSL_RUN_MODE == "production":
-                setattr(self, env_var, default_value)
-
-    def get(self, env_var: str) -> str:
-        """
-        Returns the value of an environment variable.
-        """
-        if env_var not in CONFIG_MAP:
-            raise InvalidEnvironmentVariableError(f"{env_var} is not a valid env var. ")
-        elif env_var not in self.__dict__:
-            info = CONFIG_MAP[env_var].get("info")
-            raise MissingEnvironmentVariableError(f"{env_var} is not set. {info}")
-        return self.__dict__.get(env_var)
-
-    def __iter__(self):
-        """Iterate over the environment variables."""
-        return iter(self.__dict__)
-
-    def items(self):
-        """Iterate over the environment variables and their values."""
-        return self.__dict__.items()
-
-    def show(self) -> str:
-        """Print the currently set environment vars."""
-        max_env_var_length = max(len(env_var) for env_var in self.__dict__)
-        print("Here are the current configuration settings:")
-        for env_var, value in self.__dict__.items():
-            print(f"{env_var:<{max_env_var_length}} : {value}")
-
-
-# Note: Python modules are singletons. As such, once this module is imported
-# the same instance of it is reused across the application.
-CONFIG = Config()
+# Re-export everything from edsl.config module
+from edsl.config import *
+from edsl.config.config_class import *

edsl/conversation/Conversation.py

@@ -2,13 +2,13 @@ from collections import UserList
 import asyncio
 import inspect
 from typing import Optional, Callable
-from edsl import Agent, QuestionFreeText, Results, AgentList, ScenarioList, Scenario
-from edsl.questions import QuestionBase
-from edsl.results.Result import Result
+from .. import Agent, QuestionFreeText, Results, AgentList, ScenarioList, Scenario
+from ..questions import QuestionBase
+from ..results.Result import Result
 from jinja2 import Template
-from edsl.data import Cache
+from ..caching import Cache
 
-from edsl.conversation.next_speaker_utilities import (
+from .next_speaker_utilities import (
     default_turn_taking_generator,
     speaker_closure,
 )
@@ -83,7 +83,7 @@ class Conversation:
 
         self.agent_list = agent_list
 
-        from edsl import Model
+        from .. import Model
 
         for agent in self.agent_list:
             if not hasattr(agent, "model"):
@@ -200,7 +200,7 @@ What do you say next?"""
         """Get the next statement from the speaker."""
         q = self.next_statement_question
         # assert q.parameters == {"agent_name", "conversation"}, q.parameters
-        from edsl import Scenario
+        from .. import Scenario
 
         if self.per_round_message_template is None:
             round_message = None

edsl/conversation/car_buying.py

@@ -1,6 +1,6 @@
-from edsl import Agent, AgentList, QuestionFreeText
-from edsl import Cache
-from edsl.conversation.Conversation import Conversation, ConversationList
+from .. import Agent, AgentList, QuestionFreeText
+from .. import Cache
+from .Conversation import Conversation, ConversationList
 
 a1 = Agent(
     name="Alice",
@@ -46,7 +46,7 @@ q = QuestionFreeText(
     question_name="car_brand",
 )
 
-from edsl import QuestionList
+from .. import QuestionList
 
 q_actors = QuestionList(
     question_text="""This was a conversation about buying a car: {{ transcript }}. 

edsl/conversation/chips.py

@@ -1,11 +1,11 @@
 from typing import Optional
 
-from edsl import Agent, AgentList, QuestionFreeText
-from edsl import Cache
-from edsl import QuestionList
-from edsl import Model
+from .. import Agent, AgentList, QuestionFreeText
+from .. import Cache
+from .. import QuestionList
+from .. import Model
 
-from edsl.conversation.Conversation import Conversation, ConversationList
+from .Conversation import Conversation, ConversationList
 
 m = Model("gemini-1.5-flash")
 
@@ -79,7 +79,7 @@ with Cache() as c:
         question_name="actors",
     )
 
-    from edsl import QuestionList
+    from .. import QuestionList
 
     q_transfers = QuestionList(
         question_text="""This was a conversation/negotiation: {{ transcript }}. 

edsl/coop/__init__.py

@@ -1,2 +1,25 @@
-from edsl.coop.utils import EDSLObject, ObjectType, VisibilityType, ObjectRegistry
-from edsl.coop.coop import Coop
+
+"""
+The coop module provides connectivity with Expected Parrot's cloud services.
+
+This module enables EDSL to interact with cloud-based resources for enhanced functionality:
+1. Remote storage and sharing of EDSL objects (surveys, agents, models, results, etc.)
+2. Remote inference execution for running jobs in the cloud
+3. Caching of interview results for improved performance and cost savings
+4. API key management and authentication
+5. Price and model availability information
+
+The primary interface is the Coop class, which serves as a client for the
+Expected Parrot API. Most users will only need to interact with the Coop class directly.
+
+Example:
+    >>> from edsl.coop import Coop
+    >>> coop = Coop()  # Uses API key from environment or stored location
+    >>> survey = my_survey.push()  # Uploads survey to Expected Parrot
+    >>> job_info = coop.remote_inference_create(my_job)  # Creates remote job
+"""
+
+from .utils import EDSLObject, ObjectType, VisibilityType, ObjectRegistry
+from .coop import Coop
+from .exceptions import CoopServerResponseError
+__all__ = ["Coop"]