edsl 0.1.37.dev5__py3-none-any.whl → 0.1.38__py3-none-any.whl

edsl/surveys/Survey.py

@@ -41,6 +41,8 @@ class ValidatedString(str):
 class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
     """A collection of questions that supports skip logic."""
 
+    __documentation__ = """https://docs.expectedparrot.com/en/latest/surveys.html"""
+
     questions = QuestionsDescriptor()
     """
     A collection of questions that supports skip logic.
@@ -445,35 +447,27 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
         """Return a hash of the question."""
         from edsl.utilities.utilities import dict_hash
 
-        return dict_hash(self._to_dict())
+        return dict_hash(self.to_dict(add_edsl_version=False))
 
-    def _to_dict(self) -> dict[str, Any]:
+    def to_dict(self, add_edsl_version=True) -> dict[str, Any]:
         """Serialize the Survey object to a dictionary.
 
         >>> s = Survey.example()
-        >>> s._to_dict().keys()
+        >>> s.to_dict(add_edsl_version = False).keys()
         dict_keys(['questions', 'memory_plan', 'rule_collection', 'question_groups'])
         """
         return {
             "questions": [
-                q._to_dict() for q in self.recombined_questions_and_instructions()
+                q.to_dict(add_edsl_version=add_edsl_version)
+                for q in self.recombined_questions_and_instructions()
             ],
-            "memory_plan": self.memory_plan.to_dict(),
-            "rule_collection": self.rule_collection.to_dict(),
+            "memory_plan": self.memory_plan.to_dict(add_edsl_version=add_edsl_version),
+            "rule_collection": self.rule_collection.to_dict(
+                add_edsl_version=add_edsl_version
+            ),
             "question_groups": self.question_groups,
         }
 
-    @add_edsl_version
-    def to_dict(self) -> dict[str, Any]:
-        """Serialize the Survey object to a dictionary.
-
-        >>> s = Survey.example()
-        >>> s.to_dict().keys()
-        dict_keys(['questions', 'memory_plan', 'rule_collection', 'question_groups', 'edsl_version', 'edsl_class_name'])
-
-        """
-        return self._to_dict()
-
     @classmethod
     @remove_edsl_version
     def from_dict(cls, data: dict) -> Survey:
@@ -1595,10 +1589,22 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
         # question_names_string = ", ".join([repr(name) for name in self.question_names])
         return f"Survey(questions=[{questions_string}], memory_plan={self.memory_plan}, rule_collection={self.rule_collection}, question_groups={self.question_groups})"
 
+    def _summary(self) -> dict:
+        return {
+            "EDSL Class": "Survey",
+            "Number of Questions": len(self),
+            "Question Names": self.question_names,
+        }
+
     def _repr_html_(self) -> str:
-        from edsl.utilities.utilities import data_to_html
+        footer = f"<a href={self.__documentation__}>(docs)</a>"
+        return str(self.summary(format="html")) + footer
+
+    def tree(self, node_list: Optional[List[str]] = None):
+        return self.to_scenario_list().tree(node_list=node_list)
 
-        return data_to_html(self.to_dict())
+    def table(self, *fields, tablefmt=None) -> Table:
+        return self.to_scenario_list().to_dataset().table(*fields, tablefmt=tablefmt)
 
     def rich_print(self) -> Table:
         """Print the survey in a rich format.

edsl/surveys/SurveyFlowVisualizationMixin.py

@@ -1,27 +1,85 @@
-"""A mixin for visualizing the flow of a survey."""
+"""A mixin for visualizing the flow of a survey with parameter nodes."""
 
 from typing import Optional
 from edsl.surveys.base import RulePriority, EndOfSurvey
 import tempfile
+import os
 
 
 class SurveyFlowVisualizationMixin:
-    """A mixin for visualizing the flow of a survey."""
+    """A mixin for visualizing the flow of a survey with parameter visualization."""
 
     def show_flow(self, filename: Optional[str] = None):
-        """Create an image showing the flow of users through the survey."""
+        """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")
 
-        # Add nodes for each question
+        # First collect all unique parameters and answer references
+        params_and_refs = set()
+        param_to_questions = {}  # Keep track of which questions use each parameter
+        answer_refs = set()  # Track answer references between questions
+
+        # First pass: collect parameters and their question associations
         for index, question in enumerate(self.questions):
-            graph.add_node(
-                pydot.Node(
-                    f"Q{index}", label=f"{question.question_name}", shape="ellipse"
+            # Add the main question node
+            question_node = pydot.Node(
+                f"Q{index}", label=f"{question.question_name}", shape="ellipse"
+            )
+            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))
+                    else:
+                        params_and_refs.add(param)
+                        if param not in param_to_questions:
+                            param_to_questions[param] = []
+                        param_to_questions[param].append(index)
+
+        # 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",
+            )
+            graph.add_node(param_node)
+
+            # Connect this parameter to all questions that use it
+            for q_index in param_to_questions[param]:
+                param_edge = pydot.Edge(
+                    param_node_name,
+                    f"Q{q_index}",
+                    style="dotted",
+                    color="grey",
+                    arrowsize="0.5",
                 )
+                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.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(
@@ -30,7 +88,7 @@ class SurveyFlowVisualizationMixin:
 
         # Add edges for normal flow through the survey
         num_questions = len(self.questions)
-        for index in range(num_questions - 1):  # From Q1 to Q3
+        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{num_questions-1}", "EndOfSurvey"))
@@ -64,7 +122,7 @@ class SurveyFlowVisualizationMixin:
                 if rule.next_q != EndOfSurvey and rule.next_q < num_questions
                 else "EndOfSurvey"
             )
-            if rule.before_rule:  # Assume skip rules have an attribute `is_skip`
+            if rule.before_rule:
                 edge = pydot.Edge(
                     source_node,
                     target_node,

edsl/surveys/instructions/ChangeInstruction.py

@@ -24,22 +24,24 @@ class ChangeInstruction:
     def __str__(self):
         return self.text
 
-    def _to_dict(self):
-        return {
+    def to_dict(self, add_edsl_version=True):
+        d = {
             "keep": self.keep,
             "drop": self.drop,
-            "edsl_class_name": "ChangeInstruction",
         }
+        if add_edsl_version:
+            from edsl import __version__
 
-    @add_edsl_version
-    def to_dict(self):
-        return self._to_dict()
+            d["edsl_version"] = __version__
+            d["edsl_class_name"] = "ChangeInstruction"
+
+        return d
 
     def __hash__(self) -> int:
         """Return a hash of the question."""
         from edsl.utilities.utilities import dict_hash
 
-        return dict_hash(self._to_dict())
+        return dict_hash(self.to_dict(add_edsl_version=False))
 
     @classmethod
     @remove_edsl_version

edsl/surveys/instructions/Instruction.py

@@ -18,28 +18,42 @@ class Instruction:
     def __repr__(self):
         return """Instruction(name="{}", text="{}")""".format(self.name, self.text)
 
-    def _to_dict(self):
-        return {
+    def _repr_html_(self):
+        d = self.to_dict(add_edsl_version=False)
+        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>"
+
+    @classmethod
+    def example(cls) -> "Instruction":
+        return cls(name="example", text="This is an example instruction.")
+
+    def to_dict(self, add_edsl_version=True):
+        d = {
             "name": self.name,
             "text": self.text,
             "edsl_class_name": "Instruction",
             "preamble": self.preamble,
         }
+        if add_edsl_version:
+            from edsl import __version__
+
+            d["edsl_version"] = __version__
+            d["edsl_class_name"] = "Instruction"
+        return d
 
     def add_question(self, question) -> "Survey":
         from edsl import Survey
 
         return Survey([self, question])
 
-    @add_edsl_version
-    def to_dict(self):
-        return self._to_dict()
-
     def __hash__(self) -> int:
         """Return a hash of the question."""
         from edsl.utilities.utilities import dict_hash
 
-        return dict_hash(self._to_dict())
+        return dict_hash(self.to_dict(add_edsl_version=False))
 
     @classmethod
     @remove_edsl_version

edsl/templates/error_reporting/interview_details.html

@@ -40,11 +40,11 @@
             </tr>
             <tr>
                 <td>Scenario</td>
-                <td>{{ interview.scenario._repr_html_() }}</td>
+                <td>{{ interview.scenario.__repr__() }}</td>
             </tr>
             <tr>
                 <td>Agent</td>
-                <td>{{ interview.agent._repr_html_() }}</td>
+                <td>{{ interview.agent.__repr__() }}</td>
             </tr>
             <tr>
                 <td>Model name</td>
@@ -56,7 +56,7 @@
             </tr>
             <tr>
                 <td>Model parameters</td>
-                <td>{{ interview.model._repr_html_() }}</td>
+                <td>{{ interview.model.__repr__() }}</td>
             </tr>
             <tr>
                 <td>User Prompt</td>

edsl/templates/error_reporting/interviews.html

@@ -1,10 +1,19 @@
+
+{% if interviews|length > max_interviews %}
+    <h1>Only showing the first {{ max_interviews }} interviews with errors</h1>
+{% else %}
+    <h1>Showing all interviews</h1>    
+{% endif %}
+
 {% for index, interview in interviews.items() %}
-    {% if interview.exceptions != {} %}
-       <div class="interview">Interview: {{ index }} </div>
-       Model: {{ interview.model.model }}
-    <h1>Failing questions</h1>
-    {% endif %}
-    {% for question, exceptions in interview.exceptions.items() %}
-        {% include 'interview_details.html' %}
-    {% endfor %}            
-{% endfor %}
+    {% if index < max_interviews %}
+        {% if interview.exceptions != {} %}
+        <div class="interview">Interview: {{ index }} </div>
+        Model: {{ interview.model.model }}
+        <h1>Failing questions</h1>
+        {% endif %}
+        {% for question, exceptions in interview.exceptions.items() %}
+            {% include 'interview_details.html' %}
+        {% endfor %}
+    {% endif %}            
+{% endfor %}

edsl/{conjure → utilities}/naming_utilities.py

@@ -257,7 +257,7 @@ def sanitize_string(input_string, max_length=35):
 #         print()
 
 if __name__ == "__main__":
-    from edsl.conjure.InputData import InputDataABC
+    # from edsl.conjure.InputData import InputDataABC
     import doctest
 
     doctest.testmod(optionflags=doctest.ELLIPSIS)

edsl/utilities/utilities.py

@@ -207,6 +207,21 @@ def is_notebook() -> bool:
         return False  # Probably standard Python interpreter
 
 
+def file_notice(file_name):
+    """Print a notice about the file being created."""
+    if is_notebook():
+        from IPython.display import HTML, display
+
+        link_text = "Download file"
+        display(
+            HTML(
+                f'<p>File created: {file_name}</p>.<a href="{file_name}" download>{link_text}</a>'
+            )
+        )
+    else:
+        print(f"File created: {file_name}")
+
+
 class HTMLSnippet(str):
     """Create an object with html content (`value`).
 

{edsl-0.1.37.dev5.dist-info → edsl-0.1.38.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: edsl
-Version: 0.1.37.dev5
+Version: 0.1.38
 Summary: Create and analyze LLM-based surveys
 Home-page: https://www.expectedparrot.com/
 License: MIT
@@ -45,6 +45,7 @@ Requires-Dist: rich (>=13.7.0,<14.0.0)
 Requires-Dist: setuptools (<72.0)
 Requires-Dist: simpleeval (>=0.9.13,<0.10.0)
 Requires-Dist: sqlalchemy (>=2.0.23,<3.0.0)
+Requires-Dist: tabulate (>=0.9.0,<0.10.0)
 Requires-Dist: tenacity (>=8.2.3,<9.0.0)
 Requires-Dist: urllib3 (>=1.25.4,<1.27)
 Project-URL: Documentation, https://docs.expectedparrot.com