lionagi 0.1.2__py3-none-any.whl → 0.2.0__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,313 +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()

lionagi-0.1.2.dist-info/LICENSE

@@ -1,9 +0,0 @@
-MIT License
-
-Copyright (c) 2023 HaiyangLi quantocean.li@gmail.com
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.