lionagi 0.0.201__py3-none-any.whl → 0.0.204__py3-none-any.whl

lionagi/utils/sys_util.py

@@ -1,300 +1,316 @@
 import os
+import copy
+from datetime import datetime
 import hashlib
 import re
-import copy
+
 import json
-from pathlib import Path
-from datetime import datetime
-from dateutil import parser
-from typing import Any, Dict, List, Optional, Type, Union
+import logging
+
+from typing import Any, List, Dict, Union
 
 
 def get_timestamp() -> str:
     """
-    Generates a current timestamp in a file-safe string format.
+    Generates a current timestamp in ISO format with colons and periods replaced by 
+    underscores.
 
     Returns:
-        The current timestamp in a file-safe string format.
+        str: The current timestamp.
 
     Examples:
-        >>> get_timestamp()  # Doctest: +ELLIPSIS
-        '...'
+    >>> isinstance(get_timestamp(), str)
+    True
     """
     return datetime.now().isoformat().replace(":", "_").replace(".", "_")
 
-def create_copy(input: Any, n: int) -> Any:
+def create_copy(input: Any, n: int = 1) -> Any:
     """
-    Creates a deep copy of the input object a specified number of times.
+    Creates a deep copy of the given input. If 'n' is greater than 1, returns a 
+    list of deep copies.
 
     Args:
-        input: The object to be copied.
-        n: The number of deep copies to create.
-
-    Raises:
-        ValueError: If 'n' is not a positive integer.
+        input (Any): The object to be copied.
+        n (int, optional): The number of copies to create. Defaults to 1.
 
     Returns:
-        A deep copy of 'input' or a list of deep copies if 'n' > 1.
+        Any: A deep copy of the input, or a list of deep copies.
 
+    Raises:
+        ValueError: If 'n' is not a positive integer.
+        
     Examples:
-        >>> sample_dict = {'key': 'value'}
-        >>> create_copy(sample_dict, 2)
-        [{'key': 'value'}, {'key': 'value'}]
+    >>> create_copy([1, 2, 3], 2)
+    [[1, 2, 3], [1, 2, 3]]
+    >>> create_copy("Hello")
+    'Hello'
     """
     if not isinstance(n, int) or n < 1:
         raise ValueError(f"'n' must be a positive integer: {n}")
     return copy.deepcopy(input) if n == 1 else [copy.deepcopy(input) for _ in range(n)]
 
-def create_path(dir: str, filename: str, timestamp: bool = True, dir_exist_ok: bool = True, time_prefix=False) -> str:
+def create_path(
+    dir: str, filename: str, timestamp: bool = True, dir_exist_ok: bool = True, 
+    time_prefix: bool = False
+) -> str:
     """
-    Creates a file path by optionally appending a timestamp to the filename.
+    Creates a file path with an optional timestamp, ensuring the directory exists.
 
     Args:
-        dir: The directory in which the file is to be located.
-        filename: The name of the file.
-        timestamp: If True, appends a timestamp to the filename. Defaults to True.
-        dir_exist_ok: If True, creates the directory if it doesn't exist. Defaults to True.
-        time_prefix: If True, the timestamp is added as a prefix; otherwise, it's appended. Defaults to False.
+        dir (str): The directory in which the file will be placed.
+        filename (str): The name of the file.
+        timestamp (bool, optional): Flag to include a timestamp in the filename. Defaults to True.
+        dir_exist_ok (bool, optional): Flag to create the directory if it doesn't exist. Defaults to True.
+        time_prefix (bool, optional): Flag to place the timestamp as a prefix. Defaults to False.
 
     Returns:
-        The full path to the file.
+        str: The full path of the file with the optional timestamp.
 
     Examples:
-        >>> create_path('/tmp/', 'log.txt', timestamp=False)
-        '/tmp/log.txt'
+    >>> create_path("/tmp", "log.txt", timestamp=False)
+    '/tmp/log.txt'
+    >>> isinstance(create_path("/tmp", "report", time_prefix=True), str)
+    True
     """
-    
-    dir = dir + '/' if str(dir)[-1] != '/' else dir
-    filename, ext = filename.split('.')
-    os.makedirs(dir, exist_ok=dir_exist_ok)
-    
-    if timestamp:
-        timestamp = get_timestamp()
-        return f"{dir}{timestamp}_{filename}.{ext}" if time_prefix else f"{dir}{filename}_{timestamp}.{ext}"
+    dir = dir + '/' if not dir.endswith('/') else dir
+    if '.' in filename:
+        name, ext = filename.rsplit('.', 1)
     else:
-        return f"{dir}{filename}"
+        name, ext = filename, ''
+    os.makedirs(dir, exist_ok=dir_exist_ok)
+    timestamp_str = get_timestamp() if timestamp else ''
+    filename = f"{timestamp_str}_{name}" if time_prefix else f"{name}_{timestamp_str}"
+    return f"{dir}{filename}.{ext}" if ext else f"{dir}{filename}"
 
-def split_path(path: Path) -> tuple:
+def split_path(path: str) -> tuple:
     """
-    Splits a given path into folder name and file name.
+    Splits a file path into its directory name and file name.
 
     Args:
-        path: The path to split.
+        path (str): The file path to split.
 
     Returns:
-        A tuple containing the folder name and file name.
+        tuple: A tuple containing the directory name and file name.
+
+    Examples:
+    >>> split_path("/home/user/document.txt")
+    ('/home/user', 'document.txt')
+    >>> split_path("document.txt")
+    ('', 'document.txt')
     """
-    folder_name = path.parent.name
-    file_name = path.name
+    folder_name = os.path.dirname(path)
+    file_name = os.path.basename(path)
     return (folder_name, file_name)
 
-def get_bins(input: List[str], upper: int = 7500) -> List[List[int]]:
+def str_to_num(
+    input: str, upper_bound: float = None, lower_bound: float = None, 
+    num_type: type = int, precision: int = None
+) -> Any:
     """
-    Get index of elements in a list based on their consecutive cumulative sum of length.
+    Converts the first number in a string to a specified numeric type and checks if it 
+    falls within specified bounds.
 
     Args:
-        input: List of items to be binned.
-        upper: Upper threshold for the cumulative sum of the length of items in a bin.
+        input (str): The string containing the number.
+        upper_bound (float, optional): The upper limit for the number. Defaults to None.
+        lower_bound (float, optional): The lower limit for the number. Defaults to None.
+        num_type (type): The numeric type to which the number will be converted. Default is int.
+        precision (int, optional): The precision for floating point numbers. Defaults to None.
 
     Returns:
-        List of lists, where each inner list contains the indices of the items that form a bin.
+        Any: The converted number in the specified type.
+
+    Raises:
+        ValueError: If no numeric value is found, or the number is outside the specified bounds.
 
     Examples:
-        >>> items = ['apple', 'a', 'b', 'banana', 'cheery', 'c', 'd', 'e']
-        >>> upper = 10
-        >>> get_bins(items, upper)
-        [[0, 1, 2], [3], [4, 5, 6, 7]]
+    >>> str_to_num("Value is 20.5", upper_bound=30, num_type=float)
+    20.5
+    >>> str_to_num("Temperature -5 degrees", lower_bound=0)
+    ValueError: Number -5 is less than the lower bound of 0.
+    """
+    number_str = _extract_first_number(input)
+    if number_str is None:
+        raise ValueError(f"No numeric values found in the string: {input}")
+    
+    number = _convert_to_num(number_str, num_type, precision)
+
+    if upper_bound is not None and number > upper_bound:
+        raise ValueError(f"Number {number} is greater than the upper bound of {upper_bound}.")
+    if lower_bound is not None and number < lower_bound:
+        raise ValueError(f"Number {number} is less than the lower bound of {lower_bound}.")
+
+    return number
+
+def get_bins(input: List[str], upper: int) -> List[List[int]]:
+    """
+    Distributes a list of strings into bins where the total length of strings in each 
+    bin is less than a specified upper limit.
+
+    Args:
+        input (List[str]): The list of strings to be distributed.
+        upper (int): The upper limit for the total length of strings in each bin.
+
+    Returns:
+        List[List[int]]: A list of lists, where each inner list contains indices of the 
+        input list that make up a bin.
+
+    Examples:
+    >>> get_bins(["one", "two", "three", "four", "five"], 10)
+    [[0, 1], [2], [3, 4]]
     """
     current = 0
     bins = []
-    bin = []
-    
+    current_bin = []
     for idx, item in enumerate(input):
         
         if current + len(item) < upper:
-            bin.append(idx)
+            current_bin.append(idx)
             current += len(item)
-    
-        elif current + len(item) >= upper:
-            bins.append(bin)
-            bin = [idx]
+            
+        else:
+            bins.append(current_bin)
+            current_bin = [idx]
             current = len(item)
-    
-        if idx == len(input) - 1 and len(bin) > 0:
-            bins.append(bin)
-    
+            
+    if current_bin:
+        bins.append(current_bin)
+        
     return bins
 
-def change_dict_key(dict_, old_key, new_key):
+def create_id(n: int = 32) -> str:
     """
-    Changes a key in a dictionary to a new key.
+    Creates a unique identifier using a combination of the current time and random bytes.
 
     Args:
-        dict_: The dictionary to change the key in.
-        old_key: The old key to be changed.
-        new_key: The new key to change to.
-    """
-    dict_[new_key] = dict_.pop(old_key)
-
-def create_id(n=32) -> str:
-    """
-    Generates a unique ID based on the current time and random bytes.
-
-    Args:
-        n: Length of the unique identifier to return. Defaults to 32.
+        n (int, optional): The length of the identifier. Defaults to 32.
 
     Returns:
-        A unique identifier.
+        str: The generated unique identifier.
 
     Examples:
-        >>> create_id()  # Doctest: +ELLIPSIS
-        '...'
+    >>> len(create_id())
+    32
+    >>> len(create_id(16))
+    16
     """
     current_time = datetime.now().isoformat().encode('utf-8')
     random_bytes = os.urandom(32)
     return hashlib.sha256(current_time + random_bytes).hexdigest()[:n]
 
-def str_to_datetime(datetime_str: str, fmt: Optional[str] = None) -> datetime:
+def directory_cleaner(directory: str) -> None:
     """
-    Convert a string representation of a date and time to a datetime object.
+    Deletes all files within a given directory.
 
     Args:
-        datetime_str: A string representing a date and time.
-        fmt: An optional format string.
+        directory (str): The path of the directory to clean.
 
-    Returns:
-        A datetime object corresponding to the given string.
+    Raises:
+        FileNotFoundError: If the specified directory does not exist.
+        Exception: If a file in the directory cannot be deleted.
 
     Examples:
-        >>> str_to_datetime("2023-01-01 12:00:00")
-        datetime.datetime(2023, 1, 1, 12, 0)
-        >>> str_to_datetime("January 1, 2023, 12:00 PM", "%B %d, %Y, %I:%M %p")
-        datetime.datetime(2023, 1, 1, 12, 0)
+    >>> directory_cleaner("/path/to/nonexistent/directory")
+    FileNotFoundError: The specified directory does not exist.
     """
-    if fmt:
-        return datetime.strptime(datetime_str, fmt)
-    else:
-        return parser.parse(datetime_str)
+    if not os.path.exists(directory):
+        raise FileNotFoundError("The specified directory does not exist.")
     
-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]:
+    for filename in os.listdir(directory):
+        file_path = os.path.join(directory, filename)
+        try:
+            if os.path.isfile(file_path) or os.path.islink(file_path):
+                os.unlink(file_path)
+                logging.info(f'Successfully deleted {file_path}')
+        except Exception as e:
+            logging.error(f'Failed to delete {file_path}. Reason: {e}')
+            raise
+
+def strip_lower(input: Any) -> str:
     """
-    Convert the first numeric value in the input string to the specified number type.
+    Strips and converts a given input to lower case.
 
     Args:
-        input_: The input string containing the numeric value.
-        upper_bound: The upper bound for the numeric value (optional).
-        lower_bound: The lower bound for the numeric value (optional).
-        num_type: The type of number to return (int or float).
-        precision: The number of decimal places to round to if num_type is float (optional).
+        input (Any): The input to be processed.
 
     Returns:
-        The numeric value converted to the specified type.
+        str: The processed string in lower case.
 
     Raises:
-        ValueError: If no numeric values are found or if the number type is invalid.
+        Exception: If the input cannot be converted to a string.
 
     Examples:
-        >>> str_to_num('Value is -123.456', num_type=float, precision=2)
-        -123.46
-        >>> str_to_num('Value is 100', upper_bound=99)
-        ValueError: Number 100 is greater than the upper bound of 99.
+    >>> strip_lower(" Hello WORLD ")
+    'hello world'
+    >>> strip_lower(123)
+    '123'
     """
-    numbers = re.findall(r'-?\d+\.?\d*', input_)
-    if not numbers:
-        raise ValueError(f"No numeric values found in the string: {input_}")
-    
-    number = numbers[0]
-    if num_type is int:
-        number = int(float(number))
-    elif num_type is float:
-        number = round(float(number), precision) if precision is not None else float(number)
-    else:
-        raise ValueError(f"Invalid number type: {num_type}")
-
-    if upper_bound is not None and number > upper_bound:
-        raise ValueError(f"Number {number} is greater than the upper bound of {upper_bound}.")
-    if lower_bound is not None and number < lower_bound:
-        raise ValueError(f"Number {number} is less than the lower bound of {lower_bound}.")
-
-    return number
+    try:
+        return str(input).strip().lower()
+    except:
+        return False
 
-def find_depth(nested_obj, depth_strategy='uniform', ignore_non_iterable=False):
+def _extract_first_number(inputstr: str) -> str:
     """
-    Calculates the maximum depth of a nested list, dictionary, or a combination of both.
+    Extracts the first number from a given string.
 
     Args:
-        nested_obj: The nested object to find the depth of.
-        depth_strategy: Strategy to calculate depth ('uniform' or 'mixed').
-        ignore_non_iterable: If True, non-iterable elements do not count towards depth.
+        inputstr (str): The string from which the number will be extracted.
 
     Returns:
-        The maximum depth of the nested structure.
+        str: The first number found in the string, returned as a string. 
+             Returns None if no number is found.
 
-    Raises:
-        ValueError: If an unsupported depth strategy is specified.
+    Examples:
+    >>> extract_first_number("The 2 little pigs")
+    '2'
+    >>> extract_first_number("No numbers")
+    None
     """
+    numbers = re.findall(r'-?\d+\.?\d*', inputstr)
+    return numbers[0] if numbers else None
 
-    def _uniform_depth(obj, current_depth=0):
-        """Calculates depth assuming uniform data types in nested_obj."""
-        if isinstance(obj, (list, tuple)):
-            return max((_uniform_depth(item, current_depth + 1) for item in obj), default=current_depth)
-        elif isinstance(obj, dict):
-            return max((_uniform_depth(value, current_depth + 1) for value in obj.values()), default=current_depth)
-        else:
-            return current_depth if ignore_non_iterable else 1
-
-    def _mixed_depth(obj, current_depth=0):
-        """Calculates depth allowing for mixed data types in nested_obj."""
-        if isinstance(obj, (list, tuple, dict)):
-            if isinstance(obj, dict):
-                obj = obj.values()
-            return max((_mixed_depth(item, current_depth + 1) for item in obj), default=current_depth)
-        else:
-            return current_depth if ignore_non_iterable else 1
-
-    if depth_strategy == 'uniform':
-        return _uniform_depth(nested_obj)
-    elif depth_strategy == 'mixed':
-        return _mixed_depth(nested_obj)
-    else:
-        raise ValueError("Unsupported depth strategy. Choose 'uniform' or 'mixed'.")
-
-def is_schema(dict_: Dict, schema: Dict):
+def _convert_to_num(number_str: str, num_type: type = int, precision: int = None) -> Any:
     """
-    Checks if a dictionary matches a given schema.
+    Converts a string representation of a number to a specified numeric type.
 
     Args:
-        dict_: The dictionary to check.
-        schema: The schema to validate against.
+        number_str (str): The string representation of the number.
+        num_type (type): The type to which the number will be converted. Default is int.
+        precision (int, optional): The precision for floating point numbers. Defaults to None.
 
     Returns:
-        True if the dictionary matches the schema, False otherwise.
+        Any: The converted number in the specified type.
+
+    Raises:
+        ValueError: If an invalid number type is provided.
+
+    Examples:
+    >>> convert_to_num("3.142", float, 2)
+    3.14
+    >>> convert_to_num("100", int)
+    100
     """
-    for key, expected_type in schema.items():
-        if not isinstance(dict_[key], expected_type):
-            return False
-    return True
+    if num_type is int:
+        return int(float(number_str))
+    elif num_type is float:
+        return round(float(number_str), precision) if precision is not None else float(number_str)
+    else:
+        raise ValueError(f"Invalid number type: {num_type}")
 
-def strip_lower(input_: Union[str, List[str]]) -> Union[str, List[str]]:
+def change_dict_key(dict_: Dict[Any, Any], old_key: str, new_key: str) -> None:
     """
-    Strips and converts a string or each string in a list to lowercase.
+    Changes a key in a dictionary to a new key.
 
     Args:
-        input_: A string or list of strings to process.
-
-    Returns:
-        The processed string or list of strings, or False on failure.
+        dict_ (Dict[Any, Any]): The dictionary to change the key in.
+        old_key (str): The old key to be changed.
+        new_key (str): The new key to change to.
     """
-    try:
-        return str(input_).strip().lower()
-    except:
-        return False
+    if old_key in dict_:
+        dict_[new_key] = dict_.pop(old_key)
 
-def as_dict(input_):
+def as_dict(input_: Any) -> Dict[Any, Any]:
     """
     Converts a JSON string or a dictionary to a dictionary.
 
@@ -316,3 +332,23 @@ def as_dict(input_):
         return input_
     else:
         raise f"Could not convert input to dict: {input_}"
+
+def is_schema(dict_: Dict, schema: Dict):
+    """
+    Checks if a dictionary matches a given schema.
+
+    Args:
+        dict_: The dictionary to check.
+        schema: The schema to validate against.
+
+    Returns:
+        True if the dictionary matches the schema, False otherwise.
+    """
+    for key, expected_type in schema.items():
+        if not isinstance(dict_[key], expected_type):
+            return False
+    return True
+
+def timestamp_to_datetime(timestamp):    
+    return datetime.fromtimestamp(timestamp)
+

lionagi/utils/url_util.py

@@ -0,0 +1,55 @@
+from bs4 import BeautifulSoup
+import requests
+
+def get_url_response(url: str, timeout: tuple = (1, 1), **kwargs) -> requests.Response:
+    """
+    Sends a GET request to a URL and returns the response.
+
+    Args:
+        url (str): The URL to send the GET request to.
+        timeout (tuple): A tuple specifying the connection and read timeouts in seconds.
+                         Defaults to (1, 1).
+        **kwargs: Additional keyword arguments to be passed to the requests.get() function.
+
+    Returns:
+        requests.Response: A Response object containing the server's response to the GET request.
+
+    Raises:
+        TimeoutError: If a timeout occurs while requesting or reading the response.
+        Exception: If an error other than a timeout occurs during the request.
+    """
+    try:
+        response = requests.get(url, timeout=timeout, **kwargs)
+        response.raise_for_status()
+        return response
+    except requests.exceptions.ConnectTimeout:
+        raise TimeoutError(f"Timeout: requesting >{timeout[0]} seconds.")
+    except requests.exceptions.ReadTimeout:
+        raise TimeoutError(f"Timeout: reading >{timeout[1]} seconds.")
+    except Exception as e:
+        raise e
+    
+def get_url_content(url: str) -> str:
+    """
+    Retrieve and parse the content from a given URL.
+
+    Args:
+        url (str): The URL to fetch and parse.
+
+    Returns:
+        str: The text content extracted from the URL.
+
+    Raises:
+        ValueError: If there is an issue during content retrieval or parsing.
+    """
+    try:
+        response = requests.get(url)
+        response.raise_for_status()
+
+        soup = BeautifulSoup(response.text, 'html.parser')
+
+        text_content = ' '.join([p.get_text() for p in soup.find_all('p')])
+        return text_content
+    except Exception as e:
+        raise f"Error fetching content for {url}: {e}"
+    

lionagi/version.py

@@ -1 +1 @@
-__version__ = "0.0.201"
+__version__ = "0.0.204"

{lionagi-0.0.201.dist-info → lionagi-0.0.204.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lionagi
-Version: 0.0.201
+Version: 0.0.204
 Summary: Towards automated general intelligence.
 Author: HaiyangLi
 Author-email: Haiyang Li <ocean@lionagi.ai>
@@ -217,8 +217,11 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp >=3.9.0
 Requires-Dist: python-dotenv ==1.0.0
-Requires-Dist: tiktoken ==0.5.1
-Requires-Dist: httpx ==0.25.1
+Requires-Dist: tiktoken >=0.5.1
+Requires-Dist: pydantic >=2.6.0
+Requires-Dist: cryptography >=42.0.0
+Requires-Dist: aiocache ==0.12.2
+Requires-Dist: pandas >=2.1.0
 
 ![PyPI - Version](https://img.shields.io/pypi/v/lionagi?labelColor=233476aa&color=231fc935)  ![Read the Docs](https://img.shields.io/readthedocs/lionagi)  ![PyPI - License](https://img.shields.io/pypi/l/lionagi?color=231fc935) ![PyPI - Downloads](https://img.shields.io/pypi/dm/lionagi?color=blue)
 
@@ -269,7 +272,6 @@ LionAGI is designed to be `asynchronous` only, please check python official docu
 The following example shows how to use LionAGI's `Session` object to interact with `gpt-4` model:
 
 ```python
-import lionagi as li
 
 # define system messages, context and user instruction
 system = "You are a helpful assistant designed to perform calculations."
@@ -279,8 +281,10 @@ context = {"x": 10, "y": 5}
 
 ```python
 # in interactive environment (.ipynb for example)
+import lionagi as li
+
 calculator = li.Session(system=system)
-result = await calculator.initiate(
+result = await calculator.chat(
   instruction=instruction, context=context, model="gpt-4-1106-preview"
 )
 
@@ -294,9 +298,11 @@ from dotenv import load_dotenv
 
 load_dotenv()
 
+import lionagi as li
+
 async def main():
     calculator = li.Session(system=system)
-    result = await calculator.initiate(
+    result = await calculator.chat(
       instruction=instruction, context=context, model="gpt-4-1106-preview"
     )
     print(f"Calculation Result: {result}")
@@ -325,8 +331,6 @@ When referencing LionAGI in your projects or research, please cite:
 }
 ```
 
-## Star History
-![Star History Chart](https://api.star-history.com/svg?repos=lion-agi/lionagi&type=Date)
 
 ### Requirements
 Python 3.9 or higher.