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

lionagi/tests/test_core/test_session.py

@@ -1,254 +0,0 @@
-# from lionagi.core.branch.branch import Branch
-# from lionagi.core.session.session import Session
-
-# import unittest
-# from unittest.mock import patch, call, MagicMock
-# import pandas as pd
-# import json
-# from datetime import datetime
-
-
-# class TestSession(unittest.TestCase):
-
-# 	def setUp(self):
-# 		mock_branch = MagicMock()
-
-# 		mock_branch.to_csv_file = MagicMock()
-# 		mock_branch.to_json_file = MagicMock()
-
-# 		mock_datalogger = MagicMock()
-# 		mock_datalogger.to_csv_file = MagicMock()
-# 		mock_datalogger.to_json_file = MagicMock()
-
-# 		# Assign the mocked datalogger to the mock_branch
-# 		mock_branch.datalogger = mock_datalogger
-
-# 		self.branch1 = mock_branch(name="branch1")
-# 		self.branch1.messages = pd.DataFrame(
-# 			[{
-# 				"node_id": "1", "timestamp": "2021-01-01 00:00:00",
-# 				"role": "system", "sender": "system",
-# 				"content": json.dumps({"system_info": "System message"}),
-# 			}]
-# 		)
-# 		self.branch2 = mock_branch(name="branch2")
-# 		self.branch1.messages = pd.DataFrame(
-# 			[{
-# 				"node_id": "2", "timestamp": "2021-01-01 00:01:00",
-# 				"role": "user", "sender": "user1",
-# 				"content": json.dumps({"instruction": "User message"}),
-# 			}]
-# 		)
-
-# 		branches = {"branch1": self.branch1, "branch2": self.branch2}
-
-# 		self.session = Session(
-# 			branches=branches, default_branch_name="branch1",
-# 			default_branch=branches["branch1"], )
-# 		self.session.mail_manager = MagicMock()
-
-# 	# def test_from_csv_initialization(self):
-# 	#     """Test Session initialization from a CSV file."""
-# 	#     mock_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"}),
-# 	#             ],
-# 	#         }
-# 	#     )
-# 	#     filepath = "path/to/mock.csv"
-
-# 	#     with patch("pandas.read_csv", return_value=mock_df) as mock_read_csv:
-# 	#         session = Session.from_csv(filepath)
-# 	#         mock_read_csv.assert_called_once_with(filepath)
-# 	#         pd.testing.assert_frame_equal(session.messages, mock_df)
-
-# 	# def test_from_json_initialization(self):
-# 	#     """Test Session initialization from a CSV file."""
-# 	#     mock_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"}),
-# 	#             ],
-# 	#         }
-# 	#     )
-# 	#     filepath = "path/to/mock.json"
-
-# 	#     with patch("pandas.read_json", return_value=mock_df) as mock_read_json:
-# 	#         session = Session.from_json(filepath)
-# 	#         mock_read_json.assert_called_once_with(filepath)
-# 	#         pd.testing.assert_frame_equal(session.messages, mock_df)
-
-# 	def test_to_csv_file(self):
-# 		"""Ensure to_csv_file calls each branch's to_csv_file method."""
-# 		filename = "test_export.csv"
-# 		self.session.to_csv_file(filename=filename)
-
-# 		for name, branch in self.session.branches.items():
-# 			# Verify it was called twice
-# 			self.assertEqual(branch.to_csv_file.call_count, 2)
-
-# 			# Verify the arguments of the last call
-# 			expected_filename = f"{name}_{filename}"
-# 			self.assertIn(
-# 				expected_filename,
-# 				["branch1_test_export.csv", "branch2_test_export.csv"], )
-
-# 	def test_to_json_file(self):
-# 		"""Ensure to_json_file calls each branch's to_json_file method."""
-# 		filename = "test_export.json"
-# 		self.session.to_json_file(filename=filename)
-
-# 		for name, branch in self.session.branches.items():
-# 			# Verify it was called twice
-# 			self.assertEqual(branch.to_json_file.call_count, 2)
-
-# 			# Verify the arguments of the last call
-# 			expected_filename = f"{name}_{filename}"
-# 			self.assertIn(
-# 				expected_filename,
-# 				["branch1_test_export.json", "branch2_test_export.json"], )
-
-# 	def test_log_to_csv(self):
-# 		"""Ensure log_to_csv calls each branch's log_to_csv method."""
-# 		filename = "test_export.csv"
-# 		self.session.log_to_csv(filename=filename)
-
-# 		for name, branch in self.session.branches.items():
-# 			# Verify it was called twice
-# 			self.assertEqual(branch.log_to_csv.call_count, 2)
-
-# 			# Verify the arguments of the last call
-# 			expected_filename = f"{name}_{filename}"
-# 			self.assertIn(
-# 				expected_filename,
-# 				["branch1_test_export.csv", "branch2_test_export.csv"], )
-
-# 	def test_log_to_json(self):
-# 		"""Ensure log_to_json calls each branch's log_to_json method."""
-# 		filename = "test_export.json"
-# 		self.session.log_to_json(filename=filename)
-
-# 		for name, branch in self.session.branches.items():
-# 			# Verify it was called twice
-# 			self.assertEqual(branch.log_to_json.call_count, 2)
-
-# 			# Verify the arguments of the last call
-# 			expected_filename = f"{name}_{filename}"
-# 			self.assertIn(
-# 				expected_filename,
-# 				["branch1_test_export.json", "branch2_test_export.json"], )
-
-# 	def test_all_messages(self):
-# 		"""Test aggregation of all messages across branches."""
-# 		expected_df = pd.concat(
-# 			[self.branch1.messages, self.branch2.messages], ignore_index=True
-# 		)
-
-# 		actual_df = self.session.all_messages
-
-# 		pd.testing.assert_frame_equal(actual_df, expected_df)
-
-# 	def test_new_branch_creation(self):
-# 		"""Test creating a new branch successfully."""
-# 		branch_name = "test_branch"
-# 		self.session.new_branch(branch_name=branch_name)
-# 		self.assertIn(branch_name, self.session.branches)
-
-# 	def test_new_branch_duplicate_name(self):
-# 		"""Test error handling for duplicate branch names."""
-# 		branch_name = "test_branch"
-# 		self.session.new_branch(branch_name=branch_name)
-# 		with self.assertRaises(ValueError):
-# 			self.session.new_branch(branch_name=branch_name)
-
-# 	def test_get_branch_by_name(self):
-# 		"""Test retrieving a branch by its name."""
-# 		branch_name = "test_branch"
-# 		self.session.new_branch(branch_name=branch_name)
-# 		branch = self.session.get_branch(branch_name)
-# 		self.assertIsInstance(branch, Branch)
-
-# 	def test_get_branch_invalid_name(self):
-# 		"""Test error handling for invalid branch names."""
-# 		with self.assertRaises(ValueError):
-# 			self.session.get_branch("nonexistent_branch")
-
-# 	def test_change_default_branch(self):
-# 		"""Test changing the default branch."""
-# 		branch_name = "new_default"
-# 		self.session.new_branch(branch_name=branch_name)
-# 		self.session.change_default_branch(branch_name)
-# 		self.assertEqual(self.session.default_branch_name, branch_name)
-
-# 	def test_delete_branch(self):
-# 		"""Test deleting a branch."""
-# 		branch_name = "test_branch"
-# 		self.session.new_branch(branch_name=branch_name)
-# 		self.session.delete_branch(branch_name)
-# 		self.assertNotIn(branch_name, self.session.branches)
-
-# 	def test_delete_default_branch_error(self):
-# 		"""Test error when trying to delete the default branch."""
-# 		with self.assertRaises(ValueError):
-# 			self.session.delete_branch(self.session.default_branch_name)
-
-# 	def test_merge_branch(self):
-# 		"""Test merging two branches."""
-# 		from_branch = "source_branch"
-# 		to_branch = "target_branch"
-# 		self.session.new_branch(branch_name=from_branch)
-# 		self.session.new_branch(branch_name=to_branch)
-# 		self.session.merge_branch(
-# 			from_=from_branch, to_branch=to_branch, del_=True
-# 			)
-# 		self.assertIn(to_branch, self.session.branches)
-# 		self.assertNotIn(from_branch, self.session.branches)
-
-# 	def test_collect_from_specified_branches(self):
-# 		"""Test collecting requests from specified branches."""
-# 		self.session.collect(from_=["branch1"])
-# 		self.assertEqual(self.session.mail_manager.collect.call_count, 1)
-
-# 	def test_collect_from_all_branches(self):
-# 		"""Test collecting requests from all branches."""
-# 		self.session.collect()
-# 		self.assertEqual(self.session.mail_manager.collect.call_count, 2)
-
-# 	def test_send_to_specified_branches(self):
-# 		"""Test sending requests to specified branches."""
-# 		self.session.send(to_=["branch_1"])
-# 		self.assertEqual(self.session.mail_manager.send.call_count, 1)
-
-# 	def test_send_to_all_branches(self):
-# 		"""Test sending requests to all branches."""
-# 		self.session.send()
-# 		self.assertEqual(self.session.mail_manager.send.call_count, 2)
-
-# 	def test_collect_send_all_without_receive_all(self):
-# 		"""Test collecting and sending requests across all branches without receiving."""
-# 		self.session.collect_send_all()
-# 		self.assertEqual(self.session.mail_manager.collect.call_count, 2)
-# 		self.assertEqual(self.session.mail_manager.send.call_count, 2)
-# 		self.branch1.receive_all.assert_not_called()
-# 		self.branch2.receive_all.assert_not_called()
-
-# 	def test_collect_send_all_with_receive_all(self):
-# 		"""Test collecting and sending requests across all branches with receiving."""
-# 		self.session.collect_send_all(receive_all=True)
-# 		self.branch1.receive_all.assert_called()
-# 		self.branch2.receive_all.assert_called()
-
-
-# if __name__ == "__main__":
-# 	unittest.main()

lionagi/tests/test_core/test_session_base_util.py

@@ -1,312 +0,0 @@
-# from lionagi.core.branch.util import MessageUtil
-# from lionagi.core.messages.schema import System, Instruction, Response
-
-# import unittest
-# import pandas as pd
-# import json
-# from datetime import datetime
-
-
-# class TestCreateMessage(unittest.TestCase):
-
-# 	def test_create_system_message(self):
-# 		"""Test creating a System message."""
-# 		system_info = {"system_info": "System information"}
-# 		message = MessageUtil.create_message(
-# 			system=system_info["system_info"]
-# 			)
-# 		self.assertIsInstance(message, System)
-# 		self.assertEqual(message.content, system_info)
-
-# 	def test_create_instruction_message(self):
-# 		"""Test creating an Instruction message with context."""
-# 		instruction_info = {"task": "Do something"}
-# 		context = {"additional": "context"}
-# 		message = MessageUtil.create_message(
-# 			instruction=instruction_info, context=context
-# 		)
-# 		self.assertIsInstance(message, Instruction)
-# 		self.assertEqual(message.content["instruction"], instruction_info)
-# 		self.assertEqual(message.content["context"], context)
-
-# 	def test_create_response_message(self):
-# 		"""Test creating a Response message."""
-# 		response_info = {"message": {"content": "This is a response"}}
-# 		message = MessageUtil.create_message(response=response_info)
-# 		self.assertIsInstance(message, Response)
-# 		self.assertEqual(
-# 			message.content["response"], response_info["message"]["content"]
-# 		)
-
-# 	def test_error_on_multiple_roles(self):
-# 		"""Test error is raised when multiple roles are provided."""
-# 		with self.assertRaises(ValueError):
-# 			MessageUtil.create_message(
-# 				system={"info": "info"}, instruction={"task": "task"}
-# 			)
-
-# 	def test_return_existing_base_message_instance(self):
-# 		"""Test returning an existing BaseMessage instance if provided."""
-# 		existing_message = System(system={"info": "Already created"})
-# 		message = MessageUtil.create_message(system=existing_message)
-# 		self.assertEqual(message.content, existing_message.content)
-
-
-# class TestValidateMessages(unittest.TestCase):
-
-# 	# def test_validate_messages_correct_format(self):
-# 	#     """Test messages DataFrame with the correct format."""
-# 	#     messages = pd.DataFrame({
-# 	#         "node_id": ["1"],
-# 	#         "role": ["user"],
-# 	#         "sender": ["test"],
-# 	#         "timestamp": ["2020-01-01T00:00:00"],
-# 	#         "content": ['{"message": "test"}']
-# 	#     })
-# 	#     self.assertTrue(MessageUtil.validate_messages(messages))
-
-# 	def test_validate_messages_incorrect_columns(self):
-# 		"""Test messages DataFrame with incorrect columns raises ValueError."""
-# 		messages = pd.DataFrame(
-# 			{
-# 				"id": ["1"], "type": ["user"], "source": ["test"],
-# 				"time": ["2020-01-01T00:00:00"],
-# 				"data": ['{"message": "test"}'],
-# 			}
-# 		)
-# 		with self.assertRaises(ValueError):
-# 			MessageUtil.validate_messages(messages)
-
-# 	def test_validate_messages_null_values(self):
-# 		"""Test messages DataFrame with null values raises ValueError."""
-# 		messages = pd.DataFrame(
-# 			{
-# 				"node_id": [None], "role": ["user"], "sender": ["test"],
-# 				"timestamp": ["2020-01-01T00:00:00"],
-# 				"content": ['{"message": "test"}'],
-# 			}
-# 		)
-# 		with self.assertRaises(ValueError):
-# 			MessageUtil.validate_messages(messages)
-
-
-# class TestSignMessage(unittest.TestCase):
-
-# 	def test_sign_message(self):
-# 		"""Test signing message content with sender."""
-# 		messages = pd.DataFrame(
-# 			{
-# 				"node_id": ["1"], "role": ["user"], "sender": ["test"],
-# 				"timestamp": ["2020-01-01T00:00:00"],
-# 				"content": ["Original message"],
-# 			}
-# 		)
-# 		sender = "system"
-# 		signed_messages = MessageUtil.sign_message(messages, sender)
-# 		expected_content = "Sender system: Original message"
-# 		self.assertEqual(signed_messages["content"][0], expected_content)
-
-# 	def test_sign_message_invalid_sender(self):
-# 		"""Test signing message with an invalid sender raises ValueError."""
-# 		messages = pd.DataFrame(
-# 			{
-# 				"node_id": ["1"], "role": ["user"], "sender": ["test"],
-# 				"timestamp": ["2020-01-01T00:00:00"],
-# 				"content": ["Original message"],
-# 			}
-# 		)
-# 		with self.assertRaises(ValueError):
-# 			MessageUtil.sign_message(messages, None)
-
-
-# class TestFilterMessagesBy(unittest.TestCase):
-
-# 	def setUp(self):
-# 		self.messages = pd.DataFrame(
-# 			{
-# 				"node_id": ["1", "2"], "role": ["user", "assistant"],
-# 				"sender": ["test", "assistant"],
-# 				"timestamp": [datetime(2020, 1, 1), datetime(2020, 1, 2)],
-# 				"content": ['{"message": "test"}', '{"response": "ok"}'],
-# 			}
-# 		)
-
-# 	def test_filter_by_role(self):
-# 		"""Test filtering messages by role."""
-# 		filtered = MessageUtil.filter_messages_by(
-# 			self.messages, role="assistant"
-# 			)
-# 		self.assertEqual(len(filtered), 1)
-# 		self.assertEqual(filtered.iloc[0]["sender"], "assistant")
-
-# 	def test_filter_by_sender(self):
-# 		"""Test filtering messages by sender."""
-# 		filtered = MessageUtil.filter_messages_by(
-# 			self.messages, sender="test"
-# 			)
-# 		self.assertEqual(len(filtered), 1)
-# 		self.assertEqual(filtered.iloc[0]["sender"], "test")
-
-# 	def test_filter_by_time_range(self):
-# 		"""Test filtering messages by time range."""
-# 		start_time = datetime(2020, 1, 1, 12)
-# 		end_time = datetime(2020, 1, 2, 12)
-# 		filtered = MessageUtil.filter_messages_by(
-# 			self.messages, start_time=start_time, end_time=end_time
-# 		)
-# 		self.assertEqual(len(filtered), 1)
-# 		self.assertTrue(
-# 			start_time <= filtered.iloc[0]["timestamp"] <= end_time
-# 			)
-
-
-# class TestRemoveMessage(unittest.TestCase):
-
-# 	def test_remove_message(self):
-# 		"""Test removing a message by node_id."""
-# 		messages = pd.DataFrame(
-# 			{
-# 				"node_id": ["1", "2"], "role": ["user", "assistant"],
-# 				"content": ["message1", "message2"],
-# 			}
-# 		)
-# 		updated_messages = MessageUtil.remove_message(messages, "1")
-# 		self.assertTrue(updated_messages)
-
-
-# class TestGetMessageRows(unittest.TestCase):
-
-# 	def test_get_message_rows(self):
-# 		"""Test retrieving the last 'n' message rows based on criteria."""
-# 		messages = pd.DataFrame(
-# 			{
-# 				"node_id": ["1", "2", "3"],
-# 				"role": ["user", "assistant", "user"],
-# 				"sender": ["A", "B", "A"],
-# 				"content": ["message1", "message2", "message3"],
-# 			}
-# 		)
-# 		rows = MessageUtil.get_message_rows(
-# 			messages, sender="A", role="user", n=2
-# 			)
-# 		self.assertEqual(len(rows), 2)
-
-
-# # class TestExtend(unittest.TestCase):
-
-# # def test_extend(self):
-# #     """Test extending one DataFrame with another, ensuring no duplicate 'node_id'."""
-# #     df1 = pd.DataFrame({
-# #         "node_id": ["1"],
-# #         "role": ["user"],
-# #         "sender": ["test"],
-# #         "timestamp": ["2020-01-01T00:00:00"],
-# #         "content": ['{"message": "test"}']
-# #     })
-# #     df2 = pd.DataFrame({
-# #         "node_id": ["2"],
-# #         "role": ["user"],
-# #         "sender": ["test"],
-# #         "timestamp": ["2020-01-02T00:00:00"],
-# #         "content": ['{"message": "test2"}']
-# #     })
-# #     combined = MessageUtil.extend(df1, df2)
-# #     self.assertEqual(len(combined), 2)
-
-
-# class TestToMarkdownString(unittest.TestCase):
-
-# 	def test_to_markdown_string(self):
-# 		"""Test converting messages to a Markdown-formatted string."""
-# 		messages = pd.DataFrame(
-# 			{
-# 				"node_id": ["1"], "role": ["user"],
-# 				"content": [json.dumps({"instruction": "Hello, World!"})],
-# 			}
-# 		)
-# 		markdown_str = MessageUtil.to_markdown_string(messages)
-# 		self.assertIn("Hello, World!", markdown_str)
-
-
-# # class TestSearchKeywords(unittest.TestCase):
-
-# #     def test_search_keywords(self):
-# #         """Test filtering DataFrame for rows containing specified keywords."""
-# #         messages = pd.DataFrame(
-# #             {"node_id": ["1", "2"], "content": ["Hello world", "Goodbye world"]}
-# #         )
-# #         filtered = MessageUtil.search_keywords(messages, "Hello")
-# #         print(filtered)
-# #         self.assertEqual(len(filtered), 1)
-
-
-# # class TestReplaceKeyword(unittest.TestCase):
-
-# #     def test_replace_keyword(self):
-# #         """Test replacing a keyword in DataFrame's specified column."""
-# #         messages = pd.DataFrame({"content": ["Hello world", "Goodbye world"]})
-# #         MessageUtil.replace_keyword(messages, "world", "universe")
-# #         self.assertTrue(all(messages["content"].str.contains("universe")))
-
-
-# # class TestReadCsv(unittest.TestCase):
-
-# # @patch("pandas.read_csv")
-# # def test_read_csv(self, mock_read_csv):
-# #     """Test reading a CSV file into a DataFrame."""
-# #     mock_df = pd.DataFrame(
-# #         {"node_id": ["1", "2"], "content": ["Hello, World!", "Goodbye, World!"]}
-# #     )
-# #     mock_read_csv.return_value = mock_df
-
-# #     df = MessageUtil.read_csv("path/to/nonexistent/file.csv")
-
-# #     mock_read_csv.assert_called_once_with("path/to/nonexistent/file.csv")
-
-# #     self.assertTrue(isinstance(df, pd.DataFrame))
-# #     self.assertEqual(len(df), 2)
-# #     self.assertEqual(list(df.columns), ["node_id", "content"])
-
-
-# # class TestReadJson(unittest.TestCase):
-
-# #     @patch("pandas.read_json")
-# #     def test_read_json(self, mock_read_json):
-# #         """Test reading a JSON file into a DataFrame."""
-# #         mock_df = pd.DataFrame(
-# #             {"node_id": ["1", "2"], "content": ["JSON Message 1", "JSON Message 2"]}
-# #         )
-# #         mock_read_json.return_value = mock_df
-
-# #         df = MessageUtil.read_json("path/to/nonexistent/file.json")
-
-# #         mock_read_json.assert_called_once_with("path/to/nonexistent/file.json")
-
-# #         self.assertTrue(isinstance(df, pd.DataFrame))
-# #         self.assertEqual(len(df), 2)
-# #         self.assertEqual(list(df.columns), ["node_id", "content"])
-
-
-# # class TestRemoveLastNRows(unittest.TestCase):
-
-# #     def test_remove_last_n_rows(self):
-# #         """Test removing the last 'n' rows from a DataFrame."""
-# #         messages = pd.DataFrame({"content": ["message1", "message2", "message3"]})
-# #         updated = MessageUtil.remove_last_n_rows(messages, 2)
-# #         self.assertEqual(len(updated), 1)
-
-
-# # class TestUpdateRow(unittest.TestCase):
-
-# #     def test_update_row(self):
-# #         """Test updating a row's value for a specified column."""
-# #         messages = pd.DataFrame(
-# #             {"node_id": ["1", "2"], "content": ["message1", "message2"]}
-# #         )
-# #         success = MessageUtil.update_row(messages, 0, "node_id", "3")
-# #         self.assertTrue(success)
-# #         self.assertTrue("3" in messages["node_id"].values)
-
-
-# if __name__ == "__main__":
-# 	unittest.main()

lionagi/tests/test_core/test_tool_manager.py

@@ -1,95 +0,0 @@
-# from lionagi.core.tool.tool_manager import ToolManager
-# from lionagi.core.schema import Tool
-
-# import unittest
-# from unittest.mock import patch, AsyncMock
-# import asyncio
-# import json
-
-
-# class TestToolManager(unittest.TestCase):
-# 	def setUp(self):
-# 		self.manager = ToolManager()
-# 		self.tool = Tool(
-# 			func=lambda x: x, schema_={"function": {"name": "test_func"}}
-# 			)
-
-# 	def test_register_and_check_tool(self):
-# 		"""Test registering a tool and checking its existence."""
-# 		self.manager._register_tool(self.tool)
-# 		self.assertTrue(self.manager.name_existed("test_func"))
-
-# 	def test_register_tool_type_error(self):
-# 		"""Test that registering a non-Tool object raises a TypeError."""
-# 		with self.assertRaises(TypeError):
-# 			self.manager._register_tool("not_a_tool")
-
-# 	def test_name_not_existed(self):
-# 		"""Test querying a non-registered tool's existence."""
-# 		self.assertFalse(self.manager.name_existed("non_existent_func"))
-
-
-# class TestToolInvocation(unittest.TestCase):
-
-# 	def setUp(self):
-# 		self.manager = ToolManager()
-
-# 		async def async_tool_func(x):
-# 			return x
-
-# 		self.async_tool = Tool(
-# 			func=async_tool_func,
-# 			schema_={"function": {"name": "async_test_func"}}
-# 		)
-# 		self.sync_tool = Tool(
-# 			func=lambda x: x, schema_={"function": {"name": "sync_test_func"}}
-# 		)
-
-# 	# @patch('lionagi.core.tool.tool_manager', return_value=False)  # def test_invoke_sync_tool(self, mock_is_coroutine):  #     """Test invoking a synchronous tool."""  #     self.manager._register_tool(self.sync_tool)  #     result = asyncio.run(self.manager.invoke(('sync_test_func', {'x': 10})))  #     self.assertEqual(result, 10)
-
-# 	# @patch('lionagi.core.tool.tool_manager', return_value=True)  # def test_invoke_async_tool(self, mock_call_handler, mock_is_coroutine):  #     """Test invoking an asynchronous tool."""  #     mock_call_handler.return_value = 10  #     self.manager._register_tool(self.async_tool)  #     result = asyncio.run(self.manager.invoke(('async_test_func', {'x': 10})))  #     self.assertEqual(result, 10)
-
-
-# class TestFunctionCallExtraction(unittest.TestCase):
-
-# 	def setUp(self):
-# 		self.manager = ToolManager()
-
-# 	def test_get_function_call_valid(self):
-# 		"""Test extracting a valid function call."""
-# 		response = {
-# 			"action": "action_test_func", "arguments": json.dumps({"x": 10})
-# 		}
-# 		func_call = self.manager.get_function_call(response)
-# 		self.assertEqual(func_call, ("test_func", {"x": 10}))
-
-# 	def test_get_function_call_invalid(self):
-# 		"""Test handling an invalid function call."""
-# 		with self.assertRaises(ValueError):
-# 			self.manager.get_function_call({})
-
-
-# class TestToolParser(unittest.TestCase):
-
-# 	def setUp(self):
-# 		self.manager = ToolManager()
-# 		self.tool = Tool(
-# 			func=lambda x: x, schema_={"function": {"name": "test_func"}}
-# 			)
-# 		self.manager._register_tool(self.tool)
-
-# 	def test_tool_parser_single_tool(self):
-# 		"""Test parsing a single tool name."""
-# 		parsed = self.manager.parse_tool("test_func")
-# 		self.assertIn("tools", parsed)
-# 		self.assertEqual(len(parsed["tools"]), 1)
-# 		self.assertEqual(parsed["tools"][0]["function"]["name"], "test_func")
-
-# 	def test_tool_parser_unregistered_tool(self):
-# 		"""Test parsing an unregistered tool name."""
-# 		with self.assertRaises(ValueError):
-# 			self.manager.parse_tool("unregistered_func")
-
-
-# if __name__ == "__main__":
-# 	unittest.main()