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

edsl/auto/AutoStudy.py

@@ -1,130 +0,0 @@
-from typing import Optional, TYPE_CHECKING
-
-from edsl import Model
-from edsl.auto.StageQuestions import StageQuestions
-from edsl.auto.StagePersona import StagePersona
-from edsl.auto.StagePersonaDimensions import StagePersonaDimensions
-from edsl.auto.StagePersonaDimensionValues import StagePersonaDimensionValues
-from edsl.auto.StagePersonaDimensionValueRanges import (
-    StagePersonaDimensionValueRanges,
-)
-from edsl.auto.StageLabelQuestions import StageLabelQuestions
-from edsl.auto.StageGenerateSurvey import StageGenerateSurvey
-
-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__(
-        self,
-        overall_question: str,
-        population: str,
-        model: Optional["Model"] = None,
-        survey: Optional["Survey"] = None,
-        agent_list: Optional["AgentList"] = None,
-        default_num_agents: int = 11,
-    ):
-        """AutoStudy class for generating surveys and agents."""
-
-        self.overall_question = overall_question
-        self.population = population
-        self._survey = survey
-        self._agent_list = agent_list
-        self._agent_list_generator = None
-        self._persona_mapping = None
-        self._results = None
-        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:
-            self._survey = self._create_survey()
-        return self._survey
-
-    @property
-    def persona_mapping(self):
-        if self._persona_mapping is None:
-            self._persona_mapping = self._create_persona_mapping()
-        return self._persona_mapping
-
-    @property
-    def agent_list_generator(self):
-        if self._agent_list_generator is None:
-            self._agent_list_generator = self._create_agent_list_generator()
-        return self._agent_list_generator
-
-    @property
-    def results(self):
-        if self._results is None:
-            self._results = self._create_results()
-        return self._results
-
-    def _create_survey(self):
-        survey_pipline_stages = [
-            StageQuestions,
-            StageLabelQuestions,
-            StageGenerateSurvey,
-        ]
-        survey_pipeline = gen_pipeline(survey_pipline_stages)
-        return survey_pipeline.process(
-            data=survey_pipeline.input(
-                overall_question=self.overall_question, population=self.population
-            )
-        ).survey
-
-    def _create_persona_mapping(self):
-        persona_pipeline_stages = [
-            StageQuestions,
-            StagePersona,
-            StagePersonaDimensions,
-            StagePersonaDimensionValues,
-            StagePersonaDimensionValueRanges,
-        ]
-
-        persona_pipeline = gen_pipeline(persona_pipeline_stages)
-        sample_agent_results = persona_pipeline.process(
-            persona_pipeline.input(
-                overall_question=overall_question, population=self.population
-            )
-        )
-        return sample_agent_results
-
-    def _create_agent_list_generator(self):
-        return agent_generator(
-            persona=self.persona_mapping.persona,
-            dimension_dict=self.persona_mapping.mapping,
-        )
-
-    def agent_list(self, num_agents):
-        return create_agents(
-            agent_generator=self.agent_list_generator,
-            survey=self.survey,
-            num_agents=num_agents,
-        )
-
-    def _create_results(self, num_agents=None):
-        if num_agents is None:
-            num_agents = self.default_num_agents
-        agent_list = self.agent_list(num_agents)
-        return self.survey.by(agent_list).by(self.model).run()
-
-
-if __name__ == "__main__":
-    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,243 +0,0 @@
-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

@@ -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)