edsl 0.1.37.dev5__py3-none-any.whl → 0.1.38__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())
+        d = copy.deepcopy(self.to_dict(add_edsl_version=False))
         for key, value in d.items():
             if key in exclude_components:
                 continue

edsl/questions/QuestionBasePromptsMixin.py

@@ -126,7 +126,6 @@ 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"
         )
@@ -142,22 +141,6 @@ 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,4 +1,7 @@
 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
@@ -11,9 +14,6 @@ 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,7 +112,6 @@ 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,15 +108,22 @@ class QuestionFunctional(QuestionBase):
     def question_html_content(self) -> str:
         return "NA for QuestionFunctional"
 
-    @add_edsl_version
-    def to_dict(self):
-        return {
+    # @add_edsl_version
+    def to_dict(self, add_edsl_version=True):
+        d = {
             "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,6 +21,7 @@ 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.
 
@@ -39,6 +40,7 @@ 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,6 +90,22 @@ 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.
@@ -98,18 +114,32 @@ 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 = sorted(
-                set(RegisterQuestionsMeta.question_types_to_classes().keys())
+            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"},
             )
-            return [q for q in question_list if q not in exclude]
 
 
 def get_question_class(question_type):

edsl/results/CSSParameterizer.py

@@ -0,0 +1,108 @@
+import re
+from typing import Dict, Set, Optional
+
+
+class CSSParameterizer:
+    """A utility class to parameterize CSS with custom properties (variables)."""
+
+    def __init__(self, css_content: str):
+        """
+        Initialize with CSS content to be parameterized.
+
+        Args:
+            css_content (str): The CSS content containing var() declarations
+        """
+        self.css_content = css_content
+        self._extract_variables()
+
+    def _extract_variables(self) -> None:
+        """Extract all CSS custom properties (variables) from the CSS content."""
+        # Find all var(...) declarations in the CSS
+        var_pattern = r"var\((--[a-zA-Z0-9-]+)\)"
+        self.variables = set(re.findall(var_pattern, self.css_content))
+
+    def _validate_parameters(self, parameters: Dict[str, str]) -> Set[str]:
+        """
+        Validate the provided parameters against the CSS variables.
+
+        Args:
+            parameters (Dict[str, str]): Dictionary of variable names and their values
+
+        Returns:
+            Set[str]: Set of missing variables
+        """
+        # Convert parameter keys to CSS variable format if they don't already have --
+        formatted_params = {
+            f"--{k}" if not k.startswith("--") else k for k in parameters.keys()
+        }
+
+        # print("Variables from CSS:", self.variables)
+        # print("Formatted parameters:", formatted_params)
+
+        # Find missing and extra variables
+        missing_vars = self.variables - formatted_params
+        extra_vars = formatted_params - self.variables
+
+        if extra_vars:
+            print(f"Warning: Found unused parameters: {extra_vars}")
+
+        return missing_vars
+
+    def generate_root(self, **parameters: str) -> Optional[str]:
+        """
+        Generate a :root block with the provided parameters.
+
+        Args:
+            **parameters: Keyword arguments where keys are variable names and values are their values
+
+        Returns:
+            str: Generated :root block with variables, or None if validation fails
+
+        Example:
+            >>> css = "body { height: var(--bodyHeight); }"
+            >>> parameterizer = CSSParameterizer(css)
+            >>> parameterizer.apply_parameters({'bodyHeight':"100vh"})
+            ':root {\\n  --bodyHeight: 100vh;\\n}\\n\\nbody { height: var(--bodyHeight); }'
+        """
+        missing_vars = self._validate_parameters(parameters)
+
+        if missing_vars:
+            print(f"Error: Missing required variables: {missing_vars}")
+            return None
+
+        # Format parameters with -- prefix if not present
+        formatted_params = {
+            f"--{k}" if not k.startswith("--") else k: v for k, v in parameters.items()
+        }
+
+        # Generate the :root block
+        root_block = [":root {"]
+        for var_name, value in sorted(formatted_params.items()):
+            if var_name in self.variables:
+                root_block.append(f"  {var_name}: {value};")
+        root_block.append("}")
+
+        return "\n".join(root_block)
+
+    def apply_parameters(self, parameters: dict) -> Optional[str]:
+        """
+        Generate the complete CSS with the :root block and original CSS content.
+
+        Args:
+            **parameters: Keyword arguments where keys are variable names and values are their values
+
+        Returns:
+            str: Complete CSS with :root block and original content, or None if validation fails
+        """
+        root_block = self.generate_root(**parameters)
+        if root_block is None:
+            return None
+
+        return f"{root_block}\n\n{self.css_content}"
+
+
+# Example usage
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

edsl/results/Dataset.py

@@ -5,19 +5,23 @@ 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):
+    def __init__(
+        self, data: list[dict[str, Any]] = None, print_parameters: Optional[dict] = 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.
@@ -32,7 +36,7 @@ class Dataset(UserList, ResultsExportMixin):
         _, values = list(self.data[0].items())[0]
         return len(values)
 
-    def keys(self):
+    def keys(self) -> list[str]:
         """Return the keys of the first observation in the dataset.
 
         >>> d = Dataset([{'a.b':[1,2,3,4]}])
@@ -41,10 +45,45 @@ 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.
 
@@ -89,7 +128,25 @@ class Dataset(UserList, ResultsExportMixin):
 
         return get_values(self.data[0])[0]
 
-    def select(self, *keys):
+    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:
         """Return a new dataset with only the selected keys.
 
         :param keys: The keys to select.
@@ -122,12 +179,6 @@ 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.
 
@@ -149,6 +200,9 @@ 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,
@@ -267,15 +321,92 @@ class Dataset(UserList, ResultsExportMixin):
 
         return Dataset(new_data)
 
-    @property
-    def tree(self):
+    def tree(self, node_order: Optional[list[str]] = None) -> Tree:
         """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.
+        >>> d.tree()
+        Tree(Dataset({'a': [1, 2, 3, 4], 'b': [4, 3, 2, 1]}))
         """
-        return Tree(self)
+        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()]}])
 
     @classmethod
     def example(self):