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

edsl/results/Result.py

@@ -126,9 +126,6 @@ class Result(Base, UserDict):
         self.survey = survey
         self.question_to_attributes = question_to_attributes
 
-        self._combined_dict = None
-        self._problem_keys = None
-
     ###############
     # Used in Results
     ###############
@@ -167,64 +164,25 @@ class Result(Base, UserDict):
             "answer": self.answer,
             "prompt": self.prompt,
             "raw_model_response": self.raw_model_response,
-            #            "iteration": {"iteration": self.iteration},
+            "iteration": {"iteration": self.iteration},
             "question_text": question_text_dict,
             "question_options": question_options_dict,
             "question_type": question_type_dict,
             "comment": comments_dict,
         }
 
-    def check_expression(self, expression) -> None:
-        for key in self.problem_keys:
-            if key in expression and not key + "." in expression:
-                raise ValueError(
-                    f"Key by iself {key} is problematic. Use the full key {key + '.' + key} name instead."
-                )
-        return None
-
     def code(self):
         """Return a string of code that can be used to recreate the Result object."""
         raise NotImplementedError
 
     @property
-    def problem_keys(self):
-        """Return a list of keys that are problematic."""
-        return self._problem_keys
-
-    def _compute_combined_dict_and_problem_keys(self) -> None:
+    def combined_dict(self) -> dict[str, Any]:
+        """Return a dictionary that includes all sub_dicts, but also puts the key-value pairs in each sub_dict as a key_value pair in the combined dictionary."""
         combined = {}
-        problem_keys = []
         for key, sub_dict in self.sub_dicts.items():
             combined.update(sub_dict)
-            # in some cases, the sub_dict might have keys that conflict with the main dict
-            if key in combined:
-                # The key is already in the combined dict
-                problem_keys = problem_keys + [key]
-
             combined.update({key: sub_dict})
-            # I *think* this allows us to do do things like "answer.how_feelling" i.e., that the evaluator can use
-            # dot notation to access the subdicts.
-        self._combined_dict = combined
-        self._problem_keys = problem_keys
-
-    @property
-    def combined_dict(self) -> dict[str, Any]:
-        """Return a dictionary that includes all sub_dicts, but also puts the key-value pairs in each sub_dict as a key_value pair in the combined dictionary.
-
-        >>> r = Result.example()
-        >>> r.combined_dict['how_feeling']
-        'OK'
-        """
-        if self._combined_dict is None or self._problem_keys is None:
-            self._compute_combined_dict_and_problem_keys()
-        return self._combined_dict
-
-    @property
-    def problem_keys(self):
-        """Return a list of keys that are problematic."""
-        if self._combined_dict is None or self._problem_keys is None:
-            self._compute_combined_dict_and_problem_keys()
-        return self._problem_keys
+        return combined
 
     def get_value(self, data_type: str, key: str) -> Any:
         """Return the value for a given data type and key.
@@ -268,13 +226,7 @@ class Result(Base, UserDict):
         return Result.from_dict(self.to_dict())
 
     def __eq__(self, other) -> bool:
-        """Return True if the Result object is equal to another Result object.
-
-        >>> r = Result.example()
-        >>> r == r
-        True
-
-        """
+        """Return True if the Result object is equal to another Result object."""
         return self.to_dict() == other.to_dict()
 
     ###############

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

@@ -32,9 +32,6 @@ class FileStore(Scenario):
     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})"
-
     def encode_file_to_base64_string(self, file_path):
         try:
             # Attempt to open the file in text mode
@@ -100,14 +97,8 @@ 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"
-        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 = tempfile.NamedTemporaryFile(delete=False, suffix=suffix)
+        temp_file.write(file_like_object.read())
         temp_file.close()
 
         return temp_file.name
@@ -129,149 +120,11 @@ class CSVFileStore(FileStore):
     def __init__(self, filename):
         super().__init__(filename, suffix=".csv")
 
-    @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):
         super().__init__(filename, suffix=".pdf")
 
-    def view(self):
-        pdf_path = self.to_tempfile()
-        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":
-                    # for cool kids
-                    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
-            except Exception as e:
-                print(f"Error opening PDF: {e}")
-        else:
-            print("PDF file was not created successfully.")
-
-    @classmethod
-    def example(cls):
-        import textwrap
-
-        pdf_string = textwrap.dedent(
-            """\
-        %PDF-1.4
-        1 0 obj
-        << /Type /Catalog /Pages 2 0 R >>
-        endobj
-        2 0 obj
-        << /Type /Pages /Kids [3 0 R] /Count 1 >>
-        endobj
-        3 0 obj
-        << /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Contents 4 0 R >>
-        endobj
-        4 0 obj
-        << /Length 44 >>
-        stream
-        BT
-        /F1 24 Tf
-        100 700 Td
-        (Hello, World!) Tj
-        ET
-        endstream
-        endobj
-        5 0 obj
-        << /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>
-        endobj
-        6 0 obj
-        << /ProcSet [/PDF /Text] /Font << /F1 5 0 R >> >>
-        endobj
-        xref
-        0 7
-        0000000000 65535 f 
-        0000000010 00000 n 
-        0000000053 00000 n 
-        0000000100 00000 n 
-        0000000173 00000 n 
-        0000000232 00000 n 
-        0000000272 00000 n 
-        trailer
-        << /Size 7 /Root 1 0 R >>
-        startxref
-        318
-        %%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")
-
-    @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"""
-        )
-        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")
-
-    @classmethod
-    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)""")
-            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 +132,9 @@ if __name__ == "__main__":
     # info = fs.push()
     # print(info)
 
-    # fs = CSVFileStore.example()
-    # fs.to_tempfile()
-    # print(fs.view())
-
-    # fs = PDFFileStore.example()
-    # 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):