edsl 0.1.38.dev2__py3-none-any.whl → 0.1.38.dev4__py3-none-any.whl

edsl/language_models/ModelList.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Optional, List
 from collections import UserList
 from edsl import Model
 
@@ -10,6 +10,8 @@ from edsl.utilities.utilities import dict_hash
 
 
 class ModelList(Base, UserList):
+    __documentation__ = """https://docs.expectedparrot.com/en/latest/language_models.html#module-edsl.language_models.ModelList"""
+
     def __init__(self, data: Optional[list] = None):
         """Initialize the ScenarioList class.
 
@@ -37,6 +39,9 @@ class ModelList(Base, UserList):
     def __repr__(self):
         return f"ModelList({super().__repr__()})"
 
+    def _summary(self):
+        return {"EDSL Class": "ModelList", "Number of Models": len(self)}
+
     def __hash__(self):
         """Return a hash of the ModelList. This is used for comparison of ModelLists.
 
@@ -48,6 +53,42 @@ class ModelList(Base, UserList):
 
         return dict_hash(self.to_dict(sort=True, add_edsl_version=False))
 
+    def to_scenario_list(self):
+        from edsl import ScenarioList, Scenario
+
+        sl = ScenarioList()
+        for model in self:
+            d = {"model": model.model}
+            d.update(model.parameters)
+            sl.append(Scenario(d))
+        return sl
+
+    def tree(self, node_list: Optional[List[str]] = None):
+        return self.to_scenario_list().tree(node_list)
+
+    def table(
+        self,
+        *fields,
+        tablefmt: Optional[str] = None,
+        pretty_labels: Optional[dict] = None,
+    ):
+        """
+        >>> ModelList.example().table("model")
+        model
+        -------
+        gpt-4o
+        gpt-4o
+        gpt-4o
+        """
+        return (
+            self.to_scenario_list()
+            .to_dataset()
+            .table(*fields, tablefmt=tablefmt, pretty_labels=pretty_labels)
+        )
+
+    def to_list(self):
+        return self.to_scenario_list().to_list()
+
     def to_dict(self, sort=False, add_edsl_version=True):
         if sort:
             model_list = sorted([model for model in self], key=lambda x: hash(x))
@@ -71,6 +112,11 @@ class ModelList(Base, UserList):
 
         return d
 
+    def _repr_html_(self):
+        """Return an HTML representation of the ModelList."""
+        footer = f"<a href={self.__documentation__}>(docs)</a>"
+        return str(self.summary(format="html")) + footer
+
     @classmethod
     def from_names(self, *args, **kwargs):
         """A a model list from a list of names"""

edsl/language_models/registry.py

@@ -7,6 +7,49 @@ from edsl.config import CONFIG
 # else:
 #     default_model = CONFIG.get("EDSL_DEFAULT_MODEL")
 
+from collections import UserList
+
+
+class PrettyList(UserList):
+    def __init__(self, data=None, columns=None):
+        super().__init__(data)
+        self.columns = columns
+
+    def _repr_html_(self):
+        if isinstance(self[0], list) or isinstance(self[0], tuple):
+            num_cols = len(self[0])
+        else:
+            num_cols = 1
+
+        if self.columns:
+            columns = self.columns
+        else:
+            columns = list(range(num_cols))
+
+        if num_cols > 1:
+            return (
+                "<pre><table>"
+                + "".join(["<th>" + str(column) + "</th>" for column in columns])
+                + "".join(
+                    [
+                        "<tr>"
+                        + "".join(["<td>" + str(x) + "</td>" for x in row])
+                        + "</tr>"
+                        for row in self
+                    ]
+                )
+                + "</table></pre>"
+            )
+        else:
+            return (
+                "<pre><table>"
+                + "".join(["<th>" + str(index) + "</th>" for index in columns])
+                + "".join(
+                    ["<tr>" + "<td>" + str(row) + "</td>" + "</tr>" for row in self]
+                )
+                + "</table></pre>"
+            )
+
 
 def get_model_class(model_name, registry=None):
     from edsl.inference_services.registry import default
@@ -82,17 +125,27 @@ class Model(metaclass=Meta):
 
         if search_term is None:
             if name_only:
-                return [m[0] for m in full_list]
+                return PrettyList(
+                    [m[0] for m in full_list],
+                    columns=["Model Name", "Service Name", "Code"],
+                )
             else:
-                return full_list
+                return PrettyList(
+                    full_list, columns=["Model Name", "Service Name", "Code"]
+                )
         else:
             filtered_results = [
                 m for m in full_list if search_term in m[0] or search_term in m[1]
             ]
             if name_only:
-                return [m[0] for m in filtered_results]
+                return PrettyList(
+                    [m[0] for m in filtered_results],
+                    columns=["Model Name", "Service Name", "Code"],
+                )
             else:
-                return filtered_results
+                return PrettyList(
+                    filtered_results, columns=["Model Name", "Service Name", "Code"]
+                )
 
     @classmethod
     def check_models(cls, verbose=False):

edsl/prompts/Prompt.py

@@ -29,9 +29,14 @@ class Prompt(PersistenceMixin, RichPrintingMixin):
 
     def _repr_html_(self):
         """Return an HTML representation of the Prompt."""
-        from edsl.utilities.utilities import data_to_html
-
-        return data_to_html(self.to_dict())
+        # from edsl.utilities.utilities import data_to_html
+        # return data_to_html(self.to_dict())
+        d = self.to_dict()
+        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>"
 
     def __len__(self):
         """Return the length of the prompt text."""

edsl/questions/QuestionBase.py

@@ -82,7 +82,8 @@ class QuestionBase(
         if not hasattr(self, "_fake_data_factory"):
             from polyfactory.factories.pydantic_factory import ModelFactory
 
-            class FakeData(ModelFactory[self.response_model]): ...
+            class FakeData(ModelFactory[self.response_model]):
+                ...
 
             self._fake_data_factory = FakeData
         return self._fake_data_factory
@@ -263,12 +264,9 @@ class QuestionBase(
         >>> m.execute_model_call("", "")
         {'message': [{'text': "Yo, what's up?"}], 'usage': {'prompt_tokens': 1, 'completion_tokens': 1}}
         >>> Q.run_example(show_answer = True, model = m, disable_remote_cache = True, disable_remote_inference = True)
-        ┏━━━━━━━━━━━━━━━━┓
-        ┃ answer         ┃
-        ┃ .how_are_you   ┃
-        ┡━━━━━━━━━━━━━━━━┩
-        │ Yo, what's up? │
-        └────────────────┘
+        answer.how_are_you
+        --------------------
+        Yo, what's up?
         """
         if model is None:
             from edsl import Model
@@ -284,7 +282,7 @@ class QuestionBase(
             )
         )
         if show_answer:
-            results.select("answer.*").print()
+            return results.select("answer.*").print()
         else:
             return results
 
@@ -362,16 +360,22 @@ class QuestionBase(
 
     # region: Magic methods
     def _repr_html_(self):
-        from edsl.utilities.utilities import data_to_html
+        # from edsl.utilities.utilities import data_to_html
 
-        data = self.to_dict()
-        try:
-            _ = data.pop("edsl_version")
-            _ = data.pop("edsl_class_name")
-        except KeyError:
-            print("Serialized question lacks edsl version, but is should have it.")
+        data = self.to_dict(add_edsl_version=False)
+        # keys = list(data.keys())
+        # values = list(data.values())
+        from tabulate import tabulate
+
+        return tabulate(data.items(), headers=["keys", "values"], tablefmt="html")
+
+        # try:
+        #     _ = data.pop("edsl_version")
+        #     _ = data.pop("edsl_class_name")
+        # except KeyError:
+        #     print("Serialized question lacks edsl version, but is should have it.")
 
-        return data_to_html(data)
+        # return data_to_html(data)
 
     def __getitem__(self, key: str) -> Any:
         """Get an attribute of the question so it can be treated like a dictionary.

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/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):