edsl 0.1.33__py3-none-any.whl → 0.1.33.dev1__py3-none-any.whl

edsl/questions/derived/QuestionTopK.py

@@ -3,7 +3,6 @@ from typing import Optional
 
 from edsl.exceptions import QuestionCreationValidationError
 from edsl.questions.QuestionCheckBox import QuestionCheckBox
-from edsl.questions.decorators import inject_exception
 
 
 class QuestionTopK(QuestionCheckBox):
@@ -18,9 +17,6 @@ class QuestionTopK(QuestionCheckBox):
         question_options: list[str],
         min_selections: int,
         max_selections: int,
-        question_presentation: Optional[str] = None,
-        answering_instructions: Optional[str] = None,
-        include_comment: Optional[bool] = True,
     ):
         """Initialize the question.
 
@@ -36,9 +32,6 @@ class QuestionTopK(QuestionCheckBox):
             question_options=question_options,
             min_selections=min_selections,
             max_selections=max_selections,
-            question_presentation=question_presentation,
-            answering_instructions=answering_instructions,
-            include_comment=include_comment,
         )
         if min_selections != max_selections:
             raise QuestionCreationValidationError(
@@ -53,8 +46,7 @@ class QuestionTopK(QuestionCheckBox):
     # Helpful
     ################
     @classmethod
-    @inject_exception
-    def example(cls, include_comment: bool = True) -> QuestionTopK:
+    def example(cls) -> QuestionTopK:
         """Return an example question."""
         return cls(
             question_name="two_fruits",
@@ -62,7 +54,6 @@ class QuestionTopK(QuestionCheckBox):
             question_options=["apple", "banana", "carrot", "durian"],
             min_selections=2,
             max_selections=2,
-            include_comment=include_comment,
         )
 
 

edsl/questions/derived/QuestionYesNo.py

@@ -1,10 +1,7 @@
 from __future__ import annotations
-from typing import Optional
 from edsl.questions.descriptors import QuestionOptionsDescriptor
 from edsl.questions.QuestionMultipleChoice import QuestionMultipleChoice
 
-from edsl.questions.decorators import inject_exception
-
 
 class QuestionYesNo(QuestionMultipleChoice):
     """This question prompts the agent to respond with 'Yes' or 'No'."""
@@ -16,10 +13,7 @@ class QuestionYesNo(QuestionMultipleChoice):
         self,
         question_name: str,
         question_text: str,
-        question_options: list[str] = ["No", "Yes"],
-        answering_instructions: Optional[str] = None,
-        question_presentation: Optional[str] = None,
-        include_comment: Optional[bool] = True,
+        question_options: list[str] = ["Yes", "No"],
     ):
         """Instantiate a new QuestionYesNo.
 
@@ -31,10 +25,6 @@ class QuestionYesNo(QuestionMultipleChoice):
             question_name=question_name,
             question_text=question_text,
             question_options=question_options,
-            use_code=False,
-            answering_instructions=answering_instructions,
-            question_presentation=question_presentation,
-            include_comment=include_comment,
         )
         self.question_options = question_options
 
@@ -42,14 +32,9 @@ class QuestionYesNo(QuestionMultipleChoice):
     # Helpful
     ################
     @classmethod
-    @inject_exception
-    def example(cls, include_comment: bool = True) -> QuestionYesNo:
+    def example(cls) -> QuestionYesNo:
         """Return an example of a yes/no question."""
-        return cls(
-            question_name="is_it_equal",
-            question_text="Is 5 + 5 equal to 11?",
-            include_comment=include_comment,
-        )
+        return cls(question_name="is_it_equal", question_text="Is 5 + 5 equal to 11?")
 
 
 def main():
@@ -74,9 +59,3 @@ def main():
     import doctest
 
     doctest.testmod(optionflags=doctest.ELLIPSIS)
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod(optionflags=doctest.ELLIPSIS)

edsl/questions/descriptors.py

@@ -206,14 +206,12 @@ class OptionLabelDescriptor(BaseDescriptor):
 
     def validate(self, value, instance):
         """Validate the value is a string."""
-        # key_values = [int(v) for v in value.keys()]
-
-        if value and (key_values := [float(v) for v in value.keys()]) != []:
-            if min(key_values) != min(instance.question_options):
+        if value is not None:
+            if min(value.keys()) != min(instance.question_options):
                 raise QuestionCreationValidationError(
                     f"First option needs a label (got {value})"
                 )
-            if max(key_values) != max(instance.question_options):
+            if max(value.keys()) != max(instance.question_options):
                 raise QuestionCreationValidationError(
                     f"Last option needs a label (got {value})"
                 )
@@ -221,17 +219,12 @@ class OptionLabelDescriptor(BaseDescriptor):
                 raise QuestionCreationValidationError(
                     "Option labels must be strings (got {value})."
                 )
-            for key in key_values:
+            for key in value.keys():
                 if key not in instance.question_options:
                     raise QuestionCreationValidationError(
                         f"Option label key ({key}) is not in question options ({instance.question_options})."
                     )
 
-            if len(value.values()) != len(set(value.values())):
-                raise QuestionCreationValidationError(
-                    f"Option labels must be unique (got {value})."
-                )
-
 
 class QuestionNameDescriptor(BaseDescriptor):
     """Validate that the `question_name` attribute is a valid variable name."""
@@ -240,15 +233,6 @@ class QuestionNameDescriptor(BaseDescriptor):
         """Validate the value is a valid variable name."""
         from edsl.utilities.utilities import is_valid_variable_name
 
-        if "{{" in value and "}}" in value:
-            # they're trying to use a dynamic question name - let's let this play out
-            return None
-
-        if value.endswith("_comment") or value.endswith("_generated_tokens"):
-            raise QuestionCreationValidationError(
-                f"`question_name` cannot end with '_comment' or '_generated_tokens - (got {value})."
-            )
-
         if not is_valid_variable_name(value):
             raise QuestionCreationValidationError(
                 f"`question_name` is not a valid variable name (got {value})."
@@ -295,7 +279,7 @@ class QuestionOptionsDescriptor(BaseDescriptor):
         >>> _ = q_class("dynamic_options")
         Traceback (most recent call last):
         ...
-        edsl.exceptions.questions.QuestionCreationValidationError: ...
+        edsl.exceptions.questions.QuestionCreationValidationError: Dynamic question options must be of the form: '{{ question_options }}'.
         """
         if isinstance(value, str):
             # Check if the string is a dynamic question option
@@ -303,7 +287,7 @@ class QuestionOptionsDescriptor(BaseDescriptor):
                 return None
             else:
                 raise QuestionCreationValidationError(
-                    f"Dynamic question options must have jina2 braces - instead received: {value}."
+                    "Dynamic question options must be of the form: '{{ question_options }}'."
                 )
         if not isinstance(value, list):
             raise QuestionCreationValidationError(
@@ -372,21 +356,7 @@ class QuestionOptionsDescriptor(BaseDescriptor):
 
 
 class QuestionTextDescriptor(BaseDescriptor):
-    """Validate that the `question_text` attribute is a string.
-
-
-    >>> class TestQuestion:
-    ...     question_text = QuestionTextDescriptor()
-    ...     def __init__(self, question_text: str):
-    ...         self.question_text = question_text
-
-    >>> _ = TestQuestion("What is the capital of France?")
-    >>> _ = TestQuestion("What is the capital of France? {{variable}}")
-    >>> _ = TestQuestion("What is the capital of France? {{variable name}}")
-    Traceback (most recent call last):
-    ...
-    edsl.exceptions.questions.QuestionCreationValidationError: Question text contains an invalid identifier: 'variable name'
-    """
+    """Validate that the `question_text` attribute is a string."""
 
     def validate(self, value, instance):
         """Validate the value is a string."""
@@ -403,12 +373,6 @@ class QuestionTextDescriptor(BaseDescriptor):
                 f"WARNING: Question text contains a single-braced substring: If you intended to parameterize the question with a Scenario this should be changed to a double-braced substring, e.g. {{variable}}.\nSee details on constructing Scenarios in the docs: https://docs.expectedparrot.com/en/latest/scenarios.html",
                 UserWarning,
             )
-        # iterate through all doubles braces and check if they are valid python identifiers
-        for match in re.finditer(r"\{\{([^\{\}]+)\}\}", value):
-            if " " in match.group(1).strip():
-                raise QuestionCreationValidationError(
-                    f"Question text contains an invalid identifier: '{match.group(1)}'"
-                )
 
 
 if __name__ == "__main__":

edsl/questions/question_registry.py

@@ -100,16 +100,12 @@ class Question(metaclass=Meta):
 
         >>> from edsl import Question
         >>> Question.available()
-        ['checkbox', 'extract', 'free_text', 'functional', 'likert_five', 'linear_scale', 'list', 'multiple_choice', 'numerical', 'rank', 'top_k', 'yes_no']
+        ['budget', 'checkbox', 'extract', 'free_text', 'functional', 'likert_five', 'linear_scale', 'list', 'multiple_choice', 'numerical', 'rank', 'top_k', 'yes_no']
         """
-        exclude = ["budget"]
         if show_class_names:
             return RegisterQuestionsMeta.question_types_to_classes()
         else:
-            question_list = sorted(
-                set(RegisterQuestionsMeta.question_types_to_classes().keys())
-            )
-            return [q for q in question_list if q not in exclude]
+            return sorted(set(RegisterQuestionsMeta.question_types_to_classes().keys()))
 
 
 def get_question_class(question_type):

edsl/results/Dataset.py

@@ -8,7 +8,6 @@ from typing import Any, Union, Optional
 import numpy as np
 
 from edsl.results.ResultsExportMixin import ResultsExportMixin
-from edsl.results.DatasetTree import Tree
 
 
 class Dataset(UserList, ResultsExportMixin):
@@ -31,15 +30,6 @@ class Dataset(UserList, ResultsExportMixin):
         _, values = list(self.data[0].items())[0]
         return len(values)
 
-    def keys(self):
-        """Return the keys of the first observation in the dataset.
-
-        >>> d = Dataset([{'a.b':[1,2,3,4]}])
-        >>> d.keys()
-        ['a.b']
-        """
-        return [list(o.keys())[0] for o in self]
-
     def __repr__(self) -> str:
         """Return a string representation of the dataset."""
         return f"Dataset({self.data})"
@@ -255,16 +245,6 @@ class Dataset(UserList, ResultsExportMixin):
 
         return Dataset(new_data)
 
-    @property
-    def tree(self):
-        """Return a tree representation of the dataset.
-
-        >>> d = Dataset([{'a':[1,2,3,4]}, {'b':[4,3,2,1]}])
-        >>> d.tree.print_tree()
-        Tree has not been constructed yet.
-        """
-        return Tree(self)
-
     @classmethod
     def example(self):
         """Return an example dataset.

edsl/results/DatasetExportMixin.py

@@ -4,7 +4,6 @@ import base64
 import csv
 import io
 import html
-from typing import Optional
 
 from typing import Literal, Optional, Union, List
 
@@ -42,7 +41,7 @@ class DatasetExportMixin:
         >>> Results.example().relevant_columns(data_type = "flimflam")
         Traceback (most recent call last):
         ...
-        ValueError: No columns found for data type: flimflam. Available data types are: ...
+        ValueError: No columns found for data type: flimflam. Available data types are: ['agent', 'answer', 'comment', 'model', 'prompt', 'question_options', 'question_text', 'question_type', 'raw_model_response', 'scenario'].
         """
         columns = [list(x.keys())[0] for x in self]
         if remove_prefix:
@@ -157,13 +156,12 @@ class DatasetExportMixin:
         iframe_height: int = 200,
         iframe_width: int = 600,
         web=False,
-        return_string: bool = False,
-    ) -> Union[None, str, "Results"]:
+    ) -> None:
         """Print the results in a pretty format.
 
         :param pretty_labels: A dictionary of pretty labels for the columns.
         :param filename: The filename to save the results to.
-        :param format: The format to print the results in. Options are 'rich', 'html', 'markdown', or 'latex'.
+        :param format: The format to print the results in. Options are 'rich', 'html', or 'markdown'.
         :param interactive: Whether to print the results interactively in a Jupyter notebook.
         :param split_at_dot: Whether to split the column names at the last dot w/ a newline.
         :param max_rows: The maximum number of rows to print.
@@ -172,9 +170,6 @@ class DatasetExportMixin:
         :param iframe_height: The height of the iframe.
         :param iframe_width: The width of the iframe.
         :param web: Whether to display the table in a web browser.
-        :param return_string: Whether to return the output as a string instead of printing.
-
-        :return: None if tee is False and return_string is False, the dataset if tee is True, or a string if return_string is True.
 
         Example: Print in rich format at the terminal
 
@@ -258,14 +253,11 @@ class DatasetExportMixin:
 
         >>> r.select('how_feeling').print(format='latex')
         \\begin{tabular}{l}
+        \\toprule
         ...
-        \\end{tabular}
-        <BLANKLINE>
         """
         from IPython.display import HTML, display
         from edsl.utilities.utilities import is_notebook
-        import io
-        import sys
 
         def _determine_format(format):
             if format is None:
@@ -274,9 +266,7 @@ class DatasetExportMixin:
                 else:
                     format = "rich"
             if format not in ["rich", "html", "markdown", "latex"]:
-                raise ValueError(
-                    "format must be one of 'rich', 'html', 'markdown', or 'latex'."
-                )
+                raise ValueError("format must be one of 'rich', 'html', or 'markdown'.")
 
             return format
 
@@ -295,24 +285,21 @@ class DatasetExportMixin:
 
         new_data = list(_create_data())
 
-        # Capture output if return_string is True
-        if return_string:
-            old_stdout = sys.stdout
-            sys.stdout = io.StringIO()
-
-        output = None
-
         if format == "rich":
             from edsl.utilities.interface import print_dataset_with_rich
 
-            output = print_dataset_with_rich(
+            print_dataset_with_rich(
                 new_data, filename=filename, split_at_dot=split_at_dot
             )
-        elif format == "markdown":
+            return self if tee else None
+
+        if format == "markdown":
             from edsl.utilities.interface import print_list_of_dicts_as_markdown_table
 
-            output = print_list_of_dicts_as_markdown_table(new_data, filename=filename)
-        elif format == "latex":
+            print_list_of_dicts_as_markdown_table(new_data, filename=filename)
+            return self if tee else None
+
+        if format == "latex":
             df = self.to_pandas()
             df.columns = [col.replace("_", " ") for col in df.columns]
             latex_string = df.to_latex(index=False)
@@ -322,14 +309,23 @@ class DatasetExportMixin:
                     f.write(latex_string)
             else:
                 print(latex_string)
-                output = latex_string
-        elif format == "html":
+
+            return self if tee else None
+
+        if format == "html":
             from edsl.utilities.interface import print_list_of_dicts_as_html_table
 
             html_source = print_list_of_dicts_as_html_table(
                 new_data, interactive=interactive
             )
 
+            # if download_link:
+            #     from IPython.display import HTML, display
+            #     csv_file = output.getvalue()
+            #     b64 = base64.b64encode(csv_file.encode()).decode()
+            #     download_link = f'<a href="data:file/csv;base64,{b64}" download="my_data.csv">Download CSV file</a>'
+            #     #display(HTML(download_link))
+
             if iframe:
                 iframe = f""""
                 <iframe srcdoc="{ html.escape(html_source) }" style="width: {iframe_width}px; height: {iframe_height}px;"></iframe>
@@ -342,18 +338,7 @@ class DatasetExportMixin:
 
                 view_html(html_source)
 
-            output = html_source
-
-        # Restore stdout and get captured output if return_string is True
-        if return_string:
-            captured_output = sys.stdout.getvalue()
-            sys.stdout = old_stdout
-            return captured_output or output
-
-        if tee:
-            return self
-
-        return None
+            return self if tee else None
 
     def to_csv(
         self,
@@ -472,11 +457,7 @@ class DatasetExportMixin:
         from edsl import ScenarioList, Scenario
 
         list_of_dicts = self.to_dicts(remove_prefix=remove_prefix)
-        scenarios = []
-        for d in list_of_dicts:
-            scenarios.append(Scenario(d))
-        return ScenarioList(scenarios)
-        # return ScenarioList([Scenario(d) for d in list_of_dicts])
+        return ScenarioList([Scenario(d) for d in list_of_dicts])
 
     def to_agent_list(self, remove_prefix: bool = True):
         """Convert the results to a list of dictionaries, one per agent.
@@ -520,7 +501,7 @@ class DatasetExportMixin:
 
         return list_of_dicts
 
-    def to_list(self, flatten=False, remove_none=False, unzipped=False) -> list[list]:
+    def to_list(self, flatten=False, remove_none=False) -> list[list]:
         """Convert the results to a list of lists.
 
         :param flatten: Whether to flatten the list of lists.
@@ -615,6 +596,27 @@ class DatasetExportMixin:
         if return_link:
             return filename
 
+    def to_docx(self, filename: Optional[str] = None, separator: str = "\n"):
+        """Export the results to a Word document.
+
+        :param filename: The filename to save the Word document to.
+
+
+        """
+        from docx import Document
+
+        doc = Document()
+        for entry in self:
+            key, values = list(entry.items())[0]
+            doc.add_paragraph(key)
+            line = separator.join(values)
+            doc.add_paragraph(line)
+
+        if filename is not None:
+            doc.save(filename)
+        else:
+            return doc
+
     def tally(
         self, *fields: Optional[str], top_n: Optional[int] = None, output="Dataset"
     ) -> Union[dict, "Dataset"]:

edsl/results/Result.py

@@ -53,8 +53,8 @@ class Result(Base, UserDict):
 
     >>> import warnings
     >>> warnings.simplefilter("ignore", UserWarning)
-    >>> Result.example().answer == {'how_feeling_yesterday': 'Great', 'how_feeling': 'OK'}
-    True
+    >>> Result.example().answer
+    {'how_feeling': 'OK', 'how_feeling_comment': 'This is a real survey response from a human.', 'how_feeling_yesterday': 'Great', 'how_feeling_yesterday_comment': 'This is a real survey response from a human.'}
 
     Its main data is an Agent, a Scenario, a Model, an Iteration, and an Answer.
     These are stored both in the UserDict and as attributes.
@@ -73,8 +73,6 @@ class Result(Base, UserDict):
         raw_model_response=None,
         survey: Optional["Survey"] = None,
         question_to_attributes: Optional[dict] = None,
-        generated_tokens: Optional[dict] = None,
-        comments_dict: Optional[dict] = None,
     ):
         """Initialize a Result object.
 
@@ -115,7 +113,6 @@ class Result(Base, UserDict):
             "prompt": prompt or {},
             "raw_model_response": raw_model_response or {},
             "question_to_attributes": question_to_attributes,
-            "generated_tokens": generated_tokens or {},
         }
         super().__init__(**data)
         # but also store the data as attributes
@@ -128,8 +125,6 @@ class Result(Base, UserDict):
         self.raw_model_response = raw_model_response or {}
         self.survey = survey
         self.question_to_attributes = question_to_attributes
-        self.generated_tokens = generated_tokens
-        self.comments_dict = comments_dict or {}
 
         self._combined_dict = None
         self._problem_keys = None
@@ -145,7 +140,7 @@ class Result(Base, UserDict):
         else:
             agent_name = self.agent.name
 
-        # comments_dict = {k: v for k, v in self.answer.items() if k.endswith("_comment")}
+        comments_dict = {k: v for k, v in self.answer.items() if k.endswith("_comment")}
         question_text_dict = {}
         question_options_dict = {}
         question_type_dict = {}
@@ -172,12 +167,11 @@ class Result(Base, UserDict):
             "answer": self.answer,
             "prompt": self.prompt,
             "raw_model_response": self.raw_model_response,
-            "iteration": {"iteration": self.iteration},
+            #            "iteration": {"iteration": self.iteration},
             "question_text": question_text_dict,
             "question_options": question_options_dict,
             "question_type": question_type_dict,
-            "comment": self.comments_dict,
-            "generated_tokens": self.generated_tokens,
+            "comment": comments_dict,
         }
 
     def check_expression(self, expression) -> None:
@@ -266,26 +260,6 @@ class Result(Base, UserDict):
             for key, value in subdict.items():
                 yield (index, data_type, key, str(value))
 
-    def leaves(self):
-        leaves = []
-        for question_name, answer in self.answer.items():
-            if not question_name.endswith("_comment"):
-                leaves.append(
-                    {
-                        "question": f"({question_name}): "
-                        + str(
-                            self.question_to_attributes[question_name]["question_text"]
-                        ),
-                        "answer": answer,
-                        "comment": self.answer.get(question_name + "_comment", ""),
-                        "scenario": repr(self.scenario),
-                        "agent": repr(self.agent),
-                        "model": repr(self.model),
-                        "iteration": self.iteration,
-                    }
-                )
-        return leaves
-
     ###############
     # Useful
     ###############
@@ -367,7 +341,6 @@ class Result(Base, UserDict):
                 "raw_model_response", {"raw_model_response": "No raw model response"}
             ),
             question_to_attributes=json_dict.get("question_to_attributes", None),
-            generated_tokens=json_dict.get("generated_tokens", {}),
         )
         return result