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

edsl/questions/AnswerValidatorMixin.py

@@ -2,7 +2,7 @@
 
 import re
 from typing import Any, Type, Union
-from edsl.exceptions import (
+from edsl.exceptions.questions import (
     QuestionAnswerValidationError,
 )
 
@@ -213,7 +213,12 @@ class AnswerValidatorMixin:
         - is not less than `min_value`
         - is not greater than `max_value`
         """
-        value = float(answer.get("answer"))
+        try:
+            value = float(answer.get("answer"))
+        except ValueError:
+            raise QuestionAnswerValidationError(
+                f"Answer must real number or convertible to a real number (got {answer.get('answer')})."
+            )
         if self.min_value is not None and value < self.min_value:
             raise QuestionAnswerValidationError(
                 f"Value {value} is less than {self.min_value}"
@@ -279,6 +284,46 @@ class AnswerValidatorMixin:
                 f"Rank answer {value}, but exactly {self.num_selections} selections required."
             )
 
+    def _validate_answer_matrix(self, answer: dict[str, Any]) -> None:
+        """Validate QuestionMatrix-specific answer.
+
+        Check that answer["answer"]:
+        - is a dictionary
+        - has all required question_items as keys
+        - has values that are valid options from question_options
+        - has the correct number of responses (one per item)
+        """
+        value = answer.get("answer")
+
+        # Check that answer is a dictionary
+        if not isinstance(value, dict):
+            raise QuestionAnswerValidationError(
+                f"Matrix answer must be a dictionary mapping items to responses (got {value})"
+            )
+
+        # Check that all required items are present
+        required_items = set(self.question_items)
+        provided_items = set(value.keys())
+
+        if missing_items := (required_items - provided_items):
+            raise QuestionAnswerValidationError(
+                f"Missing responses for items: {missing_items}"
+            )
+
+        if extra_items := (provided_items - required_items):
+            raise QuestionAnswerValidationError(
+                f"Unexpected responses for items: {extra_items}"
+            )
+
+        # Check that all responses are valid options
+        valid_options = set(self.question_options)
+        for item, response in value.items():
+            if response not in valid_options:
+                raise QuestionAnswerValidationError(
+                    f"Invalid response '{response}' for item '{item}'. "
+                    f"Must be one of: {valid_options}"
+                )
+
 
 if __name__ == "__main__":
     pass

edsl/questions/ExceptionExplainer.py

@@ -0,0 +1,77 @@
+from pydantic import ValidationError
+from typing import Union
+
+
+class ExceptionExplainer:
+    """
+    A class that converts validation errors into human-readable explanations,
+    specifically for Language Model responses.
+    """
+
+    def __init__(self, error: Union[ValidationError, Exception], model_response: str):
+        """
+        Initialize the explainer with the error and model response.
+
+        Args:
+            error: The validation error that occurred
+            model_response: The raw response from the Language Model
+        """
+        self.error = error
+        self.model_response = model_response
+
+    def explain(self) -> str:
+        """
+        Generate a human-readable explanation of why the model's response failed validation.
+
+        Returns:
+            A user-friendly explanation of why the model's response was invalid
+        """
+        self.error = self.error.pydantic_error
+        return self._explain_validation_error()
+
+        # Fallback for unknown errors
+        return self._create_generic_explanation()
+
+    def _explain_validation_error(self) -> str:
+        """Handle Pydantic ValidationError specifically."""
+        error_dict = self.error.errors()
+        explanations = []
+
+        context = f'The AI model returned "{self.model_response}", but this was invalid for the question you asked and the constraints you provided.\n'
+        explanations.append(context)
+        explanations.append("Reason(s) invalidated:")
+        for e in error_dict:
+            msg = e.get("msg", "Unknown error")
+            explanations.append(f"- {msg}")
+
+        main_message = "\n".join(explanations)
+        return f"{main_message}\n\n{self._get_suggestion()}"
+
+    def _create_generic_explanation(self) -> str:
+        """Create a generic explanation for non-ValidationError exceptions."""
+        return (
+            f'The AI model returned "{self.model_response}", but this response was invalid. '
+            f"Error: {str(self.error)}"
+        )
+
+    def _get_suggestion(self) -> str:
+        """Get a suggestion for handling the error."""
+        return (
+            "EDSL Advice:\n"
+            "- Look at the Model comments - often the model will provide a hint about what went wrong.\n"
+            "- If the model's response doesn't make sense, try rephrasing your question.\n"
+            "- Try using 'use_code' parameter of a MultipleChoice.\n"
+            "- A QuestionFreeText will almost always validate.\n"
+            "- Try setting the 'permissive' = True parameter in the Question constructor."
+        )
+
+
+# Example usage:
+if __name__ == "__main__":
+    try:
+        # Your validation code here
+        raise ValidationError.parse_obj({"answer": "120"})
+    except ValidationError as e:
+        explainer = ExceptionExplainer(e, "120")
+        explanation = explainer.explain()
+        print(explanation)

edsl/questions/HTMLQuestion.py

@@ -0,0 +1,103 @@
+from typing import Optional
+from edsl.prompts.Prompt import Prompt
+
+
+class HTMLQuestion:
+    def __init__(self, question):
+        self.question = question
+
+    def html(
+        self,
+        scenario: Optional[dict] = None,
+        agent: Optional[dict] = {},
+        answers: Optional[dict] = None,
+        include_question_name: bool = False,
+        height: Optional[int] = None,
+        width: Optional[int] = None,
+        iframe=False,
+    ):
+        """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}
+
+        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, "question_type"):
+            self.question.question_type = "unknown"
+
+        if hasattr(self.question, "question_html_content"):
+            question_content = self.question.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.question_text).render(context)
+        except Exception as e:
+            print(
+                f"Error rendering question: question_text = {self.question.question_text}, error = {e}"
+            )
+            question_text = self.question.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.question_name,
+                "question_text": question_text,
+                "question_type": self.question.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

edsl/questions/LoopProcessor.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)
+"""