edsl 0.1.38.dev4__py3-none-any.whl → 0.1.39__py3-none-any.whl

edsl/questions/loop_processor.py

@@ -0,0 +1,149 @@
+from typing import List, Any, Dict, Union
+from jinja2 import Environment
+from edsl.questions.QuestionBase import QuestionBase
+from edsl import ScenarioList
+
+
+class LoopProcessor:
+    def __init__(self, question: QuestionBase):
+        self.question = question
+        self.env = Environment()
+
+    def process_templates(self, scenario_list: ScenarioList) -> List[QuestionBase]:
+        """Process templates for each scenario and return list of modified questions.
+
+        Args:
+            scenario_list: List of scenarios to process templates against
+
+        Returns:
+            List of QuestionBase objects with rendered templates
+        """
+        questions = []
+        starting_name = self.question.question_name
+
+        for index, scenario in enumerate(scenario_list):
+            question_data = self.question.to_dict().copy()
+            processed_data = self._process_data(question_data, scenario)
+
+            if processed_data["question_name"] == starting_name:
+                processed_data["question_name"] += f"_{index}"
+
+            questions.append(QuestionBase.from_dict(processed_data))
+
+        return questions
+
+    def _process_data(
+        self, data: Dict[str, Any], scenario: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Process all data fields according to their type.
+
+        Args:
+            data: Dictionary of question data
+            scenario: Current scenario to render templates against
+
+        Returns:
+            Processed dictionary with rendered templates
+        """
+        processed = {}
+
+        for key, value in [(k, v) for k, v in data.items() if v is not None]:
+            processed[key] = self._process_value(key, value, scenario)
+
+        return processed
+
+    def _process_value(self, key: str, value: Any, scenario: Dict[str, Any]) -> Any:
+        """Process a single value according to its type.
+
+        Args:
+            key: Dictionary key
+            value: Value to process
+            scenario: Current scenario
+
+        Returns:
+            Processed value
+        """
+        if key == "question_options" and isinstance(value, str):
+            return value
+
+        if key == "option_labels":
+            import json
+
+            return (
+                eval(self._render_template(value, scenario))
+                if isinstance(value, str)
+                else value
+            )
+
+        if isinstance(value, str):
+            return self._render_template(value, scenario)
+
+        if isinstance(value, list):
+            return self._process_list(value, scenario)
+
+        if isinstance(value, dict):
+            return self._process_dict(value, scenario)
+
+        if isinstance(value, (int, float)):
+            return value
+
+        raise ValueError(f"Unexpected value type: {type(value)} for key '{key}'")
+
+    def _render_template(self, template: str, scenario: Dict[str, Any]) -> str:
+        """Render a single template string.
+
+        Args:
+            template: Template string to render
+            scenario: Current scenario
+
+        Returns:
+            Rendered template string
+        """
+        return self.env.from_string(template).render(scenario)
+
+    def _process_list(self, items: List[Any], scenario: Dict[str, Any]) -> List[Any]:
+        """Process all items in a list.
+
+        Args:
+            items: List of items to process
+            scenario: Current scenario
+
+        Returns:
+            List of processed items
+        """
+        return [
+            self._render_template(item, scenario) if isinstance(item, str) else item
+            for item in items
+        ]
+
+    def _process_dict(
+        self, data: Dict[str, Any], scenario: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Process all keys and values in a dictionary.
+
+        Args:
+            data: Dictionary to process
+            scenario: Current scenario
+
+        Returns:
+            Dictionary with processed keys and values
+        """
+        return {
+            (self._render_template(k, scenario) if isinstance(k, str) else k): (
+                self._render_template(v, scenario) if isinstance(v, str) else v
+            )
+            for k, v in data.items()
+        }
+
+
+# Usage example:
+"""
+from edsl import QuestionFreeText, ScenarioList
+
+question = QuestionFreeText(
+    question_text="What are your thoughts on: {{subject}}?",
+    question_name="base_{{subject}}"
+)
+processor = TemplateProcessor(question)
+scenarios = ScenarioList.from_list("subject", ["Math", "Economics", "Chemistry"])
+processed_questions = processor.process_templates(scenarios)
+"""

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

@@ -1,11 +1,16 @@
 from __future__ import annotations
 import copy
 import itertools
-from typing import Optional, List, Callable, Type
-from typing import TypeVar
+from typing import Optional, List, Callable, Type, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from edsl.questions.QuestionBase import QuestionBase
+    from edsl.scenarios.ScenarioList import ScenarioList
 
 
 class QuestionBaseGenMixin:
+    """Mixin for QuestionBase."""
+
     def copy(self) -> QuestionBase:
         """Return a deep copy of the question.
 
@@ -21,7 +26,7 @@ class QuestionBaseGenMixin:
     def option_permutations(self) -> list[QuestionBase]:
         """Return a list of questions with all possible permutations of the options.
 
-        >>> from edsl import QuestionMultipleChoice as Q
+        >>> from edsl.questions.QuestionMultipleChoice import QuestionMultipleChoice as Q
         >>> len(Q.example().option_permutations())
         24
         """
@@ -39,66 +44,60 @@ 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 import QuestionFreeText
-        >>> from edsl import ScenarioList
+        >>> from edsl.questions.QuestionFreeText import QuestionFreeText
+        >>> from edsl.scenarios.ScenarioList 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 jinja2 import Environment
-        from edsl.questions.QuestionBase import QuestionBase
+        from edsl.questions.loop_processor import LoopProcessor
 
-        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}'"
-                    )
+        lp = LoopProcessor(self)
+        return lp.process_templates(scenario_list)
 
-            if new_data["question_name"] == starting_name:
-                new_data["question_name"] = new_data["question_name"] + f"_{index}"
+    def render(self, replacement_dict: dict) -> "QuestionBase":
+        """Render the question components as jinja2 templates with the replacement dictionary.
 
-            questions.append(QuestionBase.from_dict(new_data))
-        return questions
+        :param replacement_dict: The dictionary of values to replace in the question components.
 
-    def render(self, replacement_dict: dict) -> "QuestionBase":
-        """Render the question components as jinja2 templates with the replacement dictionary."""
+        >>> 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?\""")
+
+        """
         from jinja2 import Environment
-        from edsl import Scenario
+        from edsl.scenarios.Scenario import Scenario
 
         strings_only_replacement_dict = {
             k: v for k, v in replacement_dict.items() if not isinstance(v, Scenario)
@@ -123,15 +122,23 @@ class QuestionBaseGenMixin:
 
         return self.apply_function(render_string)
 
-    def apply_function(self, func: Callable, exclude_components=None) -> QuestionBase:
+    def apply_function(
+        self, func: Callable, exclude_components: List[str] = 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/question_registry.py

@@ -96,7 +96,7 @@ class Question(metaclass=Meta):
 
         >>> from edsl import Question
         >>> Question.list_question_types()
-        ['checkbox', 'extract', 'free_text', 'functional', 'likert_five', 'linear_scale', 'list', 'multiple_choice', 'numerical', 'rank', 'top_k', 'yes_no']
+        ['checkbox', 'extract', 'free_text', 'functional', 'likert_five', 'linear_scale', 'list', 'matrix', 'multiple_choice', 'numerical', 'rank', 'top_k', 'yes_no']
         """
         return [
             q

edsl/questions/{ResponseValidatorABC.py → response_validator_abc.py}

@@ -1,23 +1,22 @@
 from abc import ABC, abstractmethod
-from pydantic import BaseModel, Field, field_validator
-
-# from decimal import Decimal
 from typing import Optional, Any, List, TypedDict
 
-from edsl.exceptions import QuestionAnswerValidationError
-from pydantic import ValidationError
+from pydantic import BaseModel, Field, field_validator, ValidationError
 
+from edsl.exceptions.questions import QuestionAnswerValidationError
+from edsl.questions.ExceptionExplainer import ExceptionExplainer
 
-class BaseResponse(BaseModel):
-    answer: Any
-    comment: Optional[str] = None
-    generated_tokens: Optional[str] = None
+from edsl.questions.data_structures import (
+    RawEdslAnswerDict,
+    EdslAnswerDict,
+)
 
 
 class ResponseValidatorABC(ABC):
     required_params: List[str] = []
 
     def __init_subclass__(cls, **kwargs):
+        """This is a metaclass that ensures that all subclasses of ResponseValidatorABC have the required class variables."""
         super().__init_subclass__(**kwargs)
         required_class_vars = ["required_params", "valid_examples", "invalid_examples"]
         for var in required_class_vars:
@@ -52,12 +51,7 @@ class ResponseValidatorABC(ABC):
         if not hasattr(self, "permissive"):
             self.permissive = False
 
-        self.fixes_tried = 0
-
-    class RawEdslAnswerDict(TypedDict):
-        answer: Any
-        comment: Optional[str]
-        generated_tokens: Optional[str]
+        self.fixes_tried = 0  # how many times we've tried to fix the answer
 
     def _preprocess(self, data: RawEdslAnswerDict) -> RawEdslAnswerDict:
         """This is for testing purposes. A question can be given an exception to throw or an answer to always return.
@@ -72,7 +66,8 @@ class ResponseValidatorABC(ABC):
         return self.override_answer if self.override_answer else data
 
     def _base_validate(self, data: RawEdslAnswerDict) -> BaseModel:
-        """This is the main validation function. It takes the response_model and checks the data against it, returning the instantiated model.
+        """This is the main validation function. It takes the response_model and checks the data against it,
+        returning the instantiated model.
 
         >>> rv = ResponseValidatorABC.example("numerical")
         >>> rv._base_validate({"answer": 42})
@@ -81,16 +76,13 @@ class ResponseValidatorABC(ABC):
         try:
             return self.response_model(**data)
         except ValidationError as e:
-            raise QuestionAnswerValidationError(e, data=data, model=self.response_model)
+            raise QuestionAnswerValidationError(
+                message=str(e), pydantic_error=e, data=data, model=self.response_model
+            )
 
     def post_validation_answer_convert(self, data):
         return data
 
-    class EdslAnswerDict(TypedDict):
-        answer: Any
-        comment: Optional[str]
-        generated_tokens: Optional[str]
-
     def validate(
         self,
         raw_edsl_answer_dict: RawEdslAnswerDict,
@@ -128,10 +120,12 @@ class ResponseValidatorABC(ABC):
             edsl_answer_dict = self._extract_answer(pydantic_edsl_answer)
             return self._post_process(edsl_answer_dict)
         except QuestionAnswerValidationError as e:
-            if verbose:
-                print(f"Failed to validate {raw_edsl_answer_dict}; {str(e)}")
             return self._handle_exception(e, raw_edsl_answer_dict)
 
+    def human_explanation(self, e: QuestionAnswerValidationError):
+        explanation = ExceptionExplainer(e, model_response=e.data).explain()
+        return explanation
+
     def _handle_exception(self, e: Exception, raw_edsl_answer_dict) -> EdslAnswerDict:
         if self.fixes_tried == 0:
             self.original_exception = e
@@ -140,12 +134,18 @@ class ResponseValidatorABC(ABC):
             self.fixes_tried += 1
             fixed_data = self.fix(raw_edsl_answer_dict)
             try:
-                return self.validate(fixed_data, fix=True)
+                return self.validate(fixed_data, fix=True)  # early return if validates
             except Exception as e:
                 pass  # we don't log failed fixes
 
+        # If the exception is already a QuestionAnswerValidationError, raise it
+        if isinstance(self.original_exception, QuestionAnswerValidationError):
+            raise self.original_exception
+
+        # If nothing worked, raise the original exception
         raise QuestionAnswerValidationError(
-            self.original_exception,
+            message=self.original_exception,
+            pydantic_error=self.original_exception,
             data=raw_edsl_answer_dict,
             model=self.response_model,
         )
@@ -167,8 +167,22 @@ class ResponseValidatorABC(ABC):
         return q.response_validator
 
 
+def main():
+    rv = ResponseValidatorABC.example()
+    print(rv.validate({"answer": 42}))
+
+
 # Example usage
 if __name__ == "__main__":
     import doctest
 
     doctest.testmod(optionflags=doctest.ELLIPSIS)
+
+    rv = ResponseValidatorABC.example()
+    # print(rv.validate({"answer": 42}))
+
+    rv = ResponseValidatorABC.example()
+    try:
+        rv.validate({"answer": "120"})
+    except QuestionAnswerValidationError as e:
+        print(rv.human_explanation(e))

edsl/questions/response_validator_factory.py

@@ -0,0 +1,34 @@
+from edsl.questions.data_structures import BaseModel
+from edsl.questions.response_validator_abc import ResponseValidatorABC
+
+
+class ResponseValidatorFactory:
+    """Factory class to create a response validator for a question."""
+
+    def __init__(self, question):
+        self.question = question
+
+    @property
+    def response_model(self) -> type["BaseModel"]:
+        if self.question._response_model is not None:
+            return self.question._response_model
+        else:
+            return self.question.create_response_model()
+
+    @property
+    def response_validator(self) -> "ResponseValidatorABC":
+        """Return the response validator."""
+        params = (
+            {
+                "response_model": self.question.response_model,
+            }
+            | {k: getattr(self.question, k) for k in self.validator_parameters}
+            | {"exception_to_throw": getattr(self.question, "exception_to_throw", None)}
+            | {"override_answer": getattr(self.question, "override_answer", None)}
+        )
+        return self.question.response_validator_class(**params)
+
+    @property
+    def validator_parameters(self) -> list[str]:
+        """Return the parameters required for the response validator."""
+        return self.question.response_validator_class.required_params

edsl/questions/templates/matrix/__init__.py

@@ -0,0 +1 @@
+

edsl/questions/templates/matrix/answering_instructions.jinja

@@ -0,0 +1,5 @@
+Please respond with a dictionary mapping row codes to column codes. E.g., {"0": 1, "1": 3}
+
+{% if include_comment %}
+After the answer, you can put a comment explaining your choices on the next line.
+{% endif %} 

edsl/questions/templates/matrix/question_presentation.jinja

@@ -0,0 +1,20 @@
+{{question_text}}
+
+Rows:
+    {% for item in question_items %}
+{{ loop.index0 }}: {{item}}
+    {% endfor %}
+
+Columns:
+    {% for option in question_options %}
+{{ loop.index0 }}: {{option}}
+        {%- if option in option_labels %}
+ ({{option_labels[option]}})
+        {%- endif %}
+    {% endfor %}
+
+
+Select one column option for each row.
+{% if required %}
+All rows require a response.
+{% endif %} 

edsl/results/CSSParameterizer.py

@@ -67,7 +67,7 @@ class CSSParameterizer:
         missing_vars = self._validate_parameters(parameters)
 
         if missing_vars:
-            print(f"Error: Missing required variables: {missing_vars}")
+            # print(f"Error: Missing required variables: {missing_vars}")
             return None
 
         # Format parameters with -- prefix if not present