lionagi 0.1.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

lionagi/lions/coder/code_form.py

@@ -0,0 +1,13 @@
+from typing import Any
+from pydantic import Field
+from lionagi.libs import ParseUtil, SysUtil
+from lionagi.core import Session
+from lionagi.core.form.action_form import ActionForm
+
+
+class CodeForm(ActionForm):
+    template_name: str = "code_form"
+    language: str = Field(
+        default="python",
+        description="The programming language of the code to be executed.",
+    )

lionagi/lions/coder/coder.py

@@ -1,18 +1,49 @@
 import asyncio
+from pathlib import Path
+
+from lionagi import logging as _logging
 from lionagi.core import Session
+from lionagi.libs import ParseUtil
 
 from .base_prompts import CODER_PROMPTS
-from .util import extract_code_blocks, install_missing_dependencies, set_up_interpreter
+from .util import install_missing_dependencies, set_up_interpreter, save_code_file
 
 
 class Coder:
+
     def __init__(
-        self, prompts=None, session=None, session_kwargs=None, required_libraries=None
+        self,
+        prompts: dict = None,
+        session: Session = None,
+        session_kwargs: dict = None,
+        required_libraries: list = None,
+        work_dir: Path | str = None,
+    ) -> None:
+
+        self.prompts = prompts or CODER_PROMPTS
+        self.session = session or self._create_session(session_kwargs)
+        self.required_libraries = required_libraries or ["lionagi"]
+        self.work_dir = work_dir or Path.cwd() / "coder" / "code_files"
+
+    def _create_session(self, session_kwargs: dict = None) -> Session:
+        session_kwargs = session_kwargs or {}
+        return Session(system=self.prompts["system"], **session_kwargs)
+
+
+class Coder:
+    def __init__(
+        self,
+        prompts=None,
+        session=None,
+        session_kwargs=None,
+        required_libraries=None,
+        work_dir=None,
     ):
         print("Initializing Coder...")
         self.prompts = prompts or CODER_PROMPTS
         self.session = session or self._create_session(session_kwargs)
         self.required_libraries = required_libraries or ["lionagi"]
+        self.work_dir = work_dir or Path.cwd() / "coder" / "code_files"
         print("Coder initialized.")
 
     def _create_session(self, session_kwargs=None):
@@ -32,7 +63,7 @@ class Coder:
         print("Writing code...")
         code = await self.session.chat(self.prompts["write_code"], context=context)
         print("Code writing completed.")
-        return extract_code_blocks(code)
+        return ParseUtil.extract_code_blocks(code)
 
     async def _review_code(self, context=None):
         print("Reviewing code...")
@@ -78,6 +109,22 @@ class Coder:
             print("Code execution completed.")
             return execution
 
+    def _save_code_file(self, code, **kwargs):
+        print("Saving code...")
+        save_code_file(code, self.work_dir, **kwargs)
+        print("Code saved.")
+
+    @staticmethod
+    def _load_code_file(file_path):
+        print("Loading code...")
+        try:
+            with open(file_path, "r") as file:
+                print("Code loaded.")
+                return file.read()
+        except FileNotFoundError:
+            _logging.error(f"File not found: {file_path}")
+            return None
+
 
 async def main():
     print("Starting main function...")

lionagi/lions/coder/util.py

@@ -1,3 +1,6 @@
+from typing import Any
+from pathlib import Path
+
 E2B_key_scheme = "E2B_API_KEY"
 
 
@@ -21,31 +24,6 @@ def set_up_interpreter(interpreter_provider="e2b", key_scheme=E2B_key_scheme):
         raise ValueError("Invalid interpreter provider")
 
 
-def extract_code_blocks(code):
-    print("Extracting code blocks...")
-    code_blocks = []
-    lines = code.split("\n")
-    inside_code_block = False
-    current_block = []
-
-    for line in lines:
-        if line.startswith("```"):
-            if inside_code_block:
-                code_blocks.append("\n".join(current_block))
-                current_block = []
-                inside_code_block = False
-            else:
-                inside_code_block = True
-        elif inside_code_block:
-            current_block.append(line)
-
-    if current_block:
-        code_blocks.append("\n".join(current_block))
-
-    print(f"Extracted {len(code_blocks)} code block(s).")
-    return "\n\n".join(code_blocks)
-
-
 def install_missing_dependencies(required_libraries):
     print("Checking for missing dependencies...")
     missing_libraries = [
@@ -89,3 +67,30 @@ def install_library(library):
         print(
             "You may need to run the script with administrative privileges or use a virtual environment."
         )
+
+
+def save_code_file(
+    code: Any,
+    directory: Path | str = None,
+    filename: str = "code.py",
+    timestamp: bool = True,
+    dir_exist_ok: bool = True,
+    time_prefix: bool = False,
+    custom_timestamp_format: str | None = None,
+    random_hash_digits: int = 3,
+    verbose: bool = True,
+):
+
+    from lionagi.libs import SysUtil
+
+    return SysUtil.save_to_file(
+        text=code,
+        directory=directory,
+        filename=filename,
+        timestamp=timestamp,
+        dir_exist_ok=dir_exist_ok,
+        time_prefix=time_prefix,
+        custom_timestamp_format=custom_timestamp_format,
+        random_hash_digits=random_hash_digits,
+        verbose=verbose,
+    )

lionagi/tests/libs/test_func_call.py

@@ -296,8 +296,8 @@ class TestRCall(unittest.IsolatedAsyncioTestCase):
             await asyncio.sleep(2)
             return x
 
-        with self.assertRaises(asyncio.TimeoutError):
-            await rcall(async_func, 5, timeout=1)
+        with self.assertRaises(RuntimeError):
+            await rcall(async_func, 5, timeout=0.1)
 
     async def test_retry_mechanism(self):
         attempt_count = 0
@@ -307,22 +307,22 @@ class TestRCall(unittest.IsolatedAsyncioTestCase):
             attempt_count += 1
             raise ValueError("Test Error")
 
-        with self.assertRaises(ValueError):
-            await rcall(sync_func, 5, retries=3)
+        with self.assertRaises(RuntimeError):
+            await rcall(sync_func, 5, retries=3, delay=0.1, backoff_factor=1.1)
         self.assertEqual(attempt_count, 3)  # Initial call + 3 retries
 
     async def test_default_value_on_exception(self):
         def sync_func(x):
             raise ValueError("Test Error")
 
-        result = await rcall(sync_func, 5, default=10)
+        result = await rcall(sync_func, 5, default=10, delay=0)
         self.assertEqual(result, 10)
 
     async def test_exception_propagation(self):
         def sync_func(x):
             raise ValueError("Test Error")
 
-        with self.assertRaises(ValueError):
+        with self.assertRaises(RuntimeError):
             await rcall(sync_func, 5)
 
 
@@ -581,22 +581,22 @@ class TestCallDecorator(unittest.IsolatedAsyncioTestCase):
 class TestThrottleClass(unittest.TestCase):
 
     def test_throttling_behavior_sync(self):
-        throttle_decorator = Throttle(2)  # 2 seconds throttle period
+        throttle_decorator = Throttle(0.1)  # 2 seconds throttle period
 
         @throttle_decorator
         def test_func():
             return time.time()
 
         first_call_time = test_func()
-        time.sleep(1)  # Sleep less than the throttle period
+        time.sleep(0.1)  # Sleep less than the throttle period
         second_call_time = test_func()
 
         self.assertGreaterEqual(
-            second_call_time - first_call_time, 2
+            second_call_time - first_call_time, 0.1
         )  # Second call should be throttled
 
     def test_throttling_behavior_async(self):
-        throttle_decorator = Throttle(2)  # 2 seconds throttle period
+        throttle_decorator = Throttle(1)  # 2 seconds throttle period
 
         @throttle_decorator
         async def test_func():
@@ -604,28 +604,28 @@ class TestThrottleClass(unittest.TestCase):
 
         async def async_test():
             first_call_time = await test_func()
-            await asyncio.sleep(1)  # Sleep less than the throttle period
+            await asyncio.sleep(0.1)  # Sleep less than the throttle period
             second_call_time = await test_func()
 
             self.assertGreaterEqual(
-                second_call_time - first_call_time, 2
+                second_call_time - first_call_time, 1
             )  # Second call should be throttled
 
         asyncio.run(async_test())
 
     def test_successive_calls_with_sufficient_delay(self):
-        throttle_decorator = Throttle(1)  # 1 second throttle period
+        throttle_decorator = Throttle(0.1)  # 1 second throttle period
 
         @throttle_decorator
         def test_func():
             return time.time()
 
         first_call_time = test_func()
-        time.sleep(1.1)  # Sleep more than the throttle period
+        time.sleep(0.12)  # Sleep more than the throttle period
         second_call_time = test_func()
 
         self.assertLess(
-            second_call_time - first_call_time, 1.5
+            second_call_time - first_call_time, 0.2
         )  # Second call should not be throttled
 
 
@@ -633,7 +633,7 @@ class TestAsyncRetryDecorator(unittest.IsolatedAsyncioTestCase):
     async def test_successful_retry(self):
         attempt = 0
 
-        @CallDecorator.retry(retries=3, delay=1, backoff_factor=2)
+        @CallDecorator.retry(retries=3, delay=0.1, backoff_factor=2)
         async def test_func():
             nonlocal attempt
             attempt += 1
@@ -648,20 +648,22 @@ class TestAsyncRetryDecorator(unittest.IsolatedAsyncioTestCase):
     async def test_retry_limit(self):
         attempt = 0
 
-        @CallDecorator.retry(retries=2, delay=1, backoff_factor=2)
+        @CallDecorator.retry(retries=2, delay=0.1, backoff_factor=2)
         async def test_func():
             nonlocal attempt
             attempt += 1
             raise ValueError("Test failure")
 
-        with self.assertRaises(ValueError):
+        try:
             await test_func()
+        except:
+            pass
         self.assertEqual(attempt, 2)
 
     async def test_immediate_success(self):
         attempt = 0
 
-        @CallDecorator.retry(retries=3, delay=1, backoff_factor=2)
+        @CallDecorator.retry(retries=3, delay=0.1, backoff_factor=2)
         async def test_func():
             nonlocal attempt
             attempt += 1
@@ -675,7 +677,7 @@ class TestAsyncRetryDecorator(unittest.IsolatedAsyncioTestCase):
         attempt = 0
         start_time = time.time()
 
-        @CallDecorator.retry(retries=3, delay=1, backoff_factor=2)
+        @CallDecorator.retry(retries=3, delay=0.1, backoff_factor=2)
         async def test_func():
             nonlocal attempt
             attempt += 1
@@ -690,7 +692,7 @@ class TestAsyncRetryDecorator(unittest.IsolatedAsyncioTestCase):
         self.assertEqual(result, "Success")
         # Note: The actual delay might be slightly longer than expected due to asyncio's event loop scheduling.
         self.assertTrue(
-            elapsed_time >= 3, f"Elapsed time was {elapsed_time}, expected >= 3"
+            elapsed_time >= 0.3, f"Elapsed time was {elapsed_time}, expected >= 3"
         )
         self.assertEqual(attempt, 3)
 

lionagi/tests/libs/test_nested.py

@@ -39,7 +39,7 @@ class TestNSet(unittest.TestCase):
         """Test flattening and then unflattening a nested dictionary."""
         original = {"a": {"b": {"c": 1}}}
         flattened = flatten(original)
-        self.assertEqual(flattened, {"a_b_c": 1})
+        self.assertEqual(flattened, {"a[^_^]b[^_^]c": 1})
         unflattened = unflatten(flattened)
         self.assertEqual(original, unflattened)
 
@@ -225,27 +225,36 @@ 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})
+        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})
+        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}})
+        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})
+        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})
+        self.assertEqual(nested_dict, {"a[^_^]b": 1})
 
     def test_flatten_empty_structure(self):
         self.assertEqual(flatten({}), {})
@@ -254,18 +263,18 @@ class TestFlatten(unittest.TestCase):
     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})
+        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}
+        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]}
+        flat_dict = {"0[^_^]0": 1, "0[^_^]1": 2, "1": [3, 4]}
         result = unflatten(flat_dict)
         self.assertEqual(result, [[1, 2], [3, 4]])
 
@@ -275,26 +284,26 @@ class TestUnflatten(unittest.TestCase):
         self.assertEqual(result, {"a": {"b": 1, "c": {"d": 2}}})
 
     def test_unflatten_with_custom_logic(self):
-        flat_dict = {"a_1": "one", "a_2": "two"}
+        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}
+        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}})
+        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}
+        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}]])
+        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}
+        flat_dict = {"0[^_^]0": 1, "1[^_^]key": 2}
         result = unflatten(flat_dict)
         self.assertEqual(result, [[1], {"key": 2}])
 
@@ -319,7 +328,7 @@ class TestNInsert(unittest.TestCase):
     def test_insert_with_max_depth(self):
         obj = {}
         ninsert(obj, ["a", "b", "c"], "value", max_depth=1)
-        self.assertEqual(obj, {"a": {"b_c": "value"}})
+        self.assertEqual(obj, {"a": {"b[^_^]c": "value"}})
 
     def test_insert_into_empty_structure(self):
         obj = {}
@@ -331,24 +340,30 @@ 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"]
+        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"]
+        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"]
+        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"]
+        expected_keys = ["a", "b[^_^]c"]
         self.assertEqual(
             set(get_flattened_keys(nested_mix, dict_only=True)), set(expected_keys)
         )
@@ -358,7 +373,7 @@ class TestGetFlattenedKeys(unittest.TestCase):
 
     def test_keys_from_deeply_nested_structure(self):
         deeply_nested = {"a": {"b": {"c": {"d": 1}}}}
-        expected_keys = ["a_b_c_d"]
+        expected_keys = ["a[^_^]b[^_^]c[^_^]d"]
         self.assertEqual(set(get_flattened_keys(deeply_nested)), set(expected_keys))
 
 

lionagi/tests/libs/test_parse.py

@@ -55,7 +55,7 @@ class TestFuzzyParseJson(unittest.TestCase):
     def test_extract_code_block(self):
         """Test extracting and parsing code blocks from Markdown."""
         markdown = '```python\nprint("Hello, world!")\n```'
-        result = ParseUtil.extract_code_block(
+        result = ParseUtil.extract_json_block(
             markdown, language="python", parser=lambda x: x
         )
         self.assertEqual(result, 'print("Hello, world!")')