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

edsl/questions/SimpleAskMixin.py

@@ -1,73 +1,73 @@
-from rich.table import Table
-from rich.console import Console
-import math
-
-
-def logprob_to_prob(logprob):
-    if logprob is None:
-        return None
-    return math.exp(logprob)
-
-
-def format_output(data):
-    content = data["choices"][0]["logprobs"]["content"]
-    table = Table(show_header=True, header_style="bold magenta")
-
-    # First pass to determine the maximum number of top tokens
-    max_tokens = max(len(item["top_logprobs"]) for item in content)
-
-    # Set up the table columns
-    table.add_column("Token", style="bold")
-    for i in range(max_tokens):
-        table.add_column(f"Top Token {i+1}")
-
-    for item in content:
-        token = item["token"].strip()
-        top_tokens = [
-            (top["token"].strip(), logprob_to_prob(top.get("logprob")))
-            for top in item["top_logprobs"]
-        ]
-
-        # Row data starts with the main token
-        row = [token]
-
-        # Add each top token with coloring based on probability
-        for token, probability in top_tokens:
-            if probability is not None:
-                # Assign color based on probability value
-                if probability > 0.5:
-                    color = "green"
-                elif probability > 0.2:
-                    color = "yellow"
-                else:
-                    color = "red"
-                formatted_token = f"[{color}]{token} ({probability:.2f})[/]"
-            else:
-                formatted_token = f"{token} (N/A)"
-            row.append(formatted_token)
-
-        # Ensure row has enough columns
-        while len(row) < max_tokens + 1:
-            row.append("")
-
-        table.add_row(*row)
-
-    console = Console()
-    console.print(table)
-
-
-class SimpleAskMixin:
-    # def simple_ask(self, question: QuestionBase, system_prompt = "You are a helpful agent pretending to be a human.", top_logprobs = 2):
-
-    def simple_ask(
-        self,
-        model=None,
-        system_prompt="You are a helpful agent pretending to be a human. Do not break character",
-        top_logprobs=4,
-    ):
-        from edsl import Model
-
-        if model is None:
-            model = Model()
-        response = model.simple_ask(self, system_prompt, top_logprobs)
-        return format_output(response)
+from rich.table import Table
+from rich.console import Console
+import math
+
+
+def logprob_to_prob(logprob):
+    if logprob is None:
+        return None
+    return math.exp(logprob)
+
+
+def format_output(data):
+    content = data["choices"][0]["logprobs"]["content"]
+    table = Table(show_header=True, header_style="bold magenta")
+
+    # First pass to determine the maximum number of top tokens
+    max_tokens = max(len(item["top_logprobs"]) for item in content)
+
+    # Set up the table columns
+    table.add_column("Token", style="bold")
+    for i in range(max_tokens):
+        table.add_column(f"Top Token {i+1}")
+
+    for item in content:
+        token = item["token"].strip()
+        top_tokens = [
+            (top["token"].strip(), logprob_to_prob(top.get("logprob")))
+            for top in item["top_logprobs"]
+        ]
+
+        # Row data starts with the main token
+        row = [token]
+
+        # Add each top token with coloring based on probability
+        for token, probability in top_tokens:
+            if probability is not None:
+                # Assign color based on probability value
+                if probability > 0.5:
+                    color = "green"
+                elif probability > 0.2:
+                    color = "yellow"
+                else:
+                    color = "red"
+                formatted_token = f"[{color}]{token} ({probability:.2f})[/]"
+            else:
+                formatted_token = f"{token} (N/A)"
+            row.append(formatted_token)
+
+        # Ensure row has enough columns
+        while len(row) < max_tokens + 1:
+            row.append("")
+
+        table.add_row(*row)
+
+    console = Console()
+    console.print(table)
+
+
+class SimpleAskMixin:
+    # def simple_ask(self, question: QuestionBase, system_prompt = "You are a helpful agent pretending to be a human.", top_logprobs = 2):
+
+    def simple_ask(
+        self,
+        model=None,
+        system_prompt="You are a helpful agent pretending to be a human. Do not break character",
+        top_logprobs=4,
+    ):
+        from edsl import Model
+
+        if model is None:
+            model = Model()
+        response = model.simple_ask(self, system_prompt, top_logprobs)
+        return format_output(response)

edsl/questions/__init__.py

@@ -1,26 +1,26 @@
-# Schemas
-from edsl.questions.settings import Settings
-from edsl.questions.RegisterQuestionsMeta import RegisterQuestionsMeta
-
-# Base Class
-from edsl.questions.QuestionBase import QuestionBase
-
-# Core Questions
-from edsl.questions.QuestionCheckBox import QuestionCheckBox
-from edsl.questions.QuestionExtract import QuestionExtract
-from edsl.questions.QuestionFreeText import QuestionFreeText
-from edsl.questions.QuestionFunctional import QuestionFunctional
-from edsl.questions.QuestionList import QuestionList
-from edsl.questions.QuestionMultipleChoice import QuestionMultipleChoice
-from edsl.questions.QuestionNumerical import QuestionNumerical
-from edsl.questions.QuestionBudget import QuestionBudget
-from edsl.questions.QuestionRank import QuestionRank
-
-# # # Questions derived from core questions
-from edsl.questions.derived.QuestionLikertFive import QuestionLikertFive
-from edsl.questions.derived.QuestionLinearScale import QuestionLinearScale
-from edsl.questions.derived.QuestionYesNo import QuestionYesNo
-from edsl.questions.derived.QuestionTopK import QuestionTopK
-
-# # Compose Questions
-# from edsl.questions.compose_questions import compose_questions
+# Schemas
+from edsl.questions.settings import Settings
+from edsl.questions.RegisterQuestionsMeta import RegisterQuestionsMeta
+
+# Base Class
+from edsl.questions.QuestionBase import QuestionBase
+
+# Core Questions
+from edsl.questions.QuestionCheckBox import QuestionCheckBox
+from edsl.questions.QuestionExtract import QuestionExtract
+from edsl.questions.QuestionFreeText import QuestionFreeText
+from edsl.questions.QuestionFunctional import QuestionFunctional
+from edsl.questions.QuestionList import QuestionList
+from edsl.questions.QuestionMultipleChoice import QuestionMultipleChoice
+from edsl.questions.QuestionNumerical import QuestionNumerical
+from edsl.questions.QuestionBudget import QuestionBudget
+from edsl.questions.QuestionRank import QuestionRank
+
+# # # Questions derived from core questions
+from edsl.questions.derived.QuestionLikertFive import QuestionLikertFive
+from edsl.questions.derived.QuestionLinearScale import QuestionLinearScale
+from edsl.questions.derived.QuestionYesNo import QuestionYesNo
+from edsl.questions.derived.QuestionTopK import QuestionTopK
+
+# # Compose Questions
+# from edsl.questions.compose_questions import compose_questions

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