edsl 0.1.30.dev4__py3-none-any.whl → 0.1.31__py3-none-any.whl

edsl/results/Results.py

@@ -604,6 +604,38 @@ class Results(UserList, Mixins, Base):
             self = self.add_column(key, values)
         return self
 
+    @staticmethod
+    def _create_evaluator(
+        result: Result, functions_dict: Optional[dict] = None
+    ) -> EvalWithCompoundTypes:
+        """Create an evaluator for the expression.
+
+        >>> from unittest.mock import Mock
+        >>> result = Mock()
+        >>> result.combined_dict = {'how_feeling': 'OK'}
+
+        >>> evaluator = Results._create_evaluator(result = result, functions_dict = {})
+        >>> evaluator.eval("how_feeling == 'OK'")
+        True
+
+        >>> result.combined_dict = {'answer': {'how_feeling': 'OK'}}
+        >>> evaluator = Results._create_evaluator(result = result, functions_dict = {})
+        >>> evaluator.eval("answer.how_feeling== 'OK'")
+        True
+
+        Note that you need to refer to the answer dictionary in the expression.
+
+        >>> evaluator.eval("how_feeling== 'OK'")
+        Traceback (most recent call last):
+        ...
+        simpleeval.NameNotDefined: 'how_feeling' is not defined for expression 'how_feeling== 'OK''
+        """
+        if functions_dict is None:
+            functions_dict = {}
+        return EvalWithCompoundTypes(
+            names=result.combined_dict, functions=functions_dict
+        )
+
     def mutate(
         self, new_var_string: str, functions_dict: Optional[dict] = None
     ) -> Results:
@@ -636,13 +668,8 @@ class Results(UserList, Mixins, Base):
         # create the evaluator
         functions_dict = functions_dict or {}
 
-        def create_evaluator(result: Result) -> EvalWithCompoundTypes:
-            return EvalWithCompoundTypes(
-                names=result.combined_dict, functions=functions_dict
-            )
-
         def new_result(old_result: "Result", var_name: str) -> "Result":
-            evaluator = create_evaluator(old_result)
+            evaluator = self._create_evaluator(old_result, functions_dict)
             value = evaluator.eval(expression)
             new_result = old_result.copy()
             new_result["answer"][var_name] = value
@@ -742,6 +769,9 @@ class Results(UserList, Mixins, Base):
         >>> results = Results.example()
         >>> results.select('how_feeling')
         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': ['gpt-4-1106-preview', 'gpt-4-1106-preview', 'gpt-4-1106-preview', 'gpt-4-1106-preview']}, {'answer.how_feeling': ['OK', 'Great', 'Terrible', 'OK']}])
         """
 
         if len(self) == 0:
@@ -799,10 +829,19 @@ class Results(UserList, Mixins, Base):
             # 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)
+        # sorted(new_data, key=sort_by_key_order)
         from edsl.results.Dataset import Dataset
 
-        return Dataset(new_data)
+        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 sort_by(self, *columns: str, reverse: bool = False) -> Results:
         import warnings
@@ -917,29 +956,29 @@ class Results(UserList, Mixins, Base):
                 "You must use '==' instead of '=' in the filter expression."
             )
 
-        def create_evaluator(result):
-            """Create an evaluator for the given result.
-            The 'combined_dict' is a mapping of all values for that Result object.
-            """
-            return EvalWithCompoundTypes(names=result.combined_dict)
-
         try:
             # iterates through all the results and evaluates the expression
-            new_data = [
-                result
-                for result in self.data
-                if create_evaluator(result).eval(expression)
-            ]
+            new_data = []
+            for result in self.data:
+                evaluator = self._create_evaluator(result)
+                result.check_expression(expression)  # check expression
+                if evaluator.eval(expression):
+                    new_data.append(result)
+
+        except ValueError as e:
+            raise ResultsFilterError(
+                f"Error in filter. Exception:{e}",
+                f"The expression you provided was: {expression}",
+                "See https://docs.expectedparrot.com/en/latest/results.html#filtering-results for more details.",
+            )
         except Exception as e:
             raise ResultsFilterError(
-                f"""Error in filter. Exception:{e}.
-            The expression you provided was: {expression}. 
-            Please make sure that the expression is a valid Python expression that evaluates to a boolean.
-            For example, 'how_feeling == "Great"' is a valid expression, as is 'how_feeling in ["Great", "Terrible"]'.
-            However, 'how_feeling = "Great"' is not a valid expression.
-
-            See https://docs.expectedparrot.com/en/latest/results.html#filtering-results for more details.
-            """
+                f"""Error in filter. Exception:{e}.""",
+                f"""The expression you provided was: {expression}.""",
+                """Please make sure that the expression is a valid Python expression that evaluates to a boolean.""",
+                """For example, 'how_feeling == "Great"' is a valid expression, as is 'how_feeling in ["Great", "Terrible"]'., """,
+                """However, 'how_feeling = "Great"' is not a valid expression.""",
+                """See https://docs.expectedparrot.com/en/latest/results.html#filtering-results for more details.""",
             )
 
         if len(new_data) == 0:

edsl/results/ResultsToolsMixin.py

@@ -37,12 +37,12 @@ class ResultsToolsMixin:
         print_exceptions=False,
     ) -> dict:
         from edsl import ScenarioList
+        from edsl import QuestionCheckBox
 
         values = self.select(field).to_list()
         scenarios = ScenarioList.from_list("field", values).add_value(
             "context", context
         )
-
         q = QuestionCheckBox(
             question_text="""
             {{ context }}

edsl/scenarios/Scenario.py

@@ -182,6 +182,19 @@ class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
                 new_scenario[key] = self[key]
         return new_scenario
 
+    @classmethod
+    def from_url(cls, url: str, field_name: Optional[str] = "text") -> "Scenario":
+        """Creates a scenario from a URL.
+
+        :param url: The URL to create the scenario from.
+        :param field_name: The field name to use for the text.
+
+        """
+        import requests
+
+        text = requests.get(url).text
+        return cls({"url": url, field_name: text})
+
     @classmethod
     def from_image(cls, image_path: str) -> str:
         """Creates a scenario with a base64 encoding of an image.
@@ -207,6 +220,7 @@ class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
     @classmethod
     def from_pdf(cls, pdf_path):
         import fitz  # PyMuPDF
+        from edsl import Scenario
 
         # Ensure the file exists
         if not os.path.exists(pdf_path):

edsl/scenarios/ScenarioList.py

@@ -1,12 +1,14 @@
 """A list of Scenarios to be used in a survey."""
 
 from __future__ import annotations
+from typing import Any, Optional, Union, List, Callable
 import csv
 import random
 from collections import UserList, Counter
 from collections.abc import Iterable
+
 from simpleeval import EvalWithCompoundTypes
-from typing import Any, Optional, Union, List
+
 from edsl.Base import Base
 from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
 from edsl.scenarios.Scenario import Scenario
@@ -58,7 +60,13 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
         return f"ScenarioList({self.data})"
 
     def __mul__(self, other: ScenarioList) -> ScenarioList:
-        """Takes the cross product of two ScenarioLists."""
+        """Takes the cross product of two ScenarioLists.
+
+        >>> s1 = ScenarioList.from_list("a", [1, 2])
+        >>> s2 = ScenarioList.from_list("b", [3, 4])
+        >>> s1 * s2
+        ScenarioList([Scenario({'a': 1, 'b': 3}), Scenario({'a': 1, 'b': 4}), Scenario({'a': 2, 'b': 3}), Scenario({'a': 2, 'b': 4})])
+        """
         from itertools import product
 
         new_sl = []
@@ -79,7 +87,12 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
         return self.__mul__(other)
 
     def shuffle(self, seed: Optional[str] = "edsl") -> ScenarioList:
-        """Shuffle the ScenarioList."""
+        """Shuffle the ScenarioList.
+
+        >>> s = ScenarioList.from_list("a", [1,2,3,4])
+        >>> s.shuffle()
+        ScenarioList([Scenario({'a': 3}), Scenario({'a': 4}), Scenario({'a': 1}), Scenario({'a': 2})])
+        """
         random.seed(seed)
         random.shuffle(self.data)
         return self
@@ -107,10 +120,14 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
         return dict(Counter([scenario[field] for scenario in self]))
 
     def sample(self, n: int, seed="edsl") -> ScenarioList:
-        """Return a random sample from the ScenarioList"""
+        """Return a random sample from the ScenarioList
 
-        if seed != "edsl":
-            random.seed(seed)
+        >>> s = ScenarioList.from_list("a", [1,2,3,4,5,6])
+        >>> s.sample(3)
+        ScenarioList([Scenario({'a': 2}), Scenario({'a': 1}), Scenario({'a': 3})])
+        """
+
+        random.seed(seed)
 
         return ScenarioList(random.sample(self.data, n))
 
@@ -136,7 +153,9 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
                 new_scenarios.append(new_scenario)
         return ScenarioList(new_scenarios)
 
-    def mutate(self, new_var_string: str, functions_dict: dict = None) -> ScenarioList:
+    def mutate(
+        self, new_var_string: str, functions_dict: Optional[dict[str, Callable]] = None
+    ) -> ScenarioList:
         """
         Return a new ScenarioList with a new variable added.
 
@@ -145,6 +164,7 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
         >>> s = ScenarioList([Scenario({'a': 1, 'b': 2}), Scenario({'a': 1, 'b': 1})])
         >>> s.mutate("c = a + b")
         ScenarioList([Scenario({'a': 1, 'b': 2, 'c': 3}), Scenario({'a': 1, 'b': 1, 'c': 2})])
+
         """
         if "=" not in new_var_string:
             raise Exception(
@@ -222,6 +242,16 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
 
         return ScenarioList(new_data)
 
+    def from_urls(self, urls: list[str], field_name: Optional[str] = "text") -> ScenarioList:
+        """Create a ScenarioList from a list of URLs.
+
+        :param urls: A list of URLs.
+        :param field_name: The name of the field to store the text from the URLs.
+
+
+        """
+        return ScenarioList([Scenario.from_url(url, field_name) for url in urls])
+
     def select(self, *fields) -> ScenarioList:
         """
         Selects scenarios with only the references fields.
@@ -264,11 +294,19 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
         return cls([Scenario({name: value}) for value in values])
 
     def to_dataset(self) -> "Dataset":
+        """
+        >>> s = ScenarioList.from_list("a", [1,2,3])
+        >>> s.to_dataset()
+        Dataset([{'a': [1, 2, 3]}])
+        >>> s = ScenarioList.from_list("a", [1,2,3]).add_list("b", [4,5,6])
+        >>> s.to_dataset()
+        Dataset([{'a': [1, 2, 3]}, {'b': [4, 5, 6]}])
+        """
         from edsl.results.Dataset import Dataset
 
         keys = self[0].keys()
-        data = {key: [scenario[key] for scenario in self.data] for key in keys}
-        return Dataset([data])
+        data = [{key: [scenario[key] for scenario in self.data]} for key in keys]
+        return Dataset(data)
 
     def add_list(self, name, values) -> ScenarioList:
         """Add a list of values to a ScenarioList.
@@ -286,7 +324,7 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
                 self.append(Scenario({name: value}))
         return self
 
-    def add_value(self, name, value):
+    def add_value(self, name: str, value: Any) -> ScenarioList:
         """Add a value to all scenarios in a ScenarioList.
 
         Example:
@@ -340,7 +378,7 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
         """
         return cls([Scenario(row) for row in df.to_dict(orient="records")])
 
-    def to_key_value(self, field, value=None) -> Union[dict, set]:
+    def to_key_value(self, field: str, value=None) -> Union[dict, set]:
         """Return the set of values in the field.
 
         Example:
@@ -459,16 +497,16 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
             table.add_row(str(i), s.rich_print())
         return table
 
-    def print(
-        self,
-        format: Optional[str] = None,
-        max_rows: Optional[int] = None,
-        pretty_labels: Optional[dict] = None,
-        filename: str = None,
-    ):
-        from edsl.utilities.interface import print_scenario_list
-
-        print_scenario_list(self[:max_rows])
+    # def print(
+    #     self,
+    #     format: Optional[str] = None,
+    #     max_rows: Optional[int] = None,
+    #     pretty_labels: Optional[dict] = None,
+    #     filename: str = None,
+    # ):
+    #     from edsl.utilities.interface import print_scenario_list
+
+    #     print_scenario_list(self[:max_rows])
 
     def __getitem__(self, key: Union[int, slice]) -> Any:
         """Return the item at the given index.

edsl/scenarios/ScenarioListExportMixin.py

@@ -5,7 +5,7 @@ from edsl.results.DatasetExportMixin import DatasetExportMixin
 
 
 def to_dataset(func):
-    """Convert the Results object to a Dataset object before calling the function."""
+    """Convert the object to a Dataset object before calling the function."""
 
     @wraps(func)
     def wrapper(self, *args, **kwargs):
@@ -20,13 +20,24 @@ def to_dataset(func):
     return wrapper
 
 
-def decorate_all_methods(cls):
-    for attr_name, attr_value in cls.__dict__.items():
-        if callable(attr_value):
+def decorate_methods_from_mixin(cls, mixin_cls):
+    for attr_name, attr_value in mixin_cls.__dict__.items():
+        if callable(attr_value) and not attr_name.startswith("__"):
             setattr(cls, attr_name, to_dataset(attr_value))
     return cls
 
 
-@decorate_all_methods
+# def decorate_all_methods(cls):
+#     for attr_name, attr_value in cls.__dict__.items():
+#         if callable(attr_value):
+#             setattr(cls, attr_name, to_dataset(attr_value))
+#     return cls
+
+
+# @decorate_all_methods
 class ScenarioListExportMixin(DatasetExportMixin):
     """Mixin class for exporting Results objects."""
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        decorate_methods_from_mixin(cls, DatasetExportMixin)

edsl/scenarios/ScenarioListPdfMixin.py

@@ -43,6 +43,9 @@ class ScenarioListPdfMixin:
 
     @staticmethod
     def extract_text_from_pdf(pdf_path):
+        from edsl import Scenario
+
+        # TODO: Add test case
         # Ensure the file exists
         if not os.path.exists(pdf_path):
             raise FileNotFoundError(f"The file {pdf_path} does not exist.")

edsl/study/Study.py

@@ -461,13 +461,13 @@ class Study:
         else:
             self.objects[oe.hash] = oe
 
-    def push(self, refresh=False) -> None:
+    def push(self) -> dict:
         """Push the objects to coop."""
 
         from edsl import Coop
 
         coop = Coop()
-        coop.create(self, description=self.description)
+        return coop.create(self, description=self.description)
 
     @classmethod
     def pull(cls, uuid: Optional[Union[str, UUID]] = None, url: Optional[str] = None):

edsl/surveys/Survey.py

@@ -106,6 +106,39 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
 
         return dict_hash(self._to_dict())
 
+    def __add__(self, other: Survey) -> Survey:
+        """Combine two surveys.
+
+        :param other: The other survey to combine with this one.
+        >>> s1 = Survey.example()
+        >>> from edsl import QuestionFreeText
+        >>> s2 = Survey([QuestionFreeText(question_text="What is your name?", question_name="yo")])
+        >>> s3 = s1 + s2
+        Traceback (most recent call last):
+        ...
+        ValueError: ('Cannot combine two surveys with non-default rules.', "Please use the 'clear_non_default_rules' method to remove non-default rules from the survey.")
+        >>> s3 = s1.clear_non_default_rules() + s2
+        >>> len(s3.questions)
+        4
+
+        """
+        if (
+            len(self.rule_collection.non_default_rules) > 0
+            or len(other.rule_collection.non_default_rules) > 0
+        ):
+            raise ValueError(
+                "Cannot combine two surveys with non-default rules.",
+                "Please use the 'clear_non_default_rules' method to remove non-default rules from the survey.",
+            )
+
+        return Survey(questions=self.questions + other.questions)
+
+    def clear_non_default_rules(self) -> Survey:
+        s = Survey()
+        for question in self.questions:
+            s.add_question(question)
+        return s
+
     @property
     def parameters(self):
         return set.union(*[q.parameters for q in self.questions])
@@ -1151,4 +1184,5 @@ def main():
 if __name__ == "__main__":
     import doctest
 
-    doctest.testmod(optionflags=doctest.ELLIPSIS | doctest.SKIP)
+    # doctest.testmod(optionflags=doctest.ELLIPSIS | doctest.SKIP)
+    doctest.testmod(optionflags=doctest.ELLIPSIS)

{edsl-0.1.30.dev4.dist-info → edsl-0.1.31.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: edsl
-Version: 0.1.30.dev4
+Version: 0.1.31
 Summary: Create and analyze LLM-based surveys
 Home-page: https://www.expectedparrot.com/
 License: MIT
@@ -19,10 +19,11 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Dist: aiohttp (>=3.9.1,<4.0.0)
 Requires-Dist: anthropic (>=0.23.1,<0.24.0)
 Requires-Dist: black[jupyter] (>=24.4.2,<25.0.0)
+Requires-Dist: groq (>=0.9.0,<0.10.0)
 Requires-Dist: jinja2 (>=3.1.2,<4.0.0)
 Requires-Dist: jupyter (>=1.0.0,<2.0.0)
 Requires-Dist: markdown2 (>=2.4.11,<3.0.0)
-Requires-Dist: matplotlib (>=3.8.4,<4.0.0)
+Requires-Dist: matplotlib (>=3.8,<3.9)
 Requires-Dist: nest-asyncio (>=1.5.9,<2.0.0)
 Requires-Dist: numpy (>=1.22,<2.0)
 Requires-Dist: openai (>=1.4.0,<2.0.0)
@@ -35,6 +36,7 @@ Requires-Dist: python-docx (>=1.1.0,<2.0.0)
 Requires-Dist: python-dotenv (>=1.0.0,<2.0.0)
 Requires-Dist: restrictedpython (>=7.1,<8.0)
 Requires-Dist: rich (>=13.7.0,<14.0.0)
+Requires-Dist: setuptools (<72.0)
 Requires-Dist: simpleeval (>=0.9.13,<0.10.0)
 Requires-Dist: sqlalchemy (>=2.0.23,<3.0.0)
 Requires-Dist: tenacity (>=8.2.3,<9.0.0)