edsl 0.1.36.dev6__py3-none-any.whl → 0.1.37__py3-none-any.whl

edsl/auto/StagePersona.py

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