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

edsl/questions/descriptors.py

@@ -53,33 +53,12 @@ class BaseDescriptor(ABC):
 
     def __set__(self, instance, value: Any) -> None:
         """Set the value of the attribute."""
-        self.validate(value, instance)
-        # from edsl.prompts.registry import get_classes
-
-        instance.__dict__[self.name] = value
-        # if self.name == "_instructions":
-        #     instructions = value
-        #     if value is not None:
-        #         instance.__dict__[self.name] = instructions
-        #         instance.set_instructions = True
-        #     else:
-        #         potential_prompt_classes = get_classes(
-        #             question_type=instance.question_type
-        #         )
-        #         if len(potential_prompt_classes) > 0:
-        #             instructions = potential_prompt_classes[0]().text
-        #             instance.__dict__[self.name] = instructions
-        #             instance.set_instructions = False
-        #         else:
-        #             if not hasattr(instance, "default_instructions"):
-        #                 raise Exception(
-        #                     "No default instructions found and no matching prompts!"
-        #                 )
-        #             instructions = instance.default_instructions
-        #             instance.__dict__[self.name] = instructions
-        #             instance.set_instructions = False
-
-        # instance.set_instructions = value != instance.default_instructions
+        new_value = self.validate(value, instance)
+
+        if new_value is not None:
+            instance.__dict__[self.name] = new_value
+        else:
+            instance.__dict__[self.name] = value
 
     def __set_name__(self, owner, name: str) -> None:
         """Set the name of the attribute."""
@@ -400,10 +379,24 @@ class QuestionTextDescriptor(BaseDescriptor):
         if contains_single_braced_substring(value):
             import warnings
 
+            # # warnings.warn(
+            # #     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,
+            # # )
             warnings.warn(
-                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",
+                "WARNING: Question text contains a single-braced substring. "
+                "If you intended to parameterize the question with a Scenario, this will "
+                "be changed to a double-braced substring, e.g. {{variable}}.\n"
+                "See details on constructing Scenarios in the docs: "
+                "https://docs.expectedparrot.com/en/latest/scenarios.html",
                 UserWarning,
             )
+            # Automatically replace single braces with double braces
+            # This is here because if the user is using an f-string, the double brace will get converted to a single brace.
+            # This undoes that.
+            value = re.sub(r"\{([^\{\}]+)\}", r"{{\1}}", value)
+            return value
+
         # 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():
@@ -411,6 +404,8 @@ class QuestionTextDescriptor(BaseDescriptor):
                     f"Question text contains an invalid identifier: '{match.group(1)}'"
                 )
 
+        return None
+
 
 if __name__ == "__main__":
     import doctest

edsl/results/DatasetExportMixin.py

@@ -437,7 +437,30 @@ class DatasetExportMixin:
         b64 = base64.b64encode(csv_string.encode()).decode()
         return f'<a href="data:file/csv;base64,{b64}" download="my_data.csv">Download CSV file</a>'
 
-    def to_pandas(self, remove_prefix: bool = False) -> "pd.DataFrame":
+    def to_pandas(
+        self, remove_prefix: bool = False, lists_as_strings=False
+    ) -> "DataFrame":
+        """Convert the results to a pandas DataFrame, ensuring that lists remain as lists.
+
+        :param remove_prefix: Whether to remove the prefix from the column names.
+
+        """
+        return self._to_pandas_strings(remove_prefix)
+        # if lists_as_strings:
+        #     return self._to_pandas_strings(remove_prefix=remove_prefix)
+
+        # import pandas as pd
+
+        # df = pd.DataFrame(self.data)
+
+        # if remove_prefix:
+        #     # Optionally remove prefixes from column names
+        #     df.columns = [col.split(".")[-1] for col in df.columns]
+
+        # df_sorted = df.sort_index(axis=1)  # Sort columns alphabetically
+        # return df_sorted
+
+    def _to_pandas_strings(self, remove_prefix: bool = False) -> "pd.DataFrame":
         """Convert the results to a pandas DataFrame.
 
         :param remove_prefix: Whether to remove the prefix from the column names.
@@ -451,6 +474,7 @@ class DatasetExportMixin:
         2           Terrible
         3                 OK
         """
+
         import pandas as pd
 
         csv_string = self.to_csv(remove_prefix=remove_prefix)

edsl/results/Result.py

@@ -117,6 +117,7 @@ class Result(Base, UserDict):
             "raw_model_response": raw_model_response or {},
             "question_to_attributes": question_to_attributes,
             "generated_tokens": generated_tokens or {},
+            "comments_dict": comments_dict or {},
         }
         super().__init__(**data)
         # but also store the data as attributes
@@ -155,15 +156,15 @@ class Result(Base, UserDict):
             if key in self.question_to_attributes:
                 # You might be tempted to just use the naked key
                 # but this is a bad idea because it pollutes the namespace
-                question_text_dict[key + "_question_text"] = (
-                    self.question_to_attributes[key]["question_text"]
-                )
-                question_options_dict[key + "_question_options"] = (
-                    self.question_to_attributes[key]["question_options"]
-                )
-                question_type_dict[key + "_question_type"] = (
-                    self.question_to_attributes[key]["question_type"]
-                )
+                question_text_dict[
+                    key + "_question_text"
+                ] = self.question_to_attributes[key]["question_text"]
+                question_options_dict[
+                    key + "_question_options"
+                ] = self.question_to_attributes[key]["question_options"]
+                question_type_dict[
+                    key + "_question_type"
+                ] = self.question_to_attributes[key]["question_type"]
 
         return {
             "agent": self.agent.traits
@@ -256,10 +257,25 @@ class Result(Base, UserDict):
 
         """
         d = {}
-        data_types = self.sub_dicts.keys()
+        problem_keys = []
+        data_types = sorted(self.sub_dicts.keys())
         for data_type in data_types:
             for key in self.sub_dicts[data_type]:
+                if key in d:
+                    import warnings
+
+                    warnings.warn(
+                        f"Key '{key}' of data type '{data_type}' is already in use. Renaming to {key}_{data_type}"
+                    )
+                    problem_keys.append((key, data_type))
+                    key = f"{key}_{data_type}"
+                    # raise ValueError(f"Key '{key}' is already in the dictionary")
                 d[key] = data_type
+
+        for key, data_type in problem_keys:
+            self.sub_dicts[data_type][f"{key}_{data_type}"] = self.sub_dicts[
+                data_type
+            ].pop(key)
         return d
 
     def rows(self, index) -> tuple[int, str, str, str]:
@@ -370,6 +386,7 @@ class Result(Base, UserDict):
             ),
             question_to_attributes=json_dict.get("question_to_attributes", None),
             generated_tokens=json_dict.get("generated_tokens", {}),
+            comments_dict=json_dict.get("comments_dict", {}),
         )
         return result
 

edsl/results/Results.py

@@ -7,11 +7,17 @@ from __future__ import annotations
 import json
 import random
 from collections import UserList, defaultdict
-from typing import Optional, Callable, Any, Type, Union, List
+from typing import Optional, Callable, Any, Type, Union, List, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from edsl import Survey, Cache, AgentList, ModelList, ScenarioList
+    from edsl.results.Result import Result
+    from edsl.jobs.tasks.TaskHistory import TaskHistory
 
 from simpleeval import EvalWithCompoundTypes
 
 from edsl.exceptions.results import (
+    ResultsError,
     ResultsBadMutationstringError,
     ResultsColumnNotFoundError,
     ResultsInvalidNameError,
@@ -40,7 +46,7 @@ class Mixins(
     ResultsGGMixin,
     ResultsToolsMixin,
 ):
-    def print_long(self, max_rows=None) -> None:
+    def print_long(self, max_rows: int = None) -> None:
         """Print the results in long format.
 
         >>> from edsl.results import Results
@@ -84,13 +90,13 @@ class Results(UserList, Mixins, Base):
 
     def __init__(
         self,
-        survey: Optional["Survey"] = None,
-        data: Optional[list["Result"]] = None,
+        survey: Optional[Survey] = None,
+        data: Optional[list[Result]] = None,
         created_columns: Optional[list[str]] = None,
-        cache: Optional["Cache"] = None,
+        cache: Optional[Cache] = None,
         job_uuid: Optional[str] = None,
         total_results: Optional[int] = None,
-        task_history: Optional["TaskHistory"] = None,
+        task_history: Optional[TaskHistory] = None,
     ):
         """Instantiate a `Results` object with a survey and a list of `Result` objects.
 
@@ -110,7 +116,7 @@ class Results(UserList, Mixins, Base):
         self._total_results = total_results
         self.cache = cache or Cache()
 
-        self.task_history = task_history or TaskHistory(interviews = [])
+        self.task_history = task_history or TaskHistory(interviews=[])
 
         if hasattr(self, "_add_output_functions"):
             self._add_output_functions()
@@ -235,11 +241,11 @@ class Results(UserList, Mixins, Base):
         >>> r3 = r + r2
         """
         if self.survey != other.survey:
-            raise Exception(
-                "The surveys are not the same so they cannot be added together."
+            raise ResultsError(
+                "The surveys are not the same so the the results cannot be added together."
             )
         if self.created_columns != other.created_columns:
-            raise Exception(
+            raise ResultsError(
                 "The created columns are not the same so they cannot be added together."
             )
 
@@ -258,16 +264,7 @@ class Results(UserList, Mixins, Base):
         from IPython.display import HTML
 
         json_str = json.dumps(self.to_dict()["data"], indent=4)
-        from pygments import highlight
-        from pygments.lexers import JsonLexer
-        from pygments.formatters import HtmlFormatter
-
-        formatted_json = highlight(
-            json_str,
-            JsonLexer(),
-            HtmlFormatter(style="default", full=True, noclasses=True),
-        )
-        return HTML(formatted_json).data
+        return f"<pre>{json_str}</pre>"
 
     def _to_dict(self, sort=False):
         from edsl.data.Cache import Cache
@@ -301,7 +298,7 @@ class Results(UserList, Mixins, Base):
             "b_not_a": [other_results[i] for i in indices_other],
         }
 
-    @property 
+    @property
     def has_unfixed_exceptions(self):
         return self.task_history.has_unfixed_exceptions
 
@@ -326,7 +323,7 @@ class Results(UserList, Mixins, Base):
     def hashes(self) -> set:
         return set(hash(result) for result in self.data)
 
-    def sample(self, n: int) -> "Results":
+    def sample(self, n: int) -> Results:
         """Return a random sample of the results.
 
         :param n: The number of samples to return.
@@ -344,7 +341,7 @@ class Results(UserList, Mixins, Base):
                 indices = list(range(len(values)))
                 sampled_indices = random.sample(indices, n)
                 if n > len(indices):
-                    raise ValueError(
+                    raise ResultsError(
                         f"Cannot sample {n} items from a list of length {len(indices)}."
                     )
             entry[key] = [values[i] for i in sampled_indices]
@@ -397,11 +394,12 @@ class Results(UserList, Mixins, Base):
         - Uses the key_to_data_type property of the Result class.
         - Includes any columns that the user has created with `mutate`
         """
-        d = {}
+        d: dict = {}
         for result in self.data:
             d.update(result.key_to_data_type)
         for column in self.created_columns:
             d[column] = "answer"
+
         return d
 
     @property
@@ -451,7 +449,7 @@ class Results(UserList, Mixins, Base):
         from edsl.utilities.utilities import shorten_string
 
         if not self.survey:
-            raise Exception("Survey is not defined so no answer keys are available.")
+            raise ResultsError("Survey is not defined so no answer keys are available.")
 
         answer_keys = self._data_type_to_keys["answer"]
         answer_keys = {k for k in answer_keys if "_comment" not in k}
@@ -464,7 +462,7 @@ class Results(UserList, Mixins, Base):
         return sorted_dict
 
     @property
-    def agents(self) -> "AgentList":
+    def agents(self) -> AgentList:
         """Return a list of all of the agents in the Results.
 
         Example:
@@ -478,7 +476,7 @@ class Results(UserList, Mixins, Base):
         return AgentList([r.agent for r in self.data])
 
     @property
-    def models(self) -> list[Type["LanguageModel"]]:
+    def models(self) -> ModelList:
         """Return a list of all of the models in the Results.
 
         Example:
@@ -487,10 +485,12 @@ class Results(UserList, Mixins, Base):
         >>> r.models[0]
         Model(model_name = ...)
         """
-        return [r.model for r in self.data]
+        from edsl import ModelList
+
+        return ModelList([r.model for r in self.data])
 
     @property
-    def scenarios(self) -> "ScenarioList":
+    def scenarios(self) -> ScenarioList:
         """Return a list of all of the scenarios in the Results.
 
         Example:
@@ -567,7 +567,7 @@ class Results(UserList, Mixins, Base):
         )
         return sorted(list(all_keys))
 
-    def first(self) -> "Result":
+    def first(self) -> Result:
         """Return the first observation in the results.
 
         Example:
@@ -817,7 +817,7 @@ class Results(UserList, Mixins, Base):
 
         return Results(survey=self.survey, data=new_data, created_columns=None)
 
-    def select(self, *columns: Union[str, list[str]]) -> "Dataset":
+    def select(self, *columns: Union[str, list[str]]) -> Results:
         """
         Select data from the results and format it.
 
@@ -830,93 +830,12 @@ class Results(UserList, Mixins, Base):
         Dataset([{'answer.how_feeling': ['OK', 'Great', 'Terrible', 'OK']}])
 
         >>> results.select('how_feeling', 'model', 'how_feeling')
-        Dataset([{'answer.how_feeling': ['OK', 'Great', 'Terrible', 'OK']}, {'model.model': ['...', '...', '...', '...']}, {'answer.how_feeling': ['OK', 'Great', 'Terrible', 'OK']}])
+        Dataset([{'answer.how_feeling': ['OK', 'Great', 'Terrible', 'OK']}, {'answer.how_feeling': ['OK', 'Great', 'Terrible', 'OK']}, {'model.model': ['...', '...', '...', '...']}, {'answer.how_feeling': ['OK', 'Great', 'Terrible', 'OK']}, {'answer.how_feeling': ['OK', 'Great', 'Terrible', 'OK']}])
 
         >>> from edsl import Results; r = Results.example(); r.select('answer.how_feeling_y')
         Dataset([{'answer.how_feeling_yesterday': ['Great', 'Good', 'OK', 'Terrible']}])
         """
 
-        # if len(self) == 0:
-        #    raise Exception("No data to select from---the Results object is empty.")
-
-        if not columns or columns == ("*",) or columns == (None,):
-            # is the users passes nothing, then we'll return all the columns
-            columns = ("*.*",)
-
-        if isinstance(columns[0], list):
-            columns = tuple(columns[0])
-
-        def get_data_types_to_return(parsed_data_type):
-            if parsed_data_type == "*":  # they want all of the columns
-                return self.known_data_types
-            else:
-                if parsed_data_type not in self.known_data_types:
-                    raise Exception(
-                        f"Data type {parsed_data_type} not found in data. Did you mean one of {self.known_data_types}"
-                    )
-                return [parsed_data_type]
-
-        # we're doing to populate this with the data we want to fetch
-        to_fetch = defaultdict(list)
-
-        new_data = []
-        items_in_order = []
-        # iterate through the passed columns
-        for column in columns:
-            # a user could pass 'result.how_feeling' or just 'how_feeling'
-            matches = self._matching_columns(column)
-            if len(matches) > 1:
-                raise Exception(
-                    f"Column '{column}' is ambiguous. Did you mean one of {matches}?"
-                )
-            if len(matches) == 0 and ".*" not in column:
-                raise Exception(f"Column '{column}' not found in data.")
-            if len(matches) == 1:
-                column = matches[0]
-
-            parsed_data_type, parsed_key = self._parse_column(column)
-            data_types = get_data_types_to_return(parsed_data_type)
-            found_once = False  # we need to track this to make sure we found the key at least once
-
-            for data_type in data_types:
-                # the keys for that data_type e.g.,# if data_type is 'answer', then the keys are 'how_feeling', 'how_feeling_comment', etc.
-                relevant_keys = self._data_type_to_keys[data_type]
-
-                for key in relevant_keys:
-                    if key == parsed_key or parsed_key == "*":
-                        found_once = True
-                        to_fetch[data_type].append(key)
-                        items_in_order.append(data_type + "." + key)
-
-            if not found_once:
-                raise Exception(f"Key {parsed_key} not found in data.")
-
-        for data_type in to_fetch:
-            for key in to_fetch[data_type]:
-                entries = self._fetch_list(data_type, key)
-                new_data.append({data_type + "." + key: entries})
-
-        def sort_by_key_order(dictionary):
-            # Extract the single key from the dictionary
-            single_key = next(iter(dictionary))
-            # Return the index of this key in the list_of_keys
-            return items_in_order.index(single_key)
-
-        # sorted(new_data, key=sort_by_key_order)
-        from edsl.results.Dataset import Dataset
-
-        sorted_new_data = []
-
-        # WORKS but slow
-        for key in items_in_order:
-            for d in new_data:
-                if key in d:
-                    sorted_new_data.append(d)
-                    break
-
-        return Dataset(sorted_new_data)
-
-    def select(self, *columns: Union[str, list[str]]) -> "Results":
         from edsl.results.Selector import Selector
 
         if len(self) == 0:
@@ -1026,6 +945,7 @@ class Results(UserList, Mixins, Base):
         Traceback (most recent call last):
         ...
         edsl.exceptions.results.ResultsFilterError: You must use '==' instead of '=' in the filter expression.
+        ...
 
         >>> r.filter("how_feeling == 'Great' or how_feeling == 'Terrible'").select('how_feeling').print()
         ┏━━━━━━━━━━━━━━┓
@@ -1103,6 +1023,7 @@ class Results(UserList, Mixins, Base):
             stop_on_exception=True,
             skip_retry=True,
             raise_validation_errors=True,
+            disable_remote_cache=True,
             disable_remote_inference=True,
         )
         return results
@@ -1110,14 +1031,6 @@ class Results(UserList, Mixins, Base):
     def rich_print(self):
         """Display an object as a table."""
         pass
-        # with io.StringIO() as buf:
-        #     console = Console(file=buf, record=True)
-
-        #     for index, result in enumerate(self):
-        #         console.print(f"Result {index}")
-        #         console.print(result.rich_print())
-
-        #     return console.export_text()
 
     def __str__(self):
         data = self.to_dict()["data"]

edsl/results/ResultsDBMixin.py

@@ -93,7 +93,7 @@ class ResultsDBMixin:
             from sqlalchemy import create_engine
 
             engine = create_engine("sqlite:///:memory:")
-            df = self.to_pandas(remove_prefix=remove_prefix)
+            df = self.to_pandas(remove_prefix=remove_prefix, lists_as_strings=True)
             df.to_sql("self", engine, index=False, if_exists="replace")
             return engine.connect()
         else:

edsl/results/Selector.py

@@ -12,6 +12,7 @@ class Selector:
         fetch_list_func,
         columns: List[str],
     ):
+        """Selects columns from a Results object"""
         self.known_data_types = known_data_types
         self._data_type_to_keys = data_type_to_keys
         self._key_to_data_type = key_to_data_type
@@ -21,10 +22,19 @@ class Selector:
     def select(self, *columns: Union[str, List[str]]) -> "Dataset":
         columns = self._normalize_columns(columns)
         to_fetch = self._get_columns_to_fetch(columns)
+        # breakpoint()
         new_data = self._fetch_data(to_fetch)
         return Dataset(new_data)
 
     def _normalize_columns(self, columns: Union[str, List[str]]) -> tuple:
+        """Normalize the columns to a tuple of strings
+
+        >>> s = Selector([], {}, {}, lambda x, y: x, [])
+        >>> s._normalize_columns([["a", "b"], ])
+        ('a', 'b')
+        >>> s._normalize_columns(None)
+        ('*.*',)
+        """
         if not columns or columns == ("*",) or columns == (None,):
             return ("*.*",)
         if isinstance(columns[0], list):
@@ -37,6 +47,7 @@ class Selector:
 
         for column in columns:
             matches = self._find_matching_columns(column)
+            # breakpoint()
             self._validate_matches(column, matches)
 
             if len(matches) == 1:
@@ -52,7 +63,7 @@ class Selector:
             search_in_list = self.columns
         else:
             search_in_list = [s.split(".")[1] for s in self.columns]
-
+        # breakpoint()
         matches = [s for s in search_in_list if s.startswith(partial_name)]
         return [partial_name] if partial_name in matches else matches
 
@@ -116,3 +127,9 @@ class Selector:
                 new_data.append({f"{data_type}.{key}": entries})
 
         return [d for key in self.items_in_order for d in new_data if key in d]
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

edsl/scenarios/FileStore.py

@@ -77,8 +77,19 @@ class FileStore(Scenario):
     def __str__(self):
         return "FileStore: self.path"
 
+    @classmethod
+    def example(self):
+        import tempfile
+
+        with tempfile.NamedTemporaryFile(suffix=".txt", delete=False) as f:
+            f.write(b"Hello, World!")
+
+        return self(path=f.name)
+
     @property
     def size(self) -> int:
+        if self.base64_string != None:
+            return (len(self.base64_string) / 4.0) * 3  # from base64 to char size
         return os.path.getsize(self.path)
 
     def upload_google(self, refresh: bool = False) -> None:
@@ -93,7 +104,7 @@ class FileStore(Scenario):
         return cls(**d)
 
     def __repr__(self):
-        return f"FileStore({self.path})"
+        return f"FileStore(path='{self.path}')"
 
     def encode_file_to_base64_string(self, file_path: str):
         try:
@@ -272,7 +283,8 @@ class CSVFileStore(FileStore):
 
         with tempfile.NamedTemporaryFile(suffix=".csv", delete=False) as f:
             r.to_csv(filename=f.name)
-            return cls(f.name)
+
+        return cls(f.name)
 
     def view(self):
         import pandas as pd
@@ -352,7 +364,8 @@ class PDFFileStore(FileStore):
 
         with tempfile.NamedTemporaryFile(suffix=".pdf", delete=False) as f:
             f.write(pdf_string.encode())
-            return cls(f.name)
+
+        return cls(f.name)
 
 
 class PNGFileStore(FileStore):
@@ -367,7 +380,8 @@ class PNGFileStore(FileStore):
 
         with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as f:
             f.write(png_string.encode())
-            return cls(f.name)
+
+        return cls(f.name)
 
     def view(self):
         import matplotlib.pyplot as plt
@@ -407,7 +421,8 @@ class HTMLFileStore(FileStore):
 
         with tempfile.NamedTemporaryFile(suffix=".html", delete=False) as f:
             f.write("<html><body><h1>Test</h1></body></html>".encode())
-            return cls(f.name)
+
+        return cls(f.name)
 
     def view(self):
         import webbrowser