edsl 0.1.15__py3-none-any.whl → 0.1.40__py3-none-any.whl

edsl/prompts/Prompt.py

@@ -1,52 +1,110 @@
-import textwrap
-from abc import ABC
-from typing import Any, List
-import io
+from __future__ import annotations
+from typing import Any, List, Union, Dict, Optional
+from pathlib import Path
 
-from rich.console import Console
-from rich.table import Table
+# from jinja2 import Undefined
 
-from jinja2 import Template, Environment, meta, TemplateSyntaxError
 
 from edsl.exceptions.prompts import TemplateRenderError
-from edsl.prompts.prompt_config import (
-    C2A,
-    names_to_component_types,
-    ComponentTypes,
-    NEGATIVE_INFINITY,
-)
-from edsl.prompts.registry import RegisterPromptsMeta
-
-from edsl.Base import PersistenceMixin, RichPrintingMixin
+from edsl.Base import PersistenceMixin, RepresentationMixin
 
 MAX_NESTING = 100
 
 
-class PromptBase(
-    PersistenceMixin, RichPrintingMixin, ABC, metaclass=RegisterPromptsMeta
-):
-    component_type = ComponentTypes.GENERIC
+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 __len__(self):
+        """Return the length of the prompt text."""
+        return len(self.text)
+
+    @classmethod
+    def prompt_attributes(cls) -> List[str]:
+        """Return the prompt class attributes."""
+        return {k: v for k, v in cls.__dict__.items() if not k.startswith("_")}
+
+    def __init__(self, text: Optional[str] = None):
+        """Create a `Prompt` object.
 
-    def __init__(self, text=None):
+        :param text: The text of the prompt.
+        """
         if text is None:
             if hasattr(self, "default_instructions"):
                 text = self.default_instructions
             else:
                 text = ""
+        if isinstance(text, Prompt):
+            # make it idempotent w/ a prompt
+            text = text.text
         self._text = text
 
+    @classmethod
+    def from_txt(cls, filename: str) -> PromptBase:
+        """Create a `Prompt` from text.
+
+        :param text: The text of the prompt.
+        """
+        with open(filename, "r") as f:
+            text = f.read()
+        return cls(text=text)
+
+    @classmethod
+    def from_template(
+        cls,
+        file_name: str,
+        path_to_folder: Optional[Union[str, Path]] = None,
+        **kwargs: Dict[str, Any],
+    ) -> "PromptBase":
+        """Create a `PromptBase` from a Jinja template.
+
+        Args:
+            file_name (str): The name of the Jinja template file.
+            path_to_folder (Union[str, Path]): The path to the folder containing the template.
+                            Can be absolute or relative.
+            **kwargs: Variables to be passed to the template for rendering.
+
+        Returns:
+            PromptBase: An instance of PromptBase with the rendered template as text.
+        """
+        # if file_name lacks the .j2 extension, add it
+        if not file_name.endswith(".jinja"):
+            file_name += ".jinja"
+
+        # Convert path_to_folder to a Path object if it's a string
+        if path_to_folder is None:
+            from importlib import resources
+            import os
+
+            path_to_folder = resources.path("edsl.questions", "prompt_templates")
+
+        try:
+            folder_path = Path(path_to_folder)
+        except Exception as e:
+            raise ValueError(f"Invalid path: {path_to_folder}. Error: {e}")
+
+        with open(folder_path.joinpath(file_name), "r") as f:
+            text = f.read()
+        return cls(text=text)
+
     @property
     def text(self):
+        """Return the `Prompt` text."""
         return self._text
 
     def __add__(self, other_prompt):
-        """
+        """Add two prompts together.
+
+        Example:
+
         >>> p = Prompt("Hello, {{person}}")
         >>> p2 = Prompt("How are you?")
         >>> p + p2
-        Prompt(text='Hello, {{person}}How are you?')
+        Prompt(text=\"""Hello, {{person}}How are you?\""")
+
         >>> p + "How are you?"
-        Prompt(text='Hello, {{person}}How are you?')
+        Prompt(text=\"""Hello, {{person}}How are you?\""")
         """
         if isinstance(other_prompt, str):
             return self.__class__(self.text + other_prompt)
@@ -54,7 +112,9 @@ class PromptBase(
             return self.__class__(text=self.text + other_prompt.text)
 
     def __str__(self):
-        """
+        """Return the `Prompt` text.
+
+        Example:
         >>> p = Prompt("Hello, {{person}}")
         >>> str(p)
         'Hello, {{person}}'
@@ -62,7 +122,10 @@ class PromptBase(
         return self.text
 
     def __contains__(self, text_to_check):
-        """
+        """Check if the text_to_check is in the `Prompt` text.
+
+        Example:
+
         >>> p = Prompt("Hello, {{person}}")
         >>> "person" in p
         True
@@ -72,42 +135,75 @@ class PromptBase(
         return text_to_check in self.text
 
     def __repr__(self):
-        """
+        """Return the `Prompt` text.
+
+        Example:
         >>> p = Prompt("Hello, {{person}}")
         >>> p
-        Prompt(text='Hello, {{person}}')
+        Prompt(text=\"""Hello, {{person}}\""")
         """
-        return f"Prompt(text='{self.text}')"
+        return f'Prompt(text="""{self.text}""")'
+
+    def template_variables(self) -> list[str]:
+        """Return the the variables in the template.
+
+        Example:
 
-    def template_variables(
-        self,
-    ) -> list[str]:
-        """
         >>> p = Prompt("Hello, {{person}}")
         >>> p.template_variables()
         ['person']
+
         """
         return self._template_variables(self.text)
 
     @staticmethod
     def _template_variables(template: str) -> list[str]:
-        """ """
-        env = Environment()
+        """Find and return the template variables.
+
+        :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))
 
-    def undefined_template_variables(self, replcement_dict):
-        return [var for var in self.template_variables() if var not in replcement_dict]
+    def undefined_template_variables(self, replacement_dict: dict):
+        """Return the variables in the template that are not in the replacement_dict.
+
+        :param replacement_dict: A dictionary of replacements to populate the template.
+
+        Example:
+
+        >>> p = Prompt("Hello, {{person}}")
+        >>> p.undefined_template_variables({"person": "John"})
+        []
+
+        >>> p = Prompt("Hello, {{title}} {{person}}")
+        >>> p.undefined_template_variables({"person": "John"})
+        ['title']
+        """
+        return [var for var in self.template_variables() if var not in replacement_dict]
 
     def unused_traits(self, traits: dict):
+        """Return the traits that are not used in the template."""
         return [trait for trait in traits if trait not in self.template_variables()]
 
     @property
     def has_variables(self) -> bool:
-        """
+        """Return True if the prompt has variables.
+
+        Example:
+
         >>> p = Prompt("Hello, {{person}}")
         >>> p.has_variables
         True
+
         >>> p = Prompt("Hello, person")
         >>> p.has_variables
         False
@@ -115,37 +211,64 @@ class PromptBase(
         return len(self.template_variables()) > 0
 
     def render(self, primary_replacement: dict, **additional_replacements) -> str:
-        """Renders the prompt with the replacements
+        """Render the prompt with the replacements.
+
+        :param primary_replacement: The primary replacement dictionary.
+        :param additional_replacements: Additional replacement dictionaries.
 
         >>> p = Prompt("Hello, {{person}}")
         >>> p.render({"person": "John"})
-        'Hello, John'
+        Prompt(text=\"""Hello, John\""")
+
         >>> p.render({"person": "Mr. {{last_name}}", "last_name": "Horton"})
-        'Hello, Mr. Horton'
+        Prompt(text=\"""Hello, Mr. Horton\""")
+
         >>> p.render({"person": "Mr. {{last_name}}", "last_name": "Ho{{letter}}ton"}, max_nesting = 1)
-        'Hello, Mr. Horton'
+        Prompt(text=\"""Hello, Mr. Ho{{ letter }}ton\""")
+
+        >>> p.render({"person": "Mr. {{last_name}}"})
+        Prompt(text=\"""Hello, Mr. {{ last_name }}\""")
         """
-        new_text = self._render(
-            self.text, primary_replacement, **additional_replacements
-        )
-        return self.__class__(text=new_text)
+        try:
+            new_text = self._render(
+                self.text, primary_replacement, **additional_replacements
+            )
+            return self.__class__(text=new_text)
+        except Exception as e:
+            print(f"Error rendering prompt: {e}")
+            return self
 
     @staticmethod
-    def _render(text, primary_replacement, **additional_replacements) -> "PromptBase":
-        """
-            Renders the template text with variables replaced from the provided named dictionaries.
-            Allows for nested variable resolution up to a specified maximum nesting depth.
+    def _render(
+        text: str, primary_replacement, **additional_replacements
+    ) -> "PromptBase":
+        """Render the template text with variables replaced from the provided named dictionaries.
+
+        :param text: The text to render.
+        :param primary_replacement: The primary replacement dictionary.
+        :param additional_replacements: Additional replacement dictionaries.
+
+        Allows for nested variable resolution up to a specified maximum nesting depth.
+
+        Example:
 
         >>> codebook = {"age": "Age"}
         >>> p = Prompt("You are an agent named {{ name }}. {{ codebook['age']}}: {{ age }}")
         >>> p.render({"name": "John", "age": 44}, codebook=codebook)
-        'You are an agent named John. Age: 44'
-
+        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
             for _ in range(MAX_NESTING):
-                rendered_text = Template(text).render(
+                # breakpoint()
+                rendered_text = env.from_string(text).render(
                     primary_replacement, **additional_replacements
                 )
                 if rendered_text == previous_text:
@@ -159,65 +282,71 @@ class PromptBase(
                 "Too much nesting - you created an infinite loop here, pal"
             )
         except TemplateSyntaxError as e:
-            raise TemplateRenderError(f"Template syntax error: {e}")
+            raise TemplateRenderError(
+                f"Template syntax error: {e}. Bad template: {text}"
+            )
+
+    def to_dict(self, add_edsl_version=False) -> dict[str, Any]:
+        """Return the `Prompt` as a dictionary.
+
+        Example:
 
-    def to_dict(self):
-        """
         >>> p = Prompt("Hello, {{person}}")
         >>> p.to_dict()
         {'text': 'Hello, {{person}}', 'class_name': 'Prompt'}
+
         """
         return {"text": self.text, "class_name": self.__class__.__name__}
 
     @classmethod
-    def from_dict(cls, data):
-        """
+    def from_dict(cls, data) -> PromptBase:
+        """Create a `Prompt` from a dictionary.
+
+        Example:
+
         >>> p = Prompt("Hello, {{person}}")
         >>> p2 = Prompt.from_dict(p.to_dict())
         >>> p2
-        Prompt(text='Hello, {{person}}')
+        Prompt(text=\"""Hello, {{person}}\""")
+
         """
-        class_name = data["class_name"]
-        cls = RegisterPromptsMeta._registry.get(class_name, Prompt)
-        return cls(text=data["text"])
-
-    def rich_print(self):
-        """Displays 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
+        # 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
 
     @classmethod
     def example(cls):
+        """Return an example of the prompt."""
         return cls(cls.default_instructions)
 
 
-class Prompt(PromptBase):
-    component_type = ComponentTypes.GENERIC
-
-
-from edsl.prompts.library.question_multiple_choice import *
-from edsl.prompts.library.agent_instructions import *
-from edsl.prompts.library.agent_persona import *
-
-from edsl.prompts.library.question_budget import *
-from edsl.prompts.library.question_checkbox import *
-from edsl.prompts.library.question_freetext import *
-from edsl.prompts.library.question_linear_scale import *
-from edsl.prompts.library.question_numerical import *
-from edsl.prompts.library.question_rank import *
-from edsl.prompts.library.question_extract import *
-from edsl.prompts.library.question_list import *
-
-
 if __name__ == "__main__":
+    print("Running doctests...")
     import doctest
 
     doctest.testmod()
+
+# from edsl.prompts.library.question_multiple_choice import *
+# from edsl.prompts.library.agent_instructions import *
+# from edsl.prompts.library.agent_persona import *
+
+# from edsl.prompts.library.question_budget import *
+# from edsl.prompts.library.question_checkbox import *
+# from edsl.prompts.library.question_freetext import *
+# from edsl.prompts.library.question_linear_scale import *
+# from edsl.prompts.library.question_numerical import *
+# from edsl.prompts.library.question_rank import *
+# from edsl.prompts.library.question_extract import *
+# from edsl.prompts.library.question_list import *

edsl/prompts/__init__.py

@@ -1,2 +1,2 @@
-from edsl.prompts.registry import get_classes
+# 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