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

edsl/auto/StageGenerateSurvey.py

@@ -1,178 +0,0 @@
-from textwrap import dedent
-from dataclasses import dataclass
-from collections import defaultdict
-
-from typing import List, Dict
-
-from edsl.auto.StageBase import StageBase
-from edsl.auto.utilities import gen_pipeline
-from edsl.auto.StageBase import FlowDataBase
-
-from edsl.auto.StageQuestions import StageQuestions
-from edsl.auto.StageLabelQuestions import StageLabelQuestions
-
-from edsl.questions import QuestionList
-from edsl.scenarios import Scenario
-from edsl import Model
-from edsl.surveys import Survey
-from edsl.questions import QuestionBase
-
-from edsl.utilities.utilities import is_valid_variable_name
-from edsl import Model
-from edsl.questions import QuestionExtract
-
-
-m = Model()
-
-
-def chunker(seq, size):
-    return (seq[pos : pos + size] for pos in range(0, len(seq), size))
-
-
-def get_short_options(question_options, num_chars=20):
-    """Gets short names for the options of a question
-    >>> get_short_options(["No, I don't own a scooter", "Yes, I own a scooter"])
-    {'No, I don\'t own a scooter': 'no_scooter', 'Yes, I own a scooter': 'yes_scooter'}
-    """
-    q = QuestionList(
-        question_text=dedent(
-            f"""\
-            We need short (less than {num_chars} characters) names for the options of a question, with no spaces.
-            E.g., if the options were "No, I don't own a scooter" and "Yes, I own a scooter", 
-            you could use "no_scooter" and "yes_scooter".
-            They should be all lower case. Use snake case.
-            The short names have to be unique.
-            The options are: {question_options}
-            The names are {question_options} of them."""
-        ),
-        # answer_template={k: None for k in question_options},
-        question_name="short_options",
-    )
-    results = q.by(m).run()
-    return results.select("short_options").first()
-
-
-def get_short_names_chunk(questions, num_chars=20):
-    q = QuestionList(
-        question_text=dedent(
-            f"""\
-            We need short (less than {num_chars} characters) names for the questions, with no spaces.
-            E.g., if the question was: "What is your first name?", you could use "first_name".
-            The short names have to be unique and not starting with numbers. They should be all lower case.
-            The questions are: {questions}
-            """
-        ),
-        question_name="short_names",
-    )
-    results = q.by(m).run()
-    short_names = results.select("short_names").first()
-    return {k: v for k, v in zip(questions, short_names)}
-
-
-def get_short_names(questions, max_size=10, num_chars=20):
-    "Gets short names for questions"
-    if len(questions) <= max_size:
-        short_names_dict = get_short_names_chunk(questions, num_chars)
-    else:
-        short_names_dict = {}
-        for chunk in chunker(questions, max_size):
-            results = get_short_names_chunk(chunk, num_chars)
-            short_names_dict.update(results)
-    return short_names_dict
-
-
-class StageGenerateSurvey(StageBase):
-    input = StageLabelQuestions.output
-
-    @dataclass
-    class Output(FlowDataBase):
-        survey: Survey
-
-    output = Output
-
-    def handle_data(self, data):
-        """This tage uses the question types to generate a survey
-        It constucts the edsl-specific dictionary needed to create a question
-        """
-        # survey = Survey(name = {data.overall_question, population = data.population, description)
-        survey = Survey()
-
-        short_names = get_short_names(data.questions)
-
-        question_count = -1
-        for question, question_type, options, option_labels in zip(
-            data.questions, data.types, data.options, data.option_labels
-        ):
-            question_count += 1
-            short_names_dict = {}
-            if question in short_names:
-                short_names_dict[question] = short_names[question]
-            data = {
-                "question_text": question,
-                "question_type": question_type,
-                "question_name": short_names.get(question, f"q{question_count}"),
-            }
-            if options is not None:
-                data["question_options"] = options
-                # make sure it's not a linear scale question, in which case we don't want to add short names
-
-            if option_labels is not None:
-                data["option_labels"] = dict(zip(options, option_labels))
-                # print(data["option_labels"])
-                # breakpoint()
-
-            if question_type == "linear_scale":
-                option_keys = option_labels
-            else:
-                option_keys = options
-
-            if options is not None:
-                short_options = get_short_options(option_keys)
-                short_names_dict.update(
-                    {k: v for k, v in zip(option_keys, short_options)}
-                )
-
-            if question_type not in ["numerical", "free_text"]:
-                data["short_names_dict"] = short_names_dict
-            _ = data.pop("short_names_dict", None)
-            q = QuestionBase.from_dict(data)
-            survey.add_question(q)
-
-        survey.print()
-        return self.output(survey=survey)
-
-
-if __name__ == "__main__":
-    # pipeline = gen_pipeline([StageQuestions, StageLabelQuestions, StageGenerateSurvey])
-
-    # results = pipeline.process(
-    #     pipeline.input(
-    #         overall_question="What are some factors that could determine whether someone likes ice cream?",
-    #         population="consumers",
-    #     )
-    # )
-    # # print(results)
-    # short_options = get_short_options(
-    #     ["No, I don't own a scooter", "Yes, I own a scooter"]
-    # )
-    # print(short_options)
-
-    sample_questions = [
-        "What are the primary goals for your company in sponsoring a research center like the MIT IDE?",
-        "How does your company measure the ROI on sponsorships like this?",
-        "What specific aspects of the MIT IDEs work align with your companys strategic interests?",
-        "Can you describe the decision-making process your company uses to select research initiatives for sponsorship?",
-        "What are the most important factors your company considers when deciding to sponsor a research center?",
-        "How important is the visibility and recognition your company receives from sponsoring a research center like the MIT IDE?",
-        "What kind of collaborative opportunities with the MIT IDE are you looking for?",
-        "What are your companys expectations regarding intellectual property and the commercialization of research outcomes?",
-        "How does your company evaluate the success of the research projects it sponsors?",
-        "Would your company be interested in engaging with students or faculty at the MIT IDE for recruitment or professional development opportunities?",
-        "How does your company plan to leverage the research and insights gained from the MIT IDE?",
-        "What challenges has your company faced in previous sponsorships that you would want to avoid in the future?",
-        "Is there any additional support or involvement your company would like to have in the MIT IDE beyond financial sponsorship?",
-        "How do you see your companys role in shaping the research agenda at the MIT IDE?",
-        "What can the MIT IDE do to make its sponsorship opportunities more attractive to your company?",
-    ]
-
-    short_names = get_short_names(sample_questions)

edsl/auto/StageLabelQuestions.py

@@ -1,125 +0,0 @@
-from textwrap import dedent
-from dataclasses import dataclass
-from collections import defaultdict
-
-from typing import List, Dict, Union
-
-from edsl.auto.StageBase import StageBase
-from edsl.auto.StageBase import FlowDataBase
-
-from edsl.auto.StageQuestions import StageQuestions
-
-from edsl.questions import QuestionMultipleChoice, QuestionList
-from edsl.scenarios import Scenario
-from edsl import Model
-from edsl.auto.utilities import gen_pipeline
-
-
-question_purpose = {
-    "multiple_choice": "When options are known and limited",
-    "free_text": "When we are asking an open-ended question",
-    "checkbox": "When multiple options can be selected e.g., have you heard of the following products:",
-    "numerical": "When the answer is a single numerical value e.g., a float",
-    "linear_scale": "When options are text like multiple choice, but can be ordered e.g., daily, weekly, monthly, etc.",
-    "yes_no": "When the question can be fully answered with either a yes or a no",
-}
-
-
-class StageLabelQuestions(StageBase):
-    input = StageQuestions.output
-
-    @dataclass
-    class Output(FlowDataBase):
-        questions: List[str]
-        types: List[str]
-        options: Dict[str, List[str]]
-        option_labels: Dict[str, Union[List[str], None]]
-
-    output = Output
-
-    def handle_data(self, data):
-        """
-        Labels each edsl question type. This is then used later to instantiate the questions
-        """
-        m = Model()
-        label_questions_scenarios = [
-            Scenario({"question": q, "question_purpose": question_purpose})
-            for q in data.questions
-        ]
-        q_type = QuestionMultipleChoice(
-            question_text=dedent(
-                """\
-        Consider this question: "{{ question }}"
-        The question options and purpose are: {{ question_purpose }}
-        Please avoid free text questions much as possible. 
-        If it could be a multiple choice, use that type.
-        What type of question should this be to make for an informative survey?"""
-            ),
-            question_options=list(question_purpose.keys()),
-            question_name="question_type",
-        )
-        ## If it is a linear scale, multiple choice or checkbox question, we need to know the options
-        option_questions = [
-            "multiple_choice",
-            "linear_scale",
-            "checkbox",
-        ]
-        q_options_mc = QuestionList(
-            question_text=dedent(
-                """\
-            Consider this question: "{{ question }}"
-            What options should this question have?"""
-            ),
-            question_name="mc_options",
-        )
-        survey = q_type.add_question(q_options_mc).add_stop_rule(
-            "question_type", f"question_type not in {option_questions}"
-        )
-        type_results = survey.by(label_questions_scenarios).by(m).run()
-        type_results.select("question", "question_type", "mc_options").print()
-
-        # breakpoint()
-
-        question_types = type_results.select("question_type").to_list()
-        options = type_results.select("mc_options").to_list()
-        # question_types, options = type_results.select(
-        #    "question_type", "mc_options"
-        # ).to_list()
-
-        type_results.select("question", "question_type", "mc_options").print()
-
-        # if the question is a yes/no question, we need to set the options to be yes/no
-        types_to_questions = defaultdict(list)
-        for question_type, question in zip(question_types, data.questions):
-            types_to_questions[question_type].append(question)
-
-        questions_to_options = dict(zip(data.questions, options))
-        question_to_option_labels = dict(
-            zip(data.questions, len(data.questions) * [None])
-        )
-        for question in types_to_questions.get("yes_no", []):
-            questions_to_options[question] = ["Yes", "No"]
-
-        for question in types_to_questions.get("linear_scale", []):
-            options = questions_to_options[question]
-            questions_to_options[question] = list(range(len(options)))
-            question_to_option_labels[question] = options
-
-        return self.output(
-            questions=data.questions,
-            types=question_types,
-            options=list(questions_to_options.values()),
-            option_labels=list(question_to_option_labels.values()),
-        )
-
-
-if __name__ == "__main__":
-    pipeline = gen_pipeline([StageQuestions, StageLabelQuestions])
-
-    results = pipeline.process(
-        pipeline.input(
-            overall_question="What are some factors that could determine whether someone likes ice cream?"
-        )
-    )
-
-    print(results.options)

edsl/auto/StagePersona.py

@@ -1,61 +0,0 @@
-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 import Model
-from edsl.auto.StageQuestions import StageQuestions
-
-from edsl.questions import QuestionFreeText
-from edsl.scenarios import Scenario
-
-from edsl.auto.utilities import gen_pipeline
-
-
-class StagePersona(StageBase):
-    input = StageQuestions.output
-
-    @dataclass
-    class Output(FlowDataBase):
-        persona: str
-        questions: List[str]
-
-    output = Output
-
-    def handle_data(self, data):
-        m = Model()
-        q_persona = QuestionFreeText(
-            question_text=dedent(
-                """\
-        Imagine a person from the population {{ population }} responding to these questions: "{{ questions }}"
-        Make up a 1 paragraph persona for this person who would have answers for these questions.
-        """
-            ),
-            question_name="persona",
-        )
-        results = (
-            q_persona.by(m)
-            .by(Scenario({"questions": data.questions, "population": data.population}))
-            .run()
-        )
-        print("Constructing a persona that could answer the following questions:")
-        print(data.questions)
-        results.select("persona").print(
-            pretty_labels={
-                "answer.persona": f"Persona that can answer: {data.questions}"
-            },
-            split_at_dot=False,
-        )
-        persona = results.select("persona").first()
-        return self.output(persona=persona, questions=data.questions)
-
-
-if __name__ == "__main__":
-    pipeline = gen_pipeline([StageQuestions, StagePersona])
-    pipeline.process(
-        pipeline.input(
-            overall_question="What are some factors that could determine whether someone likes ice cream?",
-            persona="People",
-        )
-    )

edsl/auto/StagePersonaDimensionValueRanges.py

@@ -1,88 +0,0 @@
-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.StagePersonaDimensionValues import StagePersonaDimensionValues
-
-from edsl.questions import QuestionList
-from edsl.scenarios import Scenario
-from edsl import Model
-from edsl.auto.utilities import gen_pipeline
-
-
-class StagePersonaDimensionValueRanges(StageBase):
-    input = StagePersonaDimensionValues.output
-
-    @dataclass
-    class Output(FlowDataBase):
-        focal_dimension_values: List[dict]
-        mapping: dict
-        persona: str
-
-    output = Output
-
-    def handle_data(self, data):
-        # breakpoint()
-        """Goal with this stage is to, for each dimension, get a range of values that the persona might have for that dimension."""
-        dimension_values = data["dimension_values"]
-        attribute_results = data["attribute_results"]
-        persona = data["persona"]
-        m = Model()
-        d = dict(zip(attribute_results, dimension_values))
-        q = QuestionList(
-            question_text=dedent(
-                """\
-            Consider the following persona: {{ persona }}.
-            They were categorized as having the following attributes: {{ d }}.
-            For this dimension: {{ focal_dimension }}, 
-            What are values that other people might have on this attribute?
-            """
-            ),
-            question_name="focal_dimension_values",
-        )
-        s = [
-            Scenario({"persona": persona, "d": d, "focal_dimension": k})
-            for k in d.keys()
-        ]
-        results = q.by(s).by(m).run()
-        # breakpoint()
-        results.select("focal_dimension", "answer.*").print(
-            pretty_labels={
-                "scenario.focal_dimension": f"Dimensions of a persona",
-                "answer.focal_dimension_values": f"Values a person might have for that dimension",
-            },
-            split_at_dot=False,
-        )
-
-        focal_dimension_values = results.select("focal_dimension_values").to_list()
-        mapping = dict(zip(attribute_results, focal_dimension_values))
-        return self.output(
-            focal_dimension_values=focal_dimension_values,
-            mapping=mapping,
-            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,
-            StagePersonaDimensionValueRanges,
-        ]
-    )
-    pipeline.process(
-        pipeline.input(
-            overall_question="What are some factors that could determine whether someone likes ice cream?"
-        )
-    )

edsl/auto/StagePersonaDimensionValues.py

@@ -1,74 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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",
-        )
-    )
-
-    results = StageQuestions.func(
-        overall_question="Why aren't my students studying more?", population="Tech"
-    )

edsl/auto/SurveyCreatorPipeline.py

@@ -1,21 +0,0 @@
-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.utilities.naming_utilities import sanitize_string
-
-
-m = Model()