edsl 0.1.43__py3-none-any.whl → 0.1.45__py3-none-any.whl

edsl/scenarios/PdfExtractor.py

@@ -4,10 +4,30 @@ import os
 class PdfExtractor:
     def __init__(self, pdf_path: str):
         self.pdf_path = pdf_path
+        self._has_pymupdf = self._check_pymupdf()
         #self.constructor = parent_object.__class__
 
+    def _check_pymupdf(self):
+        """Check if PyMuPDF is installed."""
+        try:
+            import fitz
+            return True
+        except ImportError:
+            return False
+        
     def get_pdf_dict(self) -> dict:
-        # Ensure the file exists
+        # First check if the file exists
+        if not os.path.exists(self.pdf_path):
+            raise FileNotFoundError(f"The file {self.pdf_path} does not exist.")
+        
+        # Then check if PyMuPDF is available
+        if not self._has_pymupdf:
+            raise ImportError(
+                "The 'fitz' module (PyMuPDF) is required for PDF extraction. "
+                "Please install it with: pip install pymupdf"
+            )
+        
+        # If we get here, we can safely import and use fitz
         import fitz
 
         if not os.path.exists(self.pdf_path):

edsl/scenarios/Scenario.py

@@ -64,6 +64,15 @@ class Scenario(Base, UserDict, ScenarioHtmlMixin):
         self.data = data if data is not None else {}
         self.name = name
 
+    def __mul__(self, scenario_list_or_scenario: Union["ScenarioList", "Scenario"]) -> "ScenarioList":
+        from edsl.scenarios.ScenarioList import ScenarioList
+        if isinstance(scenario_list_or_scenario, ScenarioList):
+            return scenario_list_or_scenario * self
+        elif isinstance(scenario_list_or_scenario, Scenario):
+            return ScenarioList([self]) * scenario_list_or_scenario
+        else:
+            raise TypeError(f"Cannot multiply Scenario with {type(scenario_list_or_scenario)}")
+
     def replicate(self, n: int) -> "ScenarioList":
         """Replicate a scenario n times to return a ScenarioList.
 
@@ -356,11 +365,18 @@ class Scenario(Base, UserDict, ScenarioHtmlMixin):
 
     @classmethod
     def from_pdf(cls, pdf_path: str):
-        from edsl.scenarios.PdfExtractor import PdfExtractor
-
-        extractor = PdfExtractor(pdf_path)
-        return Scenario(extractor.get_pdf_dict())
-
+        """Create a Scenario from a PDF file."""
+        try:
+            from edsl.scenarios.PdfExtractor import PdfExtractor
+            extractor = PdfExtractor(pdf_path)
+            return Scenario(extractor.get_pdf_dict())
+        except ImportError as e:
+            raise ImportError(
+                f"Could not extract text from PDF: {str(e)}. "
+                "PDF extraction requires the PyMuPDF library. "
+                "Install it with: pip install pymupdf"
+            )
+        
     @classmethod
     def from_pdf_to_image(cls, pdf_path, image_format="jpeg"):
         """
@@ -442,18 +458,18 @@ class Scenario(Base, UserDict, ScenarioHtmlMixin):
 
         >>> s = Scenario({"text": "This is a test.\\nThis is a test.\\n\\nThis is a test."})
         >>> s.chunk("text", num_lines = 1)
-        ScenarioList([Scenario({'text': 'This is a test.', 'text_chunk': 0}), Scenario({'text': 'This is a test.', 'text_chunk': 1}), Scenario({'text': '', 'text_chunk': 2}), Scenario({'text': 'This is a test.', 'text_chunk': 3})])
+        ScenarioList([Scenario({'text': 'This is a test.', 'text_chunk': 0, 'text_char_count': 15, 'text_word_count': 4}), Scenario({'text': 'This is a test.', 'text_chunk': 1, 'text_char_count': 15, 'text_word_count': 4}), Scenario({'text': '', 'text_chunk': 2, 'text_char_count': 0, 'text_word_count': 0}), Scenario({'text': 'This is a test.', 'text_chunk': 3, 'text_char_count': 15, 'text_word_count': 4})])
 
         >>> s.chunk("text", num_words = 2)
-        ScenarioList([Scenario({'text': 'This is', 'text_chunk': 0}), Scenario({'text': 'a test.', 'text_chunk': 1}), Scenario({'text': 'This is', 'text_chunk': 2}), Scenario({'text': 'a test.', 'text_chunk': 3}), Scenario({'text': 'This is', 'text_chunk': 4}), Scenario({'text': 'a test.', 'text_chunk': 5})])
+        ScenarioList([Scenario({'text': 'This is', 'text_chunk': 0, 'text_char_count': 7, 'text_word_count': 2}), Scenario({'text': 'a test.', 'text_chunk': 1, 'text_char_count': 7, 'text_word_count': 2}), Scenario({'text': 'This is', 'text_chunk': 2, 'text_char_count': 7, 'text_word_count': 2}), Scenario({'text': 'a test.', 'text_chunk': 3, 'text_char_count': 7, 'text_word_count': 2}), Scenario({'text': 'This is', 'text_chunk': 4, 'text_char_count': 7, 'text_word_count': 2}), Scenario({'text': 'a test.', 'text_chunk': 5, 'text_char_count': 7, 'text_word_count': 2})])
 
         >>> s = Scenario({"text": "Hello World"})
         >>> s.chunk("text", num_words = 1, include_original = True)
-        ScenarioList([Scenario({'text': 'Hello', 'text_chunk': 0, 'text_original': 'Hello World'}), Scenario({'text': 'World', 'text_chunk': 1, 'text_original': 'Hello World'})])
+        ScenarioList([Scenario({'text': 'Hello', 'text_chunk': 0, 'text_char_count': 5, 'text_word_count': 1, 'text_original': 'Hello World'}), Scenario({'text': 'World', 'text_chunk': 1, 'text_char_count': 5, 'text_word_count': 1, 'text_original': 'Hello World'})])
 
         >>> s = Scenario({"text": "Hello World"})
         >>> s.chunk("text", num_words = 1, include_original = True, hash_original = True)
-        ScenarioList([Scenario({'text': 'Hello', 'text_chunk': 0, 'text_original': 'b10a8db164e0754105b7a99be72e3fe5'}), Scenario({'text': 'World', 'text_chunk': 1, 'text_original': 'b10a8db164e0754105b7a99be72e3fe5'})])
+        ScenarioList([Scenario({'text': 'Hello', 'text_chunk': 0, 'text_char_count': 5, 'text_word_count': 1, 'text_original': 'b10a8db164e0754105b7a99be72e3fe5'}), Scenario({'text': 'World', 'text_chunk': 1, 'text_char_count': 5, 'text_word_count': 1, 'text_original': 'b10a8db164e0754105b7a99be72e3fe5'})])
 
         >>> s.chunk("text")
         Traceback (most recent call last):

edsl/scenarios/ScenarioList.py

@@ -360,6 +360,11 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
         ScenarioList([Scenario({'a': 1, 'b': 3}), Scenario({'a': 1, 'b': 4}), Scenario({'a': 2, 'b': 3}), Scenario({'a': 2, 'b': 4})])
         """
         from itertools import product
+        from edsl import Scenario
+        if isinstance(other, Scenario):
+            other = ScenarioList([other])
+        elif not isinstance(other, ScenarioList):
+            raise TypeError(f"Cannot multiply ScenarioList with {type(other)}")
 
         new_sl = []
         for s1, s2 in list(product(self, other)):
@@ -872,7 +877,7 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
         for scenario in sl:
             scenario[name] = value
         return sl
-
+    
     def rename(self, replacement_dict: dict) -> ScenarioList:
         """Rename the fields in the scenarios.
 
@@ -885,13 +890,35 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
         ScenarioList([Scenario({'first_name': 'Alice', 'years': 30}), Scenario({'first_name': 'Bob', 'years': 25})])
 
         """
-
         new_list = ScenarioList([])
         for obj in self:
             new_obj = obj.rename(replacement_dict)
             new_list.append(new_obj)
         return new_list
 
+    def replace_names(self, new_names: list) -> ScenarioList:
+        """Replace the field names in the scenarios with a new list of names.
+
+        :param new_names: A list of new field names to use.
+
+        Example:
+
+        >>> s = ScenarioList([Scenario({'name': 'Alice', 'age': 30}), Scenario({'name': 'Bob', 'age': 25})])
+        >>> s.replace_names(['first_name', 'years'])
+        ScenarioList([Scenario({'first_name': 'Alice', 'years': 30}), Scenario({'first_name': 'Bob', 'years': 25})])
+        """
+        if not self:
+            return ScenarioList([])
+            
+        if len(new_names) != len(self[0].keys()):
+            raise ScenarioError(
+                f"Length of new names ({len(new_names)}) does not match number of fields ({len(self[0].keys())})"
+            )
+
+        old_names = list(self[0].keys())
+        replacement_dict = dict(zip(old_names, new_names))
+        return self.rename(replacement_dict)
+
     ## NEEDS TO BE FIXED
     # def new_column_names(self, new_names: List[str]) -> ScenarioList:
     #     """Rename the fields in the scenarios.
@@ -935,6 +962,8 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
             entry = {
                 "line_no": line_no + 1,  # Using 1-based index for line numbers
                 "text": text,
+                "num_words": len(text.split()),
+                "num_chars": len(text),
                 "line_before": non_blank_lines[index - 1][1] if index > 0 else None,
                 "line_after": (
                     non_blank_lines[index + 1][1]
@@ -995,8 +1024,49 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
         ScenarioList([Scenario({'name': 'Alice', 'age': 30, 'location': 'New York'}), Scenario({'name': 'Bob', 'age': 25, 'location': 'Los Angeles'})])
         """
         return cls([Scenario(row) for row in df.to_dict(orient="records")])
+    
 
     @classmethod
+    def from_dta(cls, filepath: str, include_metadata: bool = True) -> ScenarioList:
+        """Create a ScenarioList from a Stata file.
+        
+        Args:
+            filepath (str): Path to the Stata (.dta) file
+            include_metadata (bool): If True, extract and preserve variable labels and value labels
+                                    as additional metadata in the ScenarioList
+        
+        Returns:
+            ScenarioList: A ScenarioList containing the data from the Stata file
+        """
+        import pandas as pd
+        
+        # Read the Stata file with pandas
+        df = pd.read_stata(filepath)
+        
+        # Create the basic ScenarioList
+        scenario_list = cls.from_pandas(df)
+        
+        # Extract and preserve metadata if requested
+        if include_metadata:
+            # Get variable labels (if any)
+            variable_labels = {}
+            if hasattr(df, 'variable_labels') and df.variable_labels:
+                variable_labels = df.variable_labels
+            
+            # Get value labels (if any)
+            value_labels = {}
+            if hasattr(df, 'value_labels') and df.value_labels:
+                value_labels = df.value_labels
+            
+            # Store the metadata in the ScenarioList's codebook
+            if variable_labels or value_labels:
+                scenario_list.codebook = {
+                    'variable_labels': variable_labels,
+                    'value_labels': value_labels
+                }
+        
+        return scenario_list
+
     def from_wikipedia(cls, url: str, table_index: int = 0):
         """
         Extracts a table from a Wikipedia page.
@@ -1456,7 +1526,7 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
 
         >>> s = ScenarioList([Scenario({'text': 'The quick brown fox jumps over the lazy dog.'})])
         >>> s.chunk('text', num_words=3)
-        ScenarioList([Scenario({'text': 'The quick brown', 'text_chunk': 0}), Scenario({'text': 'fox jumps over', 'text_chunk': 1}), Scenario({'text': 'the lazy dog.', 'text_chunk': 2})])
+        ScenarioList([Scenario({'text': 'The quick brown', 'text_chunk': 0, 'text_char_count': 15, 'text_word_count': 3}), Scenario({'text': 'fox jumps over', 'text_chunk': 1, 'text_char_count': 14, 'text_word_count': 3}), Scenario({'text': 'the lazy dog.', 'text_chunk': 2, 'text_char_count': 13, 'text_word_count': 3})])
         """
         new_scenarios = []
         for scenario in self:

edsl/scenarios/handlers/__init__.py

@@ -11,3 +11,4 @@ from .pptx import PptxMethods
 from .latex import LaTeXMethods
 from .py import PyMethods
 from .sqlite import SQLiteMethods
+from .jpeg import JpegMethods

edsl/scenarios/handlers/docx.py

@@ -37,7 +37,11 @@ class DocxMethods(FileMethods):
             print("DOCX file was not found.")
 
     def view_notebook(self):
-        import mammoth
+        try:
+            import mammoth
+        except ImportError:
+            print("mammoth is not installed. Please install it using 'pip install mammoth'.")
+            return
         from IPython.display import HTML, display
 
         with open(self.path, "rb") as docx_file:

edsl/scenarios/handlers/jpeg.py

@@ -0,0 +1,39 @@
+import tempfile
+from edsl.scenarios.file_methods import FileMethods
+
+
+class JpegMethods(FileMethods):
+    suffix = "jpeg"
+
+    def view_system(self):
+        import os
+        import subprocess
+
+        if os.path.exists(self.path):
+            try:
+                if (os_name := os.name) == "posix":
+                    subprocess.run(["open", self.path], check=True)  # macOS
+                elif os_name == "nt":
+                    os.startfile(self.path)  # Windows
+                else:
+                    subprocess.run(["xdg-open", self.path], check=True)  # Linux
+            except Exception as e:
+                print(f"Error opening JPEG: {e}")
+        else:
+            print("JPEG file was not found.")
+
+    def view_notebook(self):
+        from IPython.display import Image, display
+
+        display(Image(filename=self.path))
+
+    def example(self):
+        import matplotlib.pyplot as plt
+        import numpy as np
+
+        x = np.linspace(0, 10, 100)
+        y = np.sin(x)
+        plt.plot(x, y)
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".jpeg") as f:
+            plt.savefig(f.name)
+        return f.name

edsl/surveys/Survey.py

@@ -942,12 +942,11 @@ class Survey(SurveyExportMixin, Base):
         # TODO: temp fix by creating a cache
         if cache is None:
             from edsl.data import Cache
+
             c = Cache()
         else:
             c = cache
 
-        
-
         jobs: "Jobs" = self.get_job(model=model, agent=agent, **kwargs).using(c)
         return await jobs.run_async(
             disable_remote_inference=disable_remote_inference,
@@ -1244,6 +1243,29 @@ class Survey(SurveyExportMixin, Base):
 
         return self.by(s).by(agent).by(model)
 
+    ###################
+    # COOP METHODS
+    ###################
+    def humanize(
+        self,
+        project_name: str = "Project",
+        survey_description: Optional[str] = None,
+        survey_alias: Optional[str] = None,
+        survey_visibility: Optional["VisibilityType"] = "unlisted",
+    ) -> dict:
+        """
+        Send the survey to Coop.
+
+        Then, create a project on Coop so you can share the survey with human respondents.
+        """
+        from edsl.coop import Coop
+
+        c = Coop()
+        project_details = c.create_project(
+            self, project_name, survey_description, survey_alias, survey_visibility
+        )
+        return project_details
+
 
 def main():
     """Run the example survey."""
@@ -1255,16 +1277,16 @@ def main():
         q0 = QuestionMultipleChoice(
             question_name="q0",
             question_text="What is the capital of France?",
-            question_options=["London", "Paris", "Rome", "Boston", "I don't know"]
+            question_options=["London", "Paris", "Rome", "Boston", "I don't know"],
         )
         q1 = QuestionList(
             question_name="q1",
             question_text="Name some cities in France.",
-            max_list_items = 5
+            max_list_items=5,
         )
         q2 = QuestionNumerical(
             question_name="q2",
-            question_text="What is the population of {{ q0.answer }}?"
+            question_text="What is the population of {{ q0.answer }}?",
         )
         s = Survey(questions=[q0, q1, q2])
         s = s.add_rule(q0, "q0 == 'Paris'", q2)
@@ -1281,4 +1303,4 @@ if __name__ == "__main__":
     import doctest
 
     # doctest.testmod(optionflags=doctest.ELLIPSIS | doctest.SKIP)
-    doctest.testmod(optionflags=doctest.ELLIPSIS)
+    doctest.testmod(optionflags=doctest.ELLIPSIS)

edsl/surveys/SurveyFlowVisualization.py

@@ -8,51 +8,113 @@ import tempfile
 class SurveyFlowVisualization:
     """A mixin for visualizing the flow of a survey with parameter visualization."""
 
-    def __init__(self, survey: "Survey"):
+    def __init__(self, survey: "Survey", scenario: Optional["Scenario"] = None, agent: Optional["Agent"] = None):
         self.survey = survey
+        self.scenario = scenario or {}
+        self.agent = agent
+        #from edsl import Scenario
+        #self.scenario = Scenario({'hello': 'world'})
 
     def show_flow(self, filename: Optional[str] = None):
         """Create an image showing the flow of users through the survey and question parameters."""
         # Create a graph object
         import pydot
 
-        graph = pydot.Dot(graph_type="digraph")
+        FONT_SIZE = "10"
 
-        # First collect all unique parameters and answer references
+        graph = pydot.Dot(graph_type="digraph", fontsize=FONT_SIZE)
+
+        # First collect all unique parameters and different types of references
         params_and_refs = set()
         param_to_questions = {}  # Keep track of which questions use each parameter
-        answer_refs = set()  # Track answer references between questions
+        reference_types = {}  # Dictionary to store different types of references
+        reference_colors = {
+            'answer': 'purple',
+            'question_text': 'red',
+            'question_options': 'orange',
+            'comment': 'blue',
+            'default': "grey"
+        }
 
         # First pass: collect parameters and their question associations
         for index, question in enumerate(self.survey.questions):
-            # Add the main question node
             question_node = pydot.Node(
-                f"Q{index}", label=f"{question.question_name}", shape="ellipse"
+                f"Q{index}", label=f"{question.question_name}", shape="ellipse", fontsize=FONT_SIZE
             )
             graph.add_node(question_node)
 
-            if hasattr(question, "parameters"):
-                for param in question.parameters:
-                    # Check if this is an answer reference (contains '.answer')
-                    if ".answer" in param:
-                        answer_refs.add((param.split(".")[0], index))
+            if hasattr(question, "detailed_parameters"):
+                for param in question.detailed_parameters:
+                    if "agent." in param:
+                        # Handle agent trait references
+                        trait_name = param.replace("agent.", "")
+                        params_and_refs.add(param)
+                        if param not in param_to_questions:
+                            param_to_questions[param] = []
+                        param_to_questions[param].append(index)
+                    elif "." in param:
+                        source_q, ref_type = param.split(".", 1)
+                        if ref_type not in reference_types:
+                            reference_types[ref_type] = set()
+                        reference_types[ref_type].add((source_q, index))
                     else:
                         params_and_refs.add(param)
                         if param not in param_to_questions:
                             param_to_questions[param] = []
                         param_to_questions[param].append(index)
 
+        # Add edges for all reference types
+        for ref_type, references in reference_types.items():
+            color = reference_colors.get(ref_type, reference_colors['default'])
+            for source_q_name, target_q_index in references:
+                # Find the source question index by name
+                try:
+                    source_q_index = next(
+                        i
+                        for i, q in enumerate(self.survey.questions)
+                        if q.question_name == source_q_name
+                    )
+                except StopIteration:
+                    print(f"Source question {source_q_name} not found in survey.")
+                    continue
+                
+                ref_edge = pydot.Edge(
+                    f"Q{source_q_index}",
+                    f"Q{target_q_index}",
+                    style="dashed",
+                    color=color,
+                    label=f".{ref_type}",
+                    fontcolor=color,
+                    fontname="Courier",
+                    fontsize=FONT_SIZE
+                )
+                graph.add_edge(ref_edge)
+
         # Create parameter nodes and connect them to questions
         for param in params_and_refs:
             param_node_name = f"param_{param}"
-            param_node = pydot.Node(
-                param_node_name,
-                label=f"{{{{ {param} }}}}",
-                shape="box",
-                style="filled",
-                fillcolor="lightgrey",
-                fontsize="10",
-            )
+            node_attrs = {
+                "label": f"{{{{ {param} }}}}",
+                "shape": "box",
+                "style": "filled",
+                "fillcolor": "lightgrey",
+                "fontsize": FONT_SIZE,
+            }
+            
+            # Special handling for agent traits
+            if param.startswith("agent."):
+                node_attrs.update({
+                    "fillcolor": "lightpink",
+                    "label": f"Agent Trait\n{{{{ {param} }}}}"
+                })
+            # Check if parameter exists in scenario
+            elif self.scenario and param in self.scenario:
+                node_attrs.update({
+                    "fillcolor": "lightgreen",
+                    "label": f"Scenario\n{{{{ {param} }}}}"
+                })
+            
+            param_node = pydot.Node(param_node_name, **node_attrs)
             graph.add_node(param_node)
 
             # Connect this parameter to all questions that use it
@@ -61,39 +123,22 @@ class SurveyFlowVisualization:
                     param_node_name,
                     f"Q{q_index}",
                     style="dotted",
-                    color="grey",
                     arrowsize="0.5",
+                    fontsize=FONT_SIZE,
                 )
                 graph.add_edge(param_edge)
 
-        # Add edges for answer references
-        for source_q_name, target_q_index in answer_refs:
-            # Find the source question index by name
-            source_q_index = next(
-                i
-                for i, q in enumerate(self.survey.questions)
-                if q.question_name == source_q_name
-            )
-            ref_edge = pydot.Edge(
-                f"Q{source_q_index}",
-                f"Q{target_q_index}",
-                style="dashed",
-                color="purple",
-                label="answer reference",
-            )
-            graph.add_edge(ref_edge)
-
         # Add an "EndOfSurvey" node
         graph.add_node(
-            pydot.Node("EndOfSurvey", label="End of Survey", shape="rectangle")
+            pydot.Node("EndOfSurvey", label="End of Survey", shape="rectangle", fontsize=FONT_SIZE, style="filled", fillcolor="lightgrey")
         )
 
         # Add edges for normal flow through the survey
         num_questions = len(self.survey.questions)
         for index in range(num_questions - 1):
-            graph.add_edge(pydot.Edge(f"Q{index}", f"Q{index+1}"))
+            graph.add_edge(pydot.Edge(f"Q{index}", f"Q{index+1}", fontsize=FONT_SIZE))
 
-        graph.add_edge(pydot.Edge(f"Q{num_questions-1}", "EndOfSurvey"))
+        graph.add_edge(pydot.Edge(f"Q{num_questions-1}", "EndOfSurvey", fontsize=FONT_SIZE))
 
         relevant_rules = [
             rule
@@ -109,7 +154,7 @@ class SurveyFlowVisualization:
             "purple",
             "brown",
             "cyan",
-            "green",
+            "darkgreen",
         ]
         rule_colors = {
             rule: colors[i % len(colors)] for i, rule in enumerate(relevant_rules)
@@ -133,6 +178,8 @@ class SurveyFlowVisualization:
                     fontcolor=color,
                     tailport="n",
                     headport="n",
+                    fontname="Courier",
+                    fontsize=FONT_SIZE,
                 )
             else:
                 edge = pydot.Edge(
@@ -141,6 +188,8 @@ class SurveyFlowVisualization:
                     label=edge_label,
                     color=color,
                     fontcolor=color,
+                    fontname="Courier",
+                    fontsize=FONT_SIZE,
                 )
 
             graph.add_edge(edge)
@@ -156,9 +205,8 @@ class SurveyFlowVisualization:
             except FileNotFoundError:
                 print(
                     """File not found. Most likely it's because you don't have graphviz installed. Please install it and try again.
-                        It's 
+                        On Ubuntu, you can install it by running:
                         $ sudo apt-get install graphviz 
-                        on Ubuntu.
                     """
                 )
             from edsl.utilities.is_notebook import is_notebook

edsl/templates/error_reporting/exceptions_table.html

@@ -7,11 +7,11 @@
 <table border="1">
     <thead>
         <tr>
-            <th>Exception Type</th>
-            <th>Service</th>
-            <th>Model</th>
-            <th>Question Name</th>
-            <th>Total</th>
+            <th style="text-align: left">Exception Type</th>
+            <th style="text-align: left">Service</th>
+            <th style="text-align: left">Model</th>
+            <th style="text-align: left">Question Name</th>
+            <th style="text-align: left">Total</th>
         </tr>
     </thead>
     <tbody>
@@ -27,9 +27,8 @@
     </tbody>
 </table>
 <p>
-    <i>Note:</i> You may encounter repeated exceptions where retries were attempted. 
-    You can modify the maximum number of attempts for failed API calls in `edsl/config.py`. 
+    Note: You may encounter repeated exceptions where retries were attempted. 
 </p>
 <p>
-    Click to expand the details below for information about each exception, including code for reproducing it.
+    See details about each exception, including code for reproducing it (click to expand).
 </p>

edsl/templates/error_reporting/interview_details.html

@@ -25,7 +25,7 @@
     }
 </style>
 
-<div class="question">question_name: {{ question }}</div>
+<div class="question">Question name: {{ question }}</div>
 
 {% for exception_message in exceptions %}
 <div class="exception-detail">

edsl/templates/error_reporting/interviews.html

@@ -1,4 +1,3 @@
-<h2>Exceptions Details</h2>
 {% for index, interview in interviews.items() %}
     {% for question, exceptions in interview.exceptions.items() %}
         {% include 'interview_details.html' %}

edsl/templates/error_reporting/overview.html

@@ -4,16 +4,11 @@
     }
 </style>
 
-<h1>Exceptions Report</h1>
+<h3>Exceptions Report</h3>
 <p>
     This report summarizes exceptions encountered in the job that was run.
 </p>
-<p>
-    For advice on dealing with exceptions, please see the EDSL <a href="https://docs.expectedparrot.com/en/latest/exceptions.html">documentation</a> page. <br>
-    You can also post a question at the Expected Parrot <a href="https://discord.com/invite/mxAYkjfy9m">Discord channel</a>, open an issue on <a href="https://github.com/expectedparrot/edsl">GitHub</a>, or send an email to <a href="mailto:info@expectedparrot.com">info@expectedparrot.com</a>.
-</p>
 
-<h2>Overview</h2>
 <table border="1">
     <tbody>
         <tr>
@@ -27,5 +22,5 @@
     </tbody>
 </table>
 <p>
-    An "interview" is the result of one survey, taken by one agent, with one model and one scenario (if any).
+    An interview is the result of one survey, taken by one agent, with one model and one scenario (if any).
 </p>

edsl/templates/error_reporting/performance_plot.html

@@ -1,2 +1,2 @@
-<h2>Performance Plot</h2>
+<!-- <h2>Performance Plot</h2> -->
 {{ performance_plot_html }}

edsl/templates/error_reporting/report.css

@@ -15,7 +15,7 @@ body {
 }
 
 .question {
-    font-size: 1.2em;
+    font-size: 1.0em;
     margin-bottom: 10px;
     padding: 10px;
     background-color: #fff9c4;