edsl 0.1.30__tar.gz → 0.1.30.dev1__tar.gz

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

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

edsl-0.1.30.dev1/edsl/__version__.py

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

{edsl-0.1.30 → edsl-0.1.30.dev1}/edsl/agents/Agent.py

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

{edsl-0.1.30 → edsl-0.1.30.dev1}/edsl/agents/AgentList.py

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

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

@@ -74,14 +74,15 @@ 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:
@@ -94,10 +95,12 @@ 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(
@@ -108,8 +111,6 @@ 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 → edsl-0.1.30.dev1}/edsl/conversation/car_buying.py

@@ -30,7 +30,7 @@ c1 = Conversation(agent_list=AgentList([a1, a3, a2]), max_turns=5, verbose=True)
 c2 = Conversation(agent_list=AgentList([a1, a2]), max_turns=5, verbose=True)
 
 c = Cache.load("car_talk.json.gz")
-# breakpoint()
+breakpoint()
 combo = ConversationList([c1, c2], cache=c)
 combo.run()
 results = combo.to_results()

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

@@ -7,10 +7,17 @@ import json
 import os
 import warnings
 from typing import Optional, Union
-from edsl.Base import Base
+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.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):
@@ -34,7 +41,6 @@ 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.
@@ -53,7 +59,6 @@ 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:
@@ -117,7 +122,7 @@ class Cache(Base):
         system_prompt: str,
         user_prompt: str,
         iteration: int,
-    ) -> tuple(Union[None, str], str):
+    ) -> Union[None, str]:
         """
         Fetch a value (LLM output) from the cache.
 
@@ -130,7 +135,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)[0] is None
+        >>> c.fetch(model="gpt-3", parameters="default", system_prompt="Hello", user_prompt="Hi", iteration=1) is None
         True
 
 
@@ -146,13 +151,8 @@ 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
-        else:
-            if self.verbose:
-                print(f"Cache miss for key: {key}")
-        return None if entry is None else entry.output, key
+        return None if entry is None else entry.output
 
     def store(
         self,
@@ -354,9 +354,6 @@ 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
     ####################
@@ -473,18 +470,12 @@ class Cache(Base):
         webbrowser.open("file://" + filepath)
 
     @classmethod
-    def example(cls, randomize: bool = False) -> Cache:
+    def example(cls) -> Cache:
         """
-        Returns an example Cache instance.
-
-        :param randomize: If True, uses CacheEntry's randomize method.
+        Return an example Cache.
+        The example Cache has one entry.
         """
-        return cls(
-            data={
-                CacheEntry.example(randomize).key: CacheEntry.example(),
-                CacheEntry.example(randomize).key: CacheEntry.example(),
-            }
-        )
+        return cls(data={CacheEntry.example().key: CacheEntry.example()})
 
 
 if __name__ == "__main__":

{edsl-0.1.30 → edsl-0.1.30.dev1}/edsl/data/CacheEntry.py

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

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

@@ -17,8 +17,6 @@ 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}
@@ -32,7 +30,5 @@ 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 → edsl-0.1.30.dev1}/edsl/jobs/Jobs.py

@@ -461,13 +461,6 @@ 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(
@@ -687,9 +680,7 @@ class Jobs(Base):
     # Example methods
     #######################
     @classmethod
-    def example(
-        cls, throw_exception_probability: int = 0, randomize: bool = False
-    ) -> Jobs:
+    def example(cls, throw_exception_probability=0) -> 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.
@@ -699,13 +690,10 @@ 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",
@@ -748,10 +736,7 @@ class Jobs(Base):
         base_survey = Survey(questions=[q1, q2])
 
         scenario_list = ScenarioList(
-            [
-                Scenario({"period": f"morning{addition}"}),
-                Scenario({"period": "afternoon"}),
-            ]
+            [Scenario({"period": "morning"}), Scenario({"period": "afternoon"})]
         )
         job = base_survey.by(scenario_list).by(joy_agent, sad_agent)
 

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

@@ -25,16 +25,6 @@ class ModelBuckets:
             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":
         """Create a bucket with infinite capacity and refill rate."""

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

@@ -17,29 +17,11 @@ 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:
-            # pass
-            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.
@@ -73,17 +55,7 @@ class TokenBucket:
         self.log.append((time.monotonic(), self.tokens))
 
     def refill(self) -> None:
-        """Refill the bucket with new tokens based on elapsed time.
-
-
-
-        >>> bucket = TokenBucket(bucket_name="test", bucket_type="test", capacity=10, refill_rate=1)
-        >>> bucket.tokens = 0
-        >>> bucket.refill()
-        >>> bucket.tokens > 0
-        True
-
-        """
+        """Refill the bucket with new tokens based on elapsed time."""
         now = time.monotonic()
         elapsed = now - self.last_refill
         refill_amount = elapsed * self.refill_rate
@@ -126,7 +98,7 @@ class TokenBucket:
             raise ValueError(msg)
         while self.tokens < amount:
             self.refill()
-            await asyncio.sleep(0.01)  # Sleep briefly to prevent busy waiting
+            await asyncio.sleep(0.1)  # Sleep briefly to prevent busy waiting
         self.tokens -= amount
 
         now = time.monotonic()