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

edsl/questions/QuestionBudget.py

@@ -1,60 +1,8 @@
 from __future__ import annotations
-from typing import Any, Optional, Union, List
-
-from pydantic import Field, BaseModel, validator
-
+import random
+from typing import Any, Optional, Union
 from edsl.questions.QuestionBase import QuestionBase
 from edsl.questions.descriptors import IntegerDescriptor, QuestionOptionsDescriptor
-from edsl.questions.ResponseValidatorABC import ResponseValidatorABC
-
-
-class BudgewResponseValidator(ResponseValidatorABC):
-    valid_examples = []
-
-    invalid_examples = []
-
-    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 create_budget_model(
-    budget_sum: float, permissive: bool, question_options: List[str]
-):
-    class BudgetResponse(BaseModel):
-        answer: List[float] = Field(
-            ...,
-            description="List of non-negative numbers representing budget allocation",
-            min_items=len(question_options),
-            max_items=len(question_options),
-        )
-        comment: Optional[str] = None
-        generated_tokens: Optional[str] = None
-
-        @validator("answer")
-        def validate_answer(cls, v):
-            if len(v) != len(question_options):
-                raise ValueError(f"Must provide {len(question_options)} values")
-            if any(x < 0 for x in v):
-                raise ValueError("All values must be non-negative")
-            total = sum(v)
-            if not permissive and total != budget_sum:
-                raise ValueError(f"Sum of numbers must equal {budget_sum}")
-            elif permissive and total > budget_sum:
-                raise ValueError(f"Sum of numbers cannot exceed {budget_sum}")
-            return v
-
-        class Config:
-            extra = "forbid"
-
-    return BudgetResponse
 
 
 class QuestionBudget(QuestionBase):
@@ -63,8 +11,6 @@ class QuestionBudget(QuestionBase):
     question_type = "budget"
     budget_sum: int = IntegerDescriptor(none_allowed=False)
     question_options: list[str] = QuestionOptionsDescriptor(q_budget=True)
-    _response_model = None
-    response_validator_class = BudgewResponseValidator
 
     def __init__(
         self,
@@ -72,10 +18,6 @@ class QuestionBudget(QuestionBase):
         question_text: str,
         question_options: list[str],
         budget_sum: int,
-        include_comment: bool = True,
-        question_presentation: Optional[str] = None,
-        answering_instructions: Optional[str] = None,
-        permissive: bool = False,
     ):
         """Instantiate a new QuestionBudget.
 
@@ -88,19 +30,20 @@ class QuestionBudget(QuestionBase):
         self.question_text = question_text
         self.question_options = question_options
         self.budget_sum = budget_sum
-        self.question_presentation = question_presentation
-        self.answering_instructions = answering_instructions
-        self.permissive = permissive
-        self.include_comment = include_comment
-
-    def create_response_model(self):
-        return create_budget_model(
-            self.budget_sum, self.permissive, self.question_options
-        )
+
+    ################
+    # Answer methods
+    ################
+    def _validate_answer(self, answer: dict[str, Any]) -> dict[str, Union[int, str]]:
+        """Validate the answer."""
+        self._validate_answer_template_basic(answer)
+        self._validate_answer_key_value(answer, "answer", dict)
+        self._validate_answer_budget(answer)
+        return answer
 
     def _translate_answer_code_to_answer(
-        self, answer_code, combined_dict
-    ) -> list[dict]:
+        self, answer_codes: dict[str, int], scenario: "Scenario" = None
+    ):
         """
         Translate the answer codes to the actual answers.
 
@@ -109,35 +52,35 @@ class QuestionBudget(QuestionBase):
         This code will translate that to "a".
         """
         translated_codes = []
-        for answer_code, question_option in zip(answer_code, self.question_options):
-            translated_codes.append({question_option: answer_code})
+        for answer_code, response in answer_codes.items():
+            translated_codes.append({self.question_options[int(answer_code)]: response})
 
         return translated_codes
 
-    # def _simulate_answer(self, human_readable=True):
-    #     """Simulate a valid answer for debugging purposes (what the validator expects)."""
-    #     from edsl.utilities.utilities import random_string
-
-    #     if human_readable:
-    #         keys = self.question_options
-    #     else:
-    #         keys = range(len(self.question_options))
-    #     remaining_budget = self.budget_sum
-    #     values = []
-    #     for _ in range(len(self.question_options)):
-    #         if _ == len(self.question_options) - 1:
-    #             # Assign remaining budget to the last value
-    #             values.append(remaining_budget)
-    #         else:
-    #             # Generate a random value between 0 and remaining budget
-    #             value = random.randint(0, remaining_budget)
-    #             values.append(value)
-    #             remaining_budget -= value
-    #     answer = dict(zip(keys, values))
-    #     return {
-    #         "answer": answer,
-    #         "comment": random_string(),
-    #     }
+    def _simulate_answer(self, human_readable=True):
+        """Simulate a valid answer for debugging purposes (what the validator expects)."""
+        from edsl.utilities.utilities import random_string
+
+        if human_readable:
+            keys = self.question_options
+        else:
+            keys = range(len(self.question_options))
+        remaining_budget = self.budget_sum
+        values = []
+        for _ in range(len(self.question_options)):
+            if _ == len(self.question_options) - 1:
+                # Assign remaining budget to the last value
+                values.append(remaining_budget)
+            else:
+                # Generate a random value between 0 and remaining budget
+                value = random.randint(0, remaining_budget)
+                values.append(value)
+                remaining_budget -= value
+        answer = dict(zip(keys, values))
+        return {
+            "answer": answer,
+            "comment": random_string(),
+        }
 
     @property
     def question_html_content(self) -> str:
@@ -184,14 +127,13 @@ class QuestionBudget(QuestionBase):
     # Helpful methods
     ################
     @classmethod
-    def example(cls, include_comment: bool = True) -> QuestionBudget:
+    def example(cls) -> QuestionBudget:
         """Return an example of a budget question."""
         return cls(
             question_name="food_budget",
             question_text="How would you allocate $100?",
             question_options=["Pizza", "Ice Cream", "Burgers", "Salad"],
             budget_sum=100,
-            include_comment=include_comment,
         )
 
 

edsl/questions/QuestionCheckBox.py

@@ -10,165 +10,6 @@ from edsl.questions.descriptors import (
     QuestionOptionsDescriptor,
 )
 
-from edsl.questions.decorators import inject_exception
-
-from pydantic import field_validator
-from edsl.questions.ResponseValidatorABC import ResponseValidatorABC
-from edsl.questions.ResponseValidatorABC import BaseResponse
-
-from edsl.exceptions import QuestionAnswerValidationError
-
-from pydantic import BaseModel, Field, conlist
-from typing import List, Literal, Optional, Annotated
-
-
-def create_checkbox_response_model(
-    choices: list,
-    min_selections: Optional[int] = None,
-    max_selections: Optional[int] = None,
-    permissive: bool = False,
-):
-    """
-    Dynamically create a CheckboxResponse model with a predefined list of choices.
-
-    :param choices: A list of allowed values for the answer field.
-    :param include_comment: Whether to include a comment field in the model.
-    :return: A new Pydantic model class.
-    """
-    # Convert the choices list to a tuple for use with Literal
-    choice_tuple = tuple(choices)
-
-    field_params = {}
-    if min_selections is not None and not permissive:
-        field_params["min_items"] = min_selections
-    if max_selections is not None and not permissive:
-        field_params["max_items"] = max_selections
-
-    class CheckboxResponse(BaseModel):
-        answer: Annotated[
-            List[Literal[choice_tuple]],
-            Field(..., **field_params),
-        ] = Field(..., description="List of selected choices")
-        comment: Optional[str] = Field(None, description="Optional comment field")
-        generated_tokens: Optional[Any] = Field(default=None)
-
-        class Config:
-            @staticmethod
-            def json_schema_extra(schema: dict, model: BaseModel) -> None:
-                # Add the list of choices to the schema for better documentation
-                for prop in schema.get("properties", {}).values():
-                    if prop.get("title") == "answer":
-                        prop["items"] = {"enum": choices}
-
-    return CheckboxResponse
-
-
-class CheckBoxResponseValidator(ResponseValidatorABC):
-    required_params = [
-        "question_options",
-        "min_selections",
-        "max_selections",
-        "use_code",
-        "permissive",
-    ]
-
-    valid_examples = [
-        ({"answer": [1, 2]}, {"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": 1},
-            {"question_options": ["Good", "Great", "OK", "Bad"]},
-            "Answer code must be a list",
-        ),
-        (
-            {"answer": [1, 2, 3, 4]},
-            {
-                "question_options": ["Good", "Great", "OK", "Bad"],
-                "min_selections": 1,
-                "max_selections": 2,
-            },
-            "Too many options selected",
-        ),
-    ]
-
-    def fix(self, response, verbose=False):
-        if verbose:
-            print("Invalid response of QuestionCheckBox was: ", response)
-        response_text = response.get("generated_tokens")
-        if response_text is None or response_text == "":  # nothing to be done
-            return response
-        # Maybe it's a comma separated list?
-        proposed_list = response_text.split(",")
-        proposed_list = [item.strip() for item in proposed_list]
-        if verbose:
-            print("Using code? ", self.use_code)
-        if self.use_code:
-            try:
-                proposed_list = [int(i) for i in proposed_list]
-            except ValueError:
-                # print("Could not convert to int")
-                pass
-
-        if verbose:
-            print("Proposed solution is: ", proposed_list)
-
-        # print(f"Ivalid generated tokens was was: {response_text}")
-        if "comment" in response:
-            proposed_data = {
-                "answer": proposed_list,
-                "comment": response["comment"],
-                "generated_tokens": response.get("generated_tokens", None),
-            }
-        else:
-            proposed_data = {
-                "answer": proposed_list,
-                "generated_tokens": response.get("generated_tokens", None),
-            }
-
-        try:
-            self.response_model(**proposed_data)
-            print("Proposed solution is valid")
-            print("Returning proposed data: ", proposed_data)
-            return proposed_data
-        except Exception as e:
-            if verbose:
-                print(f"Proposed solution {proposed_data} is invalid. Error: {e}")
-            # return response
-        if verbose:
-            print("Now seeing if responses show up in the answer")
-        matches = []
-        for index, option in enumerate(self.question_options):
-            if self.use_code:
-                if str(index) in response_text:
-                    matches.append(index)
-            else:
-                if option in response_text:
-                    matches.append(index)
-        proposed_data = {
-            "answer": matches,
-            "comment": response.get("comment", None),
-            "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
-
-    def custom_validate(self, response) -> BaseResponse:
-        if response.answer is None:
-            raise QuestionAnswerValidationError("Answer is missing.")
-        return response.dict()
-
 
 class QuestionCheckBox(QuestionBase):
     """This question prompts the agent to select options from a list."""
@@ -179,9 +20,6 @@ class QuestionCheckBox(QuestionBase):
     min_selections = IntegerDescriptor(none_allowed=True)
     max_selections = IntegerDescriptor(none_allowed=True)
 
-    _response_model = None
-    response_validator_class = CheckBoxResponseValidator
-
     def __init__(
         self,
         question_name: str,
@@ -189,11 +27,6 @@ class QuestionCheckBox(QuestionBase):
         question_options: list[str],
         min_selections: Optional[int] = None,
         max_selections: Optional[int] = None,
-        include_comment: bool = True,
-        use_code: bool = True,
-        question_presentation: Optional[str] = None,
-        answering_instructions: Optional[str] = None,
-        permissive: bool = False,
     ):
         """Instantiate a new QuestionCheckBox.
 
@@ -209,28 +42,15 @@ class QuestionCheckBox(QuestionBase):
         self.max_selections = max_selections
         self.question_options = question_options
 
-        self._include_comment = include_comment
-        self._use_code = use_code
-        self.permissive = permissive
-
-        self.question_presentation = question_presentation
-        self.answering_instructions = answering_instructions
-
-    def create_response_model(self):
-        if not self._use_code:
-            return create_checkbox_response_model(
-                self.question_options,
-                min_selections=self.min_selections,
-                max_selections=self.max_selections,  # include_comment=self._include_comment
-                permissive=self.permissive,
-            )
-        else:
-            return create_checkbox_response_model(
-                list(range(len(self.question_options))),
-                min_selections=self.min_selections,
-                max_selections=self.max_selections,  # include_comment=self._include_comment
-                permissive=self.permissive,
-            )
+    ################
+    # Answer methods
+    ################
+    def _validate_answer(self, answer: Any) -> dict[str, Union[int, str]]:
+        """Validate the answer."""
+        self._validate_answer_template_basic(answer)
+        self._validate_answer_key_value(answer, "answer", list)
+        self._validate_answer_checkbox(answer)
+        return answer
 
     def _translate_answer_code_to_answer(
         self, answer_codes, scenario: "Scenario" = None
@@ -249,36 +69,33 @@ class QuestionCheckBox(QuestionBase):
         ]
         translated_codes = []
         for answer_code in answer_codes:
-            if self._use_code:
-                translated_codes.append(translated_options[int(answer_code)])
-            else:
-                translated_codes.append(answer_code)
+            translated_codes.append(translated_options[int(answer_code)])
         return translated_codes
 
-    # def _simulate_answer(self, human_readable=True) -> dict[str, Union[int, str]]:
-    #     """Simulate a valid answer for debugging purposes."""
-    #     from edsl.utilities.utilities import random_string
-
-    #     min_selections = self.min_selections or 1
-    #     max_selections = self.max_selections or len(self.question_options)
-    #     num_selections = random.randint(min_selections, max_selections)
-    #     if human_readable:
-    #         # Select a random number of options from self.question_options
-    #         selected_options = random.sample(self.question_options, num_selections)
-    #         answer = {
-    #             "answer": selected_options,
-    #             "comment": random_string(),
-    #         }
-    #     else:
-    #         # Select a random number of indices from the range of self.question_options
-    #         selected_indices = random.sample(
-    #             range(len(self.question_options)), num_selections
-    #         )
-    #         answer = {
-    #             "answer": selected_indices,
-    #             "comment": random_string(),
-    #         }
-    #     return answer
+    def _simulate_answer(self, human_readable=True) -> dict[str, Union[int, str]]:
+        """Simulate a valid answer for debugging purposes."""
+        from edsl.utilities.utilities import random_string
+
+        min_selections = self.min_selections or 1
+        max_selections = self.max_selections or len(self.question_options)
+        num_selections = random.randint(min_selections, max_selections)
+        if human_readable:
+            # Select a random number of options from self.question_options
+            selected_options = random.sample(self.question_options, num_selections)
+            answer = {
+                "answer": selected_options,
+                "comment": random_string(),
+            }
+        else:
+            # Select a random number of indices from the range of self.question_options
+            selected_indices = random.sample(
+                range(len(self.question_options)), num_selections
+            )
+            answer = {
+                "answer": selected_indices,
+                "comment": random_string(),
+            }
+        return answer
 
     @property
     def question_html_content(self) -> str:
@@ -308,8 +125,7 @@ class QuestionCheckBox(QuestionBase):
     # Helpful methods
     ################
     @classmethod
-    @inject_exception
-    def example(cls, include_comment=False, use_code=True) -> QuestionCheckBox:
+    def example(cls) -> QuestionCheckBox:
         """Return an example checkbox question."""
         return cls(
             question_name="never_eat",
@@ -323,8 +139,6 @@ class QuestionCheckBox(QuestionBase):
             ],
             min_selections=2,
             max_selections=5,
-            use_code=use_code,
-            include_comment=include_comment,
         )
 
 
@@ -351,9 +165,3 @@ def main():
     import doctest
 
     doctest.testmod(optionflags=doctest.ELLIPSIS)
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod(optionflags=doctest.ELLIPSIS)

edsl/questions/QuestionExtract.py

@@ -1,112 +1,20 @@
 from __future__ import annotations
-from typing import Any, Optional, Dict
+from typing import Any
 from edsl.questions.QuestionBase import QuestionBase
 from edsl.questions.descriptors import AnswerTemplateDescriptor
 
-from edsl.questions.ResponseValidatorABC import ResponseValidatorABC
-from edsl.questions.ResponseValidatorABC import BaseResponse
-from edsl.exceptions import QuestionAnswerValidationError
-from edsl.questions.decorators import inject_exception
-
-from typing import Dict, Any
-from pydantic import create_model, Field
-
-import json
-import re
-
-
-def extract_json(text, expected_keys, verbose=False):
-    # Escape special regex characters in keys
-    escaped_keys = [re.escape(key) for key in expected_keys]
-
-    # Create a pattern that looks for all expected keys
-    pattern = r"\{[^}]*" + r"[^}]*".join(escaped_keys) + r"[^}]*\}"
-
-    json_match = re.search(pattern, text)
-
-    if json_match:
-        json_str = json_match.group(0)
-        try:
-            # Parse the extracted string as JSON
-            json_data = json.loads(json_str)
-
-            # Verify that all expected keys are present
-            if all(key in json_data for key in expected_keys):
-                return json_data
-            else:
-                if verbose:
-                    print(
-                        "Error: Not all expected keys were found in the extracted JSON."
-                    )
-                return None
-        except json.JSONDecodeError:
-            if verbose:
-                print("Error: The extracted content is not valid JSON.")
-            return None
-    else:
-        if verbose:
-            print("Error: No JSON-like structure found with all expected keys.")
-        return None
-
-
-def dict_to_pydantic_model(input_dict: Dict[str, Any]) -> Any:
-    field_definitions = {
-        key: (str, Field(default=str(value))) for key, value in input_dict.items()
-    }
-
-    DynamicModel = create_model("DynamicModel", **field_definitions)
-
-    class AnswerModel(BaseResponse):
-        answer: DynamicModel
-        generated_tokens: Optional[str] = None
-        comment: Optional[str] = None
-
-    return AnswerModel
-
-
-class ExtractResponseValidator(ResponseValidatorABC):
-    required_params = ["answer_template"]
-    valid_examples = [({"answer": "This is great"}, {})]
-    invalid_examples = [
-        (
-            {"answer": None},
-            {"answer_template": {"name": "John Doe", "profession": "Carpenter"}},
-            "Result cannot be empty",
-        ),
-    ]
-
-    def custom_validate(self, response) -> BaseResponse:
-        return response.dict()
-
-    def fix(self, response, verbose=False):
-        raw_tokens = response["generated_tokens"]
-        if verbose:
-            print(f"Invalid response of QuestionExtract was: {raw_tokens}")
-        extracted_json = extract_json(raw_tokens, self.answer_template.keys(), verbose)
-        if verbose:
-            print("Proposed solution is: ", extracted_json)
-        return {
-            "answer": extracted_json,
-            "comment": response.get("comment", None),
-            "generated_tokens": raw_tokens,
-        }
-
 
 class QuestionExtract(QuestionBase):
     """This question prompts the agent to extract information from a string and return it in a given template."""
 
     question_type = "extract"
     answer_template: dict[str, Any] = AnswerTemplateDescriptor()
-    _response_model = None
-    response_validator_class = ExtractResponseValidator
 
     def __init__(
         self,
         question_text: str,
         answer_template: dict[str, Any],
         question_name: str,
-        answering_instructions: str = None,
-        question_presentation: str = None,
     ):
         """Initialize the question.
 
@@ -118,11 +26,33 @@ class QuestionExtract(QuestionBase):
         self.question_name = question_name
         self.question_text = question_text
         self.answer_template = answer_template
-        self.answering_instructions = answering_instructions
-        self.question_presentation = question_presentation
 
-    def create_response_model(self):
-        return dict_to_pydantic_model(self.answer_template)
+    ################
+    # Answer methods
+    ################
+    def _validate_answer(self, answer: Any) -> dict[str, Any]:
+        """Validate the answer."""
+        # raw_json = answer["answer"]
+        # fixed_json_data = re.sub(r"\'", '"', raw_json)
+        # answer["answer"] = json.loads(fixed_json_data)
+        self._validate_answer_template_basic(answer)
+        # self._validate_answer_key_value(answer, "answer", dict)
+
+        self._validate_answer_extract(answer)
+        return answer
+
+    def _translate_answer_code_to_answer(self, answer, scenario: "Scenario" = None):
+        """Return the answer 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": {key: random_string() for key in self.answer_template.keys()},
+            "comment": random_string(),
+        }
 
     @property
     def question_html_content(self) -> str:
@@ -147,7 +77,6 @@ class QuestionExtract(QuestionBase):
     # Helpful methods
     ################
     @classmethod
-    @inject_exception
     def example(cls) -> QuestionExtract:
         """Return an example question."""
         return cls(