lionagi 0.0.209__py3-none-any.whl → 0.0.210__py3-none-any.whl

lionagi/schema/status_tracker.py

@@ -1,37 +0,0 @@
-from dataclasses import dataclass
-
-
-# credit to OpenAI for the following object
-@dataclass
-class StatusTracker:
-    """
-    Class for keeping track of various task statuses.
-    
-    This class serves as a simple way to monitor different types of task
-    outcomes and errors within a system. It uses dataclasses for easy
-    creation and management of state.
-    
-    Attributes:
-        num_tasks_started:
-            The number of tasks that have been initiated.
-        num_tasks_in_progress:
-            The number of tasks currently being processed.
-        num_tasks_succeeded:
-            The number of tasks that have completed successfully.
-        num_tasks_failed:
-            The number of tasks that have failed.
-        num_rate_limit_errors:
-            The number of tasks that failed due to rate limiting.
-        num_api_errors:
-            The number of tasks that failed due to API errors.
-        num_other_errors:
-            The number of tasks that failed due to other errors.
-    """
-    num_tasks_started: int = 0
-    num_tasks_in_progress: int = 0
-    num_tasks_succeeded: int = 0
-    num_tasks_failed: int = 0
-    num_rate_limit_errors: int = 0
-    num_api_errors: int = 0
-    num_other_errors: int = 0
-    

lionagi/tests/test_utils/test_encrypt_util.py

@@ -1,323 +0,0 @@
-import unittest
-import os
-import tempfile
-import zipfile
-import hashlib
-from cryptography.fernet import InvalidToken
-from lionagi.utils.encrypt_util import EncrytionUtil
-
-
-class TestPasswordStrengthChecker(unittest.TestCase):
-
-    def test_short_passwords(self):
-        self.assertFalse(EncrytionUtil.password_strength_checker("Short1"))
-        self.assertFalse(EncrytionUtil.password_strength_checker("A1"))
-
-    def test_passwords_without_digits(self):
-        self.assertFalse(EncrytionUtil.password_strength_checker("NoDigitsHere"))
-        self.assertFalse(EncrytionUtil.password_strength_checker("Onlyletters!"))
-
-    def test_passwords_without_uppercase(self):
-        self.assertFalse(EncrytionUtil.password_strength_checker("alllowercase1"))
-        self.assertFalse(EncrytionUtil.password_strength_checker("nouppercase1!"))
-
-    def test_strong_passwords(self):
-        self.assertTrue(EncrytionUtil.password_strength_checker("ValidPass1"))
-        self.assertTrue(EncrytionUtil.password_strength_checker("AnotherGood1"))
-
-
-class TestGenerateEncryptionKey(unittest.TestCase):
-
-    def setUp(self):
-        # Strong password and predefined salt for testing
-        self.strong_password = "StrongPass1"
-        self.salt = b'0123456789abcdef'
-
-    def test_with_strong_password_and_provided_salt(self):
-        key = EncrytionUtil.generate_encryption_key(password=self.strong_password, salt=self.salt)
-        self.assertIsInstance(key, str)
-
-    def test_with_strong_password_and_no_salt(self):
-        key = EncrytionUtil.generate_encryption_key(password=self.strong_password)
-        self.assertIsInstance(key, str)
-
-    def test_with_weak_password(self):
-        with self.assertRaises(ValueError):
-            EncrytionUtil.generate_encryption_key(password="weak")
-
-    def test_with_no_password(self):
-        key = EncrytionUtil.generate_encryption_key()
-        self.assertIsInstance(key, str)
-        self.assertEqual(len(key), 44)  # Typical length of a Fernet key
-
-
-class TestEncrypt(unittest.TestCase):
-
-    def setUp(self):
-        self.valid_key = EncrytionUtil.generate_encryption_key("StrongPass1")
-        self.invalid_key = "invalidkey"
-        self.test_data = "This is a test string."
-
-    def test_valid_encryption(self):
-        encrypted_data = EncrytionUtil.encrypt(self.test_data, self.valid_key)
-        self.assertIsInstance(encrypted_data, str)
-        self.assertNotEqual(encrypted_data, self.test_data)
-
-    def test_with_invalid_key(self):
-        with self.assertRaises(Exception):
-            EncrytionUtil.encrypt(self.test_data, self.invalid_key)
-
-    def test_with_non_string_data(self):
-        with self.assertRaises(AttributeError):  # or whichever error is appropriate
-            EncrytionUtil.encrypt(12345, self.valid_key)
-
-    def test_with_empty_string(self):
-        encrypted_data = EncrytionUtil.encrypt("", self.valid_key)
-        self.assertIsInstance(encrypted_data, str)
-        self.assertNotEqual(encrypted_data, "")
-
-
-class TestDecrypt(unittest.TestCase):
-
-    def setUp(self):
-        self.valid_key = EncrytionUtil.generate_encryption_key("StrongPass1")
-        self.invalid_key = "invalidkey"
-        self.test_data = "This is a test string."
-        self.encrypted_data = EncrytionUtil.encrypt(self.test_data, self.valid_key)
-
-    def test_valid_decryption(self):
-        decrypted_data = EncrytionUtil.decrypt(self.encrypted_data, self.valid_key)
-        self.assertIsInstance(decrypted_data, str)
-        self.assertEqual(decrypted_data, self.test_data)
-
-    def test_decryption_with_invalid_key(self):
-        with self.assertRaises(ValueError):
-            EncrytionUtil.decrypt(self.encrypted_data, self.invalid_key)
-
-    def test_with_non_string_data(self):
-        with self.assertRaises(AttributeError):
-            EncrytionUtil.decrypt(12345, self.valid_key)
-
-    def test_decryption_of_non_encrypted_string(self):
-        with self.assertRaises(InvalidToken):
-            EncrytionUtil.decrypt("plain text", self.valid_key)
-
-
-class TestEncryptFile(unittest.TestCase):
-
-    def setUp(self):
-        self.valid_key = EncrytionUtil.generate_encryption_key("StrongPass1")
-        # Create a temporary file with some test data
-        self.temp_file = tempfile.NamedTemporaryFile(delete=False)
-        self.temp_file.write(b"This is a test file.")
-        self.temp_file.close()
-
-    def tearDown(self):
-        # Cleanup: Remove temporary files
-        os.remove(self.temp_file.name)
-        if os.path.exists(self.temp_file.name + '.enc'):
-            os.remove(self.temp_file.name + '.enc')
-
-    def test_encrypting_valid_file(self):
-        EncrytionUtil.encrypt_file(self.temp_file.name, self.valid_key)
-        self.assertTrue(os.path.exists(self.temp_file.name + '.enc'))
-
-    def test_with_non_existent_file_path(self):
-        with self.assertRaises(FileNotFoundError):
-            EncrytionUtil.encrypt_file("non_existent_file.txt", self.valid_key)
-
-
-class TestDecryptFile(unittest.TestCase):
-
-    def setUp(self):
-        self.valid_key = EncrytionUtil.generate_encryption_key("StrongPass1")
-        # Create a temporary file and encrypt it
-        self.temp_file = tempfile.NamedTemporaryFile(delete=False)
-        self.temp_file.write(b"This is a test file.")
-        self.temp_file.close()
-        EncrytionUtil.encrypt_file(self.temp_file.name, self.valid_key)
-
-    def tearDown(self):
-        # Cleanup: Remove temporary files
-        os.remove(self.temp_file.name)
-        if os.path.exists(self.temp_file.name + '.enc'):
-            os.remove(self.temp_file.name + '.enc')
-        decrypted_file_path = self.temp_file.name.replace('.enc', '')
-        if os.path.exists(decrypted_file_path):
-            os.remove(decrypted_file_path)
-
-    def test_decrypting_valid_encrypted_file(self):
-        EncrytionUtil.decrypt_file(self.temp_file.name + '.enc', self.valid_key)
-        decrypted_file_path = self.temp_file.name.replace('.enc', '')
-        self.assertTrue(os.path.exists(decrypted_file_path))
-
-    def test_with_non_existent_encrypted_file_path(self):
-        with self.assertRaises(FileNotFoundError):
-            EncrytionUtil.decrypt_file("non_existent_file.txt.enc", self.valid_key)
-
-    def test_decrypting_with_invalid_key(self):
-        with self.assertRaises(ValueError):
-            EncrytionUtil.decrypt_file(self.temp_file.name + '.enc', 'invalidkey')
-
-
-class TestIsEncrypted(unittest.TestCase):
-
-    def setUp(self):
-        self.valid_key = EncrytionUtil.generate_encryption_key("StrongPass1")
-        # Create a temporary file and encrypt it
-        self.temp_file = tempfile.NamedTemporaryFile(delete=False)
-        self.temp_file.write(b"This is a test file.")
-        self.temp_file.close()
-        EncrytionUtil.encrypt_file(self.temp_file.name, self.valid_key)
-
-        # Create a non-encrypted temporary file
-        self.non_encrypted_file = tempfile.NamedTemporaryFile(delete=False)
-        self.non_encrypted_file.write(b"This is a non-encrypted test file.")
-        self.non_encrypted_file.close()
-
-    def tearDown(self):
-        # Cleanup: Remove temporary files
-        os.remove(self.temp_file.name)
-        if os.path.exists(self.temp_file.name + '.enc'):
-            os.remove(self.temp_file.name + '.enc')
-        os.remove(self.non_encrypted_file.name)
-
-    def test_with_encrypted_file(self):
-        self.assertTrue(EncrytionUtil.is_encrypted(self.temp_file.name + '.enc', self.valid_key))
-
-    def test_with_non_encrypted_file(self):
-        self.assertFalse(EncrytionUtil.is_encrypted(self.non_encrypted_file.name, self.valid_key))
-
-
-class TestDecompressFile(unittest.TestCase):
-
-    def setUp(self):
-        # Create a temporary directory
-        self.temp_dir = tempfile.mkdtemp()
-
-        # Create a temporary zip file with some content
-        self.temp_zip_file = os.path.join(self.temp_dir, 'test.zip')
-        with zipfile.ZipFile(self.temp_zip_file, 'w') as zipf:
-            zipf.writestr('test.txt', 'This is a test file.')
-
-    def tearDown(self):
-        # Cleanup: Remove temporary directory and its contents
-        for root, dirs, files in os.walk(self.temp_dir, topdown=False):
-            for name in files:
-                os.remove(os.path.join(root, name))
-            for name in dirs:
-                os.rmdir(os.path.join(root, name))
-        os.rmdir(self.temp_dir)
-
-    def test_decompressing_valid_zip_file(self):
-        EncrytionUtil.decompress_file(self.temp_zip_file, self.temp_dir)
-        self.assertTrue(os.path.exists(os.path.join(self.temp_dir, 'test.txt')))
-
-    def test_with_non_existent_zip_file_path(self):
-        with self.assertRaises(FileNotFoundError):
-            EncrytionUtil.decompress_file("non_existent_file.zip", self.temp_dir)
-
-    def test_with_invalid_zip_file(self):
-        invalid_zip_file = os.path.join(self.temp_dir, 'invalid.zip')
-        with open(invalid_zip_file, 'w') as f:
-            f.write("This is not a zip file.")
-        with self.assertRaises(zipfile.BadZipFile):
-            EncrytionUtil.decompress_file(invalid_zip_file, self.temp_dir)
-
-
-class TestCompressFile(unittest.TestCase):
-
-    def setUp(self):
-        # Create a temporary file with some test data
-        self.temp_file = tempfile.NamedTemporaryFile(delete=False)
-        self.temp_file.write(b"This is a test file.")
-        self.temp_file.close()
-
-    def tearDown(self):
-        # Cleanup: Remove temporary files
-        os.remove(self.temp_file.name)
-        if os.path.exists(self.temp_file.name + '.zip'):
-            os.remove(self.temp_file.name + '.zip')
-
-    def test_compressing_valid_file(self):
-        EncrytionUtil.compress_file(self.temp_file.name)
-        self.assertTrue(os.path.exists(self.temp_file.name + '.zip'))
-
-    def test_with_non_existent_file_path(self):
-        with self.assertRaises(FileNotFoundError):
-            EncrytionUtil.compress_file("non_existent_file.txt")
-
-
-class TestBinaryToHex(unittest.TestCase):
-
-    def test_with_valid_binary_data(self):
-        # Test a variety of binary data
-        self.assertEqual(EncrytionUtil.binary_to_hex(b'\x00\x0F'), '000f')
-        self.assertEqual(EncrytionUtil.binary_to_hex(b'hello'), '68656c6c6f')
-        self.assertEqual(EncrytionUtil.binary_to_hex(b'\xff\xfe\xfd\xfc'), 'fffefdfc')
-
-    def test_with_empty_bytes(self):
-        self.assertEqual(EncrytionUtil.binary_to_hex(b''), '')
-
-
-class TestCreateHash(unittest.TestCase):
-
-    def test_hashing_with_default_algorithm(self):
-        data = "test"
-        expected_hash = hashlib.sha256(data.encode()).hexdigest()
-        self.assertEqual(EncrytionUtil.create_hash(data), expected_hash)
-
-    def test_hashing_with_different_algorithms(self):
-        data = "test"
-        algorithms = ['sha1', 'sha224', 'sha384', 'sha512']
-        for algo in algorithms:
-            with self.subTest(algorithm=algo):
-                expected_hash = hashlib.new(algo, data.encode()).hexdigest()
-                self.assertEqual(EncrytionUtil.create_hash(data, algo), expected_hash)
-
-    def test_with_unsupported_algorithm(self):
-        with self.assertRaises(ValueError):
-            EncrytionUtil.create_hash("test", "unsupported_algo")
-
-
-class TestDecodeBase64(unittest.TestCase):
-
-    def test_with_valid_base64_encoded_strings(self):
-        # Test a variety of valid base64 encoded strings
-        test_cases = [
-            ("SGVsbG8sIFdvcmxkIQ==", "Hello, World!"),
-            ("VGhpcyBpcyBhIHRlc3Q=", "This is a test"),
-            ("c29tZSBieXRlcw==", "some bytes")
-        ]
-        for encoded, original in test_cases:
-            with self.subTest(encoded=encoded):
-                self.assertEqual(EncrytionUtil.decode_base64(encoded), original)
-
-    def test_with_invalid_base64_string(self):
-        invalid_data = "This is not base64!"
-        with self.assertRaises(Exception):  # Replace Exception with the specific exception if known
-            EncrytionUtil.decode_base64(invalid_data)
-
-    def test_with_empty_string(self):
-        self.assertEqual(EncrytionUtil.decode_base64(""), "")
-
-        
-class TestEncodeBase64(unittest.TestCase):
-
-    def test_with_valid_strings(self):
-        # Test a variety of strings
-        test_cases = [
-            ("Hello, World!", "SGVsbG8sIFdvcmxkIQ=="),
-            ("This is a test", "VGhpcyBpcyBhIHRlc3Q="),
-            ("some bytes", "c29tZSBieXRlcw==")
-        ]
-        for original, encoded in test_cases:
-            with self.subTest(original=original):
-                self.assertEqual(EncrytionUtil.encode_base64(original), encoded)
-
-    def test_with_empty_string(self):
-        self.assertEqual(EncrytionUtil.encode_base64(""), "")
-
-
-if __name__ == '__main__':
-    unittest.main()

lionagi/utils/encrypt_util.py

@@ -1,283 +0,0 @@
-import base64
-import binascii
-import hashlib
-import os
-import zipfile
-from base64 import urlsafe_b64encode
-from cryptography.fernet import Fernet, InvalidToken
-from cryptography.hazmat.backends import default_backend
-from cryptography.hazmat.primitives import hashes
-from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
-from typing import Optional
-
-
-class EncrytionUtil:
-    """
-    A utility class for handling encryption, decryption, file operations, and password strength checking.
-    """
-
-    @staticmethod
-    def password_strength_checker(password: str) -> bool:
-        """
-        Check the strength of a password.
-
-        Args:
-            password (str): The password to check.
-
-        Returns:
-            bool: True if the password is strong, False otherwise.
-
-        Examples:
-            >>> password_strength_checker("Weakpass")
-            False
-            >>> password_strength_checker("Strongpass1")
-            True
-        """
-        if len(password) < 8 or not any(char.isdigit() for char in password) or not any(char.isupper() for char in password):
-            return False
-        return True
-
-    @staticmethod
-    def generate_encryption_key(password: Optional[str] = None, salt: Optional[bytes] = None) -> str:
-        """
-        Generate an encryption key from a password and salt.
-
-        Args:
-            password (Optional[str]): The password to derive the key from. If None, a random key is generated.
-            salt (Optional[bytes]): A salt for the key derivation. If None, a random salt is used.
-
-        Returns:
-            str: The generated encryption key as a URL-safe base64-encoded string.
-
-        Raises:
-            ValueError: If the password is too weak.
-
-        Examples:
-            >>> key = generate_encryption_key("Strongpass1")
-            >>> isinstance(key, str)
-            True
-        """
-        if password:
-            if not EncrytionUtil.password_strength_checker(password):
-                raise ValueError("Password is too weak.")
-            if not salt:
-                salt = os.urandom(16)
-            kdf = PBKDF2HMAC(
-                algorithm=hashes.SHA256(),
-                length=32,
-                salt=salt,
-                iterations=100000,
-                backend=default_backend()
-            )
-            key = kdf.derive(password.encode())
-            return urlsafe_b64encode(key).decode()
-        else:
-            return Fernet.generate_key().decode()
-
-    @staticmethod
-    def encrypt(data: str, key: str) -> str:
-        """
-        Encrypt the provided data using the provided key.
-
-        Args:
-            data (str): The data to encrypt.
-            key (str): The encryption key.
-
-        Returns:
-            str: The encrypted data.
-
-        Example:
-            >>> encrypt("This is some test data.", "esvCExTuhddRb8kSobU_gnNRYObyTRTI2LJF4nYai5I=")
-            'gAAAAABloX9m_S_G1VUtbfGUDB7ooHJNt8sPiSCwnp1ehe6dExvMEqtw_ua2ELk_uUbLoB6a1XkbKLOkM4UBvwmk6sMoY-yNvE-Lv-w-VNnfzf89zH82rgI='
-        """
-        fernet = Fernet(key.encode())
-        return fernet.encrypt(data.encode()).decode()
-
-    @staticmethod
-    def decrypt(data: str, key: str) -> str:
-        """
-        Decrypt the provided data using the provided key.
-
-        Args:
-            data (str): The data to decrypt.
-            key (str): The encryption key.
-
-        Returns:
-            str: The decrypted data.
-
-        Example:
-            >>> decrypt('gAAAAABloX9m_S_G1VUtbfGUDB7ooHJNt8sPiSCwnp1ehe6dExvMEqtw_ua2ELk_uUbLoB6a1XkbKLOkM4UBvwmk6sMoY-yNvE-Lv-w-VNnfzf89zH82rgI=', "esvCExTuhddRb8kSobU_gnNRYObyTRTI2LJF4nYai5I=")
-            'This is some test data.'
-        """
-        fernet = Fernet(key.encode())
-        return fernet.decrypt(data.encode()).decode()
-
-    @staticmethod
-    def encrypt_file(file_path: str, key: str, output_path: str = None):
-        """
-        Encrypt a file.
-
-        Args:
-            file_path (str): The path of the file to encrypt.
-            key (str): The encryption key.
-            output_path (str, optional): The path to save the encrypted file. If not provided, '.enc' is appended to the input file path.
-
-        Example:
-            >>> encrypt_file("test_file.txt", "esvCExTuhddRb8kSobU_gnNRYObyTRTI2LJF4nYai5I=")
-        """
-        if not output_path:
-            output_path = file_path + '.enc'
-        with open(file_path, 'rb') as file_to_encrypt:
-            encrypted_data = EncrytionUtil.encrypt(file_to_encrypt.read().decode(), key)
-        with open(output_path, 'wb') as encrypted_file:
-            encrypted_file.write(encrypted_data.encode())
-
-    @staticmethod
-    def decrypt_file(encrypted_file_path: str, key: str, output_path: str = None):
-        """
-        Decrypt a file.
-
-        Args:
-            encrypted_file_path (str): The path of the file to decrypt.
-            key (str): The encryption key.
-            output_path (str, optional): The path to save the decrypted file. If not provided, '.enc' is removed from the input file path.
-
-        Example:
-            >>> decrypt_file("test_file.txt.enc", "esvCExTuhddRb8kSobU_gnNRYObyTRTI2LJF4nYai5I=")
-        """
-        if not output_path:
-            output_path = encrypted_file_path.replace('.enc', '')
-        with open(encrypted_file_path, 'rb') as encrypted_file:
-            decrypted_data = EncrytionUtil.decrypt(encrypted_file.read().decode(), key)
-        with open(output_path, 'wb') as decrypted_file:
-            decrypted_file.write(decrypted_data.encode())
-
-    @staticmethod
-    def is_encrypted(file_path: str, key: str) -> bool:
-        """
-        Check if a file is encrypted.
-
-        Args:
-            file_path (str): The path of the file to check.
-            key (str): The encryption key.
-
-        Returns:
-            bool: True if the file is encrypted, False otherwise.
-
-        Example:
-            >>> is_encrypted("test_file.txt.enc", "esvCExTuhddRb8kSobU_gnNRYObyTRTI2LJF4nYai5I=")
-            True
-        """
-        try:
-            EncrytionUtil.decrypt_file(file_path, key, "temp_decrypted_file")
-            os.remove("temp_decrypted_file")
-            return True
-        except InvalidToken:
-            return False
-
-    @staticmethod
-    def decompress_file(file_path: str, output_path: str = None):
-        """
-        Decompress a file.
-
-        Args:
-            file_path (str): The path of the file to decompress.
-            output_path (str, optional): The path to save the decompressed file. If not provided, the file is decompressed in the same directory.
-
-        Example:
-            >>> decompress_file("test_file.txt.zip")
-        """
-        if not output_path:
-            output_path = os.path.dirname(file_path)
-        with zipfile.ZipFile(file_path, 'r') as zipf:
-            zipf.extractall(output_path)
-
-    @staticmethod
-    def compress_file(file_path: str, output_path: str = None):
-        """
-        Compress a file.
-
-        Args:
-            file_path (str): The path of the file to compress.
-            output_path (str, optional): The path to save the compressed file. If not provided, '.zip' is appended to the input file path.
-
-        Example:
-            >>> compress_file("test_file.txt")
-        """
-        if not output_path:
-            output_path = file_path + '.zip'
-        with zipfile.ZipFile(output_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
-            zipf.write(file_path)
-
-    @staticmethod
-    def binary_to_hex(data: bytes) -> str:
-        """
-        Convert binary data to a hexadecimal string representation.
-        
-        Args:
-            data: A bytes object containing binary data.
-
-        Returns:
-            A string containing the hexadecimal representation of the binary data.
-
-        Examples:
-            >>> binary_to_hex(b'\x00\x0F')
-            '000f'
-            >>> binary_to_hex(b'hello')
-            '68656c6c6f'
-        """
-        return binascii.hexlify(data).decode()
-
-    @staticmethod
-    def create_hash(data: str, algorithm: str = 'sha256') -> str:
-        """
-        Create a hash of the given data using the specified algorithm.
-
-        Args:
-            data: The string to hash.
-            algorithm: The hashing algorithm to use (default is 'sha256').
-
-        Returns:
-            The hexadecimal digest of the hash.
-
-        Examples:
-            >>> create_hash('hello')
-            '2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824'
-        """
-        hasher = hashlib.new(algorithm)
-        hasher.update(data.encode())
-        return hasher.hexdigest()
-
-    @staticmethod
-    def decode_base64(data: str) -> str:
-        """
-        Decode a base64 encoded string.
-
-        Args:
-            data: A base64 encoded string.
-
-        Returns:
-            A decoded string.
-
-        Examples:
-            >>> decode_base64('SGVsbG8sIFdvcmxkIQ==')
-            'Hello, World!'
-        """
-        return base64.b64decode(data).decode()
-
-    @staticmethod
-    def encode_base64(data: str) -> str:
-        """
-        Encode a string using base64 encoding.
-
-        Args:
-            data: A string to be encoded.
-
-        Returns:
-            A base64 encoded string.
-
-        Examples:
-            >>> encode_base64("Hello, World!")
-            'SGVsbG8sIFdvcmxkIQ=='
-        """
-        return base64.b64encode(data.encode()).decode()