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

edsl/questions/QuestionFreeText.py

@@ -1,62 +1,23 @@
 from __future__ import annotations
+import textwrap
 from typing import Any, Optional
 from uuid import uuid4
-
-from pydantic import field_validator
-
 from edsl.questions.QuestionBase import QuestionBase
-from edsl.questions.ResponseValidatorABC import ResponseValidatorABC
-
-from edsl.exceptions import QuestionAnswerValidationError
-from edsl.questions.decorators import inject_exception
-
-from pydantic import BaseModel
-from typing import Optional, Any, List
-
-from edsl.exceptions import QuestionAnswerValidationError
-
-
-class FreeTextResponse(BaseModel):
-    """
-    Validator for free text response questions.
-    """
-
-    answer: str
-    generated_tokens: Optional[str] = None
-
-
-class FreeTextResponseValidator(ResponseValidatorABC):
-    required_params = []
-    valid_examples = [({"answer": "This is great"}, {})]
-    invalid_examples = [
-        (
-            {"answer": None},
-            {},
-            "Answer code must not be missing.",
-        ),
-    ]
-
-    def fix(self, response, verbose=False):
-        return {
-            "answer": str(response.get("generated_tokens")),
-            "generated_tokens": str(response.get("generated_tokens")),
-        }
 
 
 class QuestionFreeText(QuestionBase):
     """This question prompts the agent to respond with free text."""
 
     question_type = "free_text"
-    _response_model = FreeTextResponse
-    response_validator_class = FreeTextResponseValidator
-
-    def __init__(
-        self,
-        question_name: str,
-        question_text: str,
-        answering_instructions: Optional[str] = None,
-        question_presentation: Optional[str] = None,
-    ):
+    default_instructions = textwrap.dedent(
+        """\
+        You are being asked the following question: {{question_text}}
+        Return a valid JSON formatted like this: 
+        {"answer": "<put free text answer here>"}
+        """
+    )
+
+    def __init__(self, question_name: str, question_text: str):
         """Instantiate a new QuestionFreeText.
 
         :param question_name: The name of the question.
@@ -64,8 +25,25 @@ class QuestionFreeText(QuestionBase):
         """
         self.question_name = question_name
         self.question_text = question_text
-        self.answering_instructions = answering_instructions
-        self.question_presentation = question_presentation
+
+    ################
+    # Answer methods
+    ################
+    def _validate_answer(self, answer: Any) -> dict[str, str]:
+        """Validate the answer."""
+        self._validate_answer_template_basic(answer)
+        self._validate_answer_key_value(answer, "answer", str)
+        return answer
+
+    def _translate_answer_code_to_answer(self, answer, scenario: "Scenario" = None):
+        """Do nothing, because the answer is already in a human-readable format."""
+        return answer
+
+    def _simulate_answer(self, human_readable: bool = True) -> dict[str, str]:
+        """Simulate a valid answer for debugging purposes."""
+        from edsl.utilities.utilities import random_string
+
+        return {"answer": random_string()}
 
     @property
     def question_html_content(self) -> str:
@@ -81,7 +59,6 @@ class QuestionFreeText(QuestionBase):
         return question_html_content
 
     @classmethod
-    @inject_exception
     def example(cls, randomize: bool = False) -> QuestionFreeText:
         """Return an example instance of a free text question."""
         addition = "" if not randomize else str(uuid4())

edsl/questions/QuestionFunctional.py

@@ -39,9 +39,6 @@ class QuestionFunctional(QuestionBase):
     function_source_code = ""
     function_name = ""
 
-    _response_model = None
-    response_validator_class = None
-
     def __init__(
         self,
         question_name: str,
@@ -100,10 +97,6 @@ class QuestionFunctional(QuestionBase):
         """Required by Question, but not used by QuestionFunctional."""
         raise NotImplementedError
 
-    @property
-    def question_html_content(self) -> str:
-        return "NA for QuestionFunctional"
-
     @add_edsl_version
     def to_dict(self):
         return {

edsl/questions/QuestionList.py

@@ -4,123 +4,6 @@ import textwrap
 from typing import Any, Optional, Union
 from edsl.questions.QuestionBase import QuestionBase
 from edsl.questions.descriptors import IntegerOrNoneDescriptor
-from edsl.questions.decorators import inject_exception
-
-from pydantic import field_validator, Field
-from edsl.questions.ResponseValidatorABC import ResponseValidatorABC
-from edsl.questions.ResponseValidatorABC import BaseResponse
-
-from edsl.exceptions import QuestionAnswerValidationError
-import textwrap
-import json
-
-from json_repair import repair_json
-
-
-def convert_string(s):
-    """Convert a string to a more appropriate type if possible.
-
-    >>> convert_string("3.14")
-    3.14
-    >>> convert_string("42")
-    42
-    >>> convert_string("hello")
-    'hello'
-    >>> convert_string('{"key": "value"}')
-    {'key': 'value'}
-    >>> convert_string("{'key': 'value'}")
-    {'key': 'value'}
-    """
-
-    if not isinstance(s, str):  # if it's not a string, return it as is
-        return s
-
-    # If the repair returns, continue on; otherwise, try to load it as JSON
-    if (repaired_json := repair_json(s)) == '""':
-        pass
-    else:
-        try:
-            return json.loads(repaired_json)
-        except json.JSONDecodeError:
-            pass
-
-    # Try to convert to float
-    try:
-        return float(s)
-    except ValueError:
-        pass
-
-    # Try to convert to int
-    try:
-        return int(s)
-    except ValueError:
-        pass
-
-    # If all conversions fail, return the original string
-    return s
-
-
-def create_model(max_list_items: int, permissive):
-    from pydantic import BaseModel
-
-    if permissive or max_list_items is None:
-
-        class ListResponse(BaseModel):
-            answer: list[Any]
-            comment: Optional[str] = None
-            generated_tokens: Optional[str] = None
-
-    else:
-
-        class ListResponse(BaseModel):
-            """
-            >>> nr = ListResponse(answer=["Apple", "Cherry"])
-            >>> nr.dict()
-            {'answer': ['Apple', 'Cherry'], 'comment': None, 'generated_tokens': None}
-            """
-
-            answer: list[Any] = Field(..., min_items=0, max_items=max_list_items)
-            comment: Optional[str] = None
-            generated_tokens: Optional[str] = None
-
-    return ListResponse
-
-
-class ListResponseValidator(ResponseValidatorABC):
-    required_params = ["max_list_items", "permissive"]
-    valid_examples = [({"answer": ["hello", "world"]}, {"max_list_items": 5})]
-
-    invalid_examples = [
-        (
-            {"answer": ["hello", "world", "this", "is", "a", "test"]},
-            {"max_list_items": 5},
-            "Too many items.",
-        ),
-    ]
-
-    def _check_constraints(self, response) -> None:
-        if (
-            self.max_list_items is not None
-            and len(response.answer) > self.max_list_items
-        ):
-            raise QuestionAnswerValidationError("Too many items.")
-
-    def fix(self, response, verbose=False):
-        if verbose:
-            print(f"Fixing list response: {response}")
-        answer = str(response.get("answer") or response.get("generated_tokens", ""))
-        if len(answer.split(",")) > 0:
-            return (
-                {"answer": answer.split(",")} | {"comment": response.get("comment")}
-                if "comment" in response
-                else {}
-            )
-
-    def _post_process(self, edsl_answer_dict):
-        edsl_answer_dict["answer"] = [
-            convert_string(item) for item in edsl_answer_dict["answer"]
-        ]
-        return edsl_answer_dict
 
 
 class QuestionList(QuestionBase):
@@ -128,38 +11,43 @@ class QuestionList(QuestionBase):
 
     question_type = "list"
     max_list_items: int = IntegerOrNoneDescriptor()
-    _response_model = None
-    response_validator_class = ListResponseValidator
 
     def __init__(
         self,
         question_name: str,
         question_text: str,
         max_list_items: Optional[int] = None,
-        include_comment: bool = True,
-        answering_instructions: Optional[str] = None,
-        question_presentation: Optional[str] = None,
-        permissive: bool = False,
     ):
         """Instantiate a new QuestionList.
 
         :param question_name: The name of the question.
         :param question_text: The text of the question.
         :param max_list_items: The maximum number of items that can be in the answer list.
-
-        >>> QuestionList.example().self_check()
         """
         self.question_name = question_name
         self.question_text = question_text
         self.max_list_items = max_list_items
-        self.permissive = permissive
 
-        self.include_comment = include_comment
-        self.answering_instructions = answering_instructions
-        self.question_presentations = question_presentation
+    ################
+    # Answer methods
+    ################
+    def _validate_answer(self, answer: Any) -> dict[str, Union[list[str], str]]:
+        """Validate the answer."""
+        self._validate_answer_template_basic(answer)
+        self._validate_answer_key_value(answer, "answer", list)
+        self._validate_answer_list(answer)
+        return answer
+
+    def _translate_answer_code_to_answer(self, answer, scenario: "Scenario" = None):
+        """There is no answer code."""
+        return answer
+
+    def _simulate_answer(self, human_readable: bool = True):
+        """Simulate a valid answer for debugging purposes (what the validator expects)."""
+        num_items = random.randint(1, self.max_list_items or 2)
+        from edsl.utilities.utilities import random_string
 
-    def create_response_model(self):
-        return create_model(self.max_list_items, self.permissive)
+        return {"answer": [random_string() for _ in range(num_items)]}
 
     @property
     def question_html_content(self) -> str:
@@ -190,17 +78,12 @@ class QuestionList(QuestionBase):
     # Helpful methods
     ################
     @classmethod
-    @inject_exception
-    def example(
-        cls, include_comment=True, max_list_items=None, permissive=False
-    ) -> QuestionList:
+    def example(cls) -> QuestionList:
         """Return an example of a list question."""
         return cls(
             question_name="list_of_foods",
             question_text="What are your favorite foods?",
-            include_comment=include_comment,
-            max_list_items=max_list_items,
-            permissive=permissive,
+            max_list_items=5,
         )
 
 
@@ -208,7 +91,7 @@ def main():
     """Create an example of a list question and demonstrate its functionality."""
     from edsl.questions.QuestionList import QuestionList
 
-    q = QuestionList.example(max_list_items=5)
+    q = QuestionList.example()
     q.question_text
     q.question_name
     q.max_list_items
@@ -224,8 +107,6 @@ def main():
     q.to_dict()
     assert q.from_dict(q.to_dict()) == q
 
-
-if __name__ == "__main__":
     import doctest
 
     doctest.testmod(optionflags=doctest.ELLIPSIS)

edsl/questions/QuestionMultipleChoice.py

@@ -1,114 +1,12 @@
 from __future__ import annotations
-from typing import Union, Literal, Optional, List, Any
-
+import time
+from typing import Union
+import random
+from typing import Optional
 from jinja2 import Template
-from pydantic import BaseModel, Field
 
-from edsl.scenarios.Scenario import Scenario
 from edsl.questions.QuestionBase import QuestionBase
 from edsl.questions.descriptors import QuestionOptionsDescriptor
-from edsl.questions.decorators import inject_exception
-from edsl.questions.ResponseValidatorABC import ResponseValidatorABC
-
-
-def create_response_model(choices: List[str], permissive: bool = False):
-    """
-    Create a ChoiceResponse model class with a predefined list of choices.
-
-    :param choices: A list of allowed values for the answer field.
-    :param permissive: If True, any value will be accepted as an answer.
-    :return: A new Pydantic model class.
-    """
-    choice_tuple = tuple(choices)
-
-    if not permissive:
-
-        class ChoiceResponse(BaseModel):
-            answer: Literal[choice_tuple] = Field(description="Selected choice")
-            comment: Optional[str] = Field(None, description="Optional comment field")
-            generated_tokens: Optional[Any] = Field(
-                None, description="Generated tokens"
-            )
-
-            class Config:
-                @staticmethod
-                def json_schema_extra(schema: dict, model: BaseModel) -> None:
-                    for prop in schema.get("properties", {}).values():
-                        if prop.get("title") == "answer":
-                            prop["enum"] = choices
-
-    else:
-
-        class ChoiceResponse(BaseModel):
-            answer: Any = Field(description="Selected choice (can be any value)")
-            comment: Optional[str] = Field(None, description="Optional comment field")
-            generated_tokens: Optional[Any] = Field(
-                None, description="Generated tokens"
-            )
-
-            class Config:
-                @staticmethod
-                def json_schema_extra(schema: dict, model: BaseModel) -> None:
-                    for prop in schema.get("properties", {}).values():
-                        if prop.get("title") == "answer":
-                            prop["description"] += f". Suggested choices are: {choices}"
-                    schema["title"] += " (Permissive)"
-
-    return ChoiceResponse
-
-
-class MultipleChoiceResponseValidator(ResponseValidatorABC):
-    required_params = ["question_options", "use_code"]
-
-    def fix(self, response, verbose=False):
-        response_text = str(response.get("answer"))
-        if response_text is None:
-            response_text = response.get("generated_tokens", "")
-
-        if verbose:
-            print(f"Invalid generated tokens was: {response_text}")
-
-        matches = []
-        for idx, option in enumerate(self.question_options):
-            if verbose:
-                print("The options are: ", self.question_options)
-            if str(option) in response_text:
-                if verbose:
-                    print("Match found with option ", option)
-                if option not in matches:
-                    matches.append(option)
-
-        if verbose:
-            print("The matches are: ", matches)
-        if len(matches) == 1:
-            proposed_data = {
-                "answer": matches[0],
-                "generated_tokens": response.get("generated_tokens", None),
-            }
-            try:
-                self.response_model(**proposed_data)
-                return proposed_data
-            except Exception as e:
-                if verbose:
-                    print(f"Proposed solution {proposed_data} is invalid. Error: {e}")
-            return response
-
-    valid_examples = [
-        ({"answer": 1}, {"question_options": ["Good", "Great", "OK", "Bad"]})
-    ]
-
-    invalid_examples = [
-        (
-            {"answer": -1},
-            {"question_options": ["Good", "Great", "OK", "Bad"]},
-            "Answer code must be a non-negative integer",
-        ),
-        (
-            {"answer": None},
-            {"question_options": ["Good", "Great", "OK", "Bad"]},
-            "Answer code must not be missing.",
-        ),
-    ]
 
 
 class QuestionMultipleChoice(QuestionBase):
@@ -123,53 +21,49 @@ class QuestionMultipleChoice(QuestionBase):
     question_options: Union[
         list[str], list[list], list[float], list[int]
     ] = QuestionOptionsDescriptor()
-    _response_model = None
-    response_validator_class = MultipleChoiceResponseValidator
 
     def __init__(
         self,
         question_name: str,
         question_text: str,
         question_options: Union[list[str], list[list], list[float], list[int]],
-        include_comment: bool = True,
-        use_code: bool = False,
-        answering_instructions: Optional[str] = None,
-        question_presentation: Optional[str] = None,
-        permissive: bool = False,
     ):
         """Instantiate a new QuestionMultipleChoice.
 
         :param question_name: The name of the question.
         :param question_text: The text of the question.
         :param question_options: The options the agent should select from.
-        :param include_comment: Whether to include a comment field.
-        :param use_code: Whether to use code for the options.
-        :param answering_instructions: Instructions for the question.
-        :param question_presentation: The presentation of the question.
-        :param permissive: Whether to force the answer to be one of the options.
-
         """
         self.question_name = question_name
         self.question_text = question_text
         self.question_options = question_options
 
-        self._include_comment = include_comment
-        self.use_code = use_code
-        self.answering_instructions = answering_instructions
-        self.question_presentation = question_presentation
-        self.permissive = permissive
+    # @property
+    # def question_options(self) -> Union[list[str], list[list], list[float], list[int]]:
+    #     """Return the question options."""
+    #     return self._question_options
 
     ################
     # Answer methods
     ################
+    def _validate_answer(
+        self, answer: dict[str, Union[str, int]]
+    ) -> dict[str, Union[str, int]]:
+        """Validate the answer.
 
-    def create_response_model(self):
-        if self.use_code:
-            return create_response_model(
-                list(range(len(self.question_options))), self.permissive
-            )
-        else:
-            return create_response_model(self.question_options, self.permissive)
+        >>> q = QuestionMultipleChoice.example()
+        >>> q._validate_answer({"answer": 0, "comment": "I like custard"})
+        {'answer': 0, 'comment': 'I like custard'}
+
+        >>> q = QuestionMultipleChoice(question_name="how_feeling", question_text="How are you?", question_options=["Good", "Great", "OK", "Bad"])
+        >>> q._validate_answer({"answer": -1, "comment": "I like custard"})
+        Traceback (most recent call last):
+        ...
+        edsl.exceptions.questions.QuestionAnswerValidationError: Answer code must be a non-negative integer (got -1).
+        """
+        self._validate_answer_template_basic(answer)
+        self._validate_answer_multiple_choice(answer)
+        return answer
 
     def _translate_answer_code_to_answer(
         self, answer_code: int, scenario: Optional["Scenario"] = None
@@ -180,14 +74,15 @@ class QuestionMultipleChoice(QuestionBase):
         The question options might be templates, so they need to be rendered with the scenario.
 
         >>> q = QuestionMultipleChoice.example()
-        >>> q._translate_answer_code_to_answer('Good', {})
+        >>> q._translate_answer_code_to_answer(0, {})
         'Good'
 
         >>> q = QuestionMultipleChoice(question_name="how_feeling", question_text="How are you?", question_options=["{{emotion[0]}}", "emotion[1]"])
-        >>> q._translate_answer_code_to_answer('Happy', {"emotion": ["Happy", "Sad"]})
+        >>> q._translate_answer_code_to_answer(0, {"emotion": ["Happy", "Sad"]})
         'Happy'
 
         """
+        from edsl.scenarios.Scenario import Scenario
 
         scenario = scenario or Scenario()
 
@@ -200,17 +95,31 @@ class QuestionMultipleChoice(QuestionBase):
             question_option_key = list(meta.find_undeclared_variables(parsed_content))[
                 0
             ]
+            # breakpoint()
             translated_options = scenario.get(question_option_key)
         else:
             translated_options = [
                 Template(str(option)).render(scenario)
                 for option in self.question_options
             ]
-        if self._use_code:
-            return translated_options[int(answer_code)]
+        # print("Translated options:", translated_options)
+        # breakpoint()
+        return translated_options[int(answer_code)]
+
+    def _simulate_answer(
+        self, human_readable: bool = True
+    ) -> dict[str, Union[int, str]]:
+        """Simulate a valid answer for debugging purposes."""
+        from edsl.utilities.utilities import random_string
+
+        if human_readable:
+            answer = random.choice(self.question_options)
         else:
-            # return translated_options[answer_code]
-            return answer_code
+            answer = random.choice(range(len(self.question_options)))
+        return {
+            "answer": answer,
+            "comment": random_string(),
+        }
 
     @property
     def question_html_content(self) -> str:
@@ -244,36 +153,33 @@ class QuestionMultipleChoice(QuestionBase):
     # Example
     ################
     @classmethod
-    @inject_exception
-    def example(cls, include_comment=False, use_code=False) -> QuestionMultipleChoice:
+    def example(cls) -> QuestionMultipleChoice:
         """Return an example instance."""
         return cls(
             question_text="How are you?",
             question_options=["Good", "Great", "OK", "Bad"],
             question_name="how_feeling",
-            include_comment=include_comment,
-            use_code=use_code,
         )
 
 
-# def main():
-#     """Create an example QuestionMultipleChoice and test its methods."""
-#     from edsl.questions.QuestionMultipleChoice import QuestionMultipleChoice
-
-#     q = QuestionMultipleChoice.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, {})
-#     # simulate answer
-#     q._simulate_answer()
-#     q._simulate_answer(human_readable=False)
-#     # serialization (inherits from Question)
-#     q.to_dict()
-#     assert q.from_dict(q.to_dict()) == q
+def main():
+    """Create an example QuestionMultipleChoice and test its methods."""
+    from edsl.questions.QuestionMultipleChoice import QuestionMultipleChoice
+
+    q = QuestionMultipleChoice.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, {})
+    # simulate answer
+    q._simulate_answer()
+    q._simulate_answer(human_readable=False)
+    # serialization (inherits from Question)
+    q.to_dict()
+    assert q.from_dict(q.to_dict()) == q
 
 
 if __name__ == "__main__":