edsl 0.1.37.dev4__py3-none-any.whl → 0.1.37.dev5__py3-none-any.whl

edsl/config.py

@@ -1,149 +1,149 @@
-"""This module provides a Config class that loads environment variables from a .env file and sets them as class attributes."""
-
-import os
-from dotenv import load_dotenv, find_dotenv
-from edsl.exceptions import (
-    InvalidEnvironmentVariableError,
-    MissingEnvironmentVariableError,
-)
-
-# 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')}",
-        "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.",
-    },
-}
-
-
-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 _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 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()
+"""This module provides a Config class that loads environment variables from a .env file and sets them as class attributes."""
+
+import os
+from dotenv import load_dotenv, find_dotenv
+from edsl.exceptions import (
+    InvalidEnvironmentVariableError,
+    MissingEnvironmentVariableError,
+)
+
+# 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')}",
+        "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.",
+    },
+}
+
+
+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 _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 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()

edsl/conjure/AgentConstructionMixin.py

@@ -1,152 +1,160 @@
-import random
-from typing import Generator, List, Optional, Union, Callable
-from edsl.agents.Agent import Agent
-from edsl.agents.AgentList import AgentList
-from edsl.questions import QuestionBase
-from edsl.results.Results import Results
-
-
-class AgentConstructionMixin:
-    def agent(self, index) -> Agent:
-        """Return an agent constructed from the data.
-
-        :param index: The index of the agent to construct.
-
-        >>> from edsl.conjure.InputData import InputDataABC
-        >>> id = InputDataABC.example()
-        >>> id.agent(0)
-        Agent(traits = {'morning': '1', 'feeling': '3'}, codebook = {'morning': 'how are you doing this morning?', 'feeling': 'how are you feeling?'})
-
-
-        """
-        responses = [responses[index] for responses in self.raw_data]
-        traits = {qn: r for qn, r in zip(self.question_names, responses)}
-
-        a = Agent(traits=traits, codebook=self.names_to_texts)
-
-        def construct_answer_dict_function(traits: dict) -> Callable:
-            def func(self, question: "QuestionBase", scenario=None):
-                return traits.get(question.question_name, None)
-
-            return func
-
-        a.add_direct_question_answering_method(construct_answer_dict_function(traits))
-        return a
-
-    def _agents(self, indices) -> Generator[Agent, None, None]:
-        """Return a generator of agents, one for each index."""
-        for idx in indices:
-            yield self.agent(idx)
-
-    def to_agent_list(
-        self,
-        indices: Optional[List] = None,
-        sample_size: int = None,
-        seed: str = "edsl",
-        remove_direct_question_answering_method: bool = True,
-    ) -> AgentList:
-        """Return an AgentList from the data.
-
-        :param indices: The indices of the agents to include.
-        :param sample_size: The number of agents to sample.
-        :param seed: The seed for the random number generator.
-
-        >>> from edsl.conjure.InputData import InputDataABC
-        >>> id = InputDataABC.example()
-        >>> al = id.to_agent_list()
-        >>> len(al) == id.num_observations
-        True
-        >>> al = id.to_agent_list(indices = [0, 1, 2])
-        Traceback (most recent call last):
-        ...
-        ValueError: Index 2 is greater than the number of agents 2.
-        """
-        if indices and (sample_size or seed != "edsl"):
-            raise ValueError(
-                "You cannot pass both indices and sample_size/seed, as these are mutually exclusive."
-            )
-
-        if indices:
-            if len(indices) == 0:
-                raise ValueError("Indices must be a non-empty list.")
-            if max(indices) >= self.num_observations:
-                raise ValueError(
-                    f"Index {max(indices)} is greater than the number of agents {self.num_observations}."
-                )
-            if min(indices) < 0:
-                raise ValueError(f"Index {min(indices)} is less than 0.")
-
-        if indices is None:
-            if sample_size is None:
-                indices = range(self.num_observations)
-            else:
-                if sample_size > self.num_observations:
-                    raise ValueError(
-                        f"Sample size {sample_size} is greater than the number of agents {self.num_observations}."
-                    )
-                random.seed(seed)
-                indices = random.sample(range(self.num_observations), sample_size)
-
-        agents = list(self._agents(indices))
-        if remove_direct_question_answering_method:
-            for a in agents:
-                a.remove_direct_question_answering_method()
-        return AgentList(agents)
-
-    def to_results(
-        self,
-        indices: Optional[List] = None,
-        sample_size: int = None,
-        seed: str = "edsl",
-        dryrun=False,
-    ) -> Union[Results, None]:
-        """Return the results of the survey.
-
-        :param indices: The indices of the agents to include.
-        :param sample_size: The number of agents to sample.
-        :param seed: The seed for the random number generator.
-        :param dryrun: If True, the survey will not be run, but the time to run it will be printed.
-
-        >>> from edsl.conjure.InputData import InputDataABC
-        >>> id = InputDataABC.example()
-        >>> r = id.to_results()
-        >>> len(r) == id.num_observations
-        True
-        """
-        agent_list = self.to_agent_list(
-            indices=indices,
-            sample_size=sample_size,
-            seed=seed,
-            remove_direct_question_answering_method=False,
-        )
-        DRYRUN_SAMPLE = 30
-        survey = self.to_survey()
-        if dryrun:
-            import time
-
-            start = time.time()
-            _ = survey.by(agent_list.sample(DRYRUN_SAMPLE)).run()
-            end = time.time()
-            print(f"Time to run {DRYRUN_SAMPLE} agents (s): {round(end - start, 2)}")
-            time_per_agent = (end - start) / DRYRUN_SAMPLE
-            full_sample_time = time_per_agent * len(agent_list)
-            if full_sample_time < 60:
-                print(
-                    f"Full sample will take about {round(full_sample_time, 2)} seconds."
-                )
-            if full_sample_time > 60 and full_sample_time < 3600:
-                print(
-                    f"Full sample will take about {round(full_sample_time / 60, 2)} minutes."
-                )
-            if full_sample_time > 3600:
-                print(
-                    f"Full sample will take about {round(full_sample_time / 3600, 2)} hours."
-                )
-            return None
-        return survey.by(agent_list).run()
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod(optionflags=doctest.ELLIPSIS)
+import random
+from typing import Generator, List, Optional, Union, Callable
+from edsl.agents.Agent import Agent
+from edsl.agents.AgentList import AgentList
+from edsl.questions import QuestionBase
+from edsl.results.Results import Results
+
+
+class AgentConstructionMixin:
+    def agent(self, index) -> Agent:
+        """Return an agent constructed from the data.
+
+        :param index: The index of the agent to construct.
+
+        >>> from edsl.conjure.InputData import InputDataABC
+        >>> id = InputDataABC.example()
+        >>> id.agent(0)
+        Agent(traits = {'morning': '1', 'feeling': '3'}, codebook = {'morning': 'how are you doing this morning?', 'feeling': 'how are you feeling?'})
+
+
+        """
+        responses = [responses[index] for responses in self.raw_data]
+        traits = {qn: r for qn, r in zip(self.question_names, responses)}
+
+        a = Agent(traits=traits, codebook=self.names_to_texts)
+
+        def construct_answer_dict_function(traits: dict) -> Callable:
+            def func(self, question: "QuestionBase", scenario=None):
+                return traits.get(question.question_name, None)
+
+            return func
+
+        a.add_direct_question_answering_method(construct_answer_dict_function(traits))
+        return a
+
+    def _agents(self, indices) -> Generator[Agent, None, None]:
+        """Return a generator of agents, one for each index."""
+        for idx in indices:
+            yield self.agent(idx)
+
+    def to_agent_list(
+        self,
+        indices: Optional[List] = None,
+        sample_size: int = None,
+        seed: str = "edsl",
+        remove_direct_question_answering_method: bool = True,
+    ) -> AgentList:
+        """Return an AgentList from the data.
+
+        :param indices: The indices of the agents to include.
+        :param sample_size: The number of agents to sample.
+        :param seed: The seed for the random number generator.
+
+        >>> from edsl.conjure.InputData import InputDataABC
+        >>> id = InputDataABC.example()
+        >>> al = id.to_agent_list()
+        >>> len(al) == id.num_observations
+        True
+        >>> al = id.to_agent_list(indices = [0, 1, 2])
+        Traceback (most recent call last):
+        ...
+        ValueError: Index 2 is greater than the number of agents 2.
+        """
+        if indices and (sample_size or seed != "edsl"):
+            raise ValueError(
+                "You cannot pass both indices and sample_size/seed, as these are mutually exclusive."
+            )
+
+        if indices:
+            if len(indices) == 0:
+                raise ValueError("Indices must be a non-empty list.")
+            if max(indices) >= self.num_observations:
+                raise ValueError(
+                    f"Index {max(indices)} is greater than the number of agents {self.num_observations}."
+                )
+            if min(indices) < 0:
+                raise ValueError(f"Index {min(indices)} is less than 0.")
+
+        if indices is None:
+            if sample_size is None:
+                indices = range(self.num_observations)
+            else:
+                if sample_size > self.num_observations:
+                    raise ValueError(
+                        f"Sample size {sample_size} is greater than the number of agents {self.num_observations}."
+                    )
+                random.seed(seed)
+                indices = random.sample(range(self.num_observations), sample_size)
+
+        agents = list(self._agents(indices))
+        if remove_direct_question_answering_method:
+            for a in agents:
+                a.remove_direct_question_answering_method()
+        return AgentList(agents)
+
+    def to_results(
+        self,
+        indices: Optional[List] = None,
+        sample_size: int = None,
+        seed: str = "edsl",
+        dryrun=False,
+        disable_remote_cache: bool = False,
+        disable_remote_inference: bool = False,
+    ) -> Union[Results, None]:
+        """Return the results of the survey.
+
+        :param indices: The indices of the agents to include.
+        :param sample_size: The number of agents to sample.
+        :param seed: The seed for the random number generator.
+        :param dryrun: If True, the survey will not be run, but the time to run it will be printed.
+
+        >>> from edsl.conjure.InputData import InputDataABC
+        >>> id = InputDataABC.example()
+        >>> r = id.to_results(disable_remote_cache = True, disable_remote_inference = True)
+        >>> len(r) == id.num_observations
+        True
+        """
+        agent_list = self.to_agent_list(
+            indices=indices,
+            sample_size=sample_size,
+            seed=seed,
+            remove_direct_question_answering_method=False,
+        )
+        DRYRUN_SAMPLE = 30
+        survey = self.to_survey()
+        if dryrun:
+            import time
+
+            start = time.time()
+            _ = survey.by(agent_list.sample(DRYRUN_SAMPLE)).run(
+                disable_remote_cache=disable_remote_cache,
+                disable_remote_inference=disable_remote_inference,
+            )
+            end = time.time()
+            print(f"Time to run {DRYRUN_SAMPLE} agents (s): {round(end - start, 2)}")
+            time_per_agent = (end - start) / DRYRUN_SAMPLE
+            full_sample_time = time_per_agent * len(agent_list)
+            if full_sample_time < 60:
+                print(
+                    f"Full sample will take about {round(full_sample_time, 2)} seconds."
+                )
+            if full_sample_time > 60 and full_sample_time < 3600:
+                print(
+                    f"Full sample will take about {round(full_sample_time / 60, 2)} minutes."
+                )
+            if full_sample_time > 3600:
+                print(
+                    f"Full sample will take about {round(full_sample_time / 3600, 2)} hours."
+                )
+            return None
+        return survey.by(agent_list).run(
+            disable_remote_cache=disable_remote_cache,
+            disable_remote_inference=disable_remote_inference,
+        )
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod(optionflags=doctest.ELLIPSIS)