edsl 0.1.46__py3-none-any.whl → 0.1.48__py3-none-any.whl

edsl/data/CacheEntry.py

@@ -1,230 +0,0 @@
-from __future__ import annotations
-import json
-import datetime
-import hashlib
-from typing import Optional
-from uuid import uuid4
-
-from edsl.utilities.decorators import remove_edsl_version
-
-from edsl.Base import RepresentationMixin
-
-
-class CacheEntry(RepresentationMixin):
-    """
-    A Class to represent a cache entry.
-    """
-
-    key_fields = ["model", "parameters", "system_prompt", "user_prompt", "iteration"]
-    all_fields = key_fields + ["timestamp", "output"]
-
-    def __init__(
-        self,
-        *,
-        model: str,
-        parameters: dict,
-        system_prompt: str,
-        user_prompt: str,
-        iteration: Optional[int] = None,
-        output: str,
-        timestamp: Optional[int] = None,
-    ):
-        self.model = model
-        self.parameters = parameters
-        self.system_prompt = system_prompt
-        self.user_prompt = user_prompt
-        self.output = output
-        self.iteration = iteration or 0
-        self.timestamp = timestamp or int(
-            datetime.datetime.now(datetime.timezone.utc).timestamp()
-        )
-        self._check_types()
-
-    def _check_types(self):
-        """
-        Checks if the types of the fields are correct.
-        """
-        if not isinstance(self.model, str):
-            raise TypeError("`model` should be a string.")
-        if not isinstance(self.parameters, dict):
-            raise TypeError("`parameters` should be a dictionary.")
-        if not isinstance(self.system_prompt, str):
-            raise TypeError("`system_prompt` should be a string.")
-        if not isinstance(self.user_prompt, str):
-            raise TypeError("`user_prompt` should be a string")
-        if not isinstance(self.output, str):
-            raise TypeError("`output` should be a string")
-        if not isinstance(self.iteration, int):
-            raise TypeError("`iteration` should be an integer")
-        # TODO: should probably be float
-        if not isinstance(self.timestamp, int):
-            raise TypeError(f"`timestamp` should be an integer")
-
-    @classmethod
-    def gen_key(
-        self, *, model, parameters, system_prompt, user_prompt, iteration
-    ) -> str:
-        """
-        Generates a key for the cache entry.
-        - Treats single and double quotes as the same.
-
-        TODO: add more robustness.
-        """
-        long_key = f"{model}{json.dumps(parameters, sort_keys=True)}{system_prompt}{user_prompt}{iteration}"
-        return hashlib.md5(long_key.encode()).hexdigest()
-
-    @property
-    def key(self) -> str:
-        """
-        Returns the key for the cache entry.
-        - The key is a hash of the key fields.
-        """
-        d = {k: value for k, value in self.__dict__.items() if k in self.key_fields}
-        return self.gen_key(**d)
-
-    def to_dict(self, add_edsl_version=True) -> dict:
-        """
-        Returns a dictionary representation of a CacheEntry.
-        """
-        d = {
-            "model": self.model,
-            "parameters": self.parameters,
-            "system_prompt": self.system_prompt,
-            "user_prompt": self.user_prompt,
-            "output": self.output,
-            "iteration": self.iteration,
-            "timestamp": self.timestamp,
-        }
-        # if add_edsl_version:
-        #     from edsl import __version__
-
-        #     d["edsl_version"] = __version__
-        #     d["edsl_class_name"] = self.__class__.__name__
-        return d
-
-    def keys(self):
-        return list(self.to_dict().keys())
-
-    def values(self):
-        return list(self.to_dict().values())
-
-    def __getitem__(self, key):
-        """
-        Returns the value of a field.
-        """
-        return getattr(self, key)
-
-    @classmethod
-    def from_dict(cls, data: dict) -> CacheEntry:
-        """
-        Initializes a CacheEntry object from its dictionary representation.
-        """
-        return cls(**data)
-
-    def __eq__(self, other: CacheEntry) -> bool:
-        """
-        Checks if two CacheEntry objects are equal.
-        - Does not include timestamp in the comparison.
-        """
-        if not isinstance(other, CacheEntry):
-            return False
-        for field in self.all_fields:
-            if getattr(self, field) != getattr(other, field) and field != "timestamp":
-                return False
-        return True
-
-    def __repr__(self) -> str:
-        """
-        Returns a string representation of a CacheEntry.
-        """
-        return (
-            f"CacheEntry(model={repr(self.model)}, "
-            f"parameters={self.parameters}, "
-            f"system_prompt={repr(self.system_prompt)}, "
-            f"user_prompt={repr(self.user_prompt)}, "
-            f"output={repr(self.output)}, "
-            f"iteration={self.iteration}, "
-            f"timestamp={self.timestamp})"
-        )
-
-    @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.
-        """
-        # if random, create a uuid
-        addition = "" if not randomize else str(uuid4())
-        return CacheEntry(
-            model="gpt-3.5-turbo",
-            parameters={"temperature": 0.5},
-            system_prompt=f"The quick brown fox jumps over the lazy dog.{addition}",
-            user_prompt="What does the fox say?",
-            output="The fox says 'hello'",
-            iteration=1,
-            timestamp=int(datetime.datetime.now(datetime.timezone.utc).timestamp()),
-        )
-
-    @classmethod
-    def example_dict(cls) -> dict:
-        """
-        Returns an example dictionary with a single CacheEntry.
-        - This will be useful one level up, in the Cache class.
-        """
-        cache_entry = cls.example()
-        return {cache_entry.key: cache_entry}
-
-    @classmethod
-    def fetch_input_example(cls) -> dict:
-        """
-        Creates an example input for a 'fetch' operation.
-        - This will be useful one level up, in the Cache class.
-        """
-        input = cls.example().to_dict()
-        _ = input.pop("timestamp")
-        _ = input.pop("output")
-        return input
-
-    @classmethod
-    def store_input_example(cls) -> dict:
-        """
-        Creates an example input for a 'store' operation.
-        - This will be useful one level up, in the Cache class.
-        """
-        input = cls.example().to_dict()
-        _ = input.pop("timestamp")
-        input["response"] = input.pop("output")
-        return input
-
-
-def main():
-    from edsl.data.CacheEntry import CacheEntry
-
-    # an example of how a cache entry looks
-    cache_entry = CacheEntry.example()
-    cache_entry
-
-    # .key property returns the hash of the cache entry
-    cache_entry.key
-    # to dict / from dict
-    cache_entry.to_dict()
-    CacheEntry.from_dict(cache_entry.to_dict())
-    # TODO: this will be false because equality includes timestamp
-    CacheEntry.from_dict(cache_entry.to_dict()) == CacheEntry.example()
-    # equality by checking values
-    cache_entry == CacheEntry.example()
-    # equality by checking keys
-    cache_entry.key == CacheEntry.example().key
-    # evalable repr
-    eval(repr(cache_entry)) == cache_entry
-    # not sure what these are useful for yet
-    cache_entry.example_dict()
-    cache_entry.fetch_input_example()
-    cache_entry.store_input_example()
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod()

edsl/data/SQLiteDict.py

@@ -1,292 +0,0 @@
-from __future__ import annotations
-import json
-from typing import Any, Generator, Optional, Union
-
-from edsl.config import CONFIG
-from edsl.data.CacheEntry import CacheEntry
-from edsl.data.orm import Base, Data
-
-
-class SQLiteDict:
-    """
-    A dictionary-like object that is an interface for an local database.
-    - You can use SQLiteDict as a regular dictionary.
-    - Supports only SQLite for now.
-    """
-
-    def __init__(self, db_path: Optional[str] = None):
-        """
-
-        >>> temp_db_path = SQLiteDict._get_temp_path()
-        >>> SQLiteDict(f"sqlite:///{temp_db_path}")  # Use the temp file for SQLite
-        SQLiteDict(db_path='...')
-        >>> import os; os.unlink(temp_db_path)  # Clean up the temp file after the test
-
-        """
-        from sqlalchemy.exc import SQLAlchemyError
-        from sqlalchemy.orm import sessionmaker
-        from sqlalchemy import create_engine
-
-        self.db_path = db_path or CONFIG.get("EDSL_DATABASE_PATH")
-        if not self.db_path.startswith("sqlite:///"):
-            self.db_path = f"sqlite:///{self.db_path}"
-        try:
-            from edsl.data.orm import Base, Data
-
-            self.engine = create_engine(self.db_path, echo=False, future=True)
-            Base.metadata.create_all(self.engine)
-            self.Session = sessionmaker(bind=self.engine)
-        except SQLAlchemyError as e:
-            raise Exception(
-                f"""Database initialization error: {e}. The attempted DB path was {db_path}"""
-            ) from e
-
-    @classmethod
-    def _get_temp_path(self):
-        import tempfile
-        import os
-
-        _, temp_db_path = tempfile.mkstemp(suffix=".db")
-        return temp_db_path
-
-    def __setitem__(self, key: str, value: CacheEntry) -> None:
-        """
-        Stores a key-value pair.
-
-        >>> d = SQLiteDict.example()
-        >>> d["foo"] = CacheEntry.example()
-        """
-        if not isinstance(value, CacheEntry):
-            raise ValueError(f"Value must be a CacheEntry object (got {type(value)}).")
-        with self.Session() as db:
-            from edsl.data.orm import Base, Data
-
-            db.merge(Data(key=key, value=json.dumps(value.to_dict())))
-            db.commit()
-
-    def __getitem__(self, key: str) -> CacheEntry:
-        """
-        Gets a value for a given key.
-        - Raises a KeyError if the key is not found.
-
-        >>> d = SQLiteDict.example()
-        >>> d["foo"] = CacheEntry.example()
-        >>> d["foo"] == CacheEntry.example()
-        True
-        """
-        with self.Session() as db:
-            from edsl.data.orm import Base, Data
-
-            value = db.query(Data).filter_by(key=key).first()
-            if not value:
-                raise KeyError(f"Key '{key}' not found.")
-            return CacheEntry.from_dict(json.loads(value.value))
-
-    def get(self, key: str, default: Optional[Any] = None) -> Union[CacheEntry, Any]:
-        """
-        Gets the value for a given key
-        - Returns the `default` value if the key is not found.
-
-        >>> d = SQLiteDict.example()
-        >>> d.get("foo", "bar")
-        'bar'
-        """
-        try:
-            return self[key]
-        except KeyError:
-            return default
-
-    def __bool__(self) -> bool:
-        """This is so likes like
-        self.data = data or {} 'work' as expected
-        """
-        return True
-
-    def update(
-        self,
-        new_d: Union[dict, SQLiteDict],
-        overwrite: Optional[bool] = False,
-        max_batch_size: Optional[int] = 100,
-    ) -> None:
-        """
-        Update the dictionary with the values from another dictionary.
-
-        :param new_d: The dictionary to update the current dictionary with.
-        :param overwrite: If `overwrite` is False, existing values will not be overwritten.
-        :param max_batch_size: The maximum number of items to update in a single transaction.
-
-        - If `overwrite` is True, existing values will be overwritten.
-
-        >>> d = SQLiteDict.example()
-        >>> d.update({"foo": CacheEntry.example()})
-        >>> d["foo"] == CacheEntry.example()
-        True
-        """
-        if not (isinstance(new_d, dict) or isinstance(new_d, SQLiteDict)):
-            raise ValueError(
-                f"new_d must be a dict or SQLiteDict object (got {type(new_d)})"
-            )
-        current_batch = 0
-        with self.Session() as db:
-            for key, value in new_d.items():
-                if current_batch == max_batch_size:
-                    db.commit()
-                    current_batch = 0
-                current_batch += 1
-                if key in self:
-                    if overwrite:
-                        db.merge(Data(key=key, value=json.dumps(value.to_dict())))
-                else:
-                    db.merge(Data(key=key, value=json.dumps(value.to_dict())))
-            db.commit()
-
-    def values(self) -> Generator[CacheEntry, None, None]:
-        """
-        Returns a generator that yields the values in the cache.
-
-        >>> d = SQLiteDict.example()
-        >>> d["foo"] = CacheEntry.example()
-        >>> list(d.values()) == [CacheEntry.example()]
-        True
-        """
-        with self.Session() as db:
-            for instance in db.query(Data).all():
-                yield CacheEntry.from_dict(json.loads(instance.value))
-
-    def items(self) -> Generator[tuple[str, CacheEntry], None, None]:
-        """
-        Returns a generator that yields the items in the cache.
-
-        >>> d = SQLiteDict.example()
-        >>> d["foo"] = CacheEntry.example()
-        >>> list(d.items()) == [("foo", CacheEntry.example())]
-        True
-        """
-        with self.Session() as db:
-            for instance in db.query(Data).all():
-                yield (instance.key, CacheEntry.from_dict(json.loads(instance.value)))
-
-    def to_dict(self):
-        """
-        Returns the cache as a dictionary.
-
-        >>> d = SQLiteDict.example()
-        >>> d["foo"] = CacheEntry.example()
-        >>> d.to_dict() == {"foo": CacheEntry.example()}
-        True
-        """
-        return dict(self.items())
-
-    def __delitem__(self, key: str) -> None:
-        """
-        Deletes the value for a given key.
-
-        >>> d = SQLiteDict.example()
-        >>> d["foo"] = CacheEntry.example()
-        >>> del d["foo"]
-        >>> d.get("foo", "missing")
-        'missing'
-        """
-        with self.Session() as db:
-            instance = db.query(Data).filter_by(key=key).one_or_none()
-            if instance:
-                db.delete(instance)
-                db.commit()
-            else:
-                raise KeyError(f"Key '{key}' not found.")
-
-    def __contains__(self, key: str) -> bool:
-        """
-        Checks if the dict contains the given key.
-
-        >>> d = SQLiteDict.example()
-        >>> d["foo"] = CacheEntry.example()
-        >>> "foo" in d
-        True
-        >>> "bar" in d
-        False
-        """
-        with self.Session() as db:
-            return db.query(Data).filter_by(key=key).first() is not None
-
-    def __iter__(self) -> Generator[str, None, None]:
-        """
-        Returns a generator that yields the keys in the dict.
-
-        >>> d = SQLiteDict.example()
-        >>> d["foo"] = CacheEntry.example()
-        >>> list(iter(d)) == ["foo"]
-        True
-        """
-        with self.Session() as db:
-            for instance in db.query(Data).all():
-                yield instance.key
-
-    def __len__(self) -> int:
-        """
-        Returns the number of items in the cache.
-
-        >>> d = SQLiteDict.example()
-        >>> len(d)
-        0
-        >>> d["foo"] = CacheEntry.example()
-        >>> len(d)
-        1
-        """
-        with self.Session() as db:
-            return db.query(Data).count()
-
-    def keys(self) -> Generator[str, None, None]:
-        """
-        Returns a generator that yields the keys in the cache.
-
-        >>> d = SQLiteDict.example()
-        >>> d["foo"] = CacheEntry.example()
-        >>> list(d.keys()) == ["foo"]
-        True
-        """
-        return self.__iter__()
-
-    def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(db_path={self.db_path!r})"
-
-    @classmethod
-    def example(cls) -> SQLiteDict:
-        """
-        Returns an example SQLiteDict object.
-        - The example SQLiteDict is empty and stored in memory.
-
-        >>> SQLiteDict.example()
-        SQLiteDict(db_path='sqlite:///:memory:')
-        """
-        return cls(db_path="sqlite:///:memory:")
-
-
-def main():
-    from edsl.data.CacheEntry import CacheEntry
-    from edsl.data.SQLiteDict import SQLiteDict
-
-    d = SQLiteDict.example()
-    d["foo"] = CacheEntry.example()
-    d["foo"]
-    d.get("foo")
-    d.get("poo")
-    d.get("poo", "not found")
-    d.update({"poo": CacheEntry.example()})
-    d["poo"]
-    len(d)
-    list(d.keys())
-    list(d.values())
-    list(d.items())
-    assert "poo" in d
-    assert "loo" not in d
-    del d["poo"]
-    assert len(d) == 1
-    repr(d)
-    d
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod()

edsl/data/__init__.py

@@ -1,5 +0,0 @@
-# from edsl.data.CacheEntry import CacheEntry
-# from edsl.data.SQLiteDict import SQLiteDict
-from edsl.data.Cache import Cache
-
-# from edsl.data.CacheHandler import CacheHandler

edsl/data/orm.py

@@ -1,10 +0,0 @@
-from sqlalchemy import Column, String
-from sqlalchemy.ext.declarative import declarative_base
-
-Base = declarative_base()
-
-
-class Data(Base):
-    __tablename__ = "data"
-    key = Column(String, primary_key=True)
-    value = Column(String)

edsl/exceptions/cache.py

@@ -1,5 +0,0 @@
-from edsl.exceptions.BaseException import BaseException
-
-
-class CacheError(BaseException):
-    relevant_doc = "https://docs.expectedparrot.com/en/latest/agents.html#agent-lists"

edsl/exceptions/coop.py

@@ -1,14 +0,0 @@
-class CoopErrors(Exception):
-    pass
-
-
-class CoopInvalidURLError(CoopErrors):
-    pass
-
-
-class CoopNoUUIDError(CoopErrors):
-    pass
-
-
-class CoopServerResponseError(CoopErrors):
-    pass

edsl/exceptions/data.py

@@ -1,14 +0,0 @@
-class DatabaseErrors(Exception):
-    pass
-
-
-class DatabaseConnectionError(DatabaseErrors):
-    pass
-
-
-class DatabaseCRUDError(DatabaseErrors):
-    pass
-
-
-class DatabaseIntegrityError(DatabaseErrors):
-    pass

edsl/exceptions/scenarios.py

@@ -1,29 +0,0 @@
-import re
-import textwrap
-
-# from IPython.core.error import UsageError
-
-
-class AgentListError(Exception):
-    def __init__(self, message):
-        super().__init__(message)
-
-
-class ScenarioError(Exception):
-    documentation = "https://docs.expectedparrot.com/en/latest/scenarios.html#module-edsl.scenarios.Scenario"
-
-    def __init__(self, message: str):
-        self.message = message + "\n" + "Documentation: " + self.documentation
-        super().__init__(self.message)
-
-    def __str__(self):
-        return self.make_urls_clickable(self.message)
-
-    @staticmethod
-    def make_urls_clickable(text):
-        url_pattern = r"https?://[^\s]+"
-        urls = re.findall(url_pattern, text)
-        for url in urls:
-            clickable_url = f"\033]8;;{url}\007{url}\033]8;;\007"
-            text = text.replace(url, clickable_url)
-        return text

edsl/jobs/Answers.py

@@ -1,43 +0,0 @@
-"""This module contains the Answers class, which is a helper class to hold the answers to a survey."""
-
-from collections import UserDict
-from edsl.data_transfer_models import EDSLResultObjectInput
-
-
-class Answers(UserDict):
-    """Helper class to hold the answers to a survey."""
-
-    def add_answer(
-        self, response: EDSLResultObjectInput, question: "QuestionBase"
-    ) -> None:
-        """Add a response to the answers dictionary."""
-        answer = response.answer
-        comment = response.comment
-        generated_tokens = response.generated_tokens
-        # record the answer
-        if generated_tokens:
-            self[question.question_name + "_generated_tokens"] = generated_tokens
-        self[question.question_name] = answer
-        if comment:
-            self[question.question_name + "_comment"] = comment
-
-    def replace_missing_answers_with_none(self, survey: "Survey") -> None:
-        """Replace missing answers with None. Answers can be missing if the agent skips a question."""
-        for question_name in survey.question_names:
-            if question_name not in self:
-                self[question_name] = None
-
-    def to_dict(self):
-        """Return a dictionary of the answers."""
-        return self.data
-
-    @classmethod
-    def from_dict(cls, d):
-        """Return an Answers object from a dictionary."""
-        return cls(d)
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod()