edsl 0.1.30__py3-none-any.whl → 0.1.30.dev2__py3-none-any.whl

edsl/results/Results.py

@@ -290,8 +290,7 @@ class Results(UserList, Mixins, Base):
                 ),
             )
         except Exception as e:
-            print(e)
-            # breakpoint()
+            breakpoint()
         return results
 
     ######################
@@ -604,38 +603,6 @@ 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:
@@ -668,8 +635,13 @@ 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 = self._create_evaluator(old_result, functions_dict)
+            evaluator = create_evaluator(old_result)
             value = evaluator.eval(expression)
             new_result = old_result.copy()
             new_result["answer"][var_name] = value
@@ -769,9 +741,6 @@ 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:
@@ -829,19 +798,10 @@ 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
 
-        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)
+        return Dataset(new_data)
 
     def sort_by(self, *columns: str, reverse: bool = False) -> Results:
         import warnings
@@ -956,29 +916,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 = []
-            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.",
-            )
+            new_data = [
+                result
+                for result in self.data
+                if create_evaluator(result).eval(expression)
+            ]
         except Exception as e:
             raise ResultsFilterError(
-                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.""",
+                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.
+            """
             )
 
         if len(new_data) == 0:
@@ -989,7 +949,7 @@ class Results(UserList, Mixins, Base):
         return Results(survey=self.survey, data=new_data, created_columns=None)
 
     @classmethod
-    def example(cls, debug: bool = False, randomize: bool = False) -> Results:
+    def example(cls, debug: bool = False) -> Results:
         """Return an example `Results` object.
 
         Example usage:
@@ -1002,7 +962,7 @@ class Results(UserList, Mixins, Base):
         from edsl.data.Cache import Cache
 
         c = Cache()
-        job = Jobs.example(randomize=randomize)
+        job = Jobs.example()
         results = job.run(cache=c, debug=debug)
         return results
 

edsl/scenarios/FileStore.py

@@ -31,7 +31,7 @@ class FileStore(Scenario):
     @classmethod
     def from_dict(cls, d):
         return cls(d["filename"], d["binary"], d["suffix"], d["base64_string"])
-
+    
     def __repr__(self):
         return f"FileStore(filename='{self.filename}', binary='{self.binary}', 'suffix'={self.suffix})"
 
@@ -89,6 +89,7 @@ class FileStore(Scenario):
             # Create a StringIO object for text data
             return io.StringIO(text_data)
 
+   
     def to_tempfile(self, suffix=None):
         if suffix is None:
             suffix = self.suffix
@@ -100,14 +101,14 @@ class FileStore(Scenario):
             file_like_object = self.base64_to_text_file(self["base64_string"])
 
         # Create a named temporary file
-        mode = "wb" if self.binary else "w"
+        mode = 'wb' if self.binary else 'w'
         temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=suffix, mode=mode)
-
+        
         if self.binary:
             temp_file.write(file_like_object.read())
         else:
             temp_file.write(file_like_object.read())
-
+        
         temp_file.close()
 
         return temp_file.name
@@ -132,19 +133,16 @@ class CSVFileStore(FileStore):
     @classmethod
     def example(cls):
         from edsl.results.Results import Results
-
         r = Results.example()
         import tempfile
-
         with tempfile.NamedTemporaryFile(suffix=".csv", delete=False) as f:
             r.to_csv(filename=f.name)
             return cls(f.name)
-
+        
     def view(self):
         import pandas as pd
-
         return pd.read_csv(self.to_tempfile())
-
+        
 
 class PDFFileStore(FileStore):
     def __init__(self, filename):
@@ -155,27 +153,24 @@ class PDFFileStore(FileStore):
         print(f"PDF path: {pdf_path}")  # Print the path to ensure it exists
         import os
         import subprocess
-
         if os.path.exists(pdf_path):
             try:
-                if os.name == "posix":
+                if os.name == 'posix':
                     # for cool kids
-                    subprocess.run(["open", pdf_path], check=True)  # macOS
-                elif os.name == "nt":
+                    subprocess.run(['open', pdf_path], check=True)  # macOS
+                elif os.name == 'nt':
                     os.startfile(pdf_path)  # Windows
                 else:
-                    subprocess.run(["xdg-open", pdf_path], check=True)  # Linux
+                    subprocess.run(['xdg-open', pdf_path], check=True)  # Linux
             except Exception as e:
                 print(f"Error opening PDF: {e}")
         else:
             print("PDF file was not created successfully.")
 
     @classmethod
-    def example(cls):
+    def example(cls): 
         import textwrap
-
-        pdf_string = textwrap.dedent(
-            """\
+        pdf_string = textwrap.dedent("""\
         %PDF-1.4
         1 0 obj
         << /Type /Catalog /Pages 2 0 R >>
@@ -215,15 +210,12 @@ class PDFFileStore(FileStore):
         << /Size 7 /Root 1 0 R >>
         startxref
         318
-        %%EOF"""
-        )
+        %%EOF""")
         import tempfile
-
         with tempfile.NamedTemporaryFile(suffix=".pdf", delete=False) as f:
             f.write(pdf_string.encode())
             return cls(f.name)
 
-
 class PNGFileStore(FileStore):
     def __init__(self, filename):
         super().__init__(filename, suffix=".png")
@@ -231,25 +223,19 @@ class PNGFileStore(FileStore):
     @classmethod
     def example(cls):
         import textwrap
-
-        png_string = textwrap.dedent(
-            """\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x01\x00\x00\x00\x01\x00\x08\x06\x00\x00\x00\x1f\x15\xc4\x89\x00\x00\x00\x0cIDAT\x08\xd7c\x00\x01"""
-        )
+        png_string = textwrap.dedent("""\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x01\x00\x00\x00\x01\x00\x08\x06\x00\x00\x00\x1f\x15\xc4\x89\x00\x00\x00\x0cIDAT\x08\xd7c\x00\x01""")
         import tempfile
-
         with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as f:
             f.write(png_string.encode())
             return cls(f.name)
-
+        
     def view(self):
         import matplotlib.pyplot as plt
         import matplotlib.image as mpimg
-
         img = mpimg.imread(self.to_tempfile())
         plt.imshow(img)
         plt.show()
 
-
 class SQLiteFileStore(FileStore):
     def __init__(self, filename):
         super().__init__(filename, suffix=".sqlite")
@@ -258,20 +244,18 @@ class SQLiteFileStore(FileStore):
     def example(cls):
         import sqlite3
         import tempfile
-
         with tempfile.NamedTemporaryFile(suffix=".sqlite", delete=False) as f:
             conn = sqlite3.connect(f.name)
             c = conn.cursor()
-            c.execute("""CREATE TABLE stocks (date text)""")
+            c.execute('''CREATE TABLE stocks (date text)''')
             conn.commit()
 
     def view(self):
         import subprocess
         import os
-
         sqlite_path = self.to_tempfile()
         os.system(f"sqlite3 {sqlite_path}")
-
+                                     
 
 if __name__ == "__main__":
     # file_path = "../conjure/examples/Ex11-2.sav"
@@ -279,21 +263,21 @@ if __name__ == "__main__":
     # info = fs.push()
     # print(info)
 
-    # fs = CSVFileStore.example()
-    # fs.to_tempfile()
+    #fs = CSVFileStore.example()
+    #fs.to_tempfile()
     # print(fs.view())
 
-    # fs = PDFFileStore.example()
-    # fs.view()
+    #fs = PDFFileStore.example()
+    #fs.view()
 
-    # fs = PDFFileStore("paper.pdf")
-    # fs.view()
+    #fs = PDFFileStore("paper.pdf")
+    #fs.view()
     # from edsl import Conjure
 
     fs = PNGFileStore("robot.png")
     fs.view()
 
     # c = Conjure(datafile_name=fs.to_tempfile())
-    # f = PDFFileStore("paper.pdf")
+    #f = PDFFileStore("paper.pdf")
     # print(f.to_tempfile())
-    # f.push()
+    #f.push()

edsl/scenarios/Scenario.py

@@ -1,17 +1,21 @@
 """A Scenario is a dictionary with a key/value to parameterize a question."""
 
-from __future__ import annotations
+import time
 import copy
+from collections import UserDict
+from typing import Union, List, Optional, Generator
 import base64
 import hashlib
 import os
-from collections import UserDict
-from typing import Union, List, Optional, Generator
-from uuid import uuid4
+
 from edsl.Base import Base
 from edsl.scenarios.ScenarioImageMixin import ScenarioImageMixin
 from edsl.scenarios.ScenarioHtmlMixin import ScenarioHtmlMixin
-from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
+
+from edsl.utilities.decorators import (
+    add_edsl_version,
+    remove_edsl_version,
+)
 
 
 class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
@@ -24,7 +28,9 @@ class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
 
         :param data: A dictionary of keys/values for parameterizing questions.
         """
-        self.data = data if data is not None else {}
+        if data is None:
+            data = {}
+        self.data = data
         self.name = name
 
     def replicate(self, n: int) -> "ScenarioList":
@@ -409,16 +415,17 @@ class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
         return table
 
     @classmethod
-    def example(cls, randomize: bool = False) -> Scenario:
-        """
-        Returns an example Scenario instance.
+    def example(cls) -> "Scenario":
+        """Return an example scenario.
+
+        Example:
 
-        :param randomize: If True, adds a random string to the value of the example key.
+        >>> Scenario.example()
+        Scenario({'persona': 'A reseacher studying whether LLMs can be used to generate surveys.'})
         """
-        addition = "" if not randomize else str(uuid4())
         return cls(
             {
-                "persona": f"A reseacher studying whether LLMs can be used to generate surveys.{addition}",
+                "persona": "A reseacher studying whether LLMs can be used to generate surveys."
             }
         )
 

edsl/scenarios/ScenarioList.py

@@ -5,8 +5,10 @@ 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 simpleeval import EvalWithCompoundTypes
+
 from edsl.Base import Base
 from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
 from edsl.scenarios.Scenario import Scenario
@@ -440,13 +442,9 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
         return lines
 
     @classmethod
-    def example(cls, randomize: bool = False) -> ScenarioList:
-        """
-        Return an example ScenarioList instance.
-
-        :params randomize: If True, use Scenario's randomize method to randomize the values.
-        """
-        return cls([Scenario.example(randomize), Scenario.example(randomize)])
+    def example(cls) -> ScenarioList:
+        """Return an example of the `ScenarioList`."""
+        return cls([Scenario.example(), Scenario.example()])
 
     def rich_print(self) -> None:
         """Display an object as a table."""

edsl/study/Study.py

@@ -6,12 +6,14 @@ import platform
 import socket
 from datetime import datetime
 from typing import Dict, Optional, Union
-from uuid import UUID, uuid4
 from edsl import Cache, set_session_cache, unset_session_cache
 from edsl.utilities.utilities import dict_hash
 from edsl.study.ObjectEntry import ObjectEntry
 from edsl.study.ProofOfWork import ProofOfWork
 from edsl.study.SnapShot import SnapShot
+from uuid import UUID
+
+# from edsl.Base import Base
 
 
 class Study:
@@ -400,14 +402,14 @@ class Study:
         return diff
 
     @classmethod
-    def example(cls, verbose=False, randomize=False):
+    def example(cls, verbose=False):
         import tempfile
 
         study_file = tempfile.NamedTemporaryFile()
         with cls(filename=study_file.name, verbose=verbose) as study:
             from edsl import QuestionFreeText
 
-            q = QuestionFreeText.example(randomize=randomize)
+            q = QuestionFreeText.example()
         return study
 
     @classmethod
@@ -461,13 +463,13 @@ class Study:
         else:
             self.objects[oe.hash] = oe
 
-    def push(self) -> dict:
+    def push(self, refresh=False) -> None:
         """Push the objects to coop."""
 
         from edsl import Coop
 
         coop = Coop()
-        return coop.create(self, description=self.description)
+        coop.create(self, description=self.description)
 
     @classmethod
     def pull(cls, uuid: Optional[Union[str, UUID]] = None, url: Optional[str] = None):

edsl/surveys/Survey.py

@@ -2,20 +2,23 @@
 
 from __future__ import annotations
 import re
+
 from typing import Any, Generator, Optional, Union, List, Literal, Callable
-from uuid import uuid4
-from edsl.Base import Base
+
 from edsl.exceptions import SurveyCreationError, SurveyHasNoRulesError
 from edsl.questions.QuestionBase import QuestionBase
 from edsl.surveys.base import RulePriority, EndOfSurvey
-from edsl.surveys.DAG import DAG
-from edsl.surveys.descriptors import QuestionsDescriptor
-from edsl.surveys.MemoryPlan import MemoryPlan
 from edsl.surveys.Rule import Rule
 from edsl.surveys.RuleCollection import RuleCollection
+
+from edsl.Base import Base
 from edsl.surveys.SurveyExportMixin import SurveyExportMixin
-from edsl.surveys.SurveyFlowVisualizationMixin import SurveyFlowVisualizationMixin
+from edsl.surveys.descriptors import QuestionsDescriptor
+from edsl.surveys.MemoryPlan import MemoryPlan
+
+from edsl.surveys.DAG import DAG
 from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
+from edsl.surveys.SurveyFlowVisualizationMixin import SurveyFlowVisualizationMixin
 
 
 class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
@@ -106,39 +109,6 @@ 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])
@@ -1055,7 +1025,7 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
         return res
 
     @classmethod
-    def example(cls, params: bool = False, randomize: bool = False) -> Survey:
+    def example(cls, params=False) -> Survey:
         """Return an example survey.
 
         >>> s = Survey.example()
@@ -1064,9 +1034,8 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
         """
         from edsl.questions.QuestionMultipleChoice import QuestionMultipleChoice
 
-        addition = "" if not randomize else str(uuid4())
         q0 = QuestionMultipleChoice(
-            question_text=f"Do you like school?{addition}",
+            question_text="Do you like school?",
             question_options=["yes", "no"],
             question_name="q0",
         )
@@ -1184,5 +1153,4 @@ def main():
 if __name__ == "__main__":
     import doctest
 
-    # doctest.testmod(optionflags=doctest.ELLIPSIS | doctest.SKIP)
-    doctest.testmod(optionflags=doctest.ELLIPSIS)
+    doctest.testmod(optionflags=doctest.ELLIPSIS | doctest.SKIP)

{edsl-0.1.30.dist-info → edsl-0.1.30.dev2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: edsl
-Version: 0.1.30
+Version: 0.1.30.dev2
 Summary: Create and analyze LLM-based surveys
 Home-page: https://www.expectedparrot.com/
 License: MIT