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

lionagi/libs/ln_image.py

@@ -0,0 +1,107 @@
+import base64
+import numpy as np
+from typing import Optional
+from .sys_util import SysUtil
+
+
+class ImageUtil:
+
+    @staticmethod
+    def preprocess_image(
+        image: np.ndarray, color_conversion_code: Optional[int] = None
+    ) -> np.ndarray:
+        SysUtil.check_import("cv2", pip_name="opencv-python")
+        import cv2
+
+        color_conversion_code = color_conversion_code or cv2.COLOR_BGR2RGB
+        return cv2.cvtColor(image, color_conversion_code)
+
+    @staticmethod
+    def encode_image_to_base64(image: np.ndarray, file_extension: str = ".jpg") -> str:
+        SysUtil.check_import("cv2", pip_name="opencv-python")
+        import cv2
+
+        success, buffer = cv2.imencode(file_extension, image)
+        if not success:
+            raise ValueError(f"Could not encode image to {file_extension} format.")
+        encoded_image = base64.b64encode(buffer).decode("utf-8")
+        return encoded_image
+
+    @staticmethod
+    def read_image_to_array(
+        image_path: str, color_flag: Optional[int] = None
+    ) -> np.ndarray:
+        SysUtil.check_import("cv2", pip_name="opencv-python")
+        import cv2
+
+        image = cv2.imread(image_path, color_flag)
+        color_flag = color_flag or cv2.IMREAD_COLOR
+        if image is None:
+            raise ValueError(f"Could not read image from path: {image_path}")
+        return image
+
+    @staticmethod
+    def read_image_to_base64(
+        image_path: str,
+        color_flag: Optional[int] = None,
+    ) -> str:
+        image_path = str(image_path)
+        image = ImageUtil.read_image_to_array(image_path, color_flag)
+
+        file_extension = "." + image_path.split(".")[-1]
+        return ImageUtil.encode_image_to_base64(image, file_extension)
+
+    # @staticmethod
+    # def encode_image(image_path):
+    #     with open(image_path, "rb") as image_file:
+    #         return base64.b64encode(image_file.read()).decode("utf-8")
+
+    @staticmethod
+    def calculate_image_token_usage_from_base64(image_base64: str, detail):
+        """
+        Calculate the token usage for processing OpenAI images from a base64-encoded string.
+
+        Parameters:
+        image_base64 (str): The base64-encoded string of the image.
+        detail (str): The detail level of the image, either 'low' or 'high'.
+
+        Returns:
+        int: The total token cost for processing the image.
+        """
+        import base64
+        from io import BytesIO
+        from PIL import Image
+
+        # Decode the base64 string to get image data
+        if "data:image/jpeg;base64," in image_base64:
+            image_base64 = image_base64.split("data:image/jpeg;base64,")[1]
+            image_base64.strip("{}")
+
+        image_data = base64.b64decode(image_base64)
+        image = Image.open(BytesIO(image_data))
+
+        # Get image dimensions
+        width, height = image.size
+
+        if detail == "low":
+            return 85
+
+        # Scale to fit within a 2048 x 2048 square
+        max_dimension = 2048
+        if width > max_dimension or height > max_dimension:
+            scale_factor = max_dimension / max(width, height)
+            width = int(width * scale_factor)
+            height = int(height * scale_factor)
+
+        # Scale such that the shortest side is 768px
+        min_side = 768
+        if min(width, height) > min_side:
+            scale_factor = min_side / min(width, height)
+            width = int(width * scale_factor)
+            height = int(height * scale_factor)
+
+        # Calculate the number of 512px squares
+        num_squares = (width // 512) * (height // 512)
+        token_cost = 170 * num_squares + 85
+
+        return token_cost

lionagi/libs/ln_nested.py

@@ -1,3 +1,19 @@
+"""
+Copyright 2024 HaiyangLi
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
 from collections import defaultdict
 from itertools import chain
 from typing import Any, Generator, Callable
@@ -52,7 +68,7 @@ def nset(nested_structure: dict | list, indices: list[int | str], value: Any) ->
 def nget(
     nested_structure: dict | list,
     indices: list[int | str],
-    default: Any | None = None,
+    default=...,
 ) -> Any:
     """
     retrieves a value from a nested list or dictionary structure, with an option to
@@ -98,12 +114,12 @@ def nget(
             return target_container[last_index]
         elif isinstance(target_container, dict) and last_index in target_container:
             return target_container[last_index]
-        elif default is not None:
+        elif default is not ...:
             return default
         else:
             raise LookupError("Target not found and no default value provided.")
     except (IndexError, KeyError, TypeError):
-        if default is not None:
+        if default is not ...:
             return default
         else:
             raise LookupError("Target not found and no default value provided.")
@@ -116,7 +132,7 @@ def nmerge(
     *,
     overwrite: bool = False,
     dict_sequence: bool = False,
-    sequence_separator: str = "_",
+    sequence_separator: str = "[^_^]",
     sort_list: bool = False,
     custom_sort: Callable[[Any], Any] | None = None,
 ) -> dict | list:
@@ -176,7 +192,7 @@ def flatten(
     /,
     *,
     parent_key: str = "",
-    sep: str = "_",
+    sep: str = "[^_^]",
     max_depth: int | None = None,
     inplace: bool = False,
     dict_only: bool = False,
@@ -238,7 +254,7 @@ def unflatten(
     flat_dict: dict[str, Any],
     /,
     *,
-    sep: str = "_",
+    sep: str = "[^_^]",
     custom_logic: Callable[[str], Any] | None = None,
     max_depth: int | None = None,
 ) -> dict | list:
@@ -330,7 +346,7 @@ def ninsert(
     indices: list[str | int],
     value: Any,
     *,
-    sep: str = "_",
+    sep: str = "[^_^]",
     max_depth: int | None = None,
     current_depth: int = 0,
 ) -> None:
@@ -393,12 +409,11 @@ def ninsert(
         nested_structure[last_part] = value
 
 
-# noinspection PyDecorator
 def get_flattened_keys(
     nested_structure: Any,
     /,
     *,
-    sep: str = "_",
+    sep: str = "[^_^]",
     max_depth: int | None = None,
     dict_only: bool = False,
     inplace: bool = False,
@@ -448,7 +463,7 @@ def _dynamic_flatten_in_place(
     /,
     *,
     parent_key: str = "",
-    sep: str = "_",
+    sep: str = "[^_^]",
     max_depth: int | None = None,
     current_depth: int = 0,
     dict_only: bool = False,
@@ -581,7 +596,7 @@ def _deep_update(original: dict, update: dict) -> dict:
 def _dynamic_flatten_generator(
     nested_structure: Any,
     parent_key: tuple[str, ...],
-    sep: str = "_",
+    sep: str = "[^_^]",
     max_depth: int | None = None,
     current_depth: int = 0,
     dict_only: bool = False,

lionagi/libs/ln_parse.py

@@ -1,9 +1,23 @@
+"""
+Copyright 2024 HaiyangLi
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
 from collections.abc import Callable
 import re
 import inspect
 import itertools
-import contextlib
-from functools import singledispatchmethod
 from typing import Any
 import numpy as np
 import lionagi.libs.ln_convert as convert
@@ -103,12 +117,12 @@ class ParseUtil:
     # inspired by langchain_core.output_parsers.json (MIT License)
     # https://github.com/langchain-ai/langchain/blob/master/libs/core/langchain_core/output_parsers/json.py
     @staticmethod
-    def extract_code_block(
+    def extract_json_block(
         str_to_parse: str,
         language: str | None = None,
         regex_pattern: str | None = None,
         *,
-        parser: Callable[[str], Any],
+        parser: Callable[[str], Any] = None,
     ) -> Any:
         """
         Extracts and parses a code block from Markdown content.
@@ -148,9 +162,37 @@ class ParseUtil:
             raise ValueError(
                 f"No {language or 'specified'} code block found in the Markdown content."
             )
+        if not match:
+            str_to_parse = str_to_parse.strip()
+            if str_to_parse.startswith("```json\n") and str_to_parse.endswith("\n```"):
+                str_to_parse = str_to_parse[8:-4].strip()
 
+        parser = parser or ParseUtil.fuzzy_parse_json
         return parser(code_str)
 
+    @staticmethod
+    def extract_code_blocks(code):
+        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))
+
+        return "\n\n".join(code_blocks)
+
     @staticmethod
     def md_to_json(
         str_to_parse: str,
@@ -181,7 +223,7 @@ class ParseUtil:
                 >>> md_to_json('```json\\n{"key": "value"}\\n```', expected_keys=['key'])
                 {'key': 'value'}
         """
-        json_obj = ParseUtil.extract_code_block(
+        json_obj = ParseUtil.extract_json_block(
             str_to_parse, language="json", parser=parser or ParseUtil.fuzzy_parse_json
         )
 
@@ -385,7 +427,9 @@ class ParseUtil:
         return type_mapping.get(py_type, "object")
 
     @staticmethod
-    def _func_to_schema(func, style="google"):
+    def _func_to_schema(
+        func, style="google", func_description=None, params_description=None
+    ):
         """
         Generates a schema description for a given function, using typing hints and
         docstrings. The schema includes the function's name, description, and parameters.
@@ -412,9 +456,11 @@ class ParseUtil:
         """
         # Extracting function name and docstring details
         func_name = func.__name__
-        func_description, params_description = ParseUtil._extract_docstring_details(
-            func, style
-        )
+
+        if not func_description:
+            func_description, _ = ParseUtil._extract_docstring_details(func, style)
+        if not params_description:
+            _, params_description = ParseUtil._extract_docstring_details(func, style)
 
         # Extracting parameters with typing hints
         sig = inspect.signature(func)
@@ -634,7 +680,7 @@ class StringMatch:
         # Calculate Jaro-Winkler similarity scores for each potential match
         scores = np.array(
             [
-                score_func(convert.to_str(word), correct_word)
+                score_func(str(word), str(correct_word))
                 for correct_word in correct_words_list
             ]
         )
@@ -648,26 +694,39 @@ class StringMatch:
 
         if isinstance(out_, str):
             # first try to parse it straight as a fuzzy json
+            
             try:
                 out_ = ParseUtil.fuzzy_parse_json(out_)
-            except Exception:
+                return StringMatch.correct_dict_keys(keys, out_)
+            
+            except:
                 try:
-                    # if failed we try to extract the json block and parse it
                     out_ = ParseUtil.md_to_json(out_)
+                    return StringMatch.correct_dict_keys(keys, out_)
+
                 except Exception:
-                    # if still failed we try to extract the json block using re and parse it again
-                    match = re.search(r"```json\n({.*?})\n```", out_, re.DOTALL)
-                    if match:
-                        out_ = match.group(1)
-                        try:
-                            out_ = ParseUtil.fuzzy_parse_json(out_)
-                        except:
+                    try:
+                        # if failed we try to extract the json block and parse it
+                        out_ = ParseUtil.md_to_json(out_)
+                        return StringMatch.correct_dict_keys(keys, out_)
+
+                    except Exception:
+                        # if still failed we try to extract the json block using re and parse it again
+                        match = re.search(r"```json\n({.*?})\n```", out_, re.DOTALL)
+                        if match:
+                            out_ = match.group(1)
                             try:
-                                out_ = ParseUtil.fuzzy_parse_json(
-                                    out_.replace("'", '"')
-                                )
+                                out_ = ParseUtil.fuzzy_parse_json(out_)
+                                return StringMatch.correct_dict_keys(keys, out_)
+
                             except:
-                                pass
+                                try:
+                                    out_ = ParseUtil.fuzzy_parse_json(
+                                        out_.replace("'", '"')
+                                    )
+                                    return StringMatch.correct_dict_keys(keys, out_)
+                                except:
+                                    pass
 
         if isinstance(out_, dict):
             try:

lionagi/libs/ln_queue.py

@@ -1,3 +1,19 @@
+"""
+Copyright 2024 HaiyangLi
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
 """
 A class that manages asynchronous task processing with controlled concurrency.
 """

lionagi/libs/ln_tokenize.py

@@ -0,0 +1,164 @@
+import tiktoken
+import math
+from .ln_convert import to_str
+from .special_tokens import disallowed_tokens
+
+
+class TokenizeUtil:
+
+    @staticmethod
+    def tokenize(
+        text,
+        encoding_model=None,
+        encoding_name=None,
+        return_byte=False,
+        disallowed_tokens=disallowed_tokens,
+    ):
+        encoding = None
+
+        if encoding_model:
+            try:
+                encoding_name = tiktoken.encoding_name_for_model(encoding_model)
+            except:
+                encoding_name = encoding_name or "cl100k_base"
+
+        if not encoding_name or encoding_name in tiktoken.list_encoding_names():
+            encoding_name = encoding_name or "cl100k_base"
+            encoding = tiktoken.get_encoding(encoding_name)
+
+        special_encodings = (
+            [encoding.encode(token) for token in disallowed_tokens]
+            if disallowed_tokens
+            else []
+        )
+        codes = encoding.encode(text)
+        if special_encodings and len(special_encodings) > 0:
+            codes = [code for code in codes if code not in special_encodings]
+
+        if return_byte:
+            return codes
+
+        return [encoding.decode([code]) for code in codes]
+
+    @staticmethod
+    def chunk_by_chars(
+        text: str, chunk_size: int, overlap: float, threshold: int
+    ) -> list[str | None]:
+        """
+        Chunks the input text into smaller parts, with optional overlap and threshold for final chunk.
+
+        Parameters:
+            text (str): The input text to chunk.
+
+            chunk_size (int): The size of each chunk.
+
+            overlap (float): The amount of overlap between chunks.
+
+            threshold (int): The minimum size of the final chunk.
+
+        Returns:
+            List[Union[str, None]]: A list of text chunks.
+
+        Raises:
+            ValueError: If an error occurs during chunking.
+        """
+
+        def _chunk_n1():
+            return [text]
+
+        def _chunk_n2():
+            chunks = []
+            chunks.append(text[: chunk_size + overlap_size])
+
+            if len(text) - chunk_size > threshold:
+                chunks.append(text[chunk_size - overlap_size :])
+            else:
+                return _chunk_n1()
+
+            return chunks
+
+        def _chunk_n3():
+            chunks = []
+            chunks.append(text[: chunk_size + overlap_size])
+            for i in range(1, n_chunks - 1):
+                start_idx = chunk_size * i - overlap_size
+                end_idx = chunk_size * (i + 1) + overlap_size
+                chunks.append(text[start_idx:end_idx])
+
+            if len(text) - chunk_size * (n_chunks - 1) > threshold:
+                chunks.append(text[chunk_size * (n_chunks - 1) - overlap_size :])
+            else:
+                chunks[-1] += text[chunk_size * (n_chunks - 1) + overlap_size :]
+
+            return chunks
+
+        try:
+            if not isinstance(text, str):
+                text = to_str(text)
+
+            n_chunks = math.ceil(len(text) / chunk_size)
+            overlap_size = int(overlap / 2)
+
+            if n_chunks == 1:
+                return _chunk_n1()
+
+            elif n_chunks == 2:
+                return _chunk_n2()
+
+            elif n_chunks > 2:
+                return _chunk_n3()
+
+        except Exception as e:
+            raise ValueError(f"An error occurred while chunking the text. {e}")
+
+    @staticmethod
+    def chunk_by_tokens(
+        text: str,
+        chunk_size: int,
+        overlap: float,
+        threshold: int,  # minimum size of the final chunk in number of tokens
+        encoding_model=None,
+        encoding_name=None,
+        return_tokens=False,
+        return_byte=False,
+    ) -> list[str | None]:
+
+        tokens = TokenizeUtil.tokenize(
+            text, encoding_model, encoding_name, return_byte=return_byte
+        )
+
+        n_chunks = math.ceil(len(tokens) / chunk_size)
+        overlap_size = int(overlap * chunk_size / 2)
+        residue = len(tokens) % chunk_size
+
+        if n_chunks == 1:
+            return text if not return_tokens else [tokens]
+
+        elif n_chunks == 2:
+            chunks = [tokens[: chunk_size + overlap_size]]
+            if residue > threshold:
+                chunks.append(tokens[chunk_size - overlap_size :])
+                return (
+                    [" ".join(chunk).strip() for chunk in chunks]
+                    if not return_tokens
+                    else chunks
+                )
+            else:
+                return text if not return_tokens else [tokens]
+
+        elif n_chunks > 2:
+            chunks = []
+            chunks.append(tokens[: chunk_size + overlap_size])
+            for i in range(1, n_chunks - 1):
+                start_idx = chunk_size * i - overlap_size
+                end_idx = chunk_size * (i + 1) + overlap_size
+                chunks.append(tokens[start_idx:end_idx])
+
+            if len(tokens) - chunk_size * (n_chunks - 1) > threshold:
+                chunks.append(tokens[chunk_size * (n_chunks - 1) - overlap_size :])
+            else:
+                chunks[-1] += tokens[-residue:]
+
+            return (
+                [" ".join(chunk) for chunk in chunks] if not return_tokens else chunks
+            )

lionagi/libs/ln_validate.py

@@ -1,3 +1,19 @@
+"""
+Copyright 2024 HaiyangLi
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
 """
 This module provides functions for validating and fixing field values based on their data types.