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

edsl/questions/QuestionBaseGenMixin.py

@@ -138,7 +138,7 @@ class QuestionBaseGenMixin:
         if exclude_components is None:
             exclude_components = ["question_name", "question_type"]
 
-        d = copy.deepcopy(self.to_dict(add_edsl_version=False))
+        d = copy.deepcopy(self._to_dict())
         for key, value in d.items():
             if key in exclude_components:
                 continue

edsl/questions/QuestionBasePromptsMixin.py

@@ -126,6 +126,7 @@ class QuestionBasePromptsMixin:
 
     @classmethod
     def default_question_presentation(cls):
+        # template_text = cls._read_template("question_presentation.jinja")
         template_text = template_manager.get_template(
             cls.question_type, "question_presentation.jinja"
         )
@@ -141,6 +142,22 @@ class QuestionBasePromptsMixin:
     def answering_instructions(self, value) -> None:
         self._answering_instructions = value
 
+    # @classmethod
+    # def default_answering_instructions(cls) -> str:
+    #     with resources.open_text(
+    #         f"edsl.questions.templates.{cls.question_type}",
+    #         "answering_instructions.jinja",
+    #     ) as file:
+    #         return Prompt(text=file.read())
+
+    # @classmethod
+    # def default_question_presentation(cls):
+    #     with resources.open_text(
+    #         f"edsl.questions.templates.{cls.question_type}",
+    #         "question_presentation.jinja",
+    #     ) as file:
+    #         return Prompt(text=file.read())
+
     @property
     def question_presentation(self):
         if self._question_presentation is None:

edsl/questions/QuestionExtract.py

@@ -1,7 +1,4 @@
 from __future__ import annotations
-import json
-import re
-
 from typing import Any, Optional, Dict
 from edsl.questions.QuestionBase import QuestionBase
 from edsl.questions.descriptors import AnswerTemplateDescriptor
@@ -14,6 +11,9 @@ from edsl.questions.decorators import inject_exception
 from typing import Dict, Any
 from pydantic import create_model, Field
 
+import json
+import re
+
 
 def extract_json(text, expected_keys, verbose=False):
     # Escape special regex characters in keys
@@ -112,6 +112,7 @@ class QuestionExtract(QuestionBase):
 
         :param question_name: The name of the question.
         :param question_text: The text of the question.
+        :param question_options: The options the respondent should select from.
         :param answer_template: The template for the answer.
         """
         self.question_name = question_name

edsl/questions/QuestionFunctional.py

@@ -108,22 +108,15 @@ class QuestionFunctional(QuestionBase):
     def question_html_content(self) -> str:
         return "NA for QuestionFunctional"
 
-    # @add_edsl_version
-    def to_dict(self, add_edsl_version=True):
-        d = {
+    @add_edsl_version
+    def to_dict(self):
+        return {
             "question_name": self.question_name,
             "function_source_code": self.function_source_code,
             "question_type": "functional",
             "requires_loop": self.requires_loop,
             "function_name": self.function_name,
         }
-        if add_edsl_version:
-            from edsl import __version__
-
-            d["edsl_version"] = __version__
-            d["edsl_class_name"] = self.__class__.__name__
-
-        return d
 
     @classmethod
     def example(cls):

edsl/questions/derived/QuestionTopK.py

@@ -21,7 +21,6 @@ class QuestionTopK(QuestionCheckBox):
         question_presentation: Optional[str] = None,
         answering_instructions: Optional[str] = None,
         include_comment: Optional[bool] = True,
-        use_code: Optional[bool] = True,
     ):
         """Initialize the question.
 
@@ -40,7 +39,6 @@ class QuestionTopK(QuestionCheckBox):
             question_presentation=question_presentation,
             answering_instructions=answering_instructions,
             include_comment=include_comment,
-            use_code=use_code,
         )
         if min_selections != max_selections:
             raise QuestionCreationValidationError(

edsl/questions/question_registry.py

@@ -90,22 +90,6 @@ class Question(metaclass=Meta):
         coop = Coop()
         return coop.patch(uuid, url, description, value, visibility)
 
-    @classmethod
-    def list_question_types(cls):
-        """Return a list of available question types.
-
-        >>> from edsl import Question
-        >>> Question.list_question_types()
-        ['checkbox', 'extract', 'free_text', 'functional', 'likert_five', 'linear_scale', 'list', 'multiple_choice', 'numerical', 'rank', 'top_k', 'yes_no']
-        """
-        return [
-            q
-            for q in sorted(
-                list(RegisterQuestionsMeta.question_types_to_classes().keys())
-            )
-            if q not in ["budget"]
-        ]
-
     @classmethod
     def available(cls, show_class_names: bool = False) -> Union[list, dict]:
         """Return a list of available question types.
@@ -114,32 +98,18 @@ class Question(metaclass=Meta):
 
         Example usage:
 
+        >>> from edsl import Question
+        >>> Question.available()
+        ['checkbox', 'extract', 'free_text', 'functional', 'likert_five', 'linear_scale', 'list', 'multiple_choice', 'numerical', 'rank', 'top_k', 'yes_no']
         """
-        from edsl.results.Dataset import Dataset
-
         exclude = ["budget"]
         if show_class_names:
             return RegisterQuestionsMeta.question_types_to_classes()
         else:
-            question_list = [
-                q
-                for q in sorted(
-                    set(RegisterQuestionsMeta.question_types_to_classes().keys())
-                )
-                if q not in exclude
-            ]
-            d = RegisterQuestionsMeta.question_types_to_classes()
-            question_classes = [d[q] for q in question_list]
-            example_questions = [repr(q.example()) for q in question_classes]
-
-            return Dataset(
-                [
-                    {"question_type": [q for q in question_list]},
-                    {"question_class": [q.__name__ for q in question_classes]},
-                    {"example_question": example_questions},
-                ],
-                print_parameters={"containerHeight": "auto"},
+            question_list = sorted(
+                set(RegisterQuestionsMeta.question_types_to_classes().keys())
             )
+            return [q for q in question_list if q not in exclude]
 
 
 def get_question_class(question_type):

edsl/results/Dataset.py

@@ -5,23 +5,19 @@ import random
 import json
 from collections import UserList
 from typing import Any, Union, Optional
-import sys
+
 import numpy as np
 
 from edsl.results.ResultsExportMixin import ResultsExportMixin
 from edsl.results.DatasetTree import Tree
-from edsl.results.TableDisplay import TableDisplay
 
 
 class Dataset(UserList, ResultsExportMixin):
     """A class to represent a dataset of observations."""
 
-    def __init__(
-        self, data: list[dict[str, Any]] = None, print_parameters: Optional[dict] = None
-    ):
+    def __init__(self, data: list[dict[str, Any]] = None):
         """Initialize the dataset with the given data."""
         super().__init__(data)
-        self.print_parameters = print_parameters
 
     def __len__(self) -> int:
         """Return the number of observations in the dataset.
@@ -36,7 +32,7 @@ class Dataset(UserList, ResultsExportMixin):
         _, values = list(self.data[0].items())[0]
         return len(values)
 
-    def keys(self) -> list[str]:
+    def keys(self):
         """Return the keys of the first observation in the dataset.
 
         >>> d = Dataset([{'a.b':[1,2,3,4]}])
@@ -45,45 +41,10 @@ class Dataset(UserList, ResultsExportMixin):
         """
         return [list(o.keys())[0] for o in self]
 
-    def filter(self, expression):
-        return self.to_scenario_list().filter(expression).to_dataset()
-
     def __repr__(self) -> str:
         """Return a string representation of the dataset."""
         return f"Dataset({self.data})"
 
-    def write(self, filename: str, tablefmt: Optional[str] = None) -> None:
-        return self.table(tablefmt=tablefmt).write(filename)
-
-    def _repr_html_(self):
-        # headers, data = self._tabular()
-        return self.table(print_parameters=self.print_parameters)._repr_html_()
-        # return TableDisplay(headers=headers, data=data, raw_data_set=self)
-
-    def _tabular(self) -> tuple[list[str], list[list[Any]]]:
-        # Extract headers
-        headers = []
-        for entry in self.data:
-            headers.extend(entry.keys())
-        headers = list(dict.fromkeys(headers))  # Ensure unique headers
-
-        # Extract data
-        max_len = max(len(values) for entry in self.data for values in entry.values())
-        rows = []
-        for i in range(max_len):
-            row = []
-            for header in headers:
-                for entry in self.data:
-                    if header in entry:
-                        values = entry[header]
-                        row.append(values[i] if i < len(values) else None)
-                        break
-                else:
-                    row.append(None)  # Default to None if header is missing
-            rows.append(row)
-
-        return headers, rows
-
     def _key_to_value(self, key: str) -> Any:
         """Retrieve the value associated with the given key from the dataset.
 
@@ -128,25 +89,7 @@ class Dataset(UserList, ResultsExportMixin):
 
         return get_values(self.data[0])[0]
 
-    def print(self, pretty_labels=None, **kwargs):
-        if "format" in kwargs:
-            if kwargs["format"] not in ["html", "markdown", "rich", "latex"]:
-                raise ValueError(f"Format '{kwargs['format']}' not supported.")
-        if pretty_labels is None:
-            pretty_labels = {}
-        else:
-            return self.rename(pretty_labels).print(**kwargs)
-        return self.table()
-
-    def rename(self, rename_dic) -> Dataset:
-        new_data = []
-        for observation in self.data:
-            key, values = list(observation.items())[0]
-            new_key = rename_dic.get(key, key)
-            new_data.append({new_key: values})
-        return Dataset(new_data)
-
-    def select(self, *keys) -> Dataset:
+    def select(self, *keys):
         """Return a new dataset with only the selected keys.
 
         :param keys: The keys to select.
@@ -179,6 +122,12 @@ class Dataset(UserList, ResultsExportMixin):
             json.dumps(self.data)
         )  # janky but I want to make sure it's serializable & deserializable
 
+    def _repr_html_(self) -> str:
+        """Return an HTML representation of the dataset."""
+        from edsl.utilities.utilities import data_to_html
+
+        return data_to_html(self.data)
+
     def shuffle(self, seed=None) -> Dataset:
         """Return a new dataset with the observations shuffled.
 
@@ -200,9 +149,6 @@ class Dataset(UserList, ResultsExportMixin):
 
         return self
 
-    def expand(self, field):
-        return self.to_scenario_list().expand(field).to_dataset()
-
     def sample(
         self,
         n: int = None,
@@ -321,92 +267,15 @@ class Dataset(UserList, ResultsExportMixin):
 
         return Dataset(new_data)
 
-    def tree(self, node_order: Optional[list[str]] = None) -> Tree:
+    @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()
-        Tree(Dataset({'a': [1, 2, 3, 4], 'b': [4, 3, 2, 1]}))
+        >>> d.tree.print_tree()
+        Tree has not been constructed yet.
         """
-        return Tree(self, node_order=node_order)
-
-    def table(
-        self,
-        *fields,
-        tablefmt: Optional[str] = None,
-        max_rows: Optional[int] = None,
-        pretty_labels=None,
-        print_parameters: Optional[dict] = None,
-    ):
-        if pretty_labels is not None:
-            new_fields = []
-            for field in fields:
-                new_fields.append(pretty_labels.get(field, field))
-            return self.rename(pretty_labels).table(
-                *new_fields, tablefmt=tablefmt, max_rows=max_rows
-            )
-
-        self.print_parameters = print_parameters
-
-        headers, data = self._tabular()
-
-        if tablefmt is not None:
-            from tabulate import tabulate_formats
-
-            if tablefmt not in tabulate_formats:
-                print(
-                    f"Error: The following table format is not supported: {tablefmt}",
-                    file=sys.stderr,
-                )
-                print(f"\nAvailable formats are: {tabulate_formats}", file=sys.stderr)
-                return None
-
-        if max_rows:
-            if len(data) < max_rows:
-                max_rows = None
-
-        if fields:
-            full_data = data
-            data = []
-            indices = []
-            for field in fields:
-                if field not in headers:
-                    print(
-                        f"Error: The following field was not found: {field}",
-                        file=sys.stderr,
-                    )
-                    print(f"\nAvailable fields are: {headers}", file=sys.stderr)
-
-                    # Optional: Suggest similar fields using difflib
-                    import difflib
-
-                    matches = difflib.get_close_matches(field, headers)
-                    if matches:
-                        print(f"\nDid you mean: {matches[0]} ?", file=sys.stderr)
-                    return None
-                indices.append(headers.index(field))
-            headers = fields
-            for row in full_data:
-                data.append([row[i] for i in indices])
-
-        if max_rows is not None:
-            if max_rows > len(data):
-                raise ValueError(
-                    "max_rows cannot be greater than the number of rows in the dataset."
-                )
-            last_line = data[-1]
-            spaces = len(data[max_rows])
-            filler_line = ["." for i in range(spaces)]
-            data = data[:max_rows]
-            data.append(filler_line)
-            data.append(last_line)
-
-        return TableDisplay(
-            data=data, headers=headers, tablefmt=tablefmt, raw_data_set=self
-        )
-
-    def summary(self):
-        return Dataset([{"num_observations": [len(self)], "keys": [self.keys()]}])
+        return Tree(self)
 
     @classmethod
     def example(self):