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

edsl/prompts/Prompt.py

@@ -1,43 +1,21 @@
 from __future__ import annotations
-from typing import Optional
-from abc import ABC
-from typing import Any, List
-
-from jinja2 import Environment, FileSystemLoader
-from typing import Union, Dict
+from typing import Any, List, Union, Dict, Optional
 from pathlib import Path
 
-from rich.table import Table
-from jinja2 import Template, Environment, meta, TemplateSyntaxError, Undefined
-
-
-class PreserveUndefined(Undefined):
-    def __str__(self):
-        return "{{ " + str(self._undefined_name) + " }}"
+# from jinja2 import Undefined
 
 
 from edsl.exceptions.prompts import TemplateRenderError
-from edsl.Base import PersistenceMixin, RichPrintingMixin
+from edsl.Base import PersistenceMixin, RepresentationMixin
 
 MAX_NESTING = 100
 
 
-class Prompt(PersistenceMixin, RichPrintingMixin):
+class Prompt(PersistenceMixin, RepresentationMixin):
     """Class for creating a prompt to be used in a survey."""
 
     default_instructions: Optional[str] = "Do good things, friendly LLM!"
 
-    def _repr_html_(self):
-        """Return an HTML representation of the Prompt."""
-        # from edsl.utilities.utilities import data_to_html
-        # return data_to_html(self.to_dict())
-        d = self.to_dict()
-        data = [[k, v] for k, v in d.items()]
-        from tabulate import tabulate
-
-        table = str(tabulate(data, headers=["keys", "values"], tablefmt="html"))
-        return f"<pre>{table}</pre>"
-
     def __len__(self):
         """Return the length of the prompt text."""
         return len(self.text)
@@ -185,6 +163,12 @@ class Prompt(PersistenceMixin, RichPrintingMixin):
         :param template: The template to find the variables in.
 
         """
+        from jinja2 import Environment, meta, Undefined
+
+        class PreserveUndefined(Undefined):
+            def __str__(self):
+                return "{{ " + str(self._undefined_name) + " }}"
+
         env = Environment(undefined=PreserveUndefined)
         ast = env.parse(template)
         return list(meta.find_undeclared_variables(ast))
@@ -273,6 +257,12 @@ class Prompt(PersistenceMixin, RichPrintingMixin):
         >>> p.render({"name": "John", "age": 44}, codebook=codebook)
         Prompt(text=\"""You are an agent named John. Age: 44\""")
         """
+        from jinja2 import Environment, meta, TemplateSyntaxError, Undefined
+
+        class PreserveUndefined(Undefined):
+            def __str__(self):
+                return "{{ " + str(self._undefined_name) + " }}"
+
         env = Environment(undefined=PreserveUndefined)
         try:
             previous_text = None
@@ -296,7 +286,7 @@ class Prompt(PersistenceMixin, RichPrintingMixin):
                 f"Template syntax error: {e}. Bad template: {text}"
             )
 
-    def to_dict(self) -> dict[str, Any]:
+    def to_dict(self, add_edsl_version=False) -> dict[str, Any]:
         """Return the `Prompt` as a dictionary.
 
         Example:
@@ -323,18 +313,18 @@ class Prompt(PersistenceMixin, RichPrintingMixin):
         # class_name = data["class_name"]
         return Prompt(text=data["text"])
 
-    def rich_print(self):
-        """Display an object as a table."""
-        table = Table(title="Prompt")
-        table.add_column("Attribute", style="bold")
-        table.add_column("Value")
-
-        to_display = self.__dict__.copy()
-        for attr_name, attr_value in to_display.items():
-            table.add_row(attr_name, repr(attr_value))
-        table.add_row("Component type", str(self.component_type))
-        table.add_row("Model", str(getattr(self, "model", "Not specified")))
-        return table
+    # def rich_print(self):
+    #     """Display an object as a table."""
+    #     table = Table(title="Prompt")
+    #     table.add_column("Attribute", style="bold")
+    #     table.add_column("Value")
+
+    #     to_display = self.__dict__.copy()
+    #     for attr_name, attr_value in to_display.items():
+    #         table.add_row(attr_name, repr(attr_value))
+    #     table.add_row("Component type", str(self.component_type))
+    #     table.add_row("Model", str(getattr(self, "model", "Not specified")))
+    #     return table
 
     @classmethod
     def example(cls):

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