edsl 0.1.15__py3-none-any.whl → 0.1.40__py3-none-any.whl

edsl/auto/StageBase.py

@@ -0,0 +1,243 @@
+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
+
+
+class ExceptionPipesDoNotFit(Exception):
+    pass
+
+
+class StageProcessingClosure:
+    def __init__(self, stage_func: Callable, reduction_func=lambda x: x):
+        self.data = []
+        self.stage_func = stage_func
+        # reduction function is applied to self.data when complete
+        # it might just return the list, or it might do something more complicated such as
+        # reduce the list to a dictionary
+        self.reduction_func = reduction_func
+
+    def func(self, obj: "FlowDataBase") -> None:
+        "Function to apply to each stage"
+        self.data.append(self.stage_func(obj))
+
+    def __call__(self):
+        return self.reduction_func(self.data)
+
+
+@dataclass
+class FlowDataBase:
+    """Base class for dataclasses that are passed between stages."""
+
+    _: KW_ONLY
+    # previous_stage: Dict = field(default_factory=dict)
+    previous_stage: Any = None
+    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)
+
+    def __setitem__(self, key, value):
+        """Allows dictionary-style setting."""
+        return setattr(self, key, value)
+
+    def current_values(self):
+        """Returns a dictionary of the current values of the dataclass"""
+        to_exclude = ["sent_to_stage_name", "came_from_stage_name", "previous_stage"]
+        d = asdict(self)
+        [d.pop(key) for key in to_exclude]
+        return d
+
+    def stage_input_output(self):
+        return {
+            "came_from": self.came_from_stage_name,
+            "sent_to": self.sent_to_stage_name,
+        }
+
+    def _align_values_with_padding(
+        self, stages
+    ) -> Generator[Dict[str, str], None, None]:
+        "Pads out the the names of the stages so they are aligned when printing"
+
+        def longest_value(stage):
+            return max([len(v) for v in stage.values()])
+
+        max_length = max([longest_value(stage) for stage in stages])
+        for stage in stages:
+            new_stage = {k: v.ljust(max_length) for k, v in stage.items()}
+            yield new_stage
+
+    def _reduce(self, stage_processor: StageProcessingClosure) -> Dict[str, dict]:
+        """Applies some function defined in stage_processor to each stage in the chain, working from back to front
+
+        The stage_processor will record the results of the function applied to each stage in
+        an instance of the StageProcessingClosure class.
+        The results can be accessed by calling the StageProcessingClosure instance.
+        This somewhat convoluted approach is necessary because the stages are connected in a chain and
+        we want a way to access the results of the function applied to each stage in the chain without
+        writing the while-loop over and over again.
+        """
+        stage_processor.func(self)
+        current_pipe = self
+        while True:
+            if current_pipe.previous_stage is None:
+                break
+            else:
+                current_pipe = current_pipe.previous_stage
+                stage_processor.func(
+                    current_pipe
+                )  # the result is getting stored in stage_processor.data
+
+    def combined_results(self) -> Dict[str, dict]:
+        stage_processor = StageProcessingClosure(
+            stage_func=lambda obj: obj.current_values(),
+            reduction_func=lambda x: {k: v for d in x for k, v in d.items()},
+        )
+        self._reduce(stage_processor)
+        return stage_processor()
+
+    def flow_history(self):
+        stage_processor = StageProcessingClosure(
+            stage_func=lambda obj: obj.stage_input_output()
+        )
+        self._reduce(stage_processor)
+        return stage_processor()
+
+    def visualize_flow(self) -> str:
+        """Visualize the flow of data through the chain"""
+        stages = self.flow_history()
+        new_stages = list(self._align_values_with_padding(stages))
+        new_stages.reverse()
+        return tuple(new_stages)
+
+
+class StageBase(ABC):
+    input: FlowDataBase = NotImplemented
+    output: FlowDataBase = NotImplemented
+
+    def __init__(self, **kwargs):
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+
+        if hasattr(self, "next_stage"):
+            self._validate_connection(self.next_stage)
+        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."
+        input_data = cls.input(**kwargs)
+        return cls().process(input_data)
+
+    @abstractmethod
+    def handle_data(self, data):
+        "This implements how the stage actually handles the passed in data"
+        raise NotImplementedError
+
+    def _validate_connection(self, stage):
+        "Checks that the outputs of the first stage match the inputs of the second stage"
+        if not self.output == stage.input:
+            raise ExceptionPipesDoNotFit(
+                textwrap.dedent(
+                    f"""\
+        Stage \"{self.__class__.__name__}\" cannot be connected to stage \"{stage.__class__.__name__}\".
+        The outputs of the first stage {self.output} do not match the inputs of the second stage, {stage.input}."""
+                )
+            )
+
+    def __init_subclass__(cls, **kwargs):
+        "Checks that the subclass has the required class variables of input & output"
+        super().__init_subclass__(**kwargs)
+        if cls.input is NotImplemented:
+            raise NotImplementedError(
+                f"Class {cls.__name__} lacks required class variable 'inputs'"
+            )
+        if cls.output is NotImplemented:
+            raise NotImplementedError(
+                f"Class {cls.__name__} lacks required class variable 'outputs'"
+            )
+
+    def process(self, data):
+        print(f"Running stage: {self.__class__.__name__}")
+        data.sent_to_stage_name = self.__class__.__name__
+        processed_data = self.handle_data(data)
+        processed_data.came_from_stage_name = self.__class__.__name__
+        processed_data.previous_stage = data
+        if self.next_stage:
+            return self.next_stage.process(processed_data)
+        else:
+            return processed_data
+
+
+if __name__ == "__main__":
+    pass
+    # try:
+
+    #     class StageMissing(StageBase):
+    #         def handle_data(self, data):
+    #             return data
+
+    # except NotImplementedError as e:
+    #     print(e)
+    # else:
+    #     raise Exception("Should have raised NotImplementedError")
+
+    # try:
+
+    #     class StageMissingInput(StageBase):
+    #         output = FlowDataBase
+
+    # except NotImplementedError as e:
+    #     print(e)
+
+    # else:
+    #     raise Exception("Should have raised NotImplementedError")
+
+    # @dataclass
+    # class MockInputOutput(FlowDataBase):
+    #     text: str
+
+    # class StageTest(StageBase):
+    #     input = MockInputOutput
+    #     output = MockInputOutput
+
+    #     def handle_data(self, data):
+    #         return self.output(text=data["text"] + "processed")
+
+    # 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)
+
+    # class BadMockInput(FlowDataBase):
+    #     text: str
+    #     other: str
+
+    # class StageBad(StageBase):
+    #     input = BadMockInput
+    #     output = BadMockInput
+
+    #     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)

edsl/auto/StageGenerateSurvey.py

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

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

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

@@ -0,0 +1,88 @@
+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?"
+        )
+    )