lionagi 0.0.114__py3-none-any.whl → 0.0.116__py3-none-any.whl

lionagi/tests/test_encrypt_util.py

@@ -0,0 +1,33 @@
+import unittest
+from cryptography.fernet import Fernet
+
+# Assuming the Python module with the above functions is named 'encryption_utils'
+from lionagi.utils.encrypt_util import generate_encryption_key, encrypt, decrypt
+
+class TestEncryptionUtils(unittest.TestCase):
+
+    def test_generate_encryption_key(self):
+        key = generate_encryption_key()
+        self.assertIsInstance(key, str)
+        self.assertEqual(len(key), 44)  # Fernet keys are 44 bytes long in URL-safe base64 encoding
+
+    def test_encrypt_decrypt(self):
+        key = generate_encryption_key()
+        original_data = "Test data for encryption"
+        encrypted_data = encrypt(original_data, key)
+        decrypted_data = decrypt(encrypted_data, key)
+
+        self.assertNotEqual(encrypted_data, original_data)
+        self.assertEqual(decrypted_data, original_data)
+
+    def test_invalid_key(self):
+        key = generate_encryption_key()
+        wrong_key = Fernet.generate_key().decode()
+        original_data = "Test data for encryption"
+        encrypted_data = encrypt(original_data, key)
+
+        with self.assertRaises(Exception):
+            decrypt(encrypted_data, wrong_key)
+
+if __name__ == '__main__':
+    unittest.main()

lionagi/tests/{test_flatten_util.py → test_flat_util.py}

@@ -1,6 +1,6 @@
 import unittest
 
-from ..utils.flat_util import *
+from lionagi.utils.flat_util import *
 
 class TestFlattenDict(unittest.TestCase): 
 

lionagi/tools/__init__.py

@@ -0,0 +1,5 @@
+from .tool_util import func_to_tool
+
+__all__ = [
+    "func_to_tool"
+]

lionagi/tools/tool_util.py

@@ -0,0 +1,7 @@
+# use schema and convert_util
+from ..utils.convert_util import func_to_schema
+from ..schema.base_tool import Tool
+
+def func_to_tool(func_, parser=None, docstring_style='google'):
+    schema = func_to_schema(func_, docstring_style)
+    return Tool(func=func_, parser=parser, schema_=schema)

lionagi/utils/__init__.py

@@ -1,49 +1,69 @@
+from .sys_util import (
+    create_copy, create_id, create_path, create_hash, 
+    change_dict_key, get_timestamp, get_bins, timestamp_to_datetime, 
+    is_schema, split_path
+)
+
 from .flat_util import (
     flatten_dict, flatten_list, change_separator, 
     unflatten_dict, is_flattenable, dynamic_flatten, 
-    unflatten_to_list, flatten_iterable, flatten_iterable_to_list
-    )
-
-from .sys_util import (
-    create_copy, get_timestamp, create_id, create_path, 
-    split_path, get_bins, change_dict_key
-    )
-
+    unflatten_to_list, flatten_iterable, flatten_iterable_to_list, 
+    to_list
+)
 
 from .api_util import (
     api_method, api_endpoint_from_url, api_error, 
     api_rate_limit_error
-    )
+)
+from .encrypt_util import generate_encryption_key, encrypt, decrypt
+from .convert_util import str_to_num, dict_to_xml, xml_to_dict
 
+from .io_util import to_temp, to_csv, append_to_jsonl
 from .call_util import (
     hcall, ahcall, lcall, alcall, 
     mcall, amcall, ecall, aecall
-    )
-
-from .io_util import to_temp, to_csv, append_to_jsonl
-from .load_utils import dir_to_path, dir_to_nodes,  chunk_text, read_text, file_to_chunks
-from .type_util import str_to_num, to_list
-from .tool_util import func_to_schema
-
-
-
+)
 
 
 __all__ = [
-    "api_method", "api_endpoint_from_url", "api_error", 
-    "api_rate_limit_error",
-    
-    "flatten_dict", "flatten_list", "change_separator", 
-    "unflatten_dict", "is_flattenable", "dynamic_flatten", 
-    "unflatten_to_list", "flatten_iterable", "flatten_iterable_to_list",
-    
-    "create_copy", "get_timestamp", "create_id", "create_path", 
-    "split_path", "get_bins", "change_dict_key",
-    
-    "hcall", "ahcall", "lcall", "alcall", 
-    "mcall", "amcall", "ecall", "aecall",
-    
-    "to_temp", "to_csv", "append_to_jsonl",
-    "dir_to_path", "chunk_text", "file_to_chunks",
-    "str_to_num", "to_list", "func_to_schema"
-]
+    'api_method', 
+    'api_endpoint_from_url', 
+    'api_error', 
+    'api_rate_limit_error', 
+    'flatten_dict', 
+    'flatten_list', 
+    'change_separator', 
+    'unflatten_dict', 
+    'is_flattenable', 
+    'dynamic_flatten', 
+    'unflatten_to_list', 
+    'flatten_iterable', 
+    'flatten_iterable_to_list', 
+    'create_copy', 
+    'create_id', 
+    'create_path', 
+    'create_hash', 
+    'change_dict_key', 
+    'get_timestamp', 
+    'get_bins', 
+    'timestamp_to_datetime', 
+    'is_schema', 
+    'split_path', 
+    'generate_encryption_key', 
+    'encrypt', 'decrypt', 
+    'str_to_num', 
+    'to_list', 
+    'dict_to_xml', 
+    'xml_to_dict', 
+    'to_temp', 
+    'to_csv', 
+    'append_to_jsonl', 
+    'hcall', 
+    'ahcall', 
+    'lcall', 
+    'alcall', 
+    'mcall', 
+    'amcall', 
+    'ecall', 
+    'aecall'
+]

lionagi/utils/api_util.py

@@ -1,3 +1,4 @@
+# this module has no internal dependency 
 import logging
 import re
 from typing import Callable
@@ -32,23 +33,6 @@ def api_method(http_session, method: str = "post") -> Callable:
         return http_session.options
     elif method == "patch":
         return http_session.patch
-
-def api_endpoint_from_url(request_url: str) -> str:
-    """
-    Extracts the API endpoint from a given URL.
-
-    Parameters:
-        request_url (str): The URL from which to extract the API endpoint.
-
-    Returns:
-        str: The extracted API endpoint, or an empty string if no match is found.
-
-    Examples:
-        endpoint = api_endpoint_from_url("https://api.example.com/v1/users")
-        # endpoint will be 'users'
-    """
-    match = re.search(r"^https://[^/]+/v\d+/(.+)$", request_url)
-    return match.group(1) if match else ""
     
 def api_error(response_json: dict) -> bool:
     """
@@ -84,3 +68,21 @@ def api_rate_limit_error(response_json: dict) -> bool:
             # Handle the rate limit error
     """
     return "Rate limit" in response_json["error"].get("message", "")
+
+# credit to OpenAI for this method
+def api_endpoint_from_url(request_url: str) -> str:
+    """
+    Extracts the API endpoint from a given URL.
+
+    Parameters:
+        request_url (str): The URL from which to extract the API endpoint.
+
+    Returns:
+        str: The extracted API endpoint, or an empty string if no match is found.
+
+    Examples:
+        endpoint = api_endpoint_from_url("https://api.example.com/v1/users")
+        # endpoint will be 'users'
+    """
+    match = re.search(r"^https://[^/]+/v\d+/(.+)$", request_url)
+    return match.group(1) if match else ""

lionagi/utils/call_util.py

@@ -1,9 +1,10 @@
+# use sys_util and flat_util
 import asyncio
 import time
 from typing import Any, Callable, List, Optional, Union
 
 from .sys_util import create_copy
-from .type_util import to_list
+from .flat_util import to_list
 
 
 def hcall(

lionagi/utils/convert_util.py

@@ -0,0 +1,229 @@
+# this module has no internal dependency 
+import inspect
+import re
+import xml.etree.ElementTree as ET
+from typing import Optional, Union, Any, Type, Dict
+
+
+def str_to_num(input_: str, 
+               upper_bound: Optional[Union[int, float]] = None, 
+               lower_bound: Optional[Union[int, float]] = None, 
+               num_type: Type[Union[int, float]] = int, 
+               precision: Optional[int] = None) -> Union[int, float]:
+    """
+    Converts the first number in the input string to the specified numeric type.
+
+    Parameters:
+        input_ (str): The input string to extract the number from.
+        
+        upper_bound (Optional[Union[int, float]]): The upper bound for the number. Defaults to None.
+        
+        lower_bound (Optional[Union[int, float]]): The lower bound for the number. Defaults to None.
+        
+        num_type (Type[Union[int, float]]): The type of the number to return (int or float). Defaults to int.
+        
+        precision (Optional[int]): The precision for the floating-point number. Defaults to None.
+
+    Returns:
+        Union[int, float]: The converted number.
+
+    Raises:
+        ValueError: If no numeric values are found in the string or if there are conversion errors.
+    """
+    numbers = re.findall(r'-?\d+\.?\d*', input_)
+    if not numbers:
+        raise ValueError(f"No numeric values found in the string: {input_}")
+    
+    try:
+        numbers = numbers[0]
+        if num_type is int: 
+            numbers = int(float(numbers))
+        elif num_type is float:
+            numbers = round(float(numbers), precision) if precision is not None else float(numbers)
+        else:
+            raise ValueError(f"Invalid number type: {num_type}")
+        if upper_bound is not None and numbers > upper_bound:
+            raise ValueError(f"Number {numbers} is greater than the upper bound of {upper_bound}.")
+        if lower_bound is not None and numbers < lower_bound:
+            raise ValueError(f"Number {numbers} is less than the lower bound of {lower_bound}.")
+        return numbers
+    
+    except ValueError as e:
+        raise ValueError(f"Error converting string to number: {e}")
+    
+def dict_to_xml(data: Dict[str, Any], root_tag: str = 'node') -> str:
+    """
+    Helper method to convert a dictionary to an XML string.
+
+    Parameters:
+        data (Dict[str, Any]): The dictionary to convert to XML.
+        root_tag (str): The root tag name for the XML.
+
+    Returns:
+        str: An XML string representation of the dictionary.
+    """
+    root = ET.Element(root_tag)
+    _build_xml(root, data)
+    return ET.tostring(root, encoding='unicode')
+
+def _build_xml(element: ET.Element, data: Any):
+    """Recursively builds XML elements from data."""
+    if isinstance(data, dict):
+        for key, value in data.items():
+            sub_element = ET.SubElement(element, key)
+            _build_xml(sub_element, value)
+    elif isinstance(data, list):
+        for item in data:
+            item_element = ET.SubElement(element, 'item')
+            _build_xml(item_element, item)
+    else:
+        element.text = str(data)
+
+def xml_to_dict(element: ET.Element) -> Dict[str, Any]:
+    """
+    Helper method to convert an XML element back into a dictionary.
+    """
+    dict_data = {}
+    for child in element:
+        if child.getchildren():
+            dict_data[child.tag] = xml_to_dict(child)
+        else:
+            dict_data[child.tag] = child.text
+    return dict_data
+
+def extract_docstring_details_google(func):
+    docstring = inspect.getdoc(func)
+    if not docstring:
+        return "No description available.", {}
+    lines = docstring.split('\n')
+    func_description = lines[0].strip()
+
+    param_start_pos = 0
+    lines_len = len(lines)
+
+    params_description = {}
+    for i in range(1, lines_len):
+        if lines[i].startswith('Args') or lines[i].startswith('Arguments') or lines[i].startswith('Parameters'):
+            param_start_pos = i + 1
+            break
+
+    current_param = None
+    for i in range(param_start_pos, lines_len):
+        if lines[i] == '':
+            continue
+        elif lines[i].startswith(' '):
+            param_desc = lines[i].split(':', 1)
+            if len(param_desc) == 1:
+                params_description[current_param] += ' ' + param_desc[0].strip()
+                continue
+            param, desc = param_desc
+            param = param.split('(')[0].strip()
+            params_description[param] = desc.strip()
+            current_param = param
+        else:
+            break
+    return func_description, params_description
+
+def extract_docstring_details_rest(func):
+    docstring = inspect.getdoc(func)
+    if not docstring:
+        return "No description available.", {}
+    lines = docstring.split('\n')
+    func_description = lines[0].strip()
+
+    params_description = {}
+    current_param = None
+    for line in lines[1:]:
+        line = line.strip()
+        if line.startswith(':param'):
+            param_desc = line.split(':', 2)
+            _, param, desc = param_desc
+            param = param.split()[-1].strip()
+            params_description[param] = desc.strip()
+            current_param = param
+        elif line.startswith(' '):
+            params_description[current_param] += ' ' + line
+
+    return func_description, params_description
+
+def extract_docstring_details(func, style='google'):
+    if style == 'google':
+        func_description, params_description = extract_docstring_details_google(func)
+    elif style == 'reST':
+        func_description, params_description = extract_docstring_details_rest(func)
+    else:
+        raise ValueError(f'{style} is not supported. Please choose either "google" or "reST".')
+    return func_description, params_description
+
+def python_to_json_type(py_type):
+    """
+    Converts a Python type to its JSON type equivalent.
+
+    Parameters:
+        py_type (str): The name of the Python type.
+
+    Returns:
+        str: The corresponding JSON type.
+    """
+    type_mapping = {
+        'str': 'string',
+        'int': 'number',
+        'float': 'number',
+        'list': 'array',
+        'tuple': 'array',
+        'bool': 'boolean',
+        'dict': 'object'
+    }
+    return type_mapping.get(py_type, 'object')
+
+def func_to_schema(func, style='google'):
+    """
+    Generates a schema description for a given function, using typing hints and docstrings.
+    The schema includes the function's name, description, and parameters.
+
+    Parameters:
+        func (function): The function to generate a schema for.
+
+        style (str): The docstring format.
+
+    Returns:
+        dict: A schema describing the function.
+    """
+    # Extracting function name and docstring details
+    func_name = func.__name__
+    func_description, params_description = extract_docstring_details(func, style)
+
+    # Extracting parameters with typing hints
+    sig = inspect.signature(func)
+    parameters = {
+        "type": "object",
+        "properties": {},
+        "required": [],
+    }
+
+    for name, param in sig.parameters.items():
+        # Default type to string and update if type hint is available
+        param_type = "string"
+        if param.annotation is not inspect.Parameter.empty:
+            param_type = python_to_json_type(param.annotation.__name__)
+
+        # Extract parameter description from docstring, if available
+        param_description = params_description.get(name, "No description available.")
+
+        # Assuming all parameters are required for simplicity
+        parameters["required"].append(name)
+        parameters["properties"][name] = {
+            "type": param_type,
+            "description": param_description,
+        }
+
+    # Constructing the schema
+    schema = {
+        "type": "function",
+        "function": {
+            "name": func_name,
+            "description": func_description,
+            "parameters": parameters,
+        }
+    }
+    return schema

lionagi/utils/encrypt_util.py

@@ -0,0 +1,16 @@
+# this module has no internal dependency 
+from cryptography.fernet import Fernet
+
+def generate_encryption_key() -> str:
+    """Generates a key for encryption."""
+    return Fernet.generate_key().decode()
+
+def encrypt(data: str, key: str) -> str:
+    """Encrypts data using the provided key."""
+    fernet = Fernet(key.encode())
+    return fernet.encrypt(data.encode()).decode()
+
+def decrypt(data: str, key: str) -> str:
+    """Decrypts data using the provided key."""
+    fernet = Fernet(key.encode())
+    return fernet.decrypt(data.encode()).decode()

lionagi/utils/flat_util.py

@@ -1,3 +1,4 @@
+# this module has no internal dependency 
 from typing import Dict, Iterable, List, Any, Callable, Generator, Tuple
 
 
@@ -487,6 +488,43 @@ def unflatten_dict_with_custom_logic(
         d[modified_last_part] = modified_value
     return reconstructed
 
+def to_list(input_: Any, flatten: bool = True, dropna: bool = False) -> List[Any]:
+    """
+    Converts the input to a list, optionally flattening it and dropping None values.
+
+    Parameters:
+        input_ (Any): The input to convert to a list.
+        
+        flatten (bool): Whether to flatten the input if it is a nested list. Defaults to True.
+        
+        dropna (bool): Whether to drop None values from the list. Defaults to False.
+
+    Returns:
+        List[Any]: The input converted to a list.
+
+    Raises:
+        ValueError: If the input cannot be converted to a list.
+    """
+    if isinstance(input_, list) and flatten:
+        input_ = flatten_list(input_)
+        if dropna:
+            input_ = [i for i in input_ if i is not None]
+    elif isinstance(input_, Iterable) and not isinstance(input_, (str, dict)):
+        try:
+            input_ = list(input_)
+        except:
+            raise ValueError("Input cannot be converted to a list.")
+    else:
+        input_ = [input_]
+    return input_
+
+
+
+
+
+
+
+
 # def dynamic_unflatten(flat_dict, sep='_', custom_logic=None, max_depth=None):
 #     """
 #     Unflattens a dictionary with flat keys into a nested dictionary or list.

lionagi/utils/io_util.py

@@ -1,9 +1,10 @@
+# used flat_util
 import csv
 import json
 import os
 import tempfile
 from typing import Any, Dict, List
-from .type_util import to_list
+from .flat_util import to_list
 
 
 def to_temp(input: Any, 
@@ -79,7 +80,6 @@ def to_csv(input: List[Dict[str, Any]]=None,
         writer.writeheader()
         writer.writerows(input)
 
-
 def append_to_jsonl(data: Any, filepath: str) -> None:
     """
     Appends data to a JSON lines (jsonl) file.

lionagi/utils/sys_util.py

@@ -13,12 +13,14 @@ Copyright 2023 HaiyangLi <ocean@lionagi.ai>
    See the License for the specific language governing permissions and
    limitations under the License.
 """
+
+# this module has no internal dependency 
 import os
 import copy
 import hashlib
 from pathlib import Path
 from datetime import datetime
-from typing import Any, Generator, List
+from typing import Any, Generator, List, Dict
 
 def create_copy(input: Any, n: int) -> Any:
     """
@@ -164,6 +166,48 @@ def get_bins(input: List[str], upper: int = 7500) -> List[List[int]]:
     
     return bins
 
+def change_dict_key(dict_, old_key, new_key):
+    dict_[new_key] = dict_.pop(old_key)
+
+def timestamp_to_datetime(timestamp: int) -> str:
+    if isinstance(timestamp, str):
+        try:
+            timestamp = int(timestamp)
+        except:
+            return timestamp
+    return datetime.fromtimestamp(timestamp).strftime('%Y-%m-%d %H:%M:%S')
+
+def is_schema(dict_: Dict, schema: Dict):
+    for key, expected_type in schema.items():
+        if not isinstance(dict_[key], expected_type):
+            return False
+    return True
+
+def create_hash(data: str, algorithm: str = 'sha256') -> str:
+    """
+    Generates a hash for the given data using the specified algorithm.
+
+    Parameters:
+        data (str): The data to be hashed.
+        algorithm (str): The hashing algorithm to use (e.g., 'sha256', 'md5').
+
+    Returns:
+        str: The generated hash string.
+    """
+    hasher = hashlib.new(algorithm)
+    hasher.update(data.encode())
+    return hasher.hexdigest()
+
+
+
+# def parse_function_call(response: str) -> Tuple[str, Dict]:
+#     out = json.loads(response)
+#     func = out.get('function', '').lstrip('call_')
+#     args = json.loads(out.get('arguments', '{}'))
+#     return func, args
+
+# ------------------------------------------------------------------------
+# credit to OpenAI for the following functions
 def task_id_generator() -> Generator[int, None, None]:
     """
     A generator function that yields a sequential series of task IDs.
@@ -180,12 +224,3 @@ def task_id_generator() -> Generator[int, None, None]:
     while True:
         yield task_id
         task_id += 1
-
-def change_dict_key(dict_, old_key, new_key):
-    dict_[new_key] = dict_.pop(old_key)
-
-# def parse_function_call(response: str) -> Tuple[str, Dict]:
-#     out = json.loads(response)
-#     func = out.get('function', '').lstrip('call_')
-#     args = json.loads(out.get('arguments', '{}'))
-#     return func, args

lionagi/version.py

@@ -1 +1 @@
-__version__ = "0.0.114"
+__version__ = "0.0.116"

{lionagi-0.0.114.dist-info → lionagi-0.0.116.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lionagi
-Version: 0.0.114
+Version: 0.0.116
 Summary: Towards automated general intelligence.
 Author: HaiyangLi
 Author-email: Haiyang Li <ocean@lionagi.ai>
@@ -224,7 +224,7 @@ Requires-Dist: httpx ==0.25.1
 
 
 
-[PyPI](https://pypi.org/project/lionagi/) | [Documentation](https://lionagi.readthedocs.io/en/latest/) | [Discord](https://discord.gg/7RGWqpSxze)
+[PyPI](https://pypi.org/project/lionagi/) | [Documentation](https://lionagi.readthedocs.io/en/latest/) | [Discord](https://discord.gg/mzDD5JtYRp)
 
   
 # LionAGI