edsl 0.1.38.dev4__py3-none-any.whl → 0.1.39__py3-none-any.whl

edsl/agents/QuestionTemplateReplacementsBuilder.py

@@ -0,0 +1,137 @@
+from jinja2 import Environment, meta
+from typing import Any, Set, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from edsl.agents.PromptConstructor import PromptConstructor
+    from edsl.scenarios.Scenario import Scenario
+
+
+class QuestionTemplateReplacementsBuilder:
+    def __init__(self, prompt_constructor: "PromptConstructor"):
+        self.prompt_constructor = prompt_constructor
+
+    def question_file_keys(self):
+        question_text = self.prompt_constructor.question.question_text
+        file_keys = self._find_file_keys(self.prompt_constructor.scenario)
+        return self._extract_file_keys_from_question_text(question_text, file_keys)
+
+    def scenario_file_keys(self):
+        return self._find_file_keys(self.prompt_constructor.scenario)
+
+    def get_jinja2_variables(template_str: str) -> Set[str]:
+        """
+        Extracts all variable names from a Jinja2 template using Jinja2's built-in parsing.
+
+        Args:
+        template_str (str): The Jinja2 template string
+
+        Returns:
+        Set[str]: A set of variable names found in the template
+        """
+        env = Environment()
+        ast = env.parse(template_str)
+        return meta.find_undeclared_variables(ast)
+
+    @staticmethod
+    def _find_file_keys(scenario: "Scenario") -> list:
+        """We need to find all the keys in the scenario that refer to FileStore objects.
+        These will be used to append to the prompt a list of files that are part of the scenario.
+
+        >>> from edsl import Scenario
+        >>> from edsl.scenarios.FileStore import FileStore
+        >>> import tempfile
+        >>> with tempfile.NamedTemporaryFile() as f:
+        ...     _ = f.write(b"Hello, world!")
+        ...     _ = f.seek(0)
+        ...     fs = FileStore(f.name)
+        ...     scenario = Scenario({"fs_file": fs, 'a': 1})
+        ...     QuestionTemplateReplacementsBuilder._find_file_keys(scenario)
+        ['fs_file']
+        """
+        from edsl.scenarios.FileStore import FileStore
+
+        file_entries = []
+        for key, value in scenario.items():
+            if isinstance(value, FileStore):
+                file_entries.append(key)
+        return file_entries
+
+    @staticmethod
+    def _extract_file_keys_from_question_text(
+        question_text: str, scenario_file_keys: list
+    ) -> list:
+        """
+        Extracts the file keys from a question text.
+
+        >>> from edsl import Scenario
+        >>> from edsl.scenarios.FileStore import FileStore
+        >>> import tempfile
+        >>> with tempfile.NamedTemporaryFile() as f:
+        ...     _ = f.write(b"Hello, world!")
+        ...     _ = f.seek(0)
+        ...     fs = FileStore(f.name)
+        ...     scenario = Scenario({"fs_file": fs, 'a': 1})
+        ...     QuestionTemplateReplacementsBuilder._extract_file_keys_from_question_text("{{ fs_file }}", ['fs_file'])
+        ['fs_file']
+        """
+        variables = QuestionTemplateReplacementsBuilder.get_jinja2_variables(
+            question_text
+        )
+        question_file_keys = []
+        for var in variables:
+            if var in scenario_file_keys:
+                question_file_keys.append(var)
+        return question_file_keys
+
+    def _scenario_replacements(self) -> dict[str, Any]:
+        # File references dictionary
+        file_refs = {key: f"<see file {key}>" for key in self.scenario_file_keys()}
+
+        # Scenario items excluding file keys
+        scenario_items = {
+            k: v
+            for k, v in self.prompt_constructor.scenario.items()
+            if k not in self.scenario_file_keys()
+        }
+        return {**file_refs, **scenario_items}
+
+    @staticmethod
+    def _question_data_replacements(
+        question: dict, question_data: dict
+    ) -> dict[str, Any]:
+        """Builds a dictionary of replacement values for rendering a prompt by combining multiple data sources.
+
+        >>> from edsl import QuestionMultipleChoice
+        >>> q = QuestionMultipleChoice(question_text="Do you like school?", question_name = "q0", question_options = ["yes", "no"])
+        >>> QuestionTemplateReplacementsBuilder._question_data_replacements(q, q.data)
+        {'use_code': False, 'include_comment': True, 'question_name': 'q0', 'question_text': 'Do you like school?', 'question_options': ['yes', 'no']}
+
+        """
+        question_settings = {
+            "use_code": getattr(question, "_use_code", True),
+            "include_comment": getattr(question, "_include_comment", False),
+        }
+        return {**question_settings, **question_data}
+
+    def build_replacement_dict(self, question_data: dict) -> dict[str, Any]:
+        """Builds a dictionary of replacement values for rendering a prompt by combining multiple data sources."""
+        rpl = {}
+        rpl["scenario"] = self._scenario_replacements()
+        rpl["question"] = self._question_data_replacements(
+            self.prompt_constructor.question, question_data
+        )
+        rpl["prior_answers"] = self.prompt_constructor.prior_answers_dict()
+        rpl["agent"] = {"agent": self.prompt_constructor.agent}
+
+        # Combine all dictionaries using dict.update() for clarity
+        replacement_dict = {}
+        for r in rpl.values():
+            replacement_dict.update(r)
+
+        return replacement_dict
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

edsl/agents/__init__.py

@@ -1,3 +1,2 @@
 from edsl.agents.Agent import Agent
 from edsl.agents.AgentList import AgentList
-from edsl.agents.InvigilatorBase import InvigilatorBase

edsl/agents/prompt_helpers.py

@@ -1,7 +1,7 @@
 import enum
 from typing import Dict, Optional
 from collections import UserList
-from edsl.prompts import Prompt
+from edsl.prompts.Prompt import Prompt
 
 
 class PromptComponent(enum.Enum):
@@ -12,14 +12,14 @@ class PromptComponent(enum.Enum):
 
 
 class PromptList(UserList):
-    separator = Prompt(" ")
+    separator = Prompt("")
 
     def reduce(self):
         """Reduce the list of prompts to a single prompt.
 
         >>> p = PromptList([Prompt("You are a happy-go lucky agent."), Prompt("You are an agent with the following persona: {'age': 22, 'hair': 'brown', 'height': 5.5}")])
         >>> p.reduce()
-        Prompt(text=\"""You are a happy-go lucky agent. You are an agent with the following persona: {'age': 22, 'hair': 'brown', 'height': 5.5}\""")
+        Prompt(text=\"""You are a happy-go lucky agent.You are an agent with the following persona: {'age': 22, 'hair': 'brown', 'height': 5.5}\""")
 
         """
         p = self[0]

edsl/agents/question_option_processor.py

@@ -0,0 +1,172 @@
+from jinja2 import Environment, meta
+from typing import List, Optional, Union
+
+
+class QuestionOptionProcessor:
+    """
+    Class that manages the processing of question options.
+    These can be provided directly, as a template string, or fetched from prior answers or the scenario.
+    """
+
+    def __init__(self, prompt_constructor):
+        self.prompt_constructor = prompt_constructor
+
+    @staticmethod
+    def _get_default_options() -> list:
+        """Return default placeholder options."""
+        return [f"<< Option {i} - Placeholder >>" for i in range(1, 4)]
+
+    @staticmethod
+    def _parse_template_variable(template_str: str) -> str:
+        """
+        Extract the variable name from a template string.
+
+        Args:
+            template_str (str): Jinja template string
+
+        Returns:
+            str: Name of the first undefined variable in the template
+
+        >>> QuestionOptionProcessor._parse_template_variable("Here are some {{ options }}")
+        'options'
+        >>> QuestionOptionProcessor._parse_template_variable("Here are some {{ options }} and {{ other }}")
+        Traceback (most recent call last):
+        ...
+        ValueError: Multiple variables found in template string
+        >>> QuestionOptionProcessor._parse_template_variable("Here are some")
+        Traceback (most recent call last):
+        ...
+        ValueError: No variables found in template string
+        """
+        env = Environment()
+        parsed_content = env.parse(template_str)
+        undeclared_variables = list(meta.find_undeclared_variables(parsed_content))
+        if not undeclared_variables:
+            raise ValueError("No variables found in template string")
+        if len(undeclared_variables) > 1:
+            raise ValueError("Multiple variables found in template string")
+        return undeclared_variables[0]
+
+    @staticmethod
+    def _get_options_from_scenario(
+        scenario: dict, option_key: str
+    ) -> Union[list, None]:
+        """
+        Try to get options from scenario data.
+
+        >>> from edsl import Scenario
+        >>> scenario = Scenario({"options": ["Option 1", "Option 2"]})
+        >>> QuestionOptionProcessor._get_options_from_scenario(scenario, "options")
+        ['Option 1', 'Option 2']
+
+
+        Returns:
+            list | None: List of options if found in scenario, None otherwise
+        """
+        scenario_options = scenario.get(option_key)
+        return scenario_options if isinstance(scenario_options, list) else None
+
+    @staticmethod
+    def _get_options_from_prior_answers(
+        prior_answers: dict, option_key: str
+    ) -> Union[list, None]:
+        """
+        Try to get options from prior answers.
+
+        prior_answers (dict): Dictionary of prior answers
+        option_key (str): Key to look up in prior answers
+
+        >>> from edsl import QuestionList as Q
+        >>> q = Q.example()
+        >>> q.answer = ["Option 1", "Option 2"]
+        >>> prior_answers = {"options": q}
+        >>> QuestionOptionProcessor._get_options_from_prior_answers(prior_answers, "options")
+        ['Option 1', 'Option 2']
+        >>> QuestionOptionProcessor._get_options_from_prior_answers(prior_answers, "wrong_key") is None
+        True
+
+        Returns:
+            list | None: List of options if found in prior answers, None otherwise
+        """
+        prior_answer = prior_answers.get(option_key)
+        if prior_answer and hasattr(prior_answer, "answer"):
+            if isinstance(prior_answer.answer, list):
+                return prior_answer.answer
+        return None
+
+    def get_question_options(self, question_data: dict) -> list:
+        """
+        Extract and process question options from question data.
+
+        Args:
+            question_data (dict): Dictionary containing question configuration
+
+        Returns:
+            list: List of question options. Returns default placeholders if no valid options found.
+
+        >>> class MockPromptConstructor:
+        ...     pass
+        >>> mpc = MockPromptConstructor()
+        >>> from edsl import Scenario
+        >>> mpc.scenario = Scenario({"options": ["Option 1", "Option 2"]})
+        >>> processor = QuestionOptionProcessor(mpc)
+
+        The basic case where options are directly provided:
+
+        >>> question_data = {"question_options": ["Option 1", "Option 2"]}
+        >>> processor.get_question_options(question_data)
+        ['Option 1', 'Option 2']
+
+        The case where options are provided as a template string:
+
+        >>> question_data = {"question_options": "{{ options }}"}
+        >>> processor.get_question_options(question_data)
+        ['Option 1', 'Option 2']
+
+        The case where there is a templace string but it's in the prior answers:
+
+        >>> class MockQuestion:
+        ...     pass
+        >>> q0 = MockQuestion()
+        >>> q0.answer = ["Option 1", "Option 2"]
+        >>> mpc.prior_answers_dict = lambda: {'q0': q0}
+        >>> processor = QuestionOptionProcessor(mpc)
+        >>> question_data = {"question_options": "{{ q0 }}"}
+        >>> processor.get_question_options(question_data)
+        ['Option 1', 'Option 2']
+
+        The case we're no options are found:
+        >>> processor.get_question_options({"question_options": "{{ poop }}"})
+        ['<< Option 1 - Placeholder >>', '<< Option 2 - Placeholder >>', '<< Option 3 - Placeholder >>']
+
+        """
+        options_entry = question_data.get("question_options")
+
+        # If not a template string, return as is or default
+        if not isinstance(options_entry, str):
+            return options_entry if options_entry else self._get_default_options()
+
+        # Parse template to get variable name
+        option_key = self._parse_template_variable(options_entry)
+
+        # Try getting options from scenario
+        scenario_options = self._get_options_from_scenario(
+            self.prompt_constructor.scenario, option_key
+        )
+        if scenario_options:
+            return scenario_options
+
+        # Try getting options from prior answers
+        prior_answer_options = self._get_options_from_prior_answers(
+            self.prompt_constructor.prior_answers_dict(), option_key
+        )
+        if prior_answer_options:
+            return prior_answer_options
+
+        return self._get_default_options()
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

edsl/auto/AutoStudy.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Optional, TYPE_CHECKING
 
 from edsl import Model
 from edsl.auto.StageQuestions import StageQuestions
@@ -11,10 +11,12 @@ from edsl.auto.StagePersonaDimensionValueRanges import (
 from edsl.auto.StageLabelQuestions import StageLabelQuestions
 from edsl.auto.StageGenerateSurvey import StageGenerateSurvey
 
-# from edsl.auto.StageBase import gen_pipeline
-
 from edsl.auto.utilities import agent_generator, create_agents, gen_pipeline
 
+if TYPE_CHECKING:
+    from edsl.surveys.Survey import Survey
+    from edsl.agents.AgentList import AgentList
+
 
 class AutoStudy:
     def __init__(
@@ -24,8 +26,10 @@ class AutoStudy:
         model: Optional["Model"] = None,
         survey: Optional["Survey"] = None,
         agent_list: Optional["AgentList"] = None,
-        default_num_agents=11,
+        default_num_agents: int = 11,
     ):
+        """AutoStudy class for generating surveys and agents."""
+
         self.overall_question = overall_question
         self.population = population
         self._survey = survey
@@ -36,6 +40,15 @@ class AutoStudy:
         self.default_num_agents = default_num_agents
         self.model = model or Model()
 
+    def to_dict(self):
+        return {
+            "overall_question": self.overall_question,
+            "population": self.population,
+            "survey": self.survey.to_dict(),
+            "persona_mapping": self.persona_mapping.to_dict(),
+            "results": self.results.to_dict(),
+        }
+
     @property
     def survey(self):
         if self._survey is None:
@@ -111,7 +124,7 @@ class AutoStudy:
 
 
 if __name__ == "__main__":
-    overall_question = "Should online platforms be regulated with respect to selling electric scooters?"
+    overall_question = "I have an open source Python library for working with LLMs. What are some ways we can market this to others?"
     auto_study = AutoStudy(overall_question, population="US Adults")
 
     results = auto_study.results

edsl/auto/StageBase.py

@@ -1,4 +1,5 @@
 from abc import ABC, abstractmethod
+import json
 from typing import Dict, List, Any, TypeVar, Generator, Dict, Callable
 from dataclasses import dataclass, field, KW_ONLY, fields, asdict
 import textwrap
@@ -35,6 +36,13 @@ class FlowDataBase:
     sent_to_stage_name: str = field(default_factory=str)
     came_from_stage_name: str = field(default_factory=str)
 
+    def to_dict(self):
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(**data)
+
     def __getitem__(self, key):
         """Allows dictionary-style getting."""
         return getattr(self, key)
@@ -126,6 +134,10 @@ class StageBase(ABC):
         else:
             self.next_stage = None
 
+    @classmethod
+    def function_parameters(self):
+        return fields(self.input)
+
     @classmethod
     def func(cls, **kwargs):
         "This provides a shortcut for running a stage by passing keyword arguments to the input function."
@@ -173,58 +185,59 @@ class StageBase(ABC):
 
 
 if __name__ == "__main__":
-    try:
+    pass
+    # try:
 
-        class StageMissing(StageBase):
-            def handle_data(self, data):
-                return data
+    #     class StageMissing(StageBase):
+    #         def handle_data(self, data):
+    #             return data
 
-    except NotImplementedError as e:
-        print(e)
-    else:
-        raise Exception("Should have raised NotImplementedError")
+    # except NotImplementedError as e:
+    #     print(e)
+    # else:
+    #     raise Exception("Should have raised NotImplementedError")
 
-    try:
+    # try:
 
-        class StageMissingInput(StageBase):
-            output = FlowDataBase
+    #     class StageMissingInput(StageBase):
+    #         output = FlowDataBase
 
-    except NotImplementedError as e:
-        print(e)
+    # except NotImplementedError as e:
+    #     print(e)
 
-    else:
-        raise Exception("Should have raised NotImplementedError")
+    # else:
+    #     raise Exception("Should have raised NotImplementedError")
 
-    @dataclass
-    class MockInputOutput(FlowDataBase):
-        text: str
+    # @dataclass
+    # class MockInputOutput(FlowDataBase):
+    #     text: str
 
-    class StageTest(StageBase):
-        input = MockInputOutput
-        output = MockInputOutput
+    # class StageTest(StageBase):
+    #     input = MockInputOutput
+    #     output = MockInputOutput
 
-        def handle_data(self, data):
-            return self.output(text=data["text"] + "processed")
+    #     def handle_data(self, data):
+    #         return self.output(text=data["text"] + "processed")
 
-    result = StageTest().process(MockInputOutput(text="Hello world!"))
-    print(result.text)
+    # result = StageTest().process(MockInputOutput(text="Hello world!"))
+    # print(result.text)
 
-    pipeline = StageTest(next_stage=StageTest(next_stage=StageTest()))
-    result = pipeline.process(MockInputOutput(text="Hello world!"))
-    print(result.text)
+    # pipeline = StageTest(next_stage=StageTest(next_stage=StageTest()))
+    # result = pipeline.process(MockInputOutput(text="Hello world!"))
+    # print(result.text)
 
-    class BadMockInput(FlowDataBase):
-        text: str
-        other: str
+    # class BadMockInput(FlowDataBase):
+    #     text: str
+    #     other: str
 
-    class StageBad(StageBase):
-        input = BadMockInput
-        output = BadMockInput
+    # class StageBad(StageBase):
+    #     input = BadMockInput
+    #     output = BadMockInput
 
-        def handle_data(self, data):
-            return self.output(text=data["text"] + "processed")
+    #     def handle_data(self, data):
+    #         return self.output(text=data["text"] + "processed")
 
-    try:
-        pipeline = StageTest(next_stage=StageBad(next_stage=StageTest()))
-    except ExceptionPipesDoNotFit as e:
-        print(e)
+    # try:
+    #     pipeline = StageTest(next_stage=StageBad(next_stage=StageTest()))
+    # except ExceptionPipesDoNotFit as e:
+    #     print(e)

edsl/auto/StageQuestions.py

@@ -68,6 +68,7 @@ if __name__ == "__main__":
             population="Consumers",
         )
     )
-    StageQuestions.func(
+
+    results = StageQuestions.func(
         overall_question="Why aren't my students studying more?", population="Tech"
     )

edsl/auto/utilities.py

@@ -88,12 +88,6 @@ def agent_eligibility(
         q_eligibility(model=model, questions=questions, persona=persona, cache=cache)
         == "Yes"
     )
-    # results = (
-    #     q.by(model)
-    #     .by(Scenario({"questions": questions, "persona": persona}))
-    #     .run(cache=cache)
-    # )
-    # return results.select("eligibility").first() == "Yes"
 
 
 def gen_agent_traits(dimension_dict: dict, seed_value: Optional[str] = None):

edsl/config.py

@@ -1,12 +1,16 @@
 """This module provides a Config class that loads environment variables from a .env file and sets them as class attributes."""
 
 import os
+import platformdirs
 from dotenv import load_dotenv, find_dotenv
-from edsl.exceptions import (
+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",
@@ -34,7 +38,8 @@ CONFIG_MAP = {
         "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(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": {
@@ -69,6 +74,10 @@ CONFIG_MAP = {
         "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.",
+    },
 }
 
 
@@ -81,6 +90,9 @@ class Config:
         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.
@@ -144,6 +156,14 @@ class Config:
             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__)

edsl/conversation/car_buying.py

@@ -29,7 +29,8 @@ a3 = Agent(
 c1 = Conversation(agent_list=AgentList([a1, a3, a2]), max_turns=5, verbose=True)
 c2 = Conversation(agent_list=AgentList([a1, a2]), max_turns=5, verbose=True)
 
-c = Cache.load("car_talk.json.gz")
+# c = Cache.load("car_talk.json.gz")
+c = Cache()
 # breakpoint()
 combo = ConversationList([c1, c2], cache=c)
 combo.run()

edsl/coop/CoopFunctionsMixin.py

@@ -0,0 +1,15 @@
+class CoopFunctionsMixin:
+    def better_names(self, existing_names):
+        from edsl import QuestionList, Scenario
+
+        s = Scenario({"existing_names": existing_names})
+        q = QuestionList(
+            question_text="""The following colum names are already in use: {{ existing_names }} 
+                         Please provide new names for the columns.
+                         They should be short, one or two words, and unique. They should be valid Python idenifiers. 
+                         No spaces - use underscores instead. 
+                         """,
+            question_name="better_names",
+        )
+        results = q.by(s).run(verbose=False)
+        return results.select("answer.better_names").first()