sunholo 0.100.2__py3-none-any.whl → 0.101.0__py3-none-any.whl

sunholo/gcs/add_file.py

@@ -25,6 +25,40 @@ except ImportError:
 from ..custom_logging import log
 from ..utils import ConfigManager
 
+def guess_image_type(file_path: str) -> str:
+    """
+    Guess the image type based on the file extension.
+
+    Args:
+        file_path (str): The path or URL of the image file.
+
+    Returns:
+        str: The guessed image type (e.g., "jpeg", "png", "gif", etc.)
+             or None if the extension is not recognized.
+    """
+    # Extract the file extension
+    _, ext = os.path.splitext(file_path)
+    
+    # Normalize and remove the leading dot
+    ext = ext.lower().strip('.')
+
+    # Mapping of common file extensions to image types
+    extension_to_type = {
+        "jpg": "image/jpeg",
+        "jpeg": "image/jpeg",
+        "png": "image/png",
+        "gif": "image/gif",
+        "bmp": "image/bmp",
+        "tiff": "image/tiff",
+        "tif": "image/tiff",
+        "webp": "image/webp",
+        "ico": "image/ico",
+        "svg": "image/svg",
+        "pdf": "application/pdf",
+    }
+    
+    return extension_to_type.get(ext.lower(), None)
+
 
 def handle_base64_image(base64_data: str, vector_name: str, extension: str):
     """
@@ -58,14 +92,7 @@ def handle_base64_image(base64_data: str, vector_name: str, extension: str):
         os.remove(filename)  # Clean up the saved file
 
         # Determine MIME type based on extension
-        mime_type = {
-            ".jpg": "image/jpeg",
-            ".jpeg": "image/jpeg",
-            ".png": "image/png",
-            ".gif": "image/gif",
-            ".bmp": "image/bmp",
-            ".tiff": "image/tiff"
-        }.get(extension.lower(), "application/octet-stream")  # Default MIME type if unknown
+        mime_type = guess_image_type(extension) or "application/octet-stream"
 
         return image_uri, mime_type
     except Exception as e:

sunholo/gcs/download_url.py

@@ -176,6 +176,7 @@ def construct_download_link_simple(bucket_name:str, object_name:str) -> Tuple[st
     else:
         public_url = f"https://storage.cloud.google.com/{bucket_name}/{quote(object_name)}"
     filename = os.path.basename(object_name)
+    log.info(f"Created simple download link: {public_url}")
     return public_url, filename, False
 
 def parse_gs_uri(gs_uri: str) -> Tuple[str, str]:

sunholo/gcs/extract_and_sign.py

@@ -0,0 +1,41 @@
+import re
+import asyncio
+
+from .download_url import construct_download_link
+from ..utils.mime import guess_mime_type
+from ..custom_logging import log
+
+async def extract_gs_uris_and_sign(content, pattern=r'gs://[^\n]+\.(?:png|jpg|jpeg|pdf|txt|md)'):
+
+    gs_matches = re.findall(pattern, content)
+    unique_gs_matches = set(gs_matches)
+    image_signed_urls = []
+    if unique_gs_matches:
+        log.info(f"Got gs matches: {unique_gs_matches}")
+
+        async def process_link(gs_url):
+            log.info(f"Processing {gs_url}")
+            link, encoded_filename, signed = await asyncio.to_thread(construct_download_link, gs_url)
+            if signed:
+                try:
+                    mime_type = guess_mime_type(gs_url)
+                except Exception as err:
+                    log.error(f"Could not find mime_type for {link} - {str(err)}")
+                    mime_type = "application/octet-stream"
+                    
+                return {
+                    "original": gs_url,
+                    "link": link,
+                    "name": encoded_filename,
+                    "mime": mime_type,
+                    "signed": signed
+                }
+            else:
+                log.info(f"Could not sign this GS_URI: {gs_url} - skipping")
+                return None
+
+        # Gather all tasks and run them concurrently
+        image_signed_urls = await asyncio.gather(*(process_link(gs_url) for gs_url in unique_gs_matches))
+
+    log.info(f"found files to msg: {image_signed_urls}")
+    return image_signed_urls

sunholo/genai/images.py

@@ -0,0 +1,38 @@
+import re
+from ..utils.mime import guess_mime_type
+from ..gcs import get_bytes_from_gcs
+from ..custom_logging import log
+import io
+import os
+try:
+    import google.generativeai as genai
+except ImportError:
+    genai = None
+
+def extract_gs_images_and_genai_upload(content:str):
+    # Regular expression to find gs:// URLs 
+    pattern = r'gs://[^ ]+\.(?:png|jpg|jpeg|pdf)'
+
+    gs_matches = re.findall(pattern, content)
+    unique_gs_matches = set(gs_matches)
+    output_gs_images = []
+    for gs_uri in unique_gs_matches:
+        mime_type = guess_mime_type(gs_uri)
+        if mime_type is None:
+            continue
+        
+        log.info(f"Getting bytes from GCS: {gs_uri}")
+        image_bytes = get_bytes_from_gcs(gs_uri)
+        if image_bytes is None:
+            continue
+        image_file = io.BytesIO(image_bytes)
+        image_file.name = os.path.basename(gs_uri)  # Assign a name, as some APIs require it
+        
+        try:
+            uploaded_file = genai.upload_file(image_file)
+            output_gs_images.append(uploaded_file)
+        
+        except Exception as e:
+            log.error(f"Error adding {gs_uri} to base64: {str(e)}")
+    
+    return output_gs_images

sunholo/genai/process_funcs_cls.py

@@ -17,9 +17,13 @@ try:
 except ImportError:
     genai = None
 
+from .images import extract_gs_images_and_genai_upload
+
 if TYPE_CHECKING:
     from google.generativeai.protos import Part
 
+
+
 class GenAIFunctionProcessor:
     """
     A generic class for processing function calls from google.generativeai function calling models.
@@ -366,20 +370,22 @@ class GenAIFunctionProcessor:
         
         return clean
 
-    def run_agent_loop(self, chat, content, callback, guardrail_max=10, loop_return=3):
+    def run_agent_loop(self, chat, content, callback=None, guardrail_max=10, loop_return=3):
         """
         Runs the agent loop, sending messages to the orchestrator, processing responses, and executing functions.
 
         Args:
             chat: The chat object for interaction with the orchestrator.
             content: The initial content to send to the agent.
-            callback: The callback object for handling intermediate responses.
+            callback: The callback object for handling intermediate responses. If not supplied will use self.IOCallback()
             guardrail_max (int): The maximum number of iterations for the loop.
             loop_return (int): The number of last loop iterations to return. Default 3 will return last 3 iterations. If loop_return > guardrail_max then all iterations are returned.
 
         Returns:
             tuple: (big_text, usage_metadata) from the loop execution.
         """
+        if not callback:
+            callback = self.IOCallback()
         guardrail = 0
         big_result = []
         usage_metadata = {
@@ -535,6 +541,13 @@ class GenAIFunctionProcessor:
 
             if this_text:
                 content.append(f"Agent: {this_text}")    
+                # if text includes gs:// try to download it
+                image_uploads = extract_gs_images_and_genai_upload(this_text)
+                if image_uploads:
+                    for img in image_uploads:
+                        log.info(f"Adding {img=}")
+                        content.append(img)
+                        content.append(f"{img.name} was created by agent and added")
                 log.info(f"[{guardrail}] Updated content:\n{this_text}")
                 big_result.append(this_text)
             else:
@@ -567,6 +580,15 @@ class GenAIFunctionProcessor:
 
         return big_text, usage_metadata
 
+    class IOCallback:
+        """
+        This is a default callback that will print to console any tokens it recieves.
+        """
+        def on_llm_new_token(self, token:str):
+            print(token)
+        def on_llm_end(self, response):
+            print(f"\nFull response: \n{response}")
+
     @staticmethod
     def decide_to_go_on(go_on: bool, chat_summary: str) -> dict:
         """

sunholo/invoke/async_class.py

@@ -1,63 +1,107 @@
 import asyncio
-from ..custom_logging import log
-import traceback
 from typing import Callable, Any, AsyncGenerator, Dict
+import time
+import traceback
+from ..custom_logging import setup_logging
 from tenacity import AsyncRetrying, retry_if_exception_type, wait_random_exponential, stop_after_attempt
 
+log = setup_logging("sunholo_AsyncTaskRunner")
+
 class AsyncTaskRunner:
     def __init__(self, retry_enabled=False, retry_kwargs=None):
         self.tasks = []
         self.retry_enabled = retry_enabled
         self.retry_kwargs = retry_kwargs or {}
-    
+
     def add_task(self, func: Callable[..., Any], *args: Any):
-        """Adds a task to the list of tasks to be executed."""
+        """
+        Adds a task to the list of tasks to be executed.
+        """
         log.info(f"Adding task: {func.__name__} with args: {args}")
         self.tasks.append((func.__name__, func, args))
-    
-    async def run_async_as_completed(self, callback=None) -> AsyncGenerator[Dict[str, Any], None]:
-        """
-        Runs all tasks concurrently and yields results as they complete, while periodically sending heartbeat messages.
 
-        Args:
-            callback: The callback object that will receive heartbeat messages.
+    async def run_async_as_completed(self) -> AsyncGenerator[Dict[str, Any], None]:
+        """
+        Runs all tasks concurrently and yields results as they complete,
+        while periodically sending heartbeat messages.
         """
         log.info("Running tasks asynchronously and yielding results as they complete")
-        tasks = {}
+
+        # Create a queue for inter-coroutine communication
+        queue = asyncio.Queue()
+
+        # List to keep track of all running tasks and their heartbeats
+        task_infos = []
+
+        # Start all tasks and their corresponding heartbeats
         for name, func, args in self.tasks:
-            # Pass the callback down to _task_wrapper
-            coro = self._task_wrapper(name, func, args, callback)
-            task = asyncio.create_task(coro)
-            tasks[task] = name
-        
-        log.info(f"Start async run with {len(self.tasks)} runners")
-        while tasks:
-            done, _ = await asyncio.wait(tasks.keys(), return_when=asyncio.FIRST_COMPLETED)
-            for task in done:
-                name = tasks.pop(task)
-                try:
-                    # func_name = message['func_name']; result = message['result']
-                    result = await task
-                    yield {'type':'task_complete', 'func_name': name, 'result': result}
-                except Exception as e:
-                    log.error(f"Task {name} resulted in an error: {e}\n{traceback.format_exc()}")
-                    yield {'type':'task_error', 'func_name': name, 'error': f'{e}\n{traceback.format_exc()}'}
-
-    async def _task_wrapper(self, name: str, func: Callable[..., Any], args: Any, callback=None) -> Any:
-        """Wraps the task function to process its output and handle retries, while managing heartbeat updates."""
-        async def run_func():
-            if asyncio.iscoroutinefunction(func):
-                # If the function is async, await it
-                return await func(*args)
-            else:
-                # If the function is sync, run it in a thread to prevent blocking
-                return await asyncio.to_thread(func, *args)
+            # Create an event to signal task completion to the heartbeat
+            completion_event = asyncio.Event()
+
+            # Start the main task with retries
+            task_coro = self._run_with_retries(name, func, *args, queue=queue, completion_event=completion_event)
+            task = asyncio.create_task(task_coro)
+
+            # Start the heartbeat coroutine
+            heartbeat_coro = self._send_heartbeat(name, completion_event, queue)
+            heartbeat_task = asyncio.create_task(heartbeat_coro)
+
+            # Store task information for management
+            task_infos.append({
+                'name': name,
+                'task': task,
+                'heartbeat_task': heartbeat_task,
+                'completion_event': completion_event
+            })
+
+            log.info(f"Started task '{name}' and its heartbeat")
+
+        log.info(f"Started async run with {len(self.tasks)} tasks and heartbeats")
+
+        # Create a monitor task to detect when all tasks and heartbeats are done
+        monitor = asyncio.create_task(self._monitor_tasks(task_infos, queue))
+
+        # Continuously yield messages from the queue until sentinel is received
+        while True:
+            message = await queue.get()
+            if message is None:
+                log.info("Received sentinel. Exiting message loop.")
+                break  # Sentinel received, all tasks and heartbeats are done
+            log.info(f"Received message from queue: {message}")
+            yield message
 
-        # Start the heartbeat task if a callback is provided
-        heartbeat_task = None
-        if callback:
-            heartbeat_task = asyncio.create_task(self._send_heartbeat(callback, name))
+        # Wait for the monitor to finish
+        await monitor
 
+        log.info("All tasks and heartbeats have completed")
+
+    async def _monitor_tasks(self, task_infos, queue):
+        """
+        Monitors the tasks and heartbeats, and sends a sentinel to the queue when done.
+        """
+        # Wait for all main tasks to complete
+        main_tasks = [info['task'] for info in task_infos]
+        log.info("Monitor: Waiting for all main tasks to complete")
+        await asyncio.gather(*main_tasks, return_exceptions=True)
+        log.info("Monitor: All main tasks have completed")
+
+        # Cancel all heartbeat tasks
+        for info in task_infos:
+            info['heartbeat_task'].cancel()
+            try:
+                await info['heartbeat_task']
+            except asyncio.CancelledError:
+                pass
+            log.info(f"Monitor: Heartbeat for task '{info['name']}' has been canceled")
+
+        # Send a sentinel to indicate completion
+        await queue.put(None)
+        log.info("Monitor: Sent sentinel to queue")
+
+    async def _run_with_retries(self, name: str, func: Callable[..., Any], *args: Any, queue: asyncio.Queue, completion_event: asyncio.Event) -> None:
+        """
+        Executes a task with optional retries and sends completion or error messages to the queue.
+        """
         try:
             if self.retry_enabled:
                 retry_kwargs = {
@@ -68,50 +112,67 @@ class AsyncTaskRunner:
                 }
                 async for attempt in AsyncRetrying(**retry_kwargs):
                     with attempt:
-                        return await run_func()
+                        log.info(f"Starting task '{name}' with retry")
+                        result = await self._execute_task(func, *args)
+                        await queue.put({'type': 'task_complete', 'func_name': name, 'result': result})
+                        log.info(f"Sent 'task_complete' message for task '{name}'")
+                        return
             else:
-                try:
-                    return await run_func()
-                except Exception as e:
-                    log.error(f"Error in task {name}: {e}\n{traceback.format_exc()}")
-                    raise
+                log.info(f"Starting task '{name}' with no retry")
+                result = await self._execute_task(func, *args)
+                await queue.put({'type': 'task_complete', 'func_name': name, 'result': result})
+                log.info(f"Sent 'task_complete' message for task '{name}'")
+        except Exception as e:
+            log.error(f"Error in task '{name}': {e}\n{traceback.format_exc()}")
+            await queue.put({'type': 'task_error', 'func_name': name, 'error': f'{e}\n{traceback.format_exc()}'})
+            log.info(f"Sent 'task_error' message for task '{name}'")
         finally:
-            # Stop the heartbeat task
-            if heartbeat_task:
-                heartbeat_task.cancel()
-                try:
-                    await heartbeat_task  # Ensure the heartbeat task is properly canceled
-                except asyncio.CancelledError:
-                    pass
-
-            # Send a message indicating task completion and remove spinner
-            if callback:
-                completion_html = (
-                    f"<script>"
-                    f"document.getElementById('{name}-spinner').innerHTML = '✔️ Task {name} completed!';"
-                    f"</script>"
-                )
-                await callback.async_on_llm_new_token(token=completion_html)
-
-    async def _send_heartbeat(self, callback, func_name, interval=2):
+            log.info(f"Task '{name}' completed.")
+            # Set the completion event after sending the message
+            completion_event.set()
+
+    async def _execute_task(self, func: Callable[..., Any], *args: Any) -> Any:
+        """
+        Executes the given task function and returns its result.
+
+        Args:
+            func (Callable): The callable to execute.
+            *args: Arguments to pass to the callable.
+
+        Returns:
+            Any: The result of the task.
+        """
+        if asyncio.iscoroutinefunction(func):
+            return await func(*args)
+        else:
+            return await asyncio.to_thread(func, *args)
+
+    async def _send_heartbeat(self, func_name: str, completion_event: asyncio.Event, queue: asyncio.Queue, interval: int = 2):
         """
         Sends periodic heartbeat updates to indicate the task is still in progress.
 
         Args:
-            callback: The callback to notify that the task is still working.
-            func_name: The name of the task function.
-            interval: How frequently to send heartbeat messages (in seconds).
+            func_name (str): The name of the task function.
+            completion_event (asyncio.Event): Event to signal when the task is completed.
+            queue (asyncio.Queue): The queue to send heartbeat messages to.
+            interval (int): How frequently to send heartbeat messages (in seconds).
         """
-        # Send the initial spinner HTML
-        spinner_html = (
-            f'<div id="{func_name}-spinner" style="display:inline-block; margin: 5px;">'
-            f'<div class="spinner" style="width:16px; height:16px; border: 2px solid #f3f3f3; '
-            f'border-radius: 50%; border-top: 2px solid #3498db; animation: spin 1s linear infinite;"></div>'
-            f'<style>@keyframes spin {{0% {{ transform: rotate(0deg); }} 100% {{ transform: rotate(360deg); }}}}</style>'
-            f' <span>Task {func_name} is in progress...</span></div>'
-        )
-        await callback.async_on_llm_new_token(token=spinner_html)
-
-        # Keep sending heartbeats until task completes
-        while True:
-            await asyncio.sleep(interval)  # Sleep for the interval but do not send multiple messages
+        start_time = time.time()
+        log.info(f"Starting heartbeat for task '{func_name}' with interval {interval} seconds")
+        try:
+            while not completion_event.is_set():
+                await asyncio.sleep(interval)
+                elapsed_time = int(time.time() - start_time)
+                heartbeat_message = {
+                    'type': 'heartbeat',
+                    'name': func_name,
+                    'interval': interval,
+                    'elapsed_time': elapsed_time
+                }
+                log.info(f"Sending heartbeat for task '{func_name}', running for {elapsed_time} seconds")
+                await queue.put(heartbeat_message)
+        except asyncio.CancelledError:
+            log.info(f"Heartbeat for task '{func_name}' has been canceled")
+        finally:
+            log.info(f"Heartbeat for task '{func_name}' stopped")
+

sunholo/langfuse/prompts.py

@@ -2,13 +2,14 @@ from ..custom_logging import log
 from ..utils import ConfigManager
 
 # Load the YAML file
-def load_prompt_from_yaml(key, prefix="sunholo", load_from_file=False):
+def load_prompt_from_yaml(key, prefix="sunholo", load_from_file=False, f_string=True):
     """
-    Returns a string you can use with Langfuse PromptTemplate.from_template() 
+    Returns a string you can use with prompts.
 
     Will first try to load from the Langfuse prompt library, if unavailable will look in promptConfig type file.
 
-    Langfuse prompts have {{ two braces }}, Langchain prompts have { one brace }.
+    If f_string is True will be in a Langchain style prompt e.g. { one brace }
+    If f_string is False will be Langfuse style prompt e.g. {{ two braces }}
 
     Example:
 
@@ -36,7 +37,10 @@ def load_prompt_from_yaml(key, prefix="sunholo", load_from_file=False):
             
         langfuse_prompt = langfuse.get_prompt(langfuse_template, cache_ttl_seconds=300)
 
-        return langfuse_prompt.get_langchain_prompt()
+        if f_string:
+            return langfuse_prompt.get_langchain_prompt()
+        
+        return langfuse_prompt
     
     except Exception as err:
         log.warning(f"Could not find langfuse template: {langfuse_template} - {str(err)} - attempting to load from promptConfig")

sunholo/streaming/content_buffer.py

@@ -106,7 +106,6 @@ class ContentBuffer:
         """
         async with self.lock:
             self.content = ""
-            log.debug("Content buffer cleared")
             self.content_available.clear()
 
 

sunholo/utils/mime.py

@@ -0,0 +1,63 @@
+import os
+
+def guess_mime_type(file_path: str) -> str:
+    """
+    Guess the mime type based on the file extension.
+
+    Args:
+        file_path (str): The path or URL of the image file.
+
+    Returns:
+        str: The guessed image type (e.g., "jpeg", "png", "gif", etc.)
+             or None if the extension is not recognized.
+    """
+    # Extract the file extension
+    _, ext = os.path.splitext(file_path)
+    
+    # Normalize and remove the leading dot
+    ext = ext.lower().strip('.')
+
+    # Mapping of common file extensions to file types
+    extension_to_type = {
+        "jpg": "image/jpeg",
+        "jpeg": "image/jpeg",
+        "png": "image/png",
+        "gif": "image/gif",
+        "bmp": "image/bmp",
+        "tiff": "image/tiff",
+        "tif": "image/tiff",
+        "webp": "image/webp",
+        "ico": "image/vnd.microsoft.icon",
+        "svg": "image/svg+xml",
+        "pdf": "application/pdf",
+        "txt": "text/plain",
+        "md": "text/markdown",
+        "html": "text/html",
+        "css": "text/css",
+        "js": "application/javascript",
+        "json": "application/json",
+        "xml": "application/xml",
+        "csv": "text/csv",
+        "py": "text/x-python",
+        "java": "text/x-java-source",
+        "c": "text/x-c",
+        "cpp": "text/x-c++",
+        "h": "text/x-c",
+        "hpp": "text/x-c++",
+        "sh": "application/x-sh",
+        "bat": "application/x-msdos-program",
+        "php": "application/x-httpd-php",
+        "rb": "application/x-ruby",
+        "pl": "application/x-perl",
+        "swift": "application/x-swift",
+        "r": "text/x-r",
+        "go": "text/x-go",
+        "sql": "application/sql",
+        "yaml": "text/yaml",
+        "yml": "text/yaml",
+        "ts": "application/typescript",
+        "tsx": "text/tsx",
+        "jsx": "text/jsx",
+    }
+    
+    return extension_to_type.get(ext, "")

{sunholo-0.100.2.dist-info → sunholo-0.101.0.dist-info}/METADATA

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: sunholo
-Version: 0.100.2
+Version: 0.101.0
 Summary: Large Language Model DevOps - a package to help deploy LLMs to the Cloud.
 Home-page: https://github.com/sunholo-data/sunholo-py
-Download-URL: https://github.com/sunholo-data/sunholo-py/archive/refs/tags/v0.100.2.tar.gz
+Download-URL: https://github.com/sunholo-data/sunholo-py/archive/refs/tags/v0.101.0.tar.gz
 Author: Holosun ApS
 Author-email: multivac@sunholo.com
 License: Apache License, Version 2.0

{sunholo-0.100.2.dist-info → sunholo-0.101.0.dist-info}/RECORD

@@ -80,22 +80,24 @@ sunholo/embedder/embed_chunk.py,sha256=_FdO4-9frUJlDPqXv2Ai49ejUrrMTMGti3D7bfJGf
 sunholo/excel/__init__.py,sha256=AqTMN9K4qJYi4maEgoORc5oxDVGO_eqmwzDaVP37JgY,56
 sunholo/excel/plugin.py,sha256=rl3FoECZ6Ts8KKExPrbPwr3u3CegZfsevmcjgUXAlhE,4033
 sunholo/gcs/__init__.py,sha256=SZvbsMFDko40sIRHTHppA37IijvJTae54vrhooEF5-4,90
-sunholo/gcs/add_file.py,sha256=NxUaWTP-h9l5fbjnrEYpipo5rjS3uPkjMWeDhpK113g,8369
+sunholo/gcs/add_file.py,sha256=vqgt71BodjVWKb-slr24lE0b12_ipFIbFyiSuPCVHGA,9081
 sunholo/gcs/download_folder.py,sha256=ijJTnS595JqZhBH8iHFErQilMbkuKgL-bnTCMLGuvlA,1614
-sunholo/gcs/download_url.py,sha256=oPC8phesRcpXB4zB_p0nWPKPBMs7JBhhVJ7tnVYhzD8,6356
+sunholo/gcs/download_url.py,sha256=Ul81n1rklr8WogPsuxWWD1Nr8RHU451LzHPMJNhAKzw,6416
+sunholo/gcs/extract_and_sign.py,sha256=paRrTCvCN5vkQwCB7OSkxWi-pfOgOtZ0bwdXE08c3Ps,1546
 sunholo/gcs/metadata.py,sha256=oQLcXi4brsZ74aegWyC1JZmhlaEV270HS5_UWtAYYWE,898
 sunholo/genai/__init__.py,sha256=dBl6IA3-Fx6-Vx81r0XqxHlUq6WeW1iDX188dpChu8s,115
+sunholo/genai/images.py,sha256=WaeO705mK0BOz1k7OwsGslw7qF1WiyE_zsueYt07vV8,1191
 sunholo/genai/init.py,sha256=yG8E67TduFCTQPELo83OJuWfjwTnGZsyACospahyEaY,687
-sunholo/genai/process_funcs_cls.py,sha256=DPe70E71pofInLMFBFdudFZr0ZCFHN1LFCQjpxtG8xU,26552
+sunholo/genai/process_funcs_cls.py,sha256=VvbTjyGQ_dq0xiEUx-Zn0ZomKbKTZwuoWdiWeestRfM,27419
 sunholo/genai/safety.py,sha256=mkFDO_BeEgiKjQd9o2I4UxB6XI7a9U-oOFjZ8LGRUC4,1238
 sunholo/invoke/__init__.py,sha256=o1RhwBGOtVK0MIdD55fAIMCkJsxTksi8GD5uoqVKI-8,184
-sunholo/invoke/async_class.py,sha256=LNe57uxwGwLaN44MCOVOOSMNX8FZ5buqCxevYTHUTPg,5501
+sunholo/invoke/async_class.py,sha256=Wkrv3exjN3aDQdI1Q4tv8I8xSloKgdz_LzGomayfLhw,7734
 sunholo/invoke/direct_vac_func.py,sha256=GXSCMkC6vOWGUtQjxy-ZpTrMvJa3CgcW-y9mDpJwWC8,9533
 sunholo/invoke/invoke_vac_utils.py,sha256=sJc1edHTHMzMGXjji1N67c3iUaP7BmAL5nj82Qof63M,2053
 sunholo/langfuse/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sunholo/langfuse/callback.py,sha256=jl0SZsFS53uMW9DGeM9SOL_EsRZsba0wwFGLqKzu9_U,1684
 sunholo/langfuse/evals.py,sha256=fQBaC0dBTYfgCzyfv9QBRvUfc9f42lbwQAeZmynaHO8,3841
-sunholo/langfuse/prompts.py,sha256=27BsVfihM6-h1jscbkGSO4HsATl-d4ZN6tcNCVztWoY,1300
+sunholo/langfuse/prompts.py,sha256=3Zo-YX2YpZdKNAGKjlGePXb8t8FisA9BrraA6tO7RHM,1422
 sunholo/llamaindex/__init__.py,sha256=DlY_cHWCsVEV1C5WBgDdHRgOMlJc8pDoCRukUJ8PT9w,88
 sunholo/llamaindex/get_files.py,sha256=6rhXCDqQ_lrIapISQ_OYQDjiSATXvS_9m3qq53-oIl0,781
 sunholo/llamaindex/import_files.py,sha256=Bnic5wz8c61af9Kwq8KSrNBbc4imYnzMtBCb2jzSImI,6224
@@ -114,7 +116,7 @@ sunholo/qna/__init__.py,sha256=F8q1uR_HreoSX0IfmKY1qoSwIgXhO2Q8kuDSxh9_-EE,28
 sunholo/qna/parsers.py,sha256=YpOaK5S_LxJ6FbliSYDc3AVOJ62RVduayoNnzi_p8CM,2494
 sunholo/qna/retry.py,sha256=yMw7RTkw-RXCzfENPJOt8c32mXlpvOR589EGkvK-6yI,2028
 sunholo/streaming/__init__.py,sha256=MpbydI2UYo_adttPQFkxNM33b-QRyNEbrKJx0C2AGPc,241
-sunholo/streaming/content_buffer.py,sha256=dGzzajY_DEnIxMERiApCKUSzDI5mXKByW9L4dmYRqSw,12814
+sunholo/streaming/content_buffer.py,sha256=0LHMwH4ctq5kjhIgMFNH0bA1RL0jMISlLVzzLcFrvv4,12766
 sunholo/streaming/langserve.py,sha256=hi7q8WY8DPKrALl9m_dOMxWOdE-iEuk7YW05SVDFIX8,6514
 sunholo/streaming/stream_lookup.py,sha256=hYg1DbdSE_QNJ8ZB-ynXJlWgvFjrGvwoUsGJu_E0pRQ,360
 sunholo/streaming/streaming.py,sha256=S4GzVNol3J_8tkzXodvkcR-THiTGnIKYj40NtrBhtL4,16459
@@ -132,6 +134,7 @@ sunholo/utils/config_class.py,sha256=aNhxhEHIxRvqQNq_9wFJt1yM9U1ypahCVZ3NzPWuay4
 sunholo/utils/config_schema.py,sha256=Wv-ncitzljOhgbDaq9qnFqH5LCuxNv59dTGDWgd1qdk,4189
 sunholo/utils/gcp.py,sha256=uueODEpA-P6O15-t0hmcGC9dONLO_hLfzSsSoQnkUss,4854
 sunholo/utils/gcp_project.py,sha256=Fa0IhCX12bZ1ctF_PKN8PNYd7hihEUfb90kilBfUDjg,1411
+sunholo/utils/mime.py,sha256=hTtSilPDK9oJe8yJqTcPGNV4fIUyaL43Ql8ZncB1DlU,1867
 sunholo/utils/parsers.py,sha256=wES0fRn3GONoymRXOXt-z62HCoOiUvvFXa-MfKfjCls,6421
 sunholo/utils/timedelta.py,sha256=BbLabEx7_rbErj_YbNM0MBcaFN76DC4PTe4zD2ucezg,493
 sunholo/utils/user_ids.py,sha256=SQd5_H7FE7vcTZp9AQuQDWBXd4FEEd7TeVMQe1H4Ny8,292
@@ -144,9 +147,9 @@ sunholo/vertex/init.py,sha256=1OQwcPBKZYBTDPdyU7IM4X4OmiXLdsNV30C-fee2scQ,2875
 sunholo/vertex/memory_tools.py,sha256=tBZxqVZ4InTmdBvLlOYwoSEWu4-kGquc-gxDwZCC4FA,7667
 sunholo/vertex/safety.py,sha256=S9PgQT1O_BQAkcqauWncRJaydiP8Q_Jzmu9gxYfy1VA,2482
 sunholo/vertex/type_dict_to_json.py,sha256=uTzL4o9tJRao4u-gJOFcACgWGkBOtqACmb6ihvCErL8,4694
-sunholo-0.100.2.dist-info/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
-sunholo-0.100.2.dist-info/METADATA,sha256=hkHwKSigiDOe9t6fcubbDM0Osr542-T3R8guKamW2YY,8312
-sunholo-0.100.2.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-sunholo-0.100.2.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
-sunholo-0.100.2.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
-sunholo-0.100.2.dist-info/RECORD,,
+sunholo-0.101.0.dist-info/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
+sunholo-0.101.0.dist-info/METADATA,sha256=f5ACnI-b0miaBTKmVuiOB6xgtIcwb9QXDq3s__-_3Aw,8312
+sunholo-0.101.0.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+sunholo-0.101.0.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
+sunholo-0.101.0.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
+sunholo-0.101.0.dist-info/RECORD,,