lionagi 0.0.312__py3-none-any.whl → 0.2.1__py3-none-any.whl

lionagi/tests/test_core/test_base_branch.py

@@ -1,427 +0,0 @@
-# from lionagi.core.branch.base_branch import BaseBranch
-# from lionagi.core.branch.util import MessageUtil
-# from lionagi.core.messages.schema import System
-# from lionagi.core.schema import DataLogger
-
-
-# import unittest
-# from unittest.mock import patch, MagicMock
-# import pandas as pd
-# from datetime import datetime
-# import json
-
-
-# class TestBaseBranch(unittest.TestCase):
-
-#     def setUp(self):
-#         # Patching DataLogger to avoid filesystem interactions during tests
-#         self.patcher = patch(
-#             "lionagi.core.branch.base_branch.DataLogger", autospec=True
-#         )
-#         self.MockDataLogger = self.patcher.start()
-#         self.addCleanup(self.patcher.stop)
-
-#         self.branch = BaseBranch()
-#         # Example messages to populate the DataFrame for testing
-#         self.test_messages = [
-#             {
-#                 "node_id": "1",
-#                 "timestamp": "2021-01-01 00:00:00",
-#                 "role": "system",
-#                 "sender": "system",
-#                 "content": json.dumps({"system_info": "System message"}),
-#             },
-#             {
-#                 "node_id": "2",
-#                 "timestamp": "2021-01-01 00:01:00",
-#                 "role": "user",
-#                 "sender": "user1",
-#                 "content": json.dumps({"instruction": "User message"}),
-#             },
-#             {
-#                 "node_id": "3",
-#                 "timestamp": "2021-01-01 00:02:00",
-#                 "role": "assistant",
-#                 "sender": "assistant",
-#                 "content": json.dumps({"response": "Assistant response"}),
-#             },
-#             {
-#                 "node_id": "4",
-#                 "timestamp": "2021-01-01 00:03:00",
-#                 "role": "assistant",
-#                 "sender": "action_request",
-#                 "content": json.dumps({"action_request": "Action request"}),
-#             },
-#             {
-#                 "node_id": "5",
-#                 "timestamp": "2021-01-01 00:04:00",
-#                 "role": "assistant",
-#                 "sender": "action_response",
-#                 "content": json.dumps({"action_response": "Action response"}),
-#             },
-#         ]
-#         self.branch = BaseBranch(messages=pd.DataFrame(self.test_messages))
-
-#     def test_init_with_empty_messages(self):
-#         """Test __init__ method with no messages provided."""
-#         branch = BaseBranch()
-#         self.assertTrue(branch.messages.empty)
-
-#     def test_init_with_given_messages(self):
-#         """Test __init__ method with provided messages DataFrame."""
-#         messages = pd.DataFrame(
-#             [
-#                 [
-#                     "0",
-#                     datetime(2024, 1, 1),
-#                     "system",
-#                     "system",
-#                     json.dumps({"system_info": "Hi"}),
-#                 ]
-#             ],
-#             columns=["node_id", "timestamp", "role", "sender", "content"],
-#         )
-#         branch = BaseBranch(messages=messages)
-#         self.assertFalse(branch.messages.empty)
-
-#     def test_add_message(self):
-#         """Test adding a message."""
-#         message_info = {"info": "Test Message"}
-#         with patch.object(
-#             MessageUtil, "create_message", return_value=System(system=message_info)
-#         ) as mocked_create_message:
-#             self.branch.add_message(system=message_info)
-#             mocked_create_message.assert_called_once()
-#             self.assertEqual(len(self.branch.messages), 6)
-
-#     def test_chat_messages_without_sender(self):
-#         """Test chat_messages property without including sender information."""
-#         chat_messages = self.branch.chat_messages
-#         self.assertEqual(len(chat_messages), 5)
-#         self.assertNotIn("Sender", chat_messages[0]["content"])
-
-#     def test_chat_messages_with_sender(self):
-#         """Test retrieving chat messages with sender information included."""
-#         chat_messages_with_sender = self.branch.chat_messages_with_sender
-#         expected_prefixes = [
-#             "Sender system: ",
-#             "Sender user1: ",
-#             "Sender assistant: ",
-#             "Sender action_request: ",
-#             "Sender action_response: ",
-#         ]
-
-#         # Verify the number of messages returned matches the number added
-#         self.assertEqual(len(chat_messages_with_sender), len(self.test_messages))
-
-#         # Check each message for correct sender prefix in content
-#         for i, message_dict in enumerate(chat_messages_with_sender):
-#             self.assertTrue(
-#                 message_dict["content"].startswith(expected_prefixes[i]),
-#                 msg=f"Message content does not start with expected sender prefix. Found: {message_dict['content']}",
-#             )
-
-#         # Optionally, verify the content matches after removing the prefix
-#         for i, message_dict in enumerate(chat_messages_with_sender):
-#             prefix, content = message_dict["content"].split(": ", 1)
-#             self.assertEqual(
-#                 content,
-#                 self.test_messages[i]["content"],
-#                 msg=f"Message content does not match after removing sender prefix. Found: {content}, Expected: {self.test_messages[i]['content']}",
-#             )
-
-#     def test_last_message(self):
-#         """Test retrieving the last message."""
-#         last_message = self.branch.last_message
-#         self.assertEqual(
-#             json.loads(last_message.iloc[0]["content"]),
-#             {"action_response": "Action response"},
-#         )
-
-#     def test_last_message_content(self):
-#         """Test retrieving the content of the last message."""
-#         content = self.branch.last_message_content
-#         self.assertEqual(content, {"action_response": "Action response"})
-
-#     def test_first_system_message(self):
-#         """Test retrieving the first 'system' message."""
-#         first_system_message = self.branch.first_system
-#         self.assertEqual(
-#             json.loads(first_system_message.iloc[0]["content"]),
-#             {"system_info": "System message"},
-#         )
-
-#     def test_last_response(self):
-#         """Test retrieving the last 'assistant' message."""
-#         last_response = self.branch.last_response
-#         self.assertEqual(last_response.iloc[0]["sender"], "action_response")
-
-#     def test_last_response_content(self):
-#         """Test extracting content of the last 'assistant' message."""
-#         content = self.branch.last_response_content
-#         self.assertEqual(content, {"action_response": "Action response"})
-
-#     def test_action_request_messages(self):
-#         """Test filtering messages sent by 'action_request'."""
-#         action_requests = self.branch.action_request
-#         self.assertTrue(all(action_requests["sender"] == "action_request"))
-
-#     def test_action_response_messages(self):
-#         """Test filtering messages sent by 'action_response'."""
-#         action_responses = self.branch.action_response
-#         self.assertTrue(all(action_responses["sender"] == "action_response"))
-
-#     def test_responses(self):
-#         """Test filtering of 'assistant' role messages."""
-#         responses = self.branch.responses
-#         # Verify that all returned messages have the 'assistant' role
-#         self.assertTrue(all(responses["role"] == "assistant"))
-#         # Optionally, check the count matches the expected number of 'assistant' messages
-#         expected_count = sum(
-#             1 for msg in self.test_messages if msg["role"] == "assistant"
-#         )
-#         self.assertEqual(len(responses), expected_count)
-
-#     def test_assistant_responses(self):
-#         """Test filtering of 'assistant' messages excluding action requests/responses."""
-#         assistant_responses = self.branch.assistant_responses
-#         # Verify that no returned messages are from 'action_request' or 'action_response' senders
-#         self.assertTrue(all(assistant_responses["sender"] != "action_request"))
-#         self.assertTrue(all(assistant_responses["sender"] != "action_response"))
-#         # Verify that all returned messages have the 'assistant' role
-#         self.assertTrue(all(assistant_responses["role"] == "assistant"))
-
-#     def test_info(self):
-#         """Test summarization of message counts by role."""
-#         info = self.branch.info
-#         # Verify that the dictionary contains keys for each role and 'total'
-#         self.assertIn("assistant", info)
-#         self.assertIn("user", info)
-#         self.assertIn("system", info)
-#         self.assertIn("total", info)
-#         # Optionally, verify the counts match expected values
-#         for role in ["assistant", "user", "system"]:
-#             expected_count = sum(1 for msg in self.test_messages if msg["role"] == role)
-#             self.assertEqual(info[role], expected_count)
-#         self.assertEqual(info["total"], len(self.test_messages))
-
-#     def test_sender_info(self):
-#         """Test summarization of message counts by sender."""
-#         sender_info = self.branch.sender_info
-#         # Verify that the dictionary contains keys for each sender and the counts match
-#         for sender in set(msg["sender"] for msg in self.test_messages):
-#             expected_count = sum(
-#                 1 for msg in self.test_messages if msg["sender"] == sender
-#             )
-#             self.assertEqual(sender_info.get(sender, 0), expected_count)
-
-#     def test_describe(self):
-#         """Test detailed description of the branch."""
-#         description = self.branch.describe
-#         # Verify that the description contains expected keys
-#         self.assertIn("total_messages", description)
-#         self.assertIn("summary_by_role", description)
-#         self.assertIn("messages", description)
-#         # Optionally, verify the accuracy of the values
-#         self.assertEqual(description["total_messages"], len(self.test_messages))
-#         self.assertEqual(len(description["messages"]), min(5, len(self.test_messages)))
-
-#     @patch("lionagi.libs.ln_dataframe.read_csv")
-#     def test_from_csv(cls, mock_read_csv):
-#         # Define a mock return value for read_csv
-#         mock_messages_df = pd.DataFrame(
-#             {
-#                 "node_id": ["1", "2"],
-#                 "timestamp": [datetime(2021, 1, 1), datetime(2021, 1, 1)],
-#                 "role": ["system", "user"],
-#                 "sender": ["system", "user1"],
-#                 "content": [
-#                     json.dumps({"system_info": "System message"}),
-#                     json.dumps({"instruction": "User message"}),
-#                 ],
-#             }
-#         )
-#         mock_read_csv.return_value = mock_messages_df
-
-#         # Call the from_csv class method
-#         branch = BaseBranch.from_csv(filename="dummy.csv")
-
-#         # Verify that read_csv was called correctly
-#         mock_read_csv.assert_called_once_with("dummy.csv")
-
-#         # Verify that the branch instance contains the correct messages
-#         pd.testing.assert_frame_equal(branch.messages, mock_messages_df)
-
-#     @patch("lionagi.libs.ln_dataframe.read_json")
-#     def test_from_json(cls, mock_read_csv):
-#         # Define a mock return value for read_csv
-#         mock_messages_df = pd.DataFrame(
-#             {
-#                 "node_id": ["1", "2"],
-#                 "timestamp": [datetime(2021, 1, 1), datetime(2021, 1, 1)],
-#                 "role": ["system", "user"],
-#                 "sender": ["system", "user1"],
-#                 "content": [
-#                     json.dumps({"system_info": "System message"}),
-#                     json.dumps({"instruction": "User message"}),
-#                 ],
-#             }
-#         )
-#         mock_read_csv.return_value = mock_messages_df
-
-#         # Call the from_csv class method
-#         branch = BaseBranch.from_json_string(filename="dummy.json")
-
-#         # Verify that read_csv was called correctly
-#         mock_read_csv.assert_called_once_with("dummy.json")
-
-#         # Verify that the branch instance contains the correct messages
-#         pd.testing.assert_frame_equal(branch.messages, mock_messages_df)
-
-#     @patch(
-#         "lionagi.libs.sys_util.SysUtil.create_path",
-#         return_value="path/to/messages.csv",
-#     )
-#     @patch.object(pd.DataFrame, "to_csv")
-#     def test_to_csv(self, mock_to_csv, mock_create_path):
-#         self.branch.datalogger = MagicMock()
-#         self.branch.datalogger.persist_path = "data/logs/"
-
-#         self.branch.to_csv_file("messages.csv", verbose=False, clear=False)
-
-#         mock_create_path.assert_called_once_with(
-#             self.branch.datalogger.persist_path,
-#             "messages.csv",
-#             timestamp=True,
-#             dir_exist_ok=True,
-#             time_prefix=False,
-#         )
-#         mock_to_csv.assert_called_once_with("path/to/messages.csv")
-
-#         # Verify that messages are not cleared after exporting
-#         assert not self.branch.messages.empty
-
-#     @patch(
-#         "lionagi.libs.sys_util.SysUtil.create_path",
-#         return_value="path/to/messages.json",
-#     )
-#     @patch.object(pd.DataFrame, "to_json")
-#     def test_to_json(self, mock_to_json, mock_create_path):
-#         self.branch.datalogger = MagicMock()
-#         self.branch.datalogger.persist_path = "data/logs/"
-
-#         self.branch.to_json_file("messages.json", verbose=False, clear=False)
-
-#         mock_create_path.assert_called_once_with(
-#             self.branch.datalogger.persist_path,
-#             "messages.json",
-#             timestamp=True,
-#             dir_exist_ok=True,
-#             time_prefix=False,
-#         )
-#         mock_to_json.assert_called_once_with(
-#             "path/to/messages.json", orient="records", lines=True, date_format="iso"
-#         )
-
-#         # Verify that messages are not cleared after exporting
-#         assert not self.branch.messages.empty
-
-#     # def test_log_to_csv(self):
-#     #     self.branch.log_to_csv('log.csv', verbose=False, clear=False)
-
-#     #     self.branch.datalogger.to_csv_file.assert_called_once_with(filename='log.csv', dir_exist_ok=True, timestamp=True,
-#     #                                             time_prefix=False, verbose=False, clear=False)
-
-#     # def test_log_to_json(self):
-#     #     branch = BaseBranch()
-#     #     branch.log_to_json('log.json', verbose=False, clear=False)
-
-#     #     self.branch.datalogger.to_json_file.assert_called_once_with(filename='log.json', dir_exist_ok=True, timestamp=True,
-#     #                                              time_prefix=False, verbose=False, clear=False)
-
-#     def test_remove_message(self):
-#         """Test removing a message from the branch based on its node ID."""
-#         initial_length = len(self.branch.messages)
-#         node_id_to_remove = "2"
-#         self.branch.remove_message(node_id_to_remove)
-#         final_length = len(self.branch.messages)
-#         self.assertNotIn(node_id_to_remove, self.branch.messages["node_id"].tolist())
-#         self.assertEqual(final_length, initial_length - 1)
-
-#     def test_update_message(self):
-#         """Test updating a specific message's column identified by node_id with a new value."""
-#         node_id_to_update = "2"
-#         new_value = "Updated content"
-#         self.branch.update_message(node_id_to_update, "content", new_value)
-#         updated_value = self.branch.messages.loc[
-#             self.branch.messages["node_id"] == node_id_to_update, "content"
-#         ].values[0]
-#         self.assertEqual(updated_value, new_value)
-
-#     # def test_change_first_system_message(self):
-#     #     """Test updating the first system message with new content and/or sender."""
-#     #     new_system_content = {"system_info": "Updated system message"}
-#     #     self.branch.change_first_system_message(new_system_content['system_info'])
-#     #     first_system_message_content = self.branch.messages.loc[self.branch.messages['role'] == 'system', 'content'].iloc[0]
-#     #     self.assertIn(json.dumps({"system_info": "Updated system message"}), first_system_message_content)
-
-#     def test_rollback(self):
-#         """Test removing the last 'n' messages from the branch."""
-#         steps_to_remove = 2
-#         initial_length = len(self.branch.messages)
-#         self.branch.rollback(steps_to_remove)
-#         final_length = len(self.branch.messages)
-#         self.assertEqual(final_length, initial_length - steps_to_remove)
-
-#     def test_clear_messages(self):
-#         """Test clearing all messages from the branch."""
-#         self.branch.clear_messages()
-#         self.assertTrue(self.branch.messages.empty)
-
-#     def test_replace_keyword(self):
-#         """Test replacing occurrences of a specified keyword with a replacement string."""
-#         keyword = "Assistant response"
-#         replacement = "Helper feedback"
-#         self.branch.replace_keyword(keyword, replacement)
-#         self.assertTrue(
-#             any(replacement in message for message in self.branch.messages["content"])
-#         )
-
-#     def test_search_keywords(self):
-#         """Test filtering messages by a specified keyword or list of keywords."""
-#         keyword_to_search = "Assistant"
-#         filtered_messages = self.branch.search_keywords(keyword_to_search)
-#         self.assertTrue(
-#             all(
-#                 keyword_to_search in content for content in filtered_messages["content"]
-#             )
-#         )
-
-#     def test_extend(self):
-#         """Test extending branch messages with additional messages."""
-#         additional_messages = pd.DataFrame(
-#             [
-#                 {
-#                     "node_id": "6",
-#                     "timestamp": datetime(2021, 1, 1),
-#                     "role": "user",
-#                     "sender": "user2",
-#                     "content": json.dumps({"instruction": "Another user message"}),
-#                 }
-#             ]
-#         )
-#         initial_length = len(self.branch.messages)
-#         self.branch.extend(additional_messages)
-#         self.assertEqual(len(self.branch.messages), initial_length + 1)
-
-#     def test_filter_by(self):
-#         """Test filtering messages by various criteria."""
-#         # Filtering by role
-#         filtered_messages = self.branch.filter_by(role="user")
-#         self.assertTrue(
-#             all(msg["role"] == "user" for _, msg in filtered_messages.iterrows())
-#         )
-
-
-# if __name__ == "__main__":
-#     unittest.main()

lionagi/tests/test_core/test_chat_flow.py

@@ -1,63 +0,0 @@
-# from lionagi.core.flow.monoflow import
-# from lionagi.core.session.branch import Branch
-# from lionagi.core.action.libs import func_to_tool
-
-# import unittest
-# from unittest import IsolatedAsyncioTestCase
-# from unittest.mock import patch, MagicMock, AsyncMock
-
-
-# class TestChatFlowCallChatCompletion(IsolatedAsyncioTestCase):
-#     async def asyncSetUp(self):
-#         self.branch = MagicMock()
-#         self.branch.service = MagicMock()
-#         self.branch.datalogger = MagicMock()
-#         self.branch.status_tracker = MagicMock(num_tasks_succeeded=0, num_tasks_failed=0)
-#         self.branch.add_message = MagicMock()
-
-#         # Mock chat completion service response
-#         self.branch.service.serve_chat = AsyncMock(return_value=({}, {"choices": [{'messages':{"content": "test response"}}]}))
-
-#     async def test_call_chatcompletion(self):
-#         await ChatFlow.call_chatcompletion(self.branch, sender="user")
-
-#         # Verify serve_chat was called with expected arguments
-#         self.branch.service.serve_chat.assert_called_once()
-
-#         # Verify the branch's datalogger and add_message were called appropriately
-#         self.branch.datalogger.append.assert_called_once()
-#         self.branch.add_message.assert_called_with(response={'messages': {'content': 'test response'}}, sender="user")
-
-#         # Verify status tracker update
-#         self.assertEqual(self.branch.status_tracker.num_tasks_succeeded, 1)
-#         self.assertEqual(self.branch.status_tracker.num_tasks_failed, 0)
-
-
-# class TestChatFlowChat(IsolatedAsyncioTestCase):
-
-#     async def asyncSetUp(self):
-#         self.branch = MagicMock()
-#         self.branch.add_message = MagicMock()
-#         self.branch.change_first_system_message = MagicMock()
-#         self.branch.service = AsyncMock()
-#         self.branch.datalogger = MagicMock()
-#         self.branch.call_chatcompletion = AsyncMock()
-#         self.branch.tool_manager.invoke = AsyncMock()
-
-#         self.branch.service.serve_chat = AsyncMock(
-#             return_value=({}, {"choices": [{'messages': {"content": "test response"}}]}))
-
-#     async def test_chat_with_system_and_instruction(self):
-#         instruction = "Ask about user preferences"
-#         system = "System ready"
-#         sender = "user"
-
-#         await ChatFlow.chat(self.branch, instruction=instruction, sender=sender)
-
-#         self.branch.add_message.assert_called_with(instruction=instruction, context=None, sender=sender)
-
-#         self.branch.call_chatcompletion.assert_called_once()
-
-
-# if __name__ == '__main__':
-#     unittest.main()

lionagi/tests/test_core/test_mail_manager.py

@@ -1,75 +0,0 @@
-# from lionagi.core.mail.mail_manager import MailManager
-# from lionagi.core.mail.schema import BaseMail
-
-# import unittest
-# from unittest.mock import patch
-# from collections import deque
-
-
-# class MockSource:
-#     def __init__(self):
-#         self.pending_outs = deque()
-#         self.pending_ins = {}
-
-
-# class TestMailManager(unittest.TestCase):
-
-#     def setUp(self):
-#         self.sources = {"source1": MockSource(), "source2": MockSource()}
-#         self.manager = MailManager(sources=self.sources)
-
-#     def test_add_source(self):
-#         """Test adding a new source."""
-#         self.manager.add_source({"new_source": MockSource()})
-#         self.assertIn("new_source", self.manager.sources)
-
-#     def test_add_source_existing_name(self):
-#         """Test adding a source with an existing name raises ValueError."""
-#         with self.assertRaises(ValueError):
-#             self.manager.add_source({"source1": MockSource()})
-
-#     def test_delete_source(self):
-#         """Test deleting an existing source."""
-#         self.manager.delete_source("source1")
-#         self.assertNotIn("source1", self.manager.sources)
-
-#     def test_delete_nonexistent_source(self):
-#         """Test deleting a non-existent source raises ValueError."""
-#         with self.assertRaises(ValueError):
-#             self.manager.delete_source("nonexistent_source")
-
-#     def test_collect_from_nonexistent_sender(self):
-#         """Test collecting mail from a non-existent sender raises ValueError."""
-#         with self.assertRaises(ValueError):
-#             self.manager.collect("nonexistent_sender")
-
-#     def test_send_to_nonexistent_recipient(self):
-#         """Test sending mail to a non-existent recipient raises ValueError."""
-#         with self.assertRaises(ValueError):
-#             self.manager.send("nonexistent_recipient")
-
-#     @patch("lionagi.core.mail.mail_manager.BaseMail")
-#     def test_create_mail(self, mock_base_mail):
-#         """Test creating mail using the static method."""
-#         mail = MailManager.create_mail("sender", "recipient", "messages", "package")
-#         mock_base_mail.assert_called_once_with(
-#             "sender", "recipient", "messages", "package"
-#         )
-
-#     # def test_collect_and_send_mail(self):
-#     #     """Test collecting and sending mail between existing sources."""
-#     #     # Setup: Simulate pending outs in source1
-#     #     mock_mail = BaseMail("source1", "source2", "messages", "package")
-#     #     self.sources["source1"].pending_outs.append(mock_mail)
-
-#     #     # Collect mail from source1
-#     #     self.manager.collect("source1")
-#     #     # Send mail to source2
-#     #     self.manager.send("source2")
-
-#     #     # Verify that source2 received the mail
-#     #     self.assertTrue(any(self.sources["source2"].pending_ins))
-
-
-# if __name__ == "__main__":
-#     unittest.main()

lionagi/tests/test_core/test_prompts.py

@@ -1,51 +0,0 @@
-# from to_do.base_prompt_field import *
-# from pydantic import ValidationError
-
-# import unittest
-
-
-# class TestPromptField(unittest.TestCase):
-
-#     def test_numeric_field_valid(self):
-#         try:
-#             BasePromptField(name="Age", default="30", field_type=FieldType.NUMERIC)
-#             self.fail(
-#                 "Expected ValidationError not raised for NUMERIC field with non-numeric default value."
-#             )
-#         except ValidationError:
-#             pass  # Expected
-
-#     def test_boolean_field_valid(self):
-#         try:
-#             BasePromptField(
-#                 name="Is Adult", default="True", field_type=FieldType.BOOLEAN
-#             )
-#             self.fail(
-#                 "Expected ValidationError not raised for BOOLEAN field with non-boolean default value."
-#             )
-#         except ValidationError:
-#             pass  # Expected
-
-#     def test_string_field_invalid(self):
-#         try:
-#             BasePromptField(name="Name", default=123, field_type=FieldType.STRING)
-#             self.fail(
-#                 "Expected ValidationError not raised for STRING field with non-string default value."
-#             )
-#         except ValidationError:
-#             pass  # Expected
-
-#     def test_datetime_field_invalid(self):
-#         try:
-#             BasePromptField(name="Date", default=123, field_type=FieldType.DATETIME)
-#             self.fail(
-#                 "Expected ValidationError not raised for DATETIME field with non-datetime-compatible default value."
-#             )
-#         except ValidationError:
-#             pass  # Expected
-
-
-# if __name__ == "__main__":
-#     # unittest.main()
-#     # Running the adjusted tests
-#     unittest.main(argv=[""], exit=False)