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

lionagi/schema/data_logger.py

@@ -1,126 +0,0 @@
-from collections import deque
-from typing import Dict, Any
-from ..utils.sys_util import get_timestamp, create_path, as_dict
-from ..utils.io_util import IOUtil
-
-
-class DataLogger:
-    """
-    A class for logging data entries and exporting them as CSV files.
-
-    This class provides functionality to log data entries in a deque and 
-    supports exporting the logged data to a CSV file. The DataLogger can 
-    be configured to use a specific directory for saving files.
-
-    Attributes:
-        dir (Optional[str]): 
-            The default directory where CSV files will be saved.
-        log (deque): 
-            A deque object that stores the logged data entries.
-
-    Methods:
-        __call__:
-            Adds an entry to the log.
-        to_csv:
-            Exports the logged data to a CSV file and clears the log.
-        set_dir:
-            Sets the default directory for saving CSV files.
-    """    
-
-    def __init__(self, dir= None, log: list = None) -> None:
-        """
-        Initializes the DataLogger with an optional directory and initial log.
-
-        Parameters:
-            dir (Optional[str]): The directory where CSV files will be saved. Defaults to None.
-
-            log (Optional[List]): An initial list of log entries. Defaults to an empty list.
-        """        
-        self.dir = dir
-        self.log = deque(log) if log else deque()
-
-    def add_entry(self, entry: Dict[str, Any], level: str = "INFO") -> None:
-        """
-        Adds a new entry to the log with a timestamp and a log level.
-
-        Args:
-            entry (Dict[str, Any]): The data entry to be added to the log.
-            level (str): The log level for the entry (e.g., "INFO", "ERROR"). Defaults to "INFO".
-        """
-        self.log.append({
-            "timestamp": get_timestamp(), "level": level, **as_dict(entry)
-        })
-        
-    def set_dir(self, dir: str) -> None:
-        """
-        Sets the default directory for saving CSV files.
-
-        Parameters:
-            dir (str): The directory to be set as the default for saving files.
-        """
-        self.dir = dir
-
-    def to_csv(
-        self, filename: str, 
-        file_exist_ok: bool = False,  
-        timestamp = True,
-        time_prefix: bool = False,
-        verbose: bool = True,
-        clear = True
-    ) -> None:
-        """
-        Exports the logged data to a CSV file, using the provided utilities for path creation and timestamping.
-
-        Args:
-            filename (str): The name of the CSV file.
-            file_exist_ok (bool): If True, creates the directory for the file if it does not exist. Defaults to False.
-            verbose (bool): If True, prints a message upon completion. Defaults to True.
-            time_prefix (bool): If True, adds the timestamp as a prefix to the filename. Defaults to False.
-        """
-        if not filename.endswith('.csv'):
-            filename += '.csv'
-        
-        filepath = create_path(
-            self.dir, filename, timestamp=timestamp, 
-            dir_exist_ok=file_exist_ok, time_prefix=time_prefix
-        )
-        IOUtil.to_csv(list(self.log), filepath)
-
-        if verbose:
-            print(f"{len(self.log)} logs saved to {filepath}")
-
-        if clear:
-            self.log.clear()
-
-    def to_jsonl(
-        self, filename: str, 
-        timestamp = False, 
-        time_prefix=False,
-        file_exist_ok: bool = False, 
-        verbose: bool = True, 
-        clear = True
-    ) -> None:
-        """
-        Exports the logged data to a JSONL file and optionally clears the log.
-
-        Parameters:
-            filename (str): The name of the JSONL file.
-            file_exist_ok (bool): If True, creates the directory for the file if it does not exist. Defaults to False.
-            verbose (bool): If True, prints a message upon completion. Defaults to True.
-        """
-        if not filename.endswith('.jsonl'):
-            filename += '.jsonl'
-
-        filepath = create_path(
-            self.dir, filename, timestamp=timestamp, 
-            dir_exist_ok=file_exist_ok, time_prefix=time_prefix
-        )
-        
-        for entry in self.log:
-            IOUtil.append_to_jsonl(entry, filepath)
-
-        if verbose:
-            print(f"{len(self.log)} logs saved to {filepath}")
-
-        if clear:
-            self.log.clear()

lionagi/schema/data_node.py

@@ -1,88 +0,0 @@
-from .base_node import BaseNode
-from typing import Any
-
-
-class DataNode(BaseNode):
-
-    def to_llama_index(self, **kwargs) -> Any:
-        """
-        Converts node to llama index format.
-
-        Args:
-            **kwargs: Variable length argument list.
-
-        Returns:
-            The llama index representation of the node.
-
-        Examples:
-            node = DataNode()
-            llama_index = node.to_llama_index()
-        """
-        from lionagi.bridge.llama_index import to_llama_index_textnode
-        return to_llama_index_textnode(self, **kwargs)
-
-    def to_langchain(self, **kwargs) -> Any:
-        """
-        Converts node to langchain document format.
-
-        Args:
-            **kwargs: Variable length argument list.
-
-        Returns:
-            The langchain document representation of the node.
-
-        Examples:
-            node = DataNode()
-            langchain_doc = node.to_langchain()
-        """
-        from lionagi.bridge.langchain import to_langchain_document
-        return to_langchain_document(self, **kwargs)
-
-    @classmethod
-    def from_llama_index(cls, llama_node: Any, **kwargs) -> "DataNode":
-        """
-        Creates a DataNode instance from a llama index node.
-
-        Args:
-            llama_node: The llama index node object.
-            **kwargs: Variable length argument list.
-
-        Returns:
-            An instance of DataNode.
-
-        Examples:
-            llama_node = SomeLlamaIndexNode()
-            data_node = DataNode.from_llama_index(llama_node)
-        """
-        llama_dict = llama_node.to_dict(**kwargs)
-        return cls.from_dict(llama_dict)
-
-    @classmethod
-    def from_langchain(cls, lc_doc: Any) -> "DataNode":
-        """
-        Creates a DataNode instance from a langchain document.
-
-        Args:
-            lc_doc: The langchain document object.
-
-        Returns:
-            An instance of DataNode.
-
-        Examples:
-            lc_doc = SomeLangChainDocument()
-            data_node = DataNode.from_langchain(lc_doc)
-        """
-        info_json = lc_doc.to_json()
-        info_node = {'lc_id': info_json['id']}
-        info_node = {**info_node, **info_json['kwargs']}
-        return cls(**info_node)
-
-
-class File(DataNode):
-
-    ...
-    
-
-class Chunk(DataNode):
-
-    ...    

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()