lionagi 0.2.10__py3-none-any.whl → 0.3.0__py3-none-any.whl

lionagi/tests/libs/test_nested.py

@@ -1,382 +0,0 @@
-import unittest
-
-from lionagi.libs.ln_nested import *
-
-
-class TestNSet(unittest.TestCase):
-    def test_nset_on_dict(self):
-        """Test setting a value in a nested dictionary."""
-        data = {"a": {"b": [10, 20]}}
-        nset(data, ["a", "b", 1], 99)
-        self.assertEqual(data, {"a": {"b": [10, 99]}})
-
-    def test_nset_on_list(self):
-        """Test setting a value in a nested list."""
-        data = [0, [1, 2], 3]
-        nset(data, [1, 1], 99)
-        self.assertEqual(data, [0, [1, 99], 3])
-
-    def test_nset_with_empty_indices(self):
-        """Test nset with an empty indices list."""
-        with self.assertRaises(ValueError):
-            nset({}, [], 1)
-
-    def test_nget_with_valid_path(self):
-        """Test retrieving a value from a nested structure."""
-        data = {"a": {"b": [10, 20, 30]}}
-        self.assertEqual(nget(data, ["a", "b", 2]), 30)
-
-    def test_nget_with_default(self):
-        """Test nget returning a default value when the path doesn't exist."""
-        data = {"a": 1}
-        self.assertEqual(nget(data, ["b"], default=99), 99)
-
-    def test_nget_raises_lookup_error(self):
-        """Test nget raises LookupError when no default is provided and the path doesn't exist."""
-        with self.assertRaises(LookupError):
-            nget({"a": 1}, ["b"])
-
-    def test_flatten_and_unflatten_dict(self):
-        """Test flattening and then unflattening a nested dictionary."""
-        original = {"a": {"b": {"c": 1}}}
-        flattened = flatten(original)
-        self.assertEqual(flattened, {"a[^_^]b[^_^]c": 1})
-        unflattened = unflatten(flattened)
-        self.assertEqual(original, unflattened)
-
-    def test_nfilter_dict(self):
-        """Test filtering items in a dictionary."""
-        data = {"a": 1, "b": 2, "c": 3}
-        filtered = nfilter(data, lambda x: x[1] > 1)
-        self.assertEqual(filtered, {"b": 2, "c": 3})
-
-    def test_nfilter_list(self):
-        """Test filtering items in a list."""
-        data = [1, 2, 3, 4]
-        filtered = nfilter(data, lambda x: x % 2 == 0)
-        self.assertEqual(filtered, [2, 4])
-
-    def test_ninsert_into_nested_dict(self):
-        """Test inserting a value into a nested dictionary."""
-        data = {"a": {"b": [1, 2]}}
-        ninsert(data, ["a", "b", 2], 3)
-        self.assertEqual(data, {"a": {"b": [1, 2, 3]}})
-
-    def test_ninsert_into_nested_list(self):
-        """Test inserting a value into a nested list."""
-        data = []
-        ninsert(data, [0, "a"], 1)
-        self.assertEqual(data, [{"a": 1}])
-
-
-class TestNFilter(unittest.TestCase):
-
-    def test_filter_dictionary_with_condition(self):
-        test_dict = {"a": 1, "b": 2, "c": 3}
-        result = nfilter(test_dict, lambda item: item[1] > 1)
-        self.assertEqual(result, {"b": 2, "c": 3})
-
-    def test_filter_list_with_condition(self):
-        test_list = [1, 2, 3, 4]
-        result = nfilter(test_list, lambda x: x % 2 == 0)
-        self.assertEqual(result, [2, 4])
-
-    def test_filter_empty_dictionary(self):
-        self.assertEqual(nfilter({}, lambda item: item[1] > 1), {})
-
-    def test_filter_empty_list(self):
-        self.assertEqual(nfilter([], lambda x: x % 2 == 0), [])
-
-    def test_filter_all_items_fail_condition(self):
-        test_dict = {"a": 1, "b": 2, "c": 3}
-        self.assertEqual(nfilter(test_dict, lambda item: item[1] > 5), {})
-
-    def test_filter_all_items_pass_condition(self):
-        test_list = [1, 2, 3, 4]
-        self.assertEqual(nfilter(test_list, lambda x: x > 0), test_list)
-
-    def test_filter_nested_collections(self):
-        nested_dict = {"a": [1, 2, 3], "b": [4, 5]}
-        result = nfilter(nested_dict, lambda item: len(item[1]) > 2)
-        self.assertEqual(result, {"a": [1, 2, 3]})
-
-    def test_filter_invalid_collection_type(self):
-        with self.assertRaises(TypeError):
-            nfilter("not a dict or list", lambda x: x)
-
-    def test_filter_with_complex_conditions(self):
-        test_dict = {"a": 1, "b": 2, "c": 3, "d": 4}
-        # Condition: key is not 'a' and value is an even number
-        result = nfilter(test_dict, lambda item: item[0] != "a" and item[1] % 2 == 0)
-        self.assertEqual(result, {"b": 2, "d": 4})
-
-
-class TestNSet(unittest.TestCase):
-
-    def test_set_value_in_nested_dict(self):
-        nested_dict = {"a": {"b": 1}}
-        nset(nested_dict, ["a", "b"], 2)
-        self.assertEqual(nested_dict["a"]["b"], 2)
-
-    def test_set_value_in_nested_list(self):
-        nested_list = [[1, 2], [3, 4]]
-        nset(nested_list, [1, 0], 5)
-        self.assertEqual(nested_list[1][0], 5)
-
-    def test_set_with_empty_indices_list(self):
-        with self.assertRaises(ValueError):
-            nset({}, [], 1)
-
-    def test_set_in_non_list_dict(self):
-        with self.assertRaises(TypeError):
-            nset(1, [0], "value")
-
-    def test_set_with_index_out_of_bounds(self):
-        test_list = [1, 2, 3]
-        nset(test_list, [5], 4)
-        self.assertEqual(test_list[5], 4)
-
-    def test_set_with_non_existent_dict_key(self):
-        test_dict = {"a": 1}
-        nset(test_dict, ["b"], 2)
-        self.assertEqual(test_dict["b"], 2)
-
-    def test_set_with_mixed_indices_types(self):
-        nested_structure = {"a": [1, {"b": 2}]}
-        nset(nested_structure, ["a", 1, "b"], 3)
-        self.assertEqual(nested_structure["a"][1]["b"], 3)
-
-
-class TestNGet(unittest.TestCase):
-
-    def test_get_value_from_nested_dict(self):
-        nested_dict = {"a": {"b": 1}}
-        result = nget(nested_dict, ["a", "b"])
-        self.assertEqual(result, 1)
-
-    def test_get_value_from_nested_list(self):
-        nested_list = [[1, 2], [3, 4]]
-        result = nget(nested_list, [1, 0])
-        self.assertEqual(result, 3)
-
-    # def test_get_with_non_existent_key_index(self):
-    #     nested_dict = {'a': 1}
-    #     result = nget(nested_dict, ['b'])
-    #     self.assertIsNone(result)
-
-    #     nested_list = [1, 2, 3]
-    #     result = nget(nested_list, [5])
-    #     self.assertIsNone(result)
-
-    def test_get_with_mixed_indices(self):
-        nested_structure = {"a": [1, {"b": 2}]}
-        result = nget(nested_structure, ["a", 1, "b"])
-        self.assertEqual(result, 2)
-
-    # def test_get_with_invalid_structure_type(self):  #     result = nget(1, [0])  # Attempting to retrieve from an integer, not a list/dict  #     self.assertIsNone(result)
-
-    # def test_get_with_index_out_of_bounds(self):  #     test_list = [1, 2, 3]  #     result = nget(test_list, [5])  #     self.assertIsNone(result)
-
-
-class TestNMerge(unittest.TestCase):
-
-    def test_merge_list_of_dictionaries(self):
-        dict_list = [{"a": 1}, {"b": 2}]
-        result = nmerge(dict_list)
-        self.assertEqual(result, {"a": 1, "b": 2})
-
-    def test_merge_list_of_lists(self):
-        list_of_lists = [[1, 2], [3, 4]]
-        result = nmerge(list_of_lists)
-        self.assertEqual(result, [1, 2, 3, 4])
-
-    def test_merge_empty_list(self):
-        self.assertEqual(nmerge([]), {})
-
-    def test_dict_update_option(self):
-        dict_list = [{"a": 1}, {"a": 2, "b": 3}]
-        result = nmerge(dict_list, overwrite=True)
-        self.assertEqual(result, {"a": 2, "b": 3})
-
-    def test_dict_sequence_option(self):
-        dict_list = [{"a": 1}, {"a": 2}]
-        result = nmerge(dict_list, dict_sequence=True, sequence_separator="_")
-        self.assertIn("a", result)
-        self.assertIn("a_1", result)
-
-    def test_sort_list_option(self):
-        list_of_lists = [[3, 1], [4, 2]]
-        result = nmerge(list_of_lists, sort_list=True)
-        self.assertEqual(result, [1, 2, 3, 4])
-
-    def test_custom_sort_function(self):
-        list_of_lists = [["b", "a"], ["d", "c"]]
-        custom_sort_func = lambda x: x
-        result = nmerge(list_of_lists, sort_list=True, custom_sort=custom_sort_func)
-        self.assertEqual(result, ["a", "b", "c", "d"])
-
-    def test_inhomogeneous_type_error(self):
-        mixed_list = [{"a": 1}, [1, 2]]
-        with self.assertRaises(TypeError):
-            nmerge(mixed_list)
-
-
-class TestFlatten(unittest.TestCase):
-
-    def test_flatten_nested_dict(self):
-        nested_dict = {"a": {"b": 1, "c": {"d": 2}}}
-        result = flatten(nested_dict)
-        self.assertEqual(result, {"a[^_^]b": 1, "a[^_^]c[^_^]d": 2})
-
-    def test_flatten_nested_list(self):
-        nested_list = [[1, 2], [3, [4, 5]]]
-        result = flatten(nested_list)
-        self.assertEqual(
-            result,
-            {
-                "0[^_^]0": 1,
-                "0[^_^]1": 2,
-                "1[^_^]0": 3,
-                "1[^_^]1[^_^]0": 4,
-                "1[^_^]1[^_^]1": 5,
-            },
-        )
-
-    def test_flatten_with_max_depth(self):
-        nested_dict = {"a": {"b": {"c": 1}}}
-        result = flatten(nested_dict, max_depth=1)
-        self.assertEqual(result, {"a[^_^]b": {"c": 1}})
-
-    def test_flatten_dict_only(self):
-        nested_mix = {"a": [1, 2], "b": {"c": 3}}
-        result = flatten(nested_mix, dict_only=True)
-        self.assertEqual(result, {"a": [1, 2], "b[^_^]c": 3})
-
-    def test_flatten_inplace(self):
-        nested_dict = {"a": {"b": 1}}
-        flatten(nested_dict, inplace=True)
-        self.assertEqual(nested_dict, {"a[^_^]b": 1})
-
-    def test_flatten_empty_structure(self):
-        self.assertEqual(flatten({}), {})
-        self.assertEqual(flatten([]), {})
-
-    def test_flatten_deeply_nested_structure(self):
-        deeply_nested = {"a": {"b": {"c": {"d": 1}}}}
-        result = flatten(deeply_nested)
-        self.assertEqual(result, {"a[^_^]b[^_^]c[^_^]d": 1})
-
-
-class TestUnflatten(unittest.TestCase):
-
-    def test_unflatten_to_nested_dict(self):
-        flat_dict = {"a[^_^]b": 1, "a[^_^]c[^_^]d": 2}
-        result = unflatten(flat_dict)
-        self.assertEqual(result, {"a": {"b": 1, "c": {"d": 2}}})
-
-    def test_unflatten_to_nested_list(self):
-        flat_dict = {"0[^_^]0": 1, "0[^_^]1": 2, "1": [3, 4]}
-        result = unflatten(flat_dict)
-        self.assertEqual(result, [[1, 2], [3, 4]])
-
-    def test_unflatten_with_custom_separator(self):
-        flat_dict = {"a-b": 1, "a-c-d": 2}
-        result = unflatten(flat_dict, sep="-")
-        self.assertEqual(result, {"a": {"b": 1, "c": {"d": 2}}})
-
-    def test_unflatten_with_custom_logic(self):
-        flat_dict = {"a[^_^]1": "one", "a[^_^]2": "two"}
-        custom_logic = lambda key: int(key) if key.isdigit() else key
-        result = unflatten(flat_dict, custom_logic=custom_logic)
-        self.assertEqual(result, {"a": [None, "one", "two"]})
-
-    def test_unflatten_with_max_depth(self):
-        flat_dict = {"a[^_^]b[^_^]c": 1, "a[^_^]b[^_^]d": 2}
-        result = unflatten(flat_dict, max_depth=1)
-        self.assertEqual(result, {"a": {"b[^_^]c": 1, "b[^_^]d": 2}})
-
-    def test_unflatten_with_max_depth_int(self):
-        flat_dict = {"0[^_^]0[^_^]0": 1, "0[^_^]1[^_^]0": 2}
-        result = unflatten(flat_dict, max_depth=1)
-        self.assertEqual(result, [[{"0[^_^]0": 1}, {"1[^_^]0": 2}]])
-
-    def test_unflatten_empty_flat_dict(self):
-        self.assertEqual(unflatten({}), [])
-
-    def test_unflatten_to_mixed_structure(self):
-        flat_dict = {"0[^_^]0": 1, "1[^_^]key": 2}
-        result = unflatten(flat_dict)
-        self.assertEqual(result, [[1], {"key": 2}])
-
-
-class TestNInsert(unittest.TestCase):
-
-    def test_insert_into_nested_dict(self):
-        obj = {}
-        ninsert(obj, ["a", "b"], 1)
-        self.assertEqual(obj, {"a": {"b": 1}})
-
-    def test_insert_into_nested_list(self):
-        obj = []
-        ninsert(obj, [0, 1], "value")
-        self.assertEqual(obj, [[None, "value"]])
-
-    def test_insert_with_mixed_paths(self):
-        obj = {"a": [{}]}
-        ninsert(obj, ["a", 0, "b"], 2)
-        self.assertEqual(obj, {"a": [{"b": 2}]})
-
-    def test_insert_with_max_depth(self):
-        obj = {}
-        ninsert(obj, ["a", "b", "c"], "value", max_depth=1)
-        self.assertEqual(obj, {"a": {"b[^_^]c": "value"}})
-
-    def test_insert_into_empty_structure(self):
-        obj = {}
-        ninsert(obj, ["a"], 1)
-        self.assertEqual(obj, {"a": 1})
-
-
-class TestGetFlattenedKeys(unittest.TestCase):
-
-    def test_get_keys_from_nested_dict(self):
-        nested_dict = {"a": {"b": 1, "c": {"d": 2}}}
-        expected_keys = ["a[^_^]b", "a[^_^]c[^_^]d"]
-        self.assertEqual(set(get_flattened_keys(nested_dict)), set(expected_keys))
-
-    def test_get_keys_from_nested_list(self):
-        nested_list = [[1, 2], [3, [4, 5]]]
-        expected_keys = [
-            "0[^_^]0",
-            "0[^_^]1",
-            "1[^_^]0",
-            "1[^_^]1[^_^]0",
-            "1[^_^]1[^_^]1",
-        ]
-        self.assertEqual(set(get_flattened_keys(nested_list)), set(expected_keys))
-
-    def test_get_keys_with_max_depth(self):
-        nested_dict = {"a": {"b": {"c": 1}}}
-        expected_keys = ["a[^_^]b"]
-        self.assertEqual(
-            set(get_flattened_keys(nested_dict, max_depth=1)), set(expected_keys)
-        )
-
-    def test_get_keys_dict_only(self):
-        nested_mix = {"a": [1, 2], "b": {"c": 3}}
-        expected_keys = ["a", "b[^_^]c"]
-        self.assertEqual(
-            set(get_flattened_keys(nested_mix, dict_only=True)), set(expected_keys)
-        )
-
-    def test_get_keys_from_empty_structure(self):
-        self.assertEqual(get_flattened_keys({}), [])
-
-    def test_keys_from_deeply_nested_structure(self):
-        deeply_nested = {"a": {"b": {"c": {"d": 1}}}}
-        expected_keys = ["a[^_^]b[^_^]c[^_^]d"]
-        self.assertEqual(set(get_flattened_keys(deeply_nested)), set(expected_keys))
-
-
-if __name__ == "__main__":
-    unittest.main()

lionagi/tests/libs/test_parse.py

@@ -1,171 +0,0 @@
-import unittest
-from unittest.mock import patch
-
-from lionagi.libs.ln_parse import *
-
-
-class TestFuzzyParseJson(unittest.TestCase):
-
-    def test_basic_json_parsing(self):
-        """Test parsing of correctly formatted JSON strings."""
-        json_str = '{"name": "John", "age": 30}'
-        expected = {"name": "John", "age": 30}
-        self.assertEqual(ParseUtil.fuzzy_parse_json(json_str), expected)
-
-    def test_missing_closing_brackets(self):
-        """Test JSON strings missing various closing brackets."""
-        test_cases = [
-            ('{"name": "John", "age": 30', {"name": "John", "age": 30}),
-            ('[{"name": "John", "age": 30}', [{"name": "John", "age": 30}]),
-            ('{"people": [{"name": "John"', {"people": [{"name": "John"}]}),
-        ]
-        for json_str, expected in test_cases:
-            with self.subTest(json_str=json_str):
-                self.assertEqual(ParseUtil.fuzzy_parse_json(json_str), expected)
-
-    def test_nested_structures(self):
-        """Test with nested JSON objects and arrays."""
-        json_str = '{"data": [{"id": 1, "value": "A"}, {"id": 2, "value": "B"'
-        expected = {"data": [{"id": 1, "value": "A"}, {"id": 2, "value": "B"}]}
-        self.assertEqual(ParseUtil.fuzzy_parse_json(json_str), expected)
-
-    def test_strict_mode(self):
-        """Test the function's behavior in strict mode."""
-        correct_json_str = '{"name": "John", "age": 30}'
-        malformed_json_str = '{"name": "John", "age": 30'
-        # Should work fine with correct JSON
-        self.assertEqual(
-            ParseUtil.fuzzy_parse_json(correct_json_str, strict=True),
-            {"name": "John", "age": 30},
-        )
-
-    def test_error_handling(self):
-        """Test with irreparably malformed JSON."""
-        json_str = '{"name": "John", "age": 30 something wrong}'
-        with self.assertRaises(ValueError):
-            ParseUtil.fuzzy_parse_json(json_str)
-
-    def test_escape_chars_in_json(self):
-        """Test escaping special characters in JSON strings."""
-        self.assertEqual(
-            ParseUtil.escape_chars_in_json("Line 1\nLine 2"), "Line 1\\nLine 2"
-        )
-        self.assertEqual(ParseUtil.escape_chars_in_json('Quote: "'), 'Quote: \\"')
-
-    def test_extract_code_block(self):
-        """Test extracting and parsing code blocks from Markdown."""
-        markdown = '```python\nprint("Hello, world!")\n```'
-        result = ParseUtil.extract_json_block(
-            markdown, language="python", parser=lambda x: x
-        )
-        self.assertEqual(result, 'print("Hello, world!")')
-
-    def test_md_to_json(self):
-        """Test extracting and validating JSON from Markdown content."""
-        markdown = '```json\n{"key": "value"}\n```'
-        result = ParseUtil.md_to_json(markdown, expected_keys=["key"])
-        self.assertEqual(result, {"key": "value"})
-        with self.assertRaises(ValueError):
-            ParseUtil.md_to_json(markdown, expected_keys=["missing_key"])
-
-    def test_jaro_distance(self):
-        """Test Jaro distance calculations."""
-        self.assertAlmostEqual(
-            StringMatch.jaro_distance("martha", "marhta"), 0.9444444444444445, places=7
-        )
-        self.assertAlmostEqual(StringMatch.jaro_distance("", ""), 1.0)
-        self.assertAlmostEqual(StringMatch.jaro_distance("abc", "abc"), 1.0)
-        self.assertAlmostEqual(StringMatch.jaro_distance("abc", "def"), 0.0)
-
-    def test_jaro_winkler_similarity(self):
-        """Test Jaro-Winkler similarity calculations."""
-        self.assertAlmostEqual(
-            StringMatch.jaro_winkler_similarity("dixon", "dicksonx", scaling=0.1),
-            0.8133333333333332,
-            places=7,
-        )
-        self.assertAlmostEqual(
-            StringMatch.jaro_winkler_similarity("martha", "marhta", scaling=0.1),
-            0.9611111111111111,
-            places=7,
-        )
-        self.assertAlmostEqual(
-            StringMatch.jaro_winkler_similarity("", "", scaling=0.1), 1.0
-        )
-        self.assertAlmostEqual(
-            StringMatch.jaro_winkler_similarity("abc", "abc", scaling=0.1), 1.0
-        )
-        self.assertAlmostEqual(
-            StringMatch.jaro_winkler_similarity("abc", "def", scaling=0.1), 0.0
-        )
-
-    def test_levenshtein_distance(self):
-        """Test Levenshtein distance calculations."""
-        self.assertEqual(StringMatch.levenshtein_distance("kitten", "sitting"), 3)
-        self.assertEqual(StringMatch.levenshtein_distance("", ""), 0)
-        self.assertEqual(StringMatch.levenshtein_distance("book", "back"), 2)
-        self.assertEqual(StringMatch.levenshtein_distance("book", ""), 4)
-        self.assertEqual(StringMatch.levenshtein_distance("", "back"), 4)
-
-    def test_extract_google_style(self):
-        def sample_func():
-            """
-            Sample function.
-
-            Args:
-                    param1 (int): Description of param1.
-                    param2 (str): Description of param2.
-            """
-            pass
-
-        description, params = ParseUtil._extract_docstring_details_google(sample_func)
-        self.assertEqual(description, "Sample function.")
-        self.assertDictEqual(
-            params,
-            {"param1": "Description of param1.", "param2": "Description of param2."},
-        )
-
-    def test_extract_reST_style(self):
-        def sample_func():
-            """
-            Sample function.
-
-            :param param1: Description of param1.
-            :type param1: int
-            :param param2: Description of param2.
-            :type param2: str
-            """
-            pass
-
-        description, params = ParseUtil._extract_docstring_details_rest(sample_func)
-        self.assertEqual(description, "Sample function.")
-        self.assertDictEqual(
-            params,
-            {"param1": "Description of param1.", "param2": "Description of param2."},
-        )
-
-    @patch("lionagi.libs.ln_parse.ParseUtil._extract_docstring_details")
-    def test_func_to_schema(self, mock_extract):
-        mock_extract.return_value = (
-            "Function description",
-            {"param1": "Description of param1."},
-        )
-
-        def sample_func(param1: int) -> bool:
-            pass
-
-        schema = ParseUtil._func_to_schema(sample_func)
-        self.assertEqual(schema["function"]["name"], "sample_func")
-        self.assertEqual(schema["function"]["description"], "Function description")
-        self.assertIn("param1", schema["function"]["parameters"]["properties"])
-        self.assertEqual(
-            schema["function"]["parameters"]["properties"]["param1"]["type"], "number"
-        )
-        self.assertEqual(
-            schema["function"]["parameters"]["properties"]["param1"]["description"],
-            "Description of param1.",
-        )
-
-
-if __name__ == "__main__":
-    unittest.main()

lionagi/tests/libs/test_queue.py

@@ -1,68 +0,0 @@
-import asyncio
-import unittest
-from unittest.mock import patch
-
-from lionagi.libs.ln_queue import AsyncQueue
-
-
-class TestAsyncQueue(unittest.TestCase):
-    def setUp(self):
-        self.loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(self.loop)
-        self.queue = AsyncQueue(max_concurrent_tasks=3)
-
-    def tearDown(self):
-        self.loop.close()
-
-    def test_enqueue_dequeue(self):
-        async def test():
-            await self.queue.enqueue("task1")
-            result = await self.queue.dequeue()
-            self.assertEqual(result, "task1")
-
-        self.loop.run_until_complete(test())
-
-    def test_stop(self):
-        async def test():
-            await self.queue.stop()
-            self.assertTrue(self.queue.stopped())
-
-        self.loop.run_until_complete(test())
-
-    @patch("lionagi.libs.ln_func_call.rcall", autospec=True)
-    def test_process_requests(self, mock_rcall):
-        future = asyncio.Future()
-        future.set_result("Processed successfully")
-        mock_rcall.return_value = future
-
-        async def processor(task):
-            return f"Processed {task}"
-
-        async def add_tasks():
-            for i in range(5):
-                await self.queue.enqueue(f"task{i}")
-            # This ensures that the queue stops after all tasks are added
-            await self.queue.stop()
-
-        async def process():
-            await self.queue.process_requests(processor, retry_kwargs={"retries": 2})
-
-        self.loop.create_task(add_tasks())
-        self.loop.run_until_complete(process())
-        # mock_rcall.assert_called()
-
-    def test_concurrency_limit(self):
-        async def add_tasks():
-            for i in range(10):
-                await self.queue.enqueue(f"task{i}")
-
-        async def process():
-            await asyncio.sleep(0.1)
-            await self.queue.stop()
-
-        self.loop.run_until_complete(add_tasks())
-        self.loop.run_until_complete(process())
-
-
-if __name__ == "__main__":
-    unittest.main()