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

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

@@ -1248,14 +1248,15 @@ class Survey(SurveyExportMixin, Base):
     ###################
     def humanize(
         self,
-        project_name: str,
+        project_name: str = "Project",
         survey_description: Optional[str] = None,
         survey_alias: Optional[str] = None,
         survey_visibility: Optional["VisibilityType"] = "unlisted",
-    ):
+    ) -> dict:
         """
-        Create a survey object on Coop.
-        Then, create a project on Coop so you can share the survey with humans.
+        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
 

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;

edsl/utilities/PrettyList.py

@@ -1,12 +1,26 @@
 from collections import UserList
 from edsl.results.Dataset import Dataset
 
+class Markkdown:
+
+    def __init__(self, text: str):
+        self.text = text
+
+    def __str__(self):
+        return self.text
+    
+    def _repr_markdown_(self):
+        return self.text
 
 class PrettyList(UserList):
     def __init__(self, data=None, columns=None):
         super().__init__(data)
         self.columns = columns
 
+    def to_markdown(self):
+        text = "".join([str(row) for row in self])
+        return Markkdown(text)
+
     def _repr_html_(self):
         if isinstance(self[0], list) or isinstance(self[0], tuple):
             num_cols = len(self[0])