edsl 0.1.33.dev1__py3-none-any.whl → 0.1.33.dev2__py3-none-any.whl

edsl/auto/StagePersonaDimensionValues.py

@@ -0,0 +1,74 @@
+from textwrap import dedent
+from dataclasses import dataclass
+
+from typing import List, Dict
+
+from edsl.auto.StageBase import StageBase
+from edsl.auto.StageBase import FlowDataBase
+
+from edsl.auto.StagePersonaDimensions import StagePersonaDimensions
+from edsl import Model
+from edsl.questions import QuestionList, QuestionExtract
+from edsl.scenarios import Scenario
+
+from edsl.auto.utilities import gen_pipeline
+
+
+class StagePersonaDimensionValues(StageBase):
+    input = StagePersonaDimensions.output
+
+    @dataclass
+    class Output(FlowDataBase):
+        attribute_results: List[str]
+        dimension_values: Dict[str, str]
+        persona: str
+
+    output = Output
+
+    def handle_data(self, data):
+        attribute_results = data.attribute_results
+        persona = data.persona
+        m = Model()
+        q = QuestionExtract(
+            question_text=dedent(
+                """\
+            This is a persona: "{{ persona }}"
+            They vary on the following dimensions: "{{ attribute_results }}"
+            For each dimenion, what are some values that this persona might have for that dimension?
+            Please keep answers very short, ideally one word.
+            """
+            ),
+            answer_template={k: None for k in attribute_results},
+            question_name="dimension_values",
+        )
+        results = (
+            q.by(Scenario({"attribute_results": attribute_results, "persona": persona}))
+            .by(m)
+            .run()
+        )
+        results.select("attribute_results", "dimension_values").print()
+        return self.output(
+            dimension_values=results.select("dimension_values").first(),
+            attribute_results=attribute_results,
+            persona=persona,
+        )
+
+
+if __name__ == "__main__":
+    from edsl.auto.StageQuestions import StageQuestions
+    from edsl.auto.StagePersona import StagePersona
+    from edsl.auto.StagePersonaDimensions import StagePersonaDimensions
+
+    pipeline = gen_pipeline(
+        [
+            StageQuestions,
+            StagePersona,
+            StagePersonaDimensions,
+            StagePersonaDimensionValues,
+        ]
+    )
+    pipeline.process(
+        pipeline.input(
+            overall_question="What are some factors that could determine whether someone likes ice cream?"
+        )
+    )

edsl/auto/StagePersonaDimensions.py

@@ -0,0 +1,69 @@
+from textwrap import dedent
+from dataclasses import dataclass
+
+from typing import List
+
+from edsl.auto.StageBase import StageBase
+from edsl.auto.StageBase import FlowDataBase
+
+from edsl.auto.StagePersona import StagePersona
+
+from edsl.questions import QuestionList
+from edsl.scenarios import Scenario
+from edsl import Model
+
+from edsl.auto.utilities import gen_pipeline
+
+
+class StagePersonaDimensions(StageBase):
+    input = StagePersona.output
+
+    @dataclass
+    class Output(FlowDataBase):
+        attribute_results: List[str]
+        persona: str
+
+    output = Output
+
+    def handle_data(self, data):
+        q_attributes = QuestionList(
+            question_text=dedent(
+                """\
+            Here is a persona: "{{ persona }}"
+            It was construced to be someone who could answer these questions: "{{ questions }}"
+
+            We want to identify the general dimensions that make up this persona.
+            E.g., if the person is desribed as 'happy' then a dimenion would be  'mood'
+            """
+            ),
+            question_name="find_attributes",
+        )
+        m = Model()
+        results = (
+            q_attributes.by(
+                Scenario({"persona": data.persona, "questions": data.questions})
+            )
+            .by(m)
+            .run()
+        )
+        (
+            results.select("find_attributes").print(
+                pretty_labels={
+                    "answer.find_attributes": f'Persona dimensions for: "{data.persona}"'
+                },
+                split_at_dot=False,
+            )
+        )
+        attribute_results = results.select("find_attributes").first()
+        return self.output(attribute_results=attribute_results, persona=data.persona)
+
+
+if __name__ == "__main__":
+    from edsl.auto.StageQuestions import StageQuestions
+
+    pipeline = gen_pipeline([StageQuestions, StagePersona, StagePersonaDimensions])
+    pipeline.process(
+        pipeline.input(
+            overall_question="What are some factors that could determine whether someone likes ice cream?"
+        )
+    )

edsl/auto/StageQuestions.py

@@ -0,0 +1,73 @@
+from dataclasses import dataclass
+from typing import List
+from textwrap import dedent
+
+
+from edsl import Scenario
+from edsl import Model
+from edsl.questions.QuestionList import QuestionList
+
+from edsl.auto.StageBase import StageBase
+from edsl.auto.StageBase import FlowDataBase
+
+from edsl.auto.utilities import gen_pipeline
+
+
+class StageQuestions(StageBase):
+    "This stages takes as input an overall question and returns a list of questions"
+
+    @dataclass
+    class Input(FlowDataBase):
+        overall_question: str
+        population: str
+
+    @dataclass
+    class Output(FlowDataBase):
+        questions: List[str]
+        population: str
+
+    input = Input
+    output = Output
+
+    def handle_data(self, data):
+        m = Model()
+        overall_question = data.overall_question
+        population = data.population
+        s = Scenario({"overall_question": overall_question, "population": population})
+        q = QuestionList(
+            question_text=dedent(
+                """\
+            Suppose I am interested in the question: 
+            "{{ overall_question }}" 
+            What would be some survey questions I could ask to {{ population }} that might shed light on this question?
+            """
+            ),
+            question_name="questions",
+        )
+        results = q.by(s).by(m).run()
+        (
+            results.select("questions").print(
+                pretty_labels={
+                    "answer.questions": f'Questions for overall question: "{overall_question }"'
+                },
+                split_at_dot=False,
+            )
+        )
+
+        raw_questions = results.select("questions").first()
+        questions = [q.replace("'", "").replace(":", "") for q in raw_questions]
+        return self.Output(questions=questions, population=population)
+
+
+if __name__ == "__main__":
+    pipeline = gen_pipeline([StageQuestions])
+
+    pipeline.process(
+        pipeline.input(
+            overall_question="What are some factors that could determine whether someone likes ice cream?",
+            population="Consumers",
+        )
+    )
+    StageQuestions.func(
+        overall_question="Why aren't my students studying more?", population="Tech"
+    )

edsl/auto/SurveyCreatorPipeline.py

@@ -0,0 +1,21 @@
+import random
+from typing import Dict, List, Any, TypeVar, Generator, Optional
+
+from textwrap import dedent
+
+# from edsl.language_models.model_interfaces.LanguageModelOpenAIFour import LanguageModelOpenAIFour
+from edsl import Model
+from edsl.agents.AgentList import AgentList
+from edsl.results.Results import Results
+from edsl import Agent
+
+from edsl import Scenario
+from edsl.surveys.Survey import Survey
+
+from edsl.questions.QuestionMultipleChoice import QuestionMultipleChoice
+from edsl.questions.QuestionFreeText import QuestionFreeText
+from edsl.auto.utilities import gen_pipeline
+from edsl.conjure.naming_utilities import sanitize_string
+
+
+m = Model()

edsl/auto/utilities.py

@@ -0,0 +1,224 @@
+from textwrap import dedent
+import random
+from typing import List, TypeVar, Generator, Optional
+from edsl.auto.StageBase import StageBase
+from edsl.conjure.naming_utilities import sanitize_string
+from edsl import Agent, Survey, Model, Cache, AgentList
+from edsl import QuestionFreeText, Scenario
+from edsl import QuestionMultipleChoice, Scenario, Agent, ScenarioList
+
+StageClassType = TypeVar("StageClassType", bound=StageBase)
+
+
+def gen_pipeline(stages_list: List[StageClassType]) -> StageBase:
+    """Takes as input a list of Stage classes & returns a pipeline of instantiated stages.
+    A pipeline is a linked list of stages where each stage has a next_stage attribute.
+
+    """
+    pipeline = stages_list[0]()
+    last_stage = pipeline
+    for stage in stages_list[1:]:
+        while last_stage.next_stage is not None:  # find the end of the pipeline
+            last_stage = last_stage.next_stage
+        stage_to_add = stage()
+        last_stage.next_stage = stage_to_add
+    return pipeline
+
+
+q_eligibility = QuestionMultipleChoice(
+    question_text=dedent(
+        """\
+        Consider this set of question: '{{ questions }}'.
+        Consider this persona: '{{ persona }}'.
+        Would this persona be able to answer all of these questions?
+        """
+    ),
+    question_options=["No", "Yes"],
+    question_name="eligibility",
+)
+
+
+def agent_list_eligibility(
+    agent_list: AgentList,
+    survey: Optional[Survey] = None,
+    model: Optional[Model] = None,
+    cache: Optional[Cache] = None,
+) -> List[bool]:
+    """
+    Returns whether each agent in a list is elgible for a survey i.e., can answer every question.
+
+    >>> from edsl.language_models import LanguageModel
+    >>> m = LanguageModel.example(canned_response = "1", test_model = True)
+    >>> agent_list_eligibility(AgentList.example())
+    [True, True]
+    >>> agent_list_eligibility(AgentList.example().add_trait('persona', 2*["Cool dude"]), survey = Survey.example(), model = m)
+    [True, True]
+    """
+    if survey is None:
+        return [True] * len(agent_list)
+    if "persona" not in agent_list.all_traits:
+        raise ValueError(
+            f"Each agent needs to have a persona attribute; traits are {agent_list.all_traits}"
+        )
+    sl = agent_list.select("persona").to_scenario_list()
+    sl.add_value("questions", [q.question_text for q in survey._questions])
+    results = q_eligibility.by(sl).by(model).run(cache=cache)
+    return [r == "Yes" for r in results.select("eligibility").to_list()]
+
+
+def agent_eligibility(
+    agent: Agent,
+    survey: Survey,
+    model: Optional[Model] = None,
+    cache: Optional[Cache] = None,
+) -> bool:
+    """NB: This could be parallelized.
+
+    >>> from edsl.language_models import LanguageModel
+    >>> m = LanguageModel.example(canned_response = "1", test_model = True)
+    >>> agent_eligibility(agent = Agent.example().add_trait({'persona': "Persona"}), survey = Survey.example(), model = m)
+    True
+
+    """
+    model = model or Model()
+
+    questions = [q.question_text for q in survey._questions]
+    persona = agent.traits["persona"]
+    return (
+        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):
+    """
+    >>> dimension_dict = {'attitude':['positive', 'negative']}
+    >>> ag = gen_agent_traits(dimension_dict)
+    >>> a = next(ag)
+    >>> a == {'attitude': 'positive'} or a == {'attitude': 'negative'}
+    True
+    >>> len([next(ag) for _ in range(100)])
+    100
+    """
+    if seed_value is None:
+        seed_value = "edsl"
+
+    random.seed(seed_value)
+
+    while True:
+        new_agent_traits = {}
+        for key, list_of_values in dimension_dict.items():
+            new_agent_traits[key] = random.choice(list_of_values)
+        yield new_agent_traits
+
+
+def agent_generator(
+    persona: str,
+    dimension_dict: dict,
+    model: Optional[Model] = None,
+    cache: Optional["Cache"] = None,
+) -> Generator["Results", None, None]:
+    """
+    >>> from edsl.language_models import LanguageModel
+    >>> m = LanguageModel.example(canned_response = "This is a cool dude.", test_model = True)
+    >>> ag = agent_generator(persona = "Base person", dimension_dict = {'attitude':['Positive', 'Negative']}, model = m)
+    >>> next(ag).select('new_agent_persona').first()
+    'This is a cool dude.'
+    >>> next(ag).select('new_agent_persona').first()
+    'This is a cool dude.'
+    """
+
+    if model is None:
+        model = Model()
+
+    q = QuestionFreeText(
+        question_text=dedent(
+            """\
+    Consider this persona: '{{ persona }}'.
+    Now imagine writing a new persona with these traits: 
+    '{{ new_agent_traits }}'
+    Please write this persona as a narrative.
+    """
+        ),
+        question_name="new_agent_persona",
+    )
+    agent_trait_generator = gen_agent_traits(dimension_dict)
+    codebook = {sanitize_string(k): k for k in dimension_dict.keys()}
+    while True:
+        new_agent_traits = next(agent_trait_generator)
+        yield q(
+            persona=persona,
+            new_agent_traits=new_agent_traits,
+            codebook=codebook,
+            just_answer=False,
+            cache=cache,
+            model=model,
+        )
+
+
+def create_agents(
+    agent_generator: Generator["Results", None, None],
+    survey: Optional[Survey] = None,
+    num_agents=11,
+) -> AgentList:
+    """
+    >>> from edsl.language_models import LanguageModel
+    >>> m = LanguageModel.example(canned_response = "This is a cool dude.", test_model = True)
+    >>> ag = agent_generator(persona = "Base person", dimension_dict = {'attitude':['Positive', 'Negative']}, model = m)
+    >>> new_agent_list = create_agents(agent_generator = ag)
+    >>> new_agent_list
+
+    """
+    agent_list = AgentList([])
+
+    MAX_ITERATIONS_MULTIPLIER = 2
+    iterations = 0
+
+    while len(agent_list) < num_agents:
+        iterations += 1
+        candidate_agent = next(agent_generator)
+        codebook = candidate_agent.select("codebook").to_list()[0]
+
+        koobedoc = {v: k for k, v in codebook.items()}
+        persona = candidate_agent.select("new_agent_persona").to_list()[0]
+        traits = candidate_agent.select("new_agent_traits").to_list()[0]
+        new_traits = {koobedoc[key]: value for key, value in traits.items()} | {
+            "persona": persona
+        }
+        agent = Agent(traits=new_traits, codebook=codebook)
+        if survey is not None:
+            if agent_eligibility(agent, survey):
+                agent_list.append(agent)
+            else:
+                print("Agent not eligible")
+        else:
+            agent_list.append(agent)
+
+        if iterations > MAX_ITERATIONS_MULTIPLIER * num_agents:
+            raise Exception("Too many failures")
+
+    return agent_list
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()
+    # from edsl.language_models import LanguageModel
+
+    # m = LanguageModel.example(canned_response="This is a cool dude.", test_model=True)
+    # ag = agent_generator(
+    #     persona="Base person",
+    #     dimension_dict={"attitude": ["Positive", "Negative"]},
+    #     model=m,
+    # )
+    # example = [next(ag).select("new_agent_persona").first() for _ in range(10)]
+    # dimension_dict = {"attitude": ["positive", "negative"]}
+    # ag = gen_agent_traits(dimension_dict)
+    # example = [next(ag) for _ in range(100)]

edsl/config.py

@@ -41,43 +41,34 @@ CONFIG_MAP = {
         "default": "5",
         "info": "This env var determines the maximum number of times to retry a failed API call.",
     },
+    "EDSL_DEFAULT_MODEL": {
+        "default": "gpt-4o",
+        "info": "This env var holds the default model name.",
+    },
+    "EDSL_SERVICE_TPM_BASELINE": {
+        "default": "2000000",
+        "info": "This env var holds the maximum number of tokens per minute for all models. Model-specific values such as EDSL_SERVICE_TPM_OPENAI will override this.",
+    },
+    "EDSL_SERVICE_RPM_BASELINE": {
+        "default": "100",
+        "info": "This env var holds the maximum number of requests per minute for OpenAI. Model-specific values such as EDSL_SERVICE_RPM_OPENAI will override this.",
+    },
+    "EDSL_SERVICE_TPM_OPENAI": {
+        "default": "2000000",
+        "info": "This env var holds the maximum number of tokens per minute for OpenAI.",
+    },
+    "EDSL_SERVICE_RPM_OPENAI": {
+        "default": "100",
+        "info": "This env var holds the maximum number of requests per minute for OpenAI.",
+    },
+    "EDSL_FETCH_TOKEN_PRICES": {
+        "default": "True",
+        "info": "Whether to fetch the prices for tokens",
+    },
     "EXPECTED_PARROT_URL": {
         "default": "https://www.expectedparrot.com",
         "info": "This env var holds the URL of the Expected Parrot API.",
     },
-    # "EXPECTED_PARROT_API_KEY": {
-    #     "default": None,
-    #     "info": "This env var holds your Expected Parrot API key (https://www.expectedparrot.com/).",
-    # },
-    # "OPENAI_API_KEY": {
-    #     "default": None,
-    #     "info": "This env var holds your OpenAI API key (https://platform.openai.com/api-keys).",
-    # },
-    # "DEEP_INFRA_API_KEY": {
-    #     "default": None,
-    #     "info": "This env var holds your DeepInfra API key (https://deepinfra.com/).",
-    # },
-    # "GOOGLE_API_KEY": {
-    #     "default": None,
-    #     "info": "This env var holds your Google API key (https://console.cloud.google.com/apis/credentials).",
-    # },
-    # "ANTHROPIC_API_KEY": {
-    #     "default": None,
-    #     "info": "This env var holds your Anthropic API key (https://www.anthropic.com/).",
-    # },
-    # "GROQ_API_KEY": {
-    #     "default": None,
-    #     "info": "This env var holds your GROQ API key (https://console.groq.com/login).",
-    # },
-    # "AWS_ACCESS_KEY_ID" :
-    #     "default": None,
-    #     "info": "This env var holds your AWS access key ID.",
-    # "AWS_SECRET_ACCESS_KEY:
-    #     "default": None,
-    #     "info": "This env var holds your AWS secret access key.",
-    # "AZURE_ENDPOINT_URL_AND_KEY":
-    #     "default": None,
-    #     "info": "This env var holds your Azure endpoint URL and key (URL:key). You can have several comma-separated URL-key pairs (URL1:key1,URL2:key2).",
 }
 
 
@@ -92,7 +83,7 @@ class Config:
 
     def _set_run_mode(self) -> None:
         """
-        Checks the validity and sets EDSL_RUN_MODE.
+        Sets EDSL_RUN_MODE as a class attribute.
         """
         run_mode = os.getenv("EDSL_RUN_MODE")
         default = CONFIG_MAP.get("EDSL_RUN_MODE").get("default")
@@ -107,27 +98,35 @@ class Config:
     def _load_dotenv(self) -> None:
         """
         Loads the .env
-        - Overrides existing env vars unless EDSL_RUN_MODE=="development-testrun"
+        - The .env will override existing env vars **unless** EDSL_RUN_MODE=="development-testrun"
         """
 
-        override = True
         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 Config class attributes.
+        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():
-            # we've set it already in _set_run_mode
+            # 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 the env var is set, set it as a CONFIG attribute
+            # 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

edsl/coop/PriceFetcher.py

@@ -0,0 +1,58 @@
+import requests
+import csv
+from io import StringIO
+
+
+class PriceFetcher:
+    _instance = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(PriceFetcher, cls).__new__(cls)
+            cls._instance._cached_prices = None
+        return cls._instance
+
+    def fetch_prices(self):
+        if self._cached_prices is not None:
+            return self._cached_prices
+
+        import requests
+        import csv
+        from io import StringIO
+
+        sheet_id = "1SAO3Bhntefl0XQHJv27rMxpvu6uzKDWNXFHRa7jrUDs"
+
+        # Construct the URL to fetch the CSV
+        url = f"https://docs.google.com/spreadsheets/d/{sheet_id}/export?format=csv"
+
+        try:
+            # Fetch the CSV data
+            response = requests.get(url)
+            response.raise_for_status()  # Raise an exception for bad responses
+
+            # Parse the CSV data
+            csv_data = StringIO(response.text)
+            reader = csv.reader(csv_data)
+
+            # Convert to list of dictionaries
+            headers = next(reader)
+            data = [dict(zip(headers, row)) for row in reader]
+
+            # self._cached_prices = data
+            # return data
+            price_lookup = {}
+            for entry in data:
+                service = entry.get("service", None)
+                model = entry.get("model", None)
+                if service and model:
+                    token_type = entry.get("token_type", None)
+                    if (service, model) in price_lookup:
+                        price_lookup[(service, model)].update({token_type: entry})
+                    else:
+                        price_lookup[(service, model)] = {token_type: entry}
+            self._cached_prices = price_lookup
+            return self._cached_prices
+
+        except requests.RequestException as e:
+            # print(f"An error occurred: {e}")
+            return {}