edsl 0.1.30.dev1__tar.gz → 0.1.30.dev2__tar.gz

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

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

edsl-0.1.30.dev2/edsl/__version__.py

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

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

@@ -74,15 +74,14 @@ class InvigilatorAI(PromptConstructorMixin, InvigilatorBase):
 
         This cleans up the raw response to make it suitable to pass to AgentResponseDict.
         """
-        # not actually used, but this removes the temptation to delete agent from the signature
         _ = agent
         try:
             response = question._validate_answer(raw_response)
         except Exception as e:
+            """If the response is invalid, remove it from the cache and raise the exception."""
             self._remove_from_cache(raw_response)
             raise e
 
-        # breakpoint()
         question_dict = self.survey.question_names_to_questions()
         for other_question, answer in self.current_answers.items():
             if other_question in question_dict:
@@ -95,12 +94,10 @@ class InvigilatorAI(PromptConstructorMixin, InvigilatorBase):
                     question_dict[new_question].comment = answer
 
         combined_dict = {**question_dict, **scenario}
-        # print("combined_dict: ", combined_dict)
-        # print("response: ", response)
-        # breakpoint()
         answer = question._translate_answer_code_to_answer(
             response["answer"], combined_dict
         )
+        #breakpoint()
         data = {
             "answer": answer,
             "comment": response.get(
@@ -111,6 +108,8 @@ class InvigilatorAI(PromptConstructorMixin, InvigilatorBase):
             "cached_response": raw_response.get("cached_response", None),
             "usage": raw_response.get("usage", {}),
             "raw_model_response": raw_model_response,
+            "cache_used": raw_response.get("cache_used", False),
+            "cache_key": raw_response.get("cache_key", None),
         }
         return AgentResponseDict(**data)
 

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

@@ -41,6 +41,7 @@ class Cache(Base):
         data: Optional[Union["SQLiteDict", dict]] = None,
         immediate_write: bool = True,
         method=None,
+        verbose = False
     ):
         """
         Create two dictionaries to store the cache data.
@@ -59,6 +60,7 @@ class Cache(Base):
         self.new_entries = {}
         self.new_entries_to_write_later = {}
         self.coop = None
+        self.verbose = verbose
 
         self.filename = filename
         if filename and data:
@@ -122,7 +124,7 @@ class Cache(Base):
         system_prompt: str,
         user_prompt: str,
         iteration: int,
-    ) -> Union[None, str]:
+    ) -> tuple(Union[None, str], str):
         """
         Fetch a value (LLM output) from the cache.
 
@@ -135,7 +137,7 @@ class Cache(Base):
         Return None if the response is not found.
 
         >>> c = Cache()
-        >>> c.fetch(model="gpt-3", parameters="default", system_prompt="Hello", user_prompt="Hi", iteration=1) is None
+        >>> c.fetch(model="gpt-3", parameters="default", system_prompt="Hello", user_prompt="Hi", iteration=1)[0] is None
         True
 
 
@@ -151,8 +153,13 @@ class Cache(Base):
         )
         entry = self.data.get(key, None)
         if entry is not None:
+            if self.verbose:
+                print(f"Cache hit for key: {key}")
             self.fetched_data[key] = entry
-        return None if entry is None else entry.output
+        else:
+            if self.verbose:
+                print(f"Cache miss for key: {key}")
+        return None if entry is None else entry.output, key
 
     def store(
         self,
@@ -354,6 +361,9 @@ class Cache(Base):
         for key, entry in self.new_entries_to_write_later.items():
             self.data[key] = entry
 
+        if self.filename:
+            self.write(self.filename)
+
     ####################
     # DUNDER / USEFUL
     ####################

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

@@ -17,6 +17,8 @@ class AgentResponseDict(UserDict):
         cached_response=None,
         raw_model_response=None,
         simple_model_raw_response=None,
+        cache_used=None, 
+        cache_key=None,
     ):
         """Initialize the AgentResponseDict object."""
         usage = usage or {"prompt_tokens": 0, "completion_tokens": 0}
@@ -30,5 +32,7 @@ class AgentResponseDict(UserDict):
                 "cached_response": cached_response,
                 "raw_model_response": raw_model_response,
                 "simple_model_raw_response": simple_model_raw_response,
+                "cache_used": cache_used,
+                "cache_key": cache_key,
             }
         )

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

@@ -461,6 +461,13 @@ class Jobs(Base):
             remote_inference = False
 
         if remote_inference:
+            from edsl.agents.Agent import Agent
+            from edsl.language_models.registry import Model
+            from edsl.results.Result import Result
+            from edsl.results.Results import Results
+            from edsl.scenarios.Scenario import Scenario
+            from edsl.surveys.Survey import Survey
+
             self._output("Remote inference activated. Sending job to server...")
             if remote_cache:
                 self._output(

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

@@ -24,6 +24,16 @@ 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()
+        self.tokens_bucket.turbo_mode_on()
+
+    def turbo_mode_off(self):
+        """Restore the refill rate to its original value for both buckets."""
+        self.requests_bucket.turbo_mode_off()
+        self.tokens_bucket.turbo_mode_off()
 
     @classmethod
     def infinity_bucket(cls, model_name: str = "not_specified") -> "ModelBuckets":

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

@@ -17,12 +17,29 @@ class TokenBucket:
         self.bucket_name = bucket_name
         self.bucket_type = bucket_type
         self.capacity = capacity  # Maximum number of tokens
+        self._old_capacity = capacity
         self.tokens = capacity  # Current number of available tokens
         self.refill_rate = refill_rate  # Rate at which tokens are refilled
+        self._old_refill_rate = refill_rate
         self.last_refill = time.monotonic()  # Last refill time
-
         self.log: List[Any] = []
-
+        self.turbo_mode = False
+
+    def turbo_mode_on(self):
+        """Set the refill rate to infinity."""
+        if self.turbo_mode:
+            pass
+        else:
+            self.turbo_mode = True
+            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.
 
@@ -98,7 +115,7 @@ class TokenBucket:
             raise ValueError(msg)
         while self.tokens < amount:
             self.refill()
-            await asyncio.sleep(0.1)  # Sleep briefly to prevent busy waiting
+            await asyncio.sleep(0.01)  # Sleep briefly to prevent busy waiting
         self.tokens -= amount
 
         now = time.monotonic()

{edsl-0.1.30.dev1 → edsl-0.1.30.dev2}/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],
-        debug: bool = False,
+        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.
 
@@ -99,6 +99,7 @@ class Interview(InterviewStatusMixin, InterviewTaskBuildingMixin):
         if model_buckets is None or hasattr(self.agent, "answer_question_directly"):
             model_buckets = ModelBuckets.infinity_bucket()
 
+        # FOR TESTING
         # model_buckets = ModelBuckets.infinity_bucket()
 
         ## build the tasks using the InterviewTaskBuildingMixin

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

@@ -88,6 +88,7 @@ class JobsRunnerAsyncio(JobsRunnerStatusMixin):
                     self.total_interviews.append(interview)
 
     async def run_async(self, cache=None) -> Results:
+        from edsl.results.Results import Results
         if cache is None:
             self.cache = Cache()
         else:
@@ -98,6 +99,7 @@ class JobsRunnerAsyncio(JobsRunnerStatusMixin):
         return Results(survey=self.jobs.survey, data=data)
 
     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.dev1 → edsl-0.1.30.dev2}/edsl/jobs/tasks/QuestionTaskCreator.py

@@ -144,17 +144,26 @@ class QuestionTaskCreator(UserList):
             self.task_status = TaskStatus.FAILED
             raise e
 
-        if "cached_response" in results:
-            if results["cached_response"]:
-                # Gives back the tokens b/c the API was not called.
-                self.tokens_bucket.add_tokens(requested_tokens)
-                self.requests_bucket.add_tokens(1)
-                self.from_cache = True
+        ## 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!")
+            self.tokens_bucket.turbo_mode_on()
+            self.requests_bucket.turbo_mode_on()
+        else:
+            #breakpoint()
+            #print("Turning off turbo!")
+            self.tokens_bucket.turbo_mode_off()
+            self.requests_bucket.turbo_mode_off()
 
         _ = results.pop("cached_response", None)
 
         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.dev1 → edsl-0.1.30.dev2}/edsl/language_models/LanguageModel.py

@@ -323,12 +323,10 @@ class LanguageModel(
             image_hash = hashlib.md5(encoded_image.encode()).hexdigest()
             cache_call_params["user_prompt"] = f"{user_prompt} {image_hash}"
 
-        cached_response = cache.fetch(**cache_call_params)
-
+        cached_response, cache_key = cache.fetch(**cache_call_params)
         if cached_response:
             response = json.loads(cached_response)
             cache_used = True
-            cache_key = None
         else:
             remote_call = hasattr(self, "remote") and self.remote
             f = (
@@ -340,7 +338,7 @@ class LanguageModel(
             if encoded_image:
                 params["encoded_image"] = encoded_image
             response = await f(**params)
-            cache_key = cache.store(
+            new_cache_key = cache.store(
                 user_prompt=user_prompt,
                 model=str(self.model),
                 parameters=self.parameters,
@@ -348,6 +346,7 @@ class LanguageModel(
                 response=response,
                 iteration=iteration,
             )
+            assert new_cache_key == cache_key
             cache_used = False
 
         return response, cache_used, cache_key
@@ -412,7 +411,7 @@ class LanguageModel(
 
         dict_response.update(
             {
-                "cached_used": cache_used,
+                "cache_used": cache_used,
                 "cache_key": cache_key,
                 "usage": raw_response.get("usage", {}),
                 "raw_model_response": raw_response,

edsl-0.1.30.dev2/edsl/scenarios/FileStore.py

@@ -0,0 +1,283 @@
+from edsl import Scenario
+import base64
+import io
+import tempfile
+from typing import Optional
+
+
+class FileStore(Scenario):
+    def __init__(
+        self,
+        filename: str,
+        binary: Optional[bool] = None,
+        suffix: Optional[str] = None,
+        base64_string: Optional[str] = None,
+    ):
+        self.filename = filename
+        self.suffix = suffix or "." + filename.split(".")[-1]
+        self.binary = binary or False
+        self.base64_string = base64_string or self.encode_file_to_base64_string(
+            filename
+        )
+        super().__init__(
+            {
+                "filename": self.filename,
+                "base64_string": self.base64_string,
+                "binary": self.binary,
+                "suffix": self.suffix,
+            }
+        )
+
+    @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})"
+
+    def encode_file_to_base64_string(self, file_path):
+        try:
+            # Attempt to open the file in text mode
+            with open(file_path, "r") as text_file:
+                # Read the text data
+                text_data = text_file.read()
+                # Encode the text data to a base64 string
+                base64_encoded_data = base64.b64encode(text_data.encode("utf-8"))
+        except UnicodeDecodeError:
+            # If reading as text fails, open the file in binary mode
+            with open(file_path, "rb") as binary_file:
+                # Read the binary data
+                binary_data = binary_file.read()
+                # Encode the binary data to a base64 string
+                base64_encoded_data = base64.b64encode(binary_data)
+                self.binary = True
+        # Convert the base64 bytes to a string
+        base64_string = base64_encoded_data.decode("utf-8")
+
+        return base64_string
+
+    def open(self):
+        if self.binary:
+            return self.base64_to_file(self["base64_string"], is_binary=True)
+        else:
+            return self.base64_to_text_file(self["base64_string"])
+
+    @staticmethod
+    def base64_to_text_file(base64_string):
+        # Decode the base64 string to bytes
+        text_data_bytes = base64.b64decode(base64_string)
+
+        # Convert bytes to string
+        text_data = text_data_bytes.decode("utf-8")
+
+        # Create a StringIO object from the text data
+        text_file = io.StringIO(text_data)
+
+        return text_file
+
+    @staticmethod
+    def base64_to_file(base64_string, is_binary=True):
+        # Decode the base64 string to bytes
+        file_data = base64.b64decode(base64_string)
+
+        if is_binary:
+            # Create a BytesIO object for binary data
+            return io.BytesIO(file_data)
+        else:
+            # Convert bytes to string for text data
+            text_data = file_data.decode("utf-8")
+            # 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
+        if self.binary:
+            file_like_object = self.base64_to_file(
+                self["base64_string"], is_binary=True
+            )
+        else:
+            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.close()
+
+        return temp_file.name
+
+    def push(self, description=None):
+        scenario_version = Scenario.from_dict(self.to_dict())
+        if description is None:
+            description = "File: " + self["filename"]
+        info = scenario_version.push(description=description)
+        return info
+
+    @classmethod
+    def pull(cls, uuid):
+        scenario_version = Scenario.pull(uuid)
+        return cls.from_dict(scenario_version.to_dict())
+
+
+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"
+    # fs = FileStore(file_path)
+    # 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")
+    # print(f.to_tempfile())
+    #f.push()

{edsl-0.1.30.dev1 → edsl-0.1.30.dev2}/pyproject.toml

@@ -1,18 +1,27 @@
 [build-system]
 build-backend = "poetry.core.masonry.api"
-requires = ["poetry-core"]
+requires = [ "poetry-core",]
 
 [tool.poetry]
-authors = ["Apostolos Filippas <apostolos@expectedparrot.com>", "John Horton <john@expectedparrot.com>", "Robin Horton <robin@expectedparrot.com>"]
-classifiers = ["Topic :: Scientific/Engineering :: Artificial Intelligence", "Topic :: Software Development :: Libraries :: Application Frameworks", "Topic :: Software Development :: Libraries :: Python Modules"]
+authors = [ "Apostolos Filippas <apostolos@expectedparrot.com>", "John Horton <john@expectedparrot.com>", "Robin Horton <robin@expectedparrot.com>",]
+classifiers = [ "Topic :: Scientific/Engineering :: Artificial Intelligence", "Topic :: Software Development :: Libraries :: Application Frameworks", "Topic :: Software Development :: Libraries :: Python Modules",]
 description = "Create and analyze LLM-based surveys"
 documentation = "https://docs.expectedparrot.com"
 homepage = "https://www.expectedparrot.com/"
-keywords = ["LLM", "social science", "surveys", "user research"]
+keywords = [ "LLM", "social science", "surveys", "user research",]
 license = "MIT"
 name = "edsl"
 readme = "README.md"
-version = "0.1.30.dev1"
+version = "0.1.30.dev2"
+[[tool.poetry.packages]]
+include = "edsl"
+
+[tool.tomlsort]
+all = true
+in_place = true
+spaces_before_inline_comment = 2
+spaces_indent_inline_array = 4
+trailing_comma_inline_array = true
 
 [tool.poetry.dependencies]
 python = ">=3.9.1,<3.13"
@@ -39,9 +48,12 @@ restrictedpython = "^7.1"
 pyreadstat = "^1.2.7"
 
 [tool.poetry.dependencies.black]
-extras = ["jupyter"]
+extras = [ "jupyter",]
 version = "^24.4.2"
 
+[tool.tomlsort.overrides."tool.poetry.dependencies"]
+table_keys = false
+
 [tool.poetry.group.dev.dependencies]
 coverage = "^7.3.3"
 mypy = "^1.7.1"
@@ -64,16 +76,3 @@ sphinx-fontawesome = "^0.0.6"
 sphinx-rtd-theme = "^2.0.0"
 toml = "^0.10.2"
 toml-sort = "^0.23.1"
-
-[[tool.poetry.packages]]
-include = "edsl"
-
-[tool.tomlsort]
-all = true
-in_place = true
-spaces_before_inline_comment = 2
-spaces_indent_inline_array = 4
-trailing_comma_inline_array = true
-
-[tool.tomlsort.overrides."tool.poetry.dependencies"]
-table_keys = false

edsl-0.1.30.dev1/edsl/__version__.py

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