edsl 0.1.39__py3-none-any.whl → 0.1.39.dev1__py3-none-any.whl

edsl/questions/QuestionBase.py

@@ -2,35 +2,31 @@
 
 from __future__ import annotations
 from abc import ABC, abstractmethod
-from typing import Any, Type, Optional, List, Callable, Union, TypedDict, TYPE_CHECKING
+from typing import Any, Type, Optional, List, Callable, Union, TypedDict
+import copy
 
-from edsl.exceptions.questions import (
+from edsl.exceptions import (
+    QuestionResponseValidationError,
+    QuestionAnswerValidationError,
     QuestionSerializationError,
 )
 from edsl.questions.descriptors import QuestionNameDescriptor, QuestionTextDescriptor
 
-from edsl.questions.answer_validator_mixin import AnswerValidatorMixin
-from edsl.questions.register_questions_meta import RegisterQuestionsMeta
-from edsl.Base import PersistenceMixin, RepresentationMixin
+
+from edsl.questions.AnswerValidatorMixin import AnswerValidatorMixin
+from edsl.questions.RegisterQuestionsMeta import RegisterQuestionsMeta
+from edsl.Base import PersistenceMixin, RichPrintingMixin
 from edsl.BaseDiff import BaseDiff, BaseDiffCollection
 
 from edsl.questions.SimpleAskMixin import SimpleAskMixin
 from edsl.questions.QuestionBasePromptsMixin import QuestionBasePromptsMixin
-from edsl.questions.question_base_gen_mixin import QuestionBaseGenMixin
-from edsl.utilities.remove_edsl_version import remove_edsl_version
-
-if TYPE_CHECKING:
-    from edsl.questions.response_validator_abc import ResponseValidatorABC
-    from edsl.language_models.LanguageModel import LanguageModel
-    from edsl.results.Results import Results
-    from edsl.agents.Agent import Agent
-    from edsl.surveys.Survey import Survey
-    from edsl.jobs.Jobs import Jobs
+from edsl.questions.QuestionBaseGenMixin import QuestionBaseGenMixin
+from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
 
 
 class QuestionBase(
     PersistenceMixin,
-    RepresentationMixin,
+    RichPrintingMixin,
     SimpleAskMixin,
     QuestionBasePromptsMixin,
     QuestionBaseGenMixin,
@@ -40,14 +36,6 @@ class QuestionBase(
 ):
     """ABC for the Question class. All questions inherit from this class.
     Some of the constraints on child questions are defined in the RegisterQuestionsMeta metaclass.
-
-
-    Every child class wiill have class attributes of question_type, _response_model and response_validator_class e.g.,
-
-        question_type = "free_text"
-        _response_model = FreeTextResponse
-        response_validator_class = FreeTextResponseValidator
-
     """
 
     question_name: str = QuestionNameDescriptor()
@@ -57,16 +45,36 @@ class QuestionBase(
     _question_presentation = None
 
     @property
-    def response_validator(self) -> "ResponseValidatorABC":
+    def response_model(self) -> type["BaseModel"]:
+        if self._response_model is not None:
+            return self._response_model
+        else:
+            return self.create_response_model()
+
+    # region: Validation and simulation methods
+    @property
+    def response_validator(self) -> "ResponseValidatorBase":
         """Return the response validator."""
-        from edsl.questions.response_validator_factory import ResponseValidatorFactory
+        params = (
+            {
+                "response_model": self.response_model,
+            }
+            | {k: getattr(self, k) for k in self.validator_parameters}
+            | {"exception_to_throw": getattr(self, "exception_to_throw", None)}
+            | {"override_answer": getattr(self, "override_answer", None)}
+        )
+        return self.response_validator_class(**params)
 
-        rvf = ResponseValidatorFactory(self)
-        return rvf.response_validator
+    @property
+    def validator_parameters(self) -> list[str]:
+        """Return the parameters required for the response validator.
 
-    def duplicate(self):
-        """Return a duplicate of the question."""
-        return self.from_dict(self.to_dict())
+        >>> from edsl import QuestionMultipleChoice as Q
+        >>> Q.example().validator_parameters
+        ['question_options', 'use_code']
+
+        """
+        return self.response_validator_class.required_params
 
     @property
     def fake_data_factory(self):
@@ -74,7 +82,8 @@ class QuestionBase(
         if not hasattr(self, "_fake_data_factory"):
             from polyfactory.factories.pydantic_factory import ModelFactory
 
-            class FakeData(ModelFactory[self.response_model]): ...
+            class FakeData(ModelFactory[self.response_model]):
+                ...
 
             self._fake_data_factory = FakeData
         return self._fake_data_factory
@@ -101,14 +110,17 @@ class QuestionBase(
         self, answer: dict, replacement_dict: dict = None
     ) -> ValidatedAnswer:
         """Validate the answer.
-        >>> from edsl.exceptions.questions import QuestionAnswerValidationError
-        >>> from edsl.questions import QuestionFreeText as Q
+        >>> from edsl.exceptions import QuestionAnswerValidationError
+        >>> from edsl import QuestionFreeText as Q
         >>> Q.example()._validate_answer({'answer': 'Hello', 'generated_tokens': 'Hello'})
         {'answer': 'Hello', 'generated_tokens': 'Hello'}
         """
 
         return self.response_validator.validate(answer, replacement_dict)
 
+    # endregion
+
+    # region: Serialization methods
     @property
     def name(self) -> str:
         "Helper function so questions and instructions can use the same access method"
@@ -129,7 +141,7 @@ class QuestionBase(
     def data(self) -> dict:
         """Return a dictionary of question attributes **except** for question_type.
 
-        >>> from edsl.questions import QuestionFreeText as Q
+        >>> from edsl import QuestionFreeText as Q
         >>> Q.example().data
         {'question_name': 'how_are_you', 'question_text': 'How are you?'}
         """
@@ -171,10 +183,10 @@ class QuestionBase(
 
         return candidate_data
 
-    def to_dict(self, add_edsl_version: bool = True):
+    def to_dict(self, add_edsl_version=True):
         """Convert the question to a dictionary that includes the question type (used in deserialization).
 
-        >>> from edsl.questions import QuestionFreeText as Q; Q.example().to_dict(add_edsl_version = False)
+        >>> from edsl import QuestionFreeText as Q; Q.example().to_dict(add_edsl_version = False)
         {'question_name': 'how_are_you', 'question_text': 'How are you?', 'question_type': 'free_text'}
         """
         candidate_data = self.data.copy()
@@ -225,6 +237,9 @@ class QuestionBase(
 
         return question_class(**local_data)
 
+    # endregion
+
+    # region: Running methods
     @classmethod
     def _get_test_model(self, canned_response: Optional[str] = None) -> "LanguageModel":
         """Get a test model for the question."""
@@ -249,10 +264,12 @@ class QuestionBase(
         >>> m.execute_model_call("", "")
         {'message': [{'text': "Yo, what's up?"}], 'usage': {'prompt_tokens': 1, 'completion_tokens': 1}}
         >>> Q.run_example(show_answer = True, model = m, disable_remote_cache = True, disable_remote_inference = True)
-        Dataset([{'answer.how_are_you': ["Yo, what's up?"]}])
+        answer.how_are_you
+        --------------------
+        Yo, what's up?
         """
         if model is None:
-            from edsl.language_models.model import Model
+            from edsl import Model
 
             model = Model()
         results = (
@@ -265,28 +282,26 @@ class QuestionBase(
             )
         )
         if show_answer:
-            return results.select("answer.*")
+            return results.select("answer.*").print()
         else:
             return results
 
     def __call__(
         self,
-        just_answer: bool = True,
-        model: Optional["LanguageModel"] = None,
-        agent: Optional["Agent"] = None,
+        just_answer=True,
+        model=None,
+        agent=None,
         disable_remote_cache: bool = False,
         disable_remote_inference: bool = False,
-        verbose: bool = False,
         **kwargs,
-    ) -> Union[Any, "Results"]:
+    ):
         """Call the question.
 
 
         >>> from edsl import QuestionFreeText as Q
-        >>> from edsl import Model
-        >>> m = Model("test", canned_response = "Yo, what's up?")
+        >>> m = Q._get_test_model(canned_response = "Yo, what's up?")
         >>> q = Q(question_name = "color", question_text = "What is your favorite color?")
-        >>> q(model = m, disable_remote_cache = True, disable_remote_inference = True, cache = False)
+        >>> q(model = m, disable_remote_cache = True, disable_remote_inference = True)
         "Yo, what's up?"
 
         """
@@ -295,7 +310,7 @@ class QuestionBase(
             model=model,
             agent=agent,
             **kwargs,
-            verbose=verbose,
+            cache=False,
             disable_remote_cache=disable_remote_cache,
             disable_remote_inference=disable_remote_inference,
         )
@@ -306,16 +321,15 @@ class QuestionBase(
 
     def run(self, *args, **kwargs) -> "Results":
         """Turn a single question into a survey and runs it."""
-        return self.to_survey().run(*args, **kwargs)
+        from edsl.surveys.Survey import Survey
 
-    def using(self, *args, **kwargs) -> "Jobs":
-        """Turn a single question into a survey and then a Job."""
-        return self.to_survey().to_jobs().using(*args, **kwargs)
+        s = self.to_survey()
+        return s.run(*args, **kwargs)
 
     async def run_async(
         self,
         just_answer: bool = True,
-        model: Optional["LanguageModel"] = None,
+        model: Optional["Model"] = None,
         agent: Optional["Agent"] = None,
         disable_remote_inference: bool = False,
         **kwargs,
@@ -323,10 +337,10 @@ class QuestionBase(
         """Call the question asynchronously.
 
         >>> import asyncio
-        >>> from edsl.questions import QuestionFreeText as Q
+        >>> from edsl import QuestionFreeText as Q
         >>> m = Q._get_test_model(canned_response = "Blue")
         >>> q = Q(question_name = "color", question_text = "What is your favorite color?")
-        >>> async def test_run_async(): result = await q.run_async(model=m, disable_remote_inference = True, disable_remote_cache = True); print(result)
+        >>> async def test_run_async(): result = await q.run_async(model=m, disable_remote_inference = True); print(result)
         >>> asyncio.run(test_run_async())
         Blue
         """
@@ -342,6 +356,27 @@ class QuestionBase(
         else:
             return results
 
+    # endregion
+
+    # region: Magic methods
+    def _repr_html_(self):
+        # from edsl.utilities.utilities import data_to_html
+
+        data = self.to_dict(add_edsl_version=False)
+        # keys = list(data.keys())
+        # values = list(data.values())
+        from tabulate import tabulate
+
+        return tabulate(data.items(), headers=["keys", "values"], tablefmt="html")
+
+        # try:
+        #     _ = data.pop("edsl_version")
+        #     _ = data.pop("edsl_class_name")
+        # except KeyError:
+        #     print("Serialized question lacks edsl version, but is should have it.")
+
+        # return data_to_html(data)
+
     def __getitem__(self, key: str) -> Any:
         """Get an attribute of the question so it can be treated like a dictionary.
 
@@ -349,10 +384,7 @@ class QuestionBase(
         >>> Q.example()['question_text']
         'How are you?'
         """
-        try:
-            return getattr(self, key)
-        except TypeError:
-            raise KeyError(f"Question has no attribute {key} of type {type(key)}")
+        return getattr(self, key)
 
     def __repr__(self) -> str:
         """Return a string representation of the question. Should be able to be used to reconstruct the question.
@@ -382,7 +414,9 @@ class QuestionBase(
         False
 
         """
-        return hash(self) == hash(other)
+        if not isinstance(other, QuestionBase):
+            return False
+        return self.to_dict() == other.to_dict()
 
     def __sub__(self, other) -> BaseDiff:
         """Return the difference between two objects.
@@ -399,18 +433,35 @@ class QuestionBase(
     def __add__(self, other_question_or_diff):
         """
         Compose two questions into a single question.
+
+        TODO: Probably getting deprecated.
+
         """
         if isinstance(other_question_or_diff, BaseDiff) or isinstance(
             other_question_or_diff, BaseDiffCollection
         ):
             return other_question_or_diff.apply(self)
 
+        # from edsl.questions import compose_questions
+        # return compose_questions(self, other_question_or_diff)
+
+    # def _validate_response(self, response):
+    #     """Validate the response from the LLM. Behavior depends on the question type."""
+    #     if "answer" not in response:
+    #         raise QuestionResponseValidationError(
+    #             "Response from LLM does not have an answer"
+    #         )
+    #     return response
+
     def _translate_answer_code_to_answer(
         self, answer, scenario: Optional["Scenario"] = None
     ):
         """There is over-ridden by child classes that ask for codes."""
         return answer
 
+    # endregion
+
+    # region: Forward methods
     def add_question(self, other: QuestionBase) -> "Survey":
         """Add a question to this question by turning them into a survey with two questions.
 
@@ -420,7 +471,10 @@ class QuestionBase(
         >>> len(s.questions)
         2
         """
-        return self.to_survey().add_question(other)
+        from edsl.surveys.Survey import Survey
+
+        s = Survey([self, other])
+        return s
 
     def to_survey(self) -> "Survey":
         """Turn a single question into a survey.
@@ -430,7 +484,8 @@ class QuestionBase(
         """
         from edsl.surveys.Survey import Survey
 
-        return Survey([self])
+        s = Survey([self])
+        return s
 
     def by(self, *args) -> "Jobs":
         """Turn a single question into a survey and then a Job."""
@@ -439,6 +494,15 @@ class QuestionBase(
         s = Survey([self])
         return s.by(*args)
 
+    # endregion
+
+    # region: Display methods
+    def print(self):
+        from rich import print_json
+        import json
+
+        print_json(json.dumps(self.to_dict()))
+
     def human_readable(self) -> str:
         """Print the question in a human readable format.
 
@@ -465,15 +529,97 @@ class QuestionBase(
         width: Optional[int] = None,
         iframe=False,
     ):
-        from edsl.questions.HTMLQuestion import HTMLQuestion
+        """Return the question in HTML format."""
+        from jinja2 import Template
+
+        if scenario is None:
+            scenario = {}
+
+        prior_answers_dict = {}
+
+        if isinstance(answers, dict):
+            for key, value in answers.items():
+                if not key.endswith("_comment") and not key.endswith(
+                    "_generated_tokens"
+                ):
+                    prior_answers_dict[key] = {"answer": value}
+
+        # breakpoint()
+
+        base_template = """
+        <div id="{{ question_name }}" class="survey_question" data-type="{{ question_type }}">
+            {% if include_question_name %}
+            <p>question_name: {{ question_name }}</p>
+            {% endif %}
+            <p class="question_text">{{ question_text }}</p>
+            {{ question_content }}
+        </div>
+        """
+        if not hasattr(self, "question_type"):
+            self.question_type = "unknown"
 
-        return HTMLQuestion(self).html(
-            scenario, agent, answers, include_question_name, height, width, iframe
-        )
+        if hasattr(self, "question_html_content"):
+            question_content = self.question_html_content
+        else:
+            question_content = Template("")
+
+        base_template = Template(base_template)
+
+        context = {
+            "scenario": scenario,
+            "agent": agent,
+        } | prior_answers_dict
+
+        # Render the question text
+        try:
+            question_text = Template(self.question_text).render(context)
+        except Exception as e:
+            print(
+                f"Error rendering question: question_text = {self.question_text}, error = {e}"
+            )
+            question_text = self.question_text
+
+        try:
+            question_content = Template(question_content).render(context)
+        except Exception as e:
+            print(
+                f"Error rendering question: question_content = {question_content}, error = {e}"
+            )
+            question_content = question_content
+
+        try:
+            params = {
+                "question_name": self.question_name,
+                "question_text": question_text,
+                "question_type": self.question_type,
+                "question_content": question_content,
+                "include_question_name": include_question_name,
+            }
+        except Exception as e:
+            raise ValueError(
+                f"Error rendering question: params = {params}, error = {e}"
+            )
+        rendered_html = base_template.render(**params)
+
+        if iframe:
+            import html
+            from IPython.display import display, HTML
+
+            height = height or 200
+            width = width or 600
+            escaped_output = html.escape(rendered_html)
+            # escaped_output = rendered_html
+            iframe = f""""
+            <iframe srcdoc="{ escaped_output }" style="width: {width}px; height: {height}px;"></iframe>
+            """
+            display(HTML(iframe))
+            return None
+
+        return rendered_html
 
     @classmethod
     def example_model(cls):
-        from edsl.language_models.model import Model
+        from edsl import Model
 
         q = cls.example()
         m = Model("test", canned_response=cls._simulate_answer(q)["answer"])

edsl/questions/{question_base_gen_mixin.py → QuestionBaseGenMixin.py}

@@ -1,16 +1,11 @@
 from __future__ import annotations
 import copy
 import itertools
-from typing import Optional, List, Callable, Type, TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from edsl.questions.QuestionBase import QuestionBase
-    from edsl.scenarios.ScenarioList import ScenarioList
+from typing import Optional, List, Callable, Type
+from typing import TypeVar
 
 
 class QuestionBaseGenMixin:
-    """Mixin for QuestionBase."""
-
     def copy(self) -> QuestionBase:
         """Return a deep copy of the question.
 
@@ -26,7 +21,7 @@ class QuestionBaseGenMixin:
     def option_permutations(self) -> list[QuestionBase]:
         """Return a list of questions with all possible permutations of the options.
 
-        >>> from edsl.questions.QuestionMultipleChoice import QuestionMultipleChoice as Q
+        >>> from edsl import QuestionMultipleChoice as Q
         >>> len(Q.example().option_permutations())
         24
         """
@@ -44,60 +39,66 @@ class QuestionBaseGenMixin:
             questions.append(question)
         return questions
 
-    def draw(self) -> "QuestionBase":
-        """Return a new question with a randomly selected permutation of the options.
-
-        If the question has no options, returns a copy of the original question.
-
-        >>> from edsl.questions.QuestionMultipleChoice import QuestionMultipleChoice as Q
-        >>> q = Q.example()
-        >>> drawn = q.draw()
-        >>> len(drawn.question_options) == len(q.question_options)
-        True
-        >>> q is drawn
-        False
-        """
-
-        if not hasattr(self, "question_options"):
-            return copy.deepcopy(self)
-
-        import random
-
-        question = copy.deepcopy(self)
-        question.question_options = list(
-            random.sample(self.question_options, len(self.question_options))
-        )
-        return question
-
     def loop(self, scenario_list: ScenarioList) -> List[QuestionBase]:
         """Return a list of questions with the question name modified for each scenario.
 
         :param scenario_list: The list of scenarios to loop through.
 
-        >>> from edsl.questions.QuestionFreeText import QuestionFreeText
-        >>> from edsl.scenarios.ScenarioList import ScenarioList
+        >>> from edsl import QuestionFreeText
+        >>> from edsl import ScenarioList
         >>> q = QuestionFreeText(question_text = "What are your thoughts on: {{ subject}}?", question_name = "base_{{subject}}")
         >>> len(q.loop(ScenarioList.from_list("subject", ["Math", "Economics", "Chemistry"])))
         3
-        """
-        from edsl.questions.loop_processor import LoopProcessor
 
-        lp = LoopProcessor(self)
-        return lp.process_templates(scenario_list)
+        """
+        from jinja2 import Environment
+        from edsl.questions.QuestionBase import QuestionBase
 
-    def render(self, replacement_dict: dict) -> "QuestionBase":
-        """Render the question components as jinja2 templates with the replacement dictionary.
+        starting_name = self.question_name
+        questions = []
+        for index, scenario in enumerate(scenario_list):
+            env = Environment()
+            new_data = self.to_dict().copy()
+            for key, value in [(k, v) for k, v in new_data.items() if v is not None]:
+                if (
+                    isinstance(value, str) or isinstance(value, int)
+                ) and key != "question_options":
+                    new_data[key] = env.from_string(value).render(scenario)
+                elif isinstance(value, list):
+                    new_data[key] = [
+                        env.from_string(v).render(scenario) if isinstance(v, str) else v
+                        for v in value
+                    ]
+                elif isinstance(value, dict):
+                    new_data[key] = {
+                        (
+                            env.from_string(k).render(scenario)
+                            if isinstance(k, str)
+                            else k
+                        ): (
+                            env.from_string(v).render(scenario)
+                            if isinstance(v, str)
+                            else v
+                        )
+                        for k, v in value.items()
+                    }
+                elif key == "question_options" and isinstance(value, str):
+                    new_data[key] = value
+                else:
+                    raise ValueError(
+                        f"Unexpected value type: {type(value)} for key '{key}'"
+                    )
 
-        :param replacement_dict: The dictionary of values to replace in the question components.
+            if new_data["question_name"] == starting_name:
+                new_data["question_name"] = new_data["question_name"] + f"_{index}"
 
-        >>> from edsl.questions.QuestionFreeText import QuestionFreeText
-        >>> q = QuestionFreeText(question_name = "color", question_text = "What is your favorite {{ thing }}?")
-        >>> q.render({"thing": "color"})
-        Question('free_text', question_name = \"""color\""", question_text = \"""What is your favorite color?\""")
+            questions.append(QuestionBase.from_dict(new_data))
+        return questions
 
-        """
+    def render(self, replacement_dict: dict) -> "QuestionBase":
+        """Render the question components as jinja2 templates with the replacement dictionary."""
         from jinja2 import Environment
-        from edsl.scenarios.Scenario import Scenario
+        from edsl import Scenario
 
         strings_only_replacement_dict = {
             k: v for k, v in replacement_dict.items() if not isinstance(v, Scenario)
@@ -122,23 +123,15 @@ class QuestionBaseGenMixin:
 
         return self.apply_function(render_string)
 
-    def apply_function(
-        self, func: Callable, exclude_components: List[str] = None
-    ) -> QuestionBase:
+    def apply_function(self, func: Callable, exclude_components=None) -> QuestionBase:
         """Apply a function to the question parts
 
-        :param func: The function to apply to the question parts.
-        :param exclude_components: The components to exclude from the function application.
-
         >>> from edsl.questions import QuestionFreeText
         >>> q = QuestionFreeText(question_name = "color", question_text = "What is your favorite color?")
         >>> shouting = lambda x: x.upper()
         >>> q.apply_function(shouting)
         Question('free_text', question_name = \"""color\""", question_text = \"""WHAT IS YOUR FAVORITE COLOR?\""")
 
-        >>> q.apply_function(shouting, exclude_components = ["question_type"])
-        Question('free_text', question_name = \"""COLOR\""", question_text = \"""WHAT IS YOUR FAVORITE COLOR?\""")
-
         """
         from edsl.questions.QuestionBase import QuestionBase
 

edsl/questions/QuestionBasePromptsMixin.py

@@ -1,6 +1,8 @@
 from importlib import resources
 from typing import Optional
+from edsl.prompts import Prompt
 from edsl.exceptions.questions import QuestionAnswerValidationError
+
 from functools import lru_cache
 
 
@@ -69,7 +71,7 @@ class QuestionBasePromptsMixin:
         >>> q.get_instructions(model = "gpt3")
         Prompt(text=\"""{{question_text}}. Answer in valid JSON like so {'answer': 'comment: <>}\""")
         """
-        from edsl.language_models.model import Model
+        from edsl import Model
 
         if not hasattr(self, "_model_instructions"):
             self._model_instructions = {}
@@ -120,8 +122,6 @@ class QuestionBasePromptsMixin:
         template_text = template_manager.get_template(
             cls.question_type, "answering_instructions.jinja"
         )
-        from edsl.prompts import Prompt
-
         return Prompt(text=template_text)
 
     @classmethod
@@ -129,8 +129,6 @@ class QuestionBasePromptsMixin:
         template_text = template_manager.get_template(
             cls.question_type, "question_presentation.jinja"
         )
-        from edsl.prompts import Prompt
-
         return Prompt(text=template_text)
 
     @property
@@ -184,8 +182,6 @@ class QuestionBasePromptsMixin:
     @property
     def new_default_instructions(self) -> "Prompt":
         "This is set up as a property because there are mutable question values that determine how it is rendered."
-        from edsl.prompts import Prompt
-
         return Prompt(self.question_presentation) + Prompt(self.answering_instructions)
 
     @property