edsl 0.1.30.dev2__tar.gz → 0.1.30.dev3__tar.gz

{edsl-0.1.30.dev2 → edsl-0.1.30.dev3}/PKG-INFO

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

edsl-0.1.30.dev3/edsl/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.1.30.dev3"

{edsl-0.1.30.dev2 → edsl-0.1.30.dev3}/edsl/agents/Agent.py

@@ -4,7 +4,8 @@ from __future__ import annotations
 import copy
 import inspect
 import types
-from typing import Any, Callable, Optional, Union, Dict, Sequence
+from typing import Callable, Optional, Union
+from uuid import uuid4
 from edsl.Base import Base
 
 from edsl.exceptions.agents import (
@@ -688,13 +689,14 @@ class Agent(Base):
         return table
 
     @classmethod
-    def example(cls) -> Agent:
-        """Return an example agent.
+    def example(cls, randomize: bool = False) -> Agent:
+        """
+        Returns an example Agent instance.
 
-        >>> Agent.example()
-        Agent(traits = {'age': 22, 'hair': 'brown', 'height': 5.5})
+        :param randomize: If True, adds a random string to the value of an example key.
         """
-        return cls(traits={"age": 22, "hair": "brown", "height": 5.5})
+        addition = "" if not randomize else str(uuid4())
+        return cls(traits={"age": 22, "hair": f"brown{addition}", "height": 5.5})
 
     def code(self) -> str:
         """Return the code for the agent.

{edsl-0.1.30.dev2 → edsl-0.1.30.dev3}/edsl/agents/AgentList.py

@@ -11,23 +11,15 @@ Example usage:
 """
 
 from __future__ import annotations
+import csv
+import json
 from collections import UserList
-from typing import Optional, Union, Sequence, List, Any
+from typing import Any, List, Optional, Union
 from rich import print_json
 from rich.table import Table
-import json
-import csv
-
-
 from simpleeval import EvalWithCompoundTypes
-
 from edsl.Base import Base
-
-# from edsl.agents import Agent
-from edsl.utilities.decorators import (
-    add_edsl_version,
-    remove_edsl_version,
-)
+from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
 
 
 class AgentList(UserList, Base):
@@ -239,17 +231,15 @@ class AgentList(UserList, Base):
         return cls(agents)
 
     @classmethod
-    def example(cls) -> "AgentList":
-        """Return an example AgentList.
-
-        >>> al = AgentList.example()
-        >>> len(al)
-        2
+    def example(cls, randomize: bool = False) -> AgentList:
+        """
+        Returns an example AgentList instance.
 
+        :param randomize: If True, uses Agent's randomize method.
         """
         from edsl.agents.Agent import Agent
 
-        return cls([Agent.example(), Agent.example()])
+        return cls([Agent.example(randomize), Agent.example(randomize)])
 
     @classmethod
     def from_list(self, trait_name: str, values: List[Any]):

{edsl-0.1.30.dev2 → edsl-0.1.30.dev3}/edsl/agents/Invigilator.py

@@ -97,7 +97,7 @@ class InvigilatorAI(PromptConstructorMixin, InvigilatorBase):
         answer = question._translate_answer_code_to_answer(
             response["answer"], combined_dict
         )
-        #breakpoint()
+        # breakpoint()
         data = {
             "answer": answer,
             "comment": response.get(

{edsl-0.1.30.dev2 → edsl-0.1.30.dev3}/edsl/data/Cache.py

@@ -7,17 +7,10 @@ import json
 import os
 import warnings
 from typing import Optional, Union
-import time
-from edsl.config import CONFIG
-from edsl.data.CacheEntry import CacheEntry
-
-# from edsl.data.SQLiteDict import SQLiteDict
 from edsl.Base import Base
+from edsl.data.CacheEntry import CacheEntry
 from edsl.utilities.utilities import dict_hash
-from edsl.utilities.decorators import (
-    add_edsl_version,
-    remove_edsl_version,
-)
+from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
 
 
 class Cache(Base):
@@ -41,7 +34,7 @@ class Cache(Base):
         data: Optional[Union["SQLiteDict", dict]] = None,
         immediate_write: bool = True,
         method=None,
-        verbose = False
+        verbose=False,
     ):
         """
         Create two dictionaries to store the cache data.
@@ -480,12 +473,18 @@ class Cache(Base):
         webbrowser.open("file://" + filepath)
 
     @classmethod
-    def example(cls) -> Cache:
+    def example(cls, randomize: bool = False) -> Cache:
         """
-        Return an example Cache.
-        The example Cache has one entry.
+        Returns an example Cache instance.
+
+        :param randomize: If True, uses CacheEntry's randomize method.
         """
-        return cls(data={CacheEntry.example().key: CacheEntry.example()})
+        return cls(
+            data={
+                CacheEntry.example(randomize).key: CacheEntry.example(),
+                CacheEntry.example(randomize).key: CacheEntry.example(),
+            }
+        )
 
 
 if __name__ == "__main__":

{edsl-0.1.30.dev2 → edsl-0.1.30.dev3}/edsl/data/CacheEntry.py

@@ -2,11 +2,8 @@ from __future__ import annotations
 import json
 import datetime
 import hashlib
-import random
 from typing import Optional
-
-
-# TODO: Timestamp should probably be float?
+from uuid import uuid4
 
 
 class CacheEntry:
@@ -151,10 +148,12 @@ class CacheEntry:
     @classmethod
     def example(cls, randomize: bool = False) -> CacheEntry:
         """
-        Returns a CacheEntry example.
+        Returns an example CacheEntry instance.
+
+        :param randomize: If True, adds a random string to the system prompt.
         """
-        # if random, create a random number for 0-100
-        addition = "" if not randomize else str(random.randint(0, 1000))
+        # if random, create a uuid
+        addition = "" if not randomize else str(uuid4())
         return CacheEntry(
             model="gpt-3.5-turbo",
             parameters={"temperature": 0.5},

{edsl-0.1.30.dev2 → edsl-0.1.30.dev3}/edsl/data_transfer_models.py

@@ -17,7 +17,7 @@ class AgentResponseDict(UserDict):
         cached_response=None,
         raw_model_response=None,
         simple_model_raw_response=None,
-        cache_used=None, 
+        cache_used=None,
         cache_key=None,
     ):
         """Initialize the AgentResponseDict object."""

{edsl-0.1.30.dev2 → edsl-0.1.30.dev3}/edsl/jobs/Jobs.py

@@ -687,7 +687,9 @@ class Jobs(Base):
     # Example methods
     #######################
     @classmethod
-    def example(cls, throw_exception_probability=0) -> Jobs:
+    def example(
+        cls, throw_exception_probability: int = 0, randomize: bool = False
+    ) -> Jobs:
         """Return an example Jobs instance.
 
         :param throw_exception_probability: the probability that an exception will be thrown when answering a question. This is useful for testing error handling.
@@ -697,10 +699,13 @@ class Jobs(Base):
 
         """
         import random
+        from uuid import uuid4
         from edsl.questions import QuestionMultipleChoice
         from edsl.agents.Agent import Agent
         from edsl.scenarios.Scenario import Scenario
 
+        addition = "" if not randomize else str(uuid4())
+
         # (status, question, period)
         agent_answers = {
             ("Joyful", "how_feeling", "morning"): "OK",
@@ -743,7 +748,10 @@ class Jobs(Base):
         base_survey = Survey(questions=[q1, q2])
 
         scenario_list = ScenarioList(
-            [Scenario({"period": "morning"}), Scenario({"period": "afternoon"})]
+            [
+                Scenario({"period": f"morning{addition}"}),
+                Scenario({"period": "afternoon"}),
+            ]
         )
         job = base_survey.by(scenario_list).by(joy_agent, sad_agent)
 

{edsl-0.1.30.dev2 → edsl-0.1.30.dev3}/edsl/jobs/buckets/ModelBuckets.py

@@ -24,7 +24,7 @@ class ModelBuckets:
             requests_bucket=self.requests_bucket + other.requests_bucket,
             tokens_bucket=self.tokens_bucket + other.tokens_bucket,
         )
-    
+
     def turbo_mode_on(self):
         """Set the refill rate to infinity for both buckets."""
         self.requests_bucket.turbo_mode_on()

{edsl-0.1.30.dev2 → edsl-0.1.30.dev3}/edsl/jobs/buckets/TokenBucket.py

@@ -31,15 +31,15 @@ class TokenBucket:
             pass
         else:
             self.turbo_mode = True
-            self.capacity=float("inf")
-            self.refill_rate=float("inf")
+            self.capacity = float("inf")
+            self.refill_rate = float("inf")
 
     def turbo_mode_off(self):
         """Restore the refill rate to its original value."""
         self.turbo_mode = False
         self.capacity = self._old_capacity
         self.refill_rate = self._old_refill_rate
-   
+
     def __add__(self, other) -> "TokenBucket":
         """Combine two token buckets.
 

{edsl-0.1.30.dev2 → edsl-0.1.30.dev3}/edsl/jobs/interviews/Interview.py

@@ -30,14 +30,14 @@ class Interview(InterviewStatusMixin, InterviewTaskBuildingMixin):
 
     def __init__(
         self,
-        agent: 'Agent',
-        survey: 'Survey',
-        scenario: 'Scenario',
-        model: Type['LanguageModel'],
+        agent: "Agent",
+        survey: "Survey",
+        scenario: "Scenario",
+        model: Type["LanguageModel"],
         debug: Optional[bool] = False,
         iteration: int = 0,
         cache: "Cache" = None,
-        sidecar_model: 'LanguageModel' = None,
+        sidecar_model: "LanguageModel" = None,
     ):
         """Initialize the Interview instance.
 

{edsl-0.1.30.dev2 → edsl-0.1.30.dev3}/edsl/jobs/runners/JobsRunnerAsyncio.py

@@ -89,6 +89,7 @@ class JobsRunnerAsyncio(JobsRunnerStatusMixin):
 
     async def run_async(self, cache=None) -> Results:
         from edsl.results.Results import Results
+
         if cache is None:
             self.cache = Cache()
         else:
@@ -100,6 +101,7 @@ class JobsRunnerAsyncio(JobsRunnerStatusMixin):
 
     def simple_run(self):
         from edsl.results.Results import Results
+
         data = asyncio.run(self.run_async())
         return Results(survey=self.jobs.survey, data=data)
 

{edsl-0.1.30.dev2 → edsl-0.1.30.dev3}/edsl/jobs/tasks/QuestionTaskCreator.py

@@ -144,18 +144,18 @@ class QuestionTaskCreator(UserList):
             self.task_status = TaskStatus.FAILED
             raise e
 
-        ## This isn't working 
-        #breakpoint()
-        if results.get('cache_used', False):
+        ## This isn't working
+        # breakpoint()
+        if results.get("cache_used", False):
             self.tokens_bucket.add_tokens(requested_tokens)
             self.requests_bucket.add_tokens(1)
             self.from_cache = True
-            #print("Turning on turbo!")
+            # print("Turning on turbo!")
             self.tokens_bucket.turbo_mode_on()
             self.requests_bucket.turbo_mode_on()
         else:
-            #breakpoint()
-            #print("Turning off turbo!")
+            # breakpoint()
+            # print("Turning off turbo!")
             self.tokens_bucket.turbo_mode_off()
             self.requests_bucket.turbo_mode_off()
 
@@ -163,7 +163,6 @@ class QuestionTaskCreator(UserList):
 
         tracker = self.cached_token_usage if self.from_cache else self.new_token_usage
 
-
         # TODO: This is hacky. The 'func' call should return an object that definitely has a 'usage' key.
         usage = results.get("usage", {"prompt_tokens": 0, "completion_tokens": 0})
         prompt_tokens = usage.get("prompt_tokens", 0)

{edsl-0.1.30.dev2 → edsl-0.1.30.dev3}/edsl/notebooks/Notebook.py

@@ -1,14 +1,11 @@
 """A Notebook is a utility class that allows you to easily share/pull ipynbs from Coop."""
 
+from __future__ import annotations
 import json
 from typing import Dict, List, Optional
-
-
+from uuid import uuid4
 from edsl.Base import Base
-from edsl.utilities.decorators import (
-    add_edsl_version,
-    remove_edsl_version,
-)
+from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
 
 
 class Notebook(Base):
@@ -192,10 +189,13 @@ class Notebook(Base):
         return table
 
     @classmethod
-    def example(cls) -> "Notebook":
+    def example(cls, randomize: bool = False) -> Notebook:
         """
-        Return an example Notebook.
+        Returns an example Notebook instance.
+
+        :param randomize: If True, adds a random string one of the cells' output.
         """
+        addition = "" if not randomize else str(uuid4())
         cells = [
             {
                 "cell_type": "markdown",
@@ -210,7 +210,7 @@ class Notebook(Base):
                     {
                         "name": "stdout",
                         "output_type": "stream",
-                        "text": "Hello world!\n",
+                        "text": f"Hello world!\n{addition}",
                     }
                 ],
                 "source": 'print("Hello world!")',

{edsl-0.1.30.dev2 → edsl-0.1.30.dev3}/edsl/questions/QuestionFreeText.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 import textwrap
 from typing import Any, Optional
+from uuid import uuid4
 from edsl.questions.QuestionBase import QuestionBase
 
 
@@ -65,9 +66,10 @@ class QuestionFreeText(QuestionBase):
         return question_html_content
 
     @classmethod
-    def example(cls) -> QuestionFreeText:
+    def example(cls, randomize: bool = False) -> QuestionFreeText:
         """Return an example instance of a free text question."""
-        return cls(question_name="how_are_you", question_text="How are you?")
+        addition = "" if not randomize else str(uuid4())
+        return cls(question_name="how_are_you", question_text=f"How are you?{addition}")
 
 
 def main():

{edsl-0.1.30.dev2 → edsl-0.1.30.dev3}/edsl/results/Results.py

@@ -949,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) -> Results:
+    def example(cls, debug: bool = False, randomize: bool = False) -> Results:
         """Return an example `Results` object.
 
         Example usage:
@@ -962,7 +962,7 @@ class Results(UserList, Mixins, Base):
         from edsl.data.Cache import Cache
 
         c = Cache()
-        job = Jobs.example()
+        job = Jobs.example(randomize=randomize)
         results = job.run(cache=c, debug=debug)
         return results
 

{edsl-0.1.30.dev2 → edsl-0.1.30.dev3}/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,7 +89,6 @@ 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
@@ -101,14 +100,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
@@ -133,16 +132,19 @@ 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):
@@ -153,24 +155,27 @@ 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 >>
@@ -210,12 +215,15 @@ 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")
@@ -223,19 +231,25 @@ 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")
@@ -244,18 +258,20 @@ 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"
@@ -263,21 +279,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-0.1.30.dev2 → edsl-0.1.30.dev3}/edsl/scenarios/Scenario.py

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