edsl 0.1.39.dev3__py3-none-any.whl → 0.1.39.dev5__py3-none-any.whl

edsl/questions/compose_questions.py

@@ -1,98 +1,98 @@
-"""Compose two questions where the answer to q1 is used as an input to q2."""
-
-from edsl.questions import QuestionFunctional
-from edsl.questions.QuestionBase import QuestionBase
-from edsl.scenarios.Scenario import Scenario
-
-
-def compose_questions(
-    q1: QuestionBase, q2: QuestionBase, question_name: str = None
-) -> QuestionFunctional:
-    """
-    Compose two questions where the answer to q1 is used as an input to q2.
-
-    The resulting question is a question that can be used like other questions.
-    Note that the same result can also be achieved in other ways:
-    - Using the `add_targeted_memory(q2, q1)` method in Survey
-    - Using the __add__ method in Question
-    """
-    if question_name is None:
-        question_name = f"{q1.question_name}_{q2.question_name}"
-    if q1.question_name not in q2.question_text:
-        raise ValueError(
-            f"q2 requires a field not present in q1's answer. "
-            f"q1: {q1.question_name}, q2: {q2.question_name}"
-        )
-
-    def combo(
-        scenario: Scenario, agent_traits: dict[str, str] = None
-    ) -> QuestionFunctional:
-        """Return the answer to the second question given the answer to the first question."""
-        # get the answer to the first question
-        from edsl.agents.Agent import Agent
-
-        first_answer = (
-            q1.by(scenario)
-            .by(Agent(traits=agent_traits))
-            .run()
-            .select(q1.question_name)[0]
-        )
-        # update the scenario with the answer to the first question
-        scenario.update({q1.question_name: first_answer})
-        # get the answer to the second question
-        second_answer = (
-            q2.by(scenario)
-            .by(Agent(traits=agent_traits))
-            .run()
-            .select(q2.question_name)[0]
-        )
-        return second_answer
-
-    return QuestionFunctional(
-        question_name=question_name, question_text="functional", func=combo
-    )
-
-
-# UNCOMMENT BELOW TO SEE HOW THIS WORKS
-
-# if __name__ == "__main__":
-#     from edsl.questions import QuestionFreeText, QuestionFunctional
-#     from edsl.questions.compose_questions import compose_questions
-#     from edsl.scenarios.Scenario import Scenario
-
-#     q1 = QuestionFreeText(
-#         question_text="What is the capital of {{country}}", question_name="capital"
-#     )
-#     q2 = QuestionFreeText(
-#         question_text="What is the population of {{capital}}",
-#         question_name="population",
-#     )
-#     q3 = compose_questions(q1, q2)
-
-#     jobs = q3.by(
-#         Scenario({"country": "France"}),
-#         Scenario({"country": "Germany"}),
-#         Scenario({"country": "Greece"}),
-#     )
-
-#     print("Without an agent persona")
-#     results1 = jobs.run()
-
-#     print("Adding an agent persona")
-#     results2 = jobs.by(
-#         Agent(traits={"name": "Bob, who always mentions his travel agency."})
-#     ).run()
-#     results2.select("capital_population").table()
-
-#     q1 = QuestionFreeText(
-#         question_text="What is the capital of {{country}}", question_name="capital"
-#     )
-#     q2 = QuestionFreeText(
-#         question_text="Is this {{population}} large?", question_name="population"
-#     )
-#     q3 = compose_questions(q1, q2)
-#     print("Should throw an exception:")
-#     try:
-#         q3.by(Scenario({"country": "France"})).run()
-#     except ValueError as e:
-#         print(e)
+"""Compose two questions where the answer to q1 is used as an input to q2."""
+
+from edsl.questions import QuestionFunctional
+from edsl.questions.QuestionBase import QuestionBase
+from edsl.scenarios.Scenario import Scenario
+
+
+def compose_questions(
+    q1: QuestionBase, q2: QuestionBase, question_name: str = None
+) -> QuestionFunctional:
+    """
+    Compose two questions where the answer to q1 is used as an input to q2.
+
+    The resulting question is a question that can be used like other questions.
+    Note that the same result can also be achieved in other ways:
+    - Using the `add_targeted_memory(q2, q1)` method in Survey
+    - Using the __add__ method in Question
+    """
+    if question_name is None:
+        question_name = f"{q1.question_name}_{q2.question_name}"
+    if q1.question_name not in q2.question_text:
+        raise ValueError(
+            f"q2 requires a field not present in q1's answer. "
+            f"q1: {q1.question_name}, q2: {q2.question_name}"
+        )
+
+    def combo(
+        scenario: Scenario, agent_traits: dict[str, str] = None
+    ) -> QuestionFunctional:
+        """Return the answer to the second question given the answer to the first question."""
+        # get the answer to the first question
+        from edsl.agents.Agent import Agent
+
+        first_answer = (
+            q1.by(scenario)
+            .by(Agent(traits=agent_traits))
+            .run()
+            .select(q1.question_name)[0]
+        )
+        # update the scenario with the answer to the first question
+        scenario.update({q1.question_name: first_answer})
+        # get the answer to the second question
+        second_answer = (
+            q2.by(scenario)
+            .by(Agent(traits=agent_traits))
+            .run()
+            .select(q2.question_name)[0]
+        )
+        return second_answer
+
+    return QuestionFunctional(
+        question_name=question_name, question_text="functional", func=combo
+    )
+
+
+# UNCOMMENT BELOW TO SEE HOW THIS WORKS
+
+# if __name__ == "__main__":
+#     from edsl.questions import QuestionFreeText, QuestionFunctional
+#     from edsl.questions.compose_questions import compose_questions
+#     from edsl.scenarios.Scenario import Scenario
+
+#     q1 = QuestionFreeText(
+#         question_text="What is the capital of {{country}}", question_name="capital"
+#     )
+#     q2 = QuestionFreeText(
+#         question_text="What is the population of {{capital}}",
+#         question_name="population",
+#     )
+#     q3 = compose_questions(q1, q2)
+
+#     jobs = q3.by(
+#         Scenario({"country": "France"}),
+#         Scenario({"country": "Germany"}),
+#         Scenario({"country": "Greece"}),
+#     )
+
+#     print("Without an agent persona")
+#     results1 = jobs.run()
+
+#     print("Adding an agent persona")
+#     results2 = jobs.by(
+#         Agent(traits={"name": "Bob, who always mentions his travel agency."})
+#     ).run()
+#     results2.select("capital_population").table()
+
+#     q1 = QuestionFreeText(
+#         question_text="What is the capital of {{country}}", question_name="capital"
+#     )
+#     q2 = QuestionFreeText(
+#         question_text="Is this {{population}} large?", question_name="population"
+#     )
+#     q3 = compose_questions(q1, q2)
+#     print("Should throw an exception:")
+#     try:
+#         q3.by(Scenario({"country": "France"})).run()
+#     except ValueError as e:
+#         print(e)

edsl/questions/data_structures.py

@@ -0,0 +1,20 @@
+from typing import Any, Optional, TypedDict
+from pydantic import BaseModel
+
+
+class RawEdslAnswerDict(TypedDict):
+    answer: Any
+    comment: Optional[str]
+    generated_tokens: Optional[str]
+
+
+class BaseResponse(BaseModel):
+    answer: Any
+    comment: Optional[str] = None
+    generated_tokens: Optional[str] = None
+
+
+class EdslAnswerDict(TypedDict):
+    answer: Any
+    comment: Optional[str]
+    generated_tokens: Optional[str]

edsl/questions/decorators.py

@@ -1,21 +1,21 @@
-from typing import Optional, Callable, TypeVar
-
-T = TypeVar("T")
-
-
-def inject_exception(func: Callable[..., T]) -> Callable[..., T]:
-    def wrapper(
-        cls,
-        exception_to_throw: Optional[Exception] = None,
-        override_answer: Optional[dict] = None,
-        *args,
-        **kwargs
-    ) -> T:
-        base_instance = func(cls, *args, **kwargs)
-        if exception_to_throw:
-            base_instance.exception_to_throw = exception_to_throw
-        if override_answer:
-            base_instance.override_answer = override_answer
-        return base_instance
-
-    return wrapper
+from typing import Optional, Callable, TypeVar
+
+T = TypeVar("T")
+
+
+def inject_exception(func: Callable[..., T]) -> Callable[..., T]:
+    def wrapper(
+        cls,
+        exception_to_throw: Optional[Exception] = None,
+        override_answer: Optional[dict] = None,
+        *args,
+        **kwargs
+    ) -> T:
+        base_instance = func(cls, *args, **kwargs)
+        if exception_to_throw:
+            base_instance.exception_to_throw = exception_to_throw
+        if override_answer:
+            base_instance.override_answer = override_answer
+        return base_instance
+
+    return wrapper

edsl/questions/derived/QuestionLikertFive.py

@@ -1,76 +1,76 @@
-from __future__ import annotations
-from typing import Optional
-from edsl.questions.QuestionMultipleChoice import QuestionMultipleChoice
-
-from edsl.questions.decorators import inject_exception
-
-
-class QuestionLikertFive(QuestionMultipleChoice):
-    """This question prompts the agent to respond to a statement on a 5-point Likert scale."""
-
-    question_type = "likert_five"
-    likert_options: list[str] = [
-        "Strongly disagree",
-        "Disagree",
-        "Neutral",
-        "Agree",
-        "Strongly agree",
-    ]
-
-    def __init__(
-        self,
-        question_name: str,
-        question_text: str,
-        question_options: Optional[list[str]] = likert_options,
-        answering_instructions: Optional[str] = None,
-        question_presentation: Optional[str] = None,
-        include_comment: bool = True,
-    ):
-        """Initialize the question.
-
-        :param question_name: The name of the question.
-        :param question_text: The text of the question.
-        :param question_options: The options the respondent should select from (list of strings). If not provided, the default Likert options are used (['Strongly disagree', 'Disagree', 'Neutral', 'Agree', 'Strongly agree']). To view them, run `QuestionLikertFive.likert_options`.
-        """
-        super().__init__(
-            question_name=question_name,
-            question_text=question_text,
-            question_options=question_options,
-            use_code=False,
-            include_comment=include_comment,
-            answering_instructions=answering_instructions,
-            question_presentation=question_presentation,
-        )
-
-    @classmethod
-    @inject_exception
-    def example(cls) -> QuestionLikertFive:
-        """Return an example question."""
-        return cls(
-            question_name="happy_raining",
-            question_text="I'm only happy when it rains.",
-        )
-
-
-def main():
-    """Test QuestionLikertFive."""
-    from edsl.questions.derived.QuestionLikertFive import QuestionLikertFive
-
-    q = QuestionLikertFive.example()
-    q.question_text
-    q.question_options
-    q.question_name
-    # validate an answer
-    q._validate_answer({"answer": 0, "comment": "I like custard"})
-    # translate answer code
-    q._translate_answer_code_to_answer(0, {})
-    q._simulate_answer()
-    q._simulate_answer(human_readable=False)
-    q._validate_answer(q._simulate_answer(human_readable=False))
-    # serialization (inherits from Question)
-    q.to_dict()
-    assert q.from_dict(q.to_dict()) == q
-
-    import doctest
-
-    doctest.testmod(optionflags=doctest.ELLIPSIS)
+from __future__ import annotations
+from typing import Optional
+from edsl.questions.QuestionMultipleChoice import QuestionMultipleChoice
+
+from edsl.questions.decorators import inject_exception
+
+
+class QuestionLikertFive(QuestionMultipleChoice):
+    """This question prompts the agent to respond to a statement on a 5-point Likert scale."""
+
+    question_type = "likert_five"
+    likert_options: list[str] = [
+        "Strongly disagree",
+        "Disagree",
+        "Neutral",
+        "Agree",
+        "Strongly agree",
+    ]
+
+    def __init__(
+        self,
+        question_name: str,
+        question_text: str,
+        question_options: Optional[list[str]] = likert_options,
+        answering_instructions: Optional[str] = None,
+        question_presentation: Optional[str] = None,
+        include_comment: bool = True,
+    ):
+        """Initialize the question.
+
+        :param question_name: The name of the question.
+        :param question_text: The text of the question.
+        :param question_options: The options the respondent should select from (list of strings). If not provided, the default Likert options are used (['Strongly disagree', 'Disagree', 'Neutral', 'Agree', 'Strongly agree']). To view them, run `QuestionLikertFive.likert_options`.
+        """
+        super().__init__(
+            question_name=question_name,
+            question_text=question_text,
+            question_options=question_options,
+            use_code=False,
+            include_comment=include_comment,
+            answering_instructions=answering_instructions,
+            question_presentation=question_presentation,
+        )
+
+    @classmethod
+    @inject_exception
+    def example(cls) -> QuestionLikertFive:
+        """Return an example question."""
+        return cls(
+            question_name="happy_raining",
+            question_text="I'm only happy when it rains.",
+        )
+
+
+def main():
+    """Test QuestionLikertFive."""
+    from edsl.questions.derived.QuestionLikertFive import QuestionLikertFive
+
+    q = QuestionLikertFive.example()
+    q.question_text
+    q.question_options
+    q.question_name
+    # validate an answer
+    q._validate_answer({"answer": 0, "comment": "I like custard"})
+    # translate answer code
+    q._translate_answer_code_to_answer(0, {})
+    q._simulate_answer()
+    q._simulate_answer(human_readable=False)
+    q._validate_answer(q._simulate_answer(human_readable=False))
+    # serialization (inherits from Question)
+    q.to_dict()
+    assert q.from_dict(q.to_dict()) == q
+
+    import doctest
+
+    doctest.testmod(optionflags=doctest.ELLIPSIS)

edsl/questions/derived/QuestionLinearScale.py

@@ -1,87 +1,90 @@
-from __future__ import annotations
-from typing import Optional
-
-from edsl.questions.descriptors import QuestionOptionsDescriptor, OptionLabelDescriptor
-from edsl.questions.QuestionMultipleChoice import QuestionMultipleChoice
-
-from edsl.questions.decorators import inject_exception
-
-
-class QuestionLinearScale(QuestionMultipleChoice):
-    """This question prompts the agent to respond to a statement on a linear scale."""
-
-    question_type = "linear_scale"
-    option_labels: Optional[dict[int, str]] = OptionLabelDescriptor()
-    question_options = QuestionOptionsDescriptor(linear_scale=True)
-
-    def __init__(
-        self,
-        question_name: str,
-        question_text: str,
-        question_options: list[int],
-        option_labels: Optional[dict[int, str]] = None,
-        answering_instructions: Optional[str] = None,
-        question_presentation: Optional[str] = None,
-        include_comment: Optional[bool] = True,
-    ):
-        """Instantiate a new QuestionLinearScale.
-
-        :param question_name: The name of the question.
-        :param question_text: The text of the question.
-        :param question_options: The options the respondent should select from.
-        :param option_labels: Maps question_options to labels.
-        :param instructions: Instructions for the question. If not provided, the default instructions are used. To view them, run `QuestionLinearScale.default_instructions`.
-        """
-        super().__init__(
-            question_name=question_name,
-            question_text=question_text,
-            question_options=question_options,
-            use_code=False,  # question linear scale will have it's own code
-            include_comment=include_comment,
-        )
-        self.question_options = question_options
-        self.option_labels = (
-            {int(k): v for k, v in option_labels.items()} if option_labels else {}
-        )
-        self.answering_instructions = answering_instructions
-        self.question_presentation = question_presentation
-
-    ################
-    # Helpful
-    ################
-    @classmethod
-    @inject_exception
-    def example(cls, include_comment: bool = True) -> QuestionLinearScale:
-        """Return an example of a linear scale question."""
-        return cls(
-            question_text="How much do you like ice cream?",
-            question_options=[1, 2, 3, 4, 5],
-            question_name="ice_cream",
-            option_labels={1: "I hate it", 5: "I love it"},
-            include_comment=include_comment,
-        )
-
-
-def main():
-    """Create an example of a linear scale question and demonstrate its functionality."""
-    from edsl.questions.derived.QuestionLinearScale import QuestionLinearScale
-
-    q = QuestionLinearScale.example()
-    q.question_text
-    q.question_options
-    q.question_name
-    # validate an answer
-    q._validate_answer({"answer": 3, "comment": "I like custard"})
-    # translate answer code
-    q._translate_answer_code_to_answer(3, {})
-    # simulate answer
-    q._simulate_answer()
-    q._simulate_answer(human_readable=False)
-    q._validate_answer(q._simulate_answer(human_readable=False))
-    # serialization (inherits from Question)
-    q.to_dict()
-    assert q.from_dict(q.to_dict()) == q
-
-    import doctest
-
-    doctest.testmod(optionflags=doctest.ELLIPSIS)
+from __future__ import annotations
+from typing import Optional
+
+from edsl.questions.descriptors import QuestionOptionsDescriptor, OptionLabelDescriptor
+from edsl.questions.QuestionMultipleChoice import QuestionMultipleChoice
+
+from edsl.questions.decorators import inject_exception
+
+
+class QuestionLinearScale(QuestionMultipleChoice):
+    """This question prompts the agent to respond to a statement on a linear scale."""
+
+    question_type = "linear_scale"
+    option_labels: Optional[dict[int, str]] = OptionLabelDescriptor()
+    question_options = QuestionOptionsDescriptor(linear_scale=True)
+
+    def __init__(
+        self,
+        question_name: str,
+        question_text: str,
+        question_options: list[int],
+        option_labels: Optional[dict[int, str]] = None,
+        answering_instructions: Optional[str] = None,
+        question_presentation: Optional[str] = None,
+        include_comment: Optional[bool] = True,
+    ):
+        """Instantiate a new QuestionLinearScale.
+
+        :param question_name: The name of the question.
+        :param question_text: The text of the question.
+        :param question_options: The options the respondent should select from.
+        :param option_labels: Maps question_options to labels.
+        :param instructions: Instructions for the question. If not provided, the default instructions are used. To view them, run `QuestionLinearScale.default_instructions`.
+        """
+        super().__init__(
+            question_name=question_name,
+            question_text=question_text,
+            question_options=question_options,
+            use_code=False,  # question linear scale will have it's own code
+            include_comment=include_comment,
+        )
+        self.question_options = question_options
+        if isinstance(option_labels, str):
+            self.option_labels = option_labels
+        else:
+            self.option_labels = (
+                {int(k): v for k, v in option_labels.items()} if option_labels else {}
+            )
+        self.answering_instructions = answering_instructions
+        self.question_presentation = question_presentation
+
+    ################
+    # Helpful
+    ################
+    @classmethod
+    @inject_exception
+    def example(cls, include_comment: bool = True) -> QuestionLinearScale:
+        """Return an example of a linear scale question."""
+        return cls(
+            question_text="How much do you like ice cream?",
+            question_options=[1, 2, 3, 4, 5],
+            question_name="ice_cream",
+            option_labels={1: "I hate it", 5: "I love it"},
+            include_comment=include_comment,
+        )
+
+
+def main():
+    """Create an example of a linear scale question and demonstrate its functionality."""
+    from edsl.questions.derived.QuestionLinearScale import QuestionLinearScale
+
+    q = QuestionLinearScale.example()
+    q.question_text
+    q.question_options
+    q.question_name
+    # validate an answer
+    q._validate_answer({"answer": 3, "comment": "I like custard"})
+    # translate answer code
+    q._translate_answer_code_to_answer(3, {})
+    # simulate answer
+    q._simulate_answer()
+    q._simulate_answer(human_readable=False)
+    q._validate_answer(q._simulate_answer(human_readable=False))
+    # serialization (inherits from Question)
+    q.to_dict()
+    assert q.from_dict(q.to_dict()) == q
+
+    import doctest
+
+    doctest.testmod(optionflags=doctest.ELLIPSIS)