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

edsl/prompts/__init__.py

@@ -1,2 +1,2 @@
-# from edsl.prompts.registry import get_classes
-from edsl.prompts.Prompt import Prompt
+# from edsl.prompts.registry import get_classes
+from edsl.prompts.Prompt import Prompt

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