sunholo 0.100.3__tar.gz → 0.101.2__tar.gz

{sunholo-0.100.3 → sunholo-0.101.2}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: sunholo
-Version: 0.100.3
+Version: 0.101.2
 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.3.tar.gz
+Download-URL: https://github.com/sunholo-data/sunholo-py/archive/refs/tags/v0.101.2.tar.gz
 Author: Holosun ApS
 Author-email: multivac@sunholo.com
 License: Apache License, Version 2.0

{sunholo-0.100.3 → sunholo-0.101.2}/setup.py

@@ -1,6 +1,6 @@
 from setuptools import setup, find_packages
 
-version = '0.100.3'
+version = '0.101.2'
 
 setup(
     name='sunholo',

{sunholo-0.100.3 → sunholo-0.101.2}/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-0.100.3 → sunholo-0.101.2}/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-0.101.2/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-0.101.2/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-0.100.3 → sunholo-0.101.2}/sunholo/genai/process_funcs_cls.py

@@ -14,11 +14,18 @@ try:
     import proto
     from google.generativeai.types import RequestOptions
     from google.api_core import retry
+    from google.generativeai import ChatSession
 except ImportError:
     genai = None
+    ChatSession = None
+
+from .images import extract_gs_images_and_genai_upload
 
 if TYPE_CHECKING:
     from google.generativeai.protos import Part
+    from google.generativeai import ChatSession
+
+
 
 class GenAIFunctionProcessor:
     """
@@ -365,21 +372,43 @@ class GenAIFunctionProcessor:
         log.info(f"Cleaning:\n{string}\n > to >\n{clean}")
         
         return clean
+    
+    def convert_composite_to_native(self, value):
+        """
+        Recursively converts a proto MapComposite or RepeatedComposite object to native Python types.
+
+        Args:
+            value: The proto object, which could be a MapComposite, RepeatedComposite, or a primitive.
 
-    def run_agent_loop(self, chat, content, callback, guardrail_max=10, loop_return=3):
+        Returns:
+            The equivalent Python dictionary, list, or primitive type.
+        """
+        if isinstance(value, proto.marshal.collections.maps.MapComposite):
+            # Convert MapComposite to a dictionary, recursively processing its values
+            return {key: self.convert_composite_to_native(val) for key, val in value.items()}
+        elif isinstance(value, proto.marshal.collections.repeated.RepeatedComposite):
+            # Convert RepeatedComposite to a list, recursively processing its elements
+            return [self.convert_composite_to_native(item) for item in value]
+        else:
+            # If it's a primitive value, return it as is
+            return value
+
+    def run_agent_loop(self, chat:ChatSession, content:list, 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 = {
@@ -482,7 +511,9 @@ class GenAIFunctionProcessor:
                     fn_result_json = None
                     # Convert MapComposite to a standard Python dictionary
                     if isinstance(fn_result, proto.marshal.collections.maps.MapComposite):
-                        fn_result_json = dict(fn_result)
+                        fn_result_json = self.convert_composite_to_native(fn_result)
+                    elif isinstance(fn_result, proto.marshal.collections.repeated.RepeatedComposite):
+                        fn_result = self.convert_composite_to_native(fn_result)
                     elif isinstance(fn_result, dict):
                         fn_result_json = fn_result
                     elif isinstance(fn_result, str):
@@ -535,6 +566,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 +605,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-0.101.2/sunholo/langfuse/prompts.py

@@ -0,0 +1,80 @@
+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, f_string=True):
+    """
+    Returns a string you can use with prompts.
+
+    If load_from_file=False, by default it will try to load from Langfuse, if fails (which is laggy so not ideal) then load from file.
+
+    Prompts on Langfuse should be specified with a name with {prefix}-{key} e.g. "sunholo-hello"
+    
+    Prompts in files will use yaml:
+
+    ```yaml
+    kind: promptConfig
+    apiVersion: v1
+    prompts:
+    sunholo:
+        hello: |
+            Say hello to {name} 
+    ```
+
+    And load via utils.ConfigManager:
+
+    ```python
+    # equivalent to load_prompt_from_yaml("hello", load_from_file=True)
+    config = ConfigManager("sunholo")
+    config.promptConfig("hello")
+    ```
+
+    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 }} - see https://langfuse.com/docs/prompts/get-started
+
+    Example:
+
+    ```python
+    from sunholo.langfuse.prompts import load_prompt_from_yaml
+    # f_string
+    hello_template = load_prompt_from_yaml("hello")
+    hello_template.format(name="Bob")
+
+    #langfuse style
+    hello_template = load_prompt_from_yaml("hello", f_string=False)
+    hello_template.compile(name="Bob")
+
+    # if prompt not available on langfuse, will attempt to load from local promptConfig file
+    hello_template = load_prompt_from_yaml("hello", load_from_file=True)
+
+    ```
+
+    """
+    config = ConfigManager(prefix)
+    if load_from_file:
+        
+        return config.promptConfig(key)
+
+
+    from langfuse import Langfuse
+
+    # Initialize Langfuse client
+    langfuse = Langfuse()
+
+    try:
+        if prefix is None:
+            langfuse_template = key
+        else:
+            langfuse_template = f"{prefix}-{key}"
+            
+        langfuse_prompt = langfuse.get_prompt(langfuse_template, cache_ttl_seconds=300)
+
+        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")
+
+    return config.promptConfig(key)

{sunholo-0.100.3 → sunholo-0.101.2}/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-0.101.2/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.3 → sunholo-0.101.2}/sunholo.egg-info/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: sunholo
-Version: 0.100.3
+Version: 0.101.2
 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.3.tar.gz
+Download-URL: https://github.com/sunholo-data/sunholo-py/archive/refs/tags/v0.101.2.tar.gz
 Author: Holosun ApS
 Author-email: multivac@sunholo.com
 License: Apache License, Version 2.0

{sunholo-0.100.3 → sunholo-0.101.2}/sunholo.egg-info/SOURCES.txt

@@ -94,8 +94,10 @@ sunholo/gcs/__init__.py
 sunholo/gcs/add_file.py
 sunholo/gcs/download_folder.py
 sunholo/gcs/download_url.py
+sunholo/gcs/extract_and_sign.py
 sunholo/gcs/metadata.py
 sunholo/genai/__init__.py
+sunholo/genai/images.py
 sunholo/genai/init.py
 sunholo/genai/process_funcs_cls.py
 sunholo/genai/safety.py
@@ -143,6 +145,7 @@ sunholo/utils/config_class.py
 sunholo/utils/config_schema.py
 sunholo/utils/gcp.py
 sunholo/utils/gcp_project.py
+sunholo/utils/mime.py
 sunholo/utils/parsers.py
 sunholo/utils/timedelta.py
 sunholo/utils/user_ids.py
@@ -155,5 +158,6 @@ sunholo/vertex/init.py
 sunholo/vertex/memory_tools.py
 sunholo/vertex/safety.py
 sunholo/vertex/type_dict_to_json.py
+tests/test_async.py
 tests/test_chat_history.py
 tests/test_config.py

sunholo-0.101.2/tests/test_async.py

@@ -0,0 +1,93 @@
+import asyncio
+from sunholo.invoke import AsyncTaskRunner
+# Mock logger for demonstration
+import logging
+logging.basicConfig(level=logging.INFO)
+log = logging.getLogger(__name__)
+
+
+# Dummy task functions for testing
+async def google_search(query, config_manager):
+    await asyncio.sleep(5)  # Simulate a long-running task
+    return f"Results for '{query}'"
+
+async def use_pdfs(query, arg2, arg3):
+    await asyncio.sleep(2)  # Simulate a medium-running task
+    return "No image_uri specified\n"
+
+async def process_urls(url):
+    await asyncio.sleep(1)  # Simulate a short-running task
+    return "No URLs were found"
+
+# Mock callback for demonstration
+class MockCallback:
+    async def async_on_llm_new_token(self, token):
+        log.info(f"Callback received token: {token}")
+
+# Mock functions for demonstration
+def format_token_output(func_name, tokens, result=None, error=None):
+    if error:
+        return f"Error in {func_name}: {error}"
+    return f"{func_name} completed with {tokens} tokens. Result: {result}"
+
+async def count_tokens(result):
+    return len(result.split())
+
+# Example usage
+async def main():
+    runner = AsyncTaskRunner(retry_enabled=True)
+    
+    # Add your tasks
+    runner.add_task(google_search, "<original user question>...", "<config>")
+    runner.add_task(use_pdfs, "<original user question>...", None, None)
+    runner.add_task(process_urls, "please give me a forecast of ppas for spain using wind energy")
+    
+    callback = MockCallback()
+    answers = {}
+    total_context_tokens = 0
+    
+    async for message in runner.run_async_as_completed():
+        log.info(f"Runner message={message}")
+        if message['type'] == 'heartbeat':
+            func_name = message['name']
+            elapsed_time = message['elapsed_time']
+            log.info(f"Runner Heartbeat for {func_name}, elapsed_time={elapsed_time}")
+            # Send heartbeat to callback
+            update_html = (
+                f'<div style="display: none;" data-update-id="{func_name}-spinner">'
+                f'<span class="elapsed-time">{elapsed_time} seconds elapsed</span>'
+                f'</div>'
+            )
+            await callback.async_on_llm_new_token(token=f"[[HEARTBEAT]]{update_html}[[/HEARTBEAT]]")
+        elif message['type'] == 'task_complete':
+            func_name = message['func_name']
+            result = message['result']
+            log.info(f"Runner completed task: {func_name}")
+            # Process result
+            if isinstance(result, Exception):
+                log.info(f"Error Exception for {func_name}: {str(result)}")
+                formatted_output = format_token_output(func_name, 0, error="No results")
+                await callback.async_on_llm_new_token(token=formatted_output)
+            else:
+                # Stream the result to the callback
+                tokens = await count_tokens(result)
+                total_context_tokens += tokens
+                log.info(f"Got task {func_name} to stream result length [{len(result)}] [{tokens} tokens]")
+                formatted_output = format_token_output(func_name, tokens, result=result)
+                await callback.async_on_llm_new_token(token=formatted_output)
+                answers[func_name] = result
+        elif message['type'] == 'task_error':
+            func_name = message['func_name']
+            error = message['error']
+            log.info(f"Error Exception for {func_name}: {str(error)}")
+            formatted_output = format_token_output(func_name, 0, error="No results")
+            await callback.async_on_llm_new_token(token=formatted_output)
+
+    await callback.async_on_llm_new_token(
+        token=f'<div style="margin-top: 20px; color: #333;"><strong>-- Using [{total_context_tokens}] tokens in context for final answer --</strong></div>'
+    )
+    log.info("All tasks have been processed.")
+
+# Run the main coroutine
+if __name__ == "__main__":
+    asyncio.run(main())

sunholo-0.100.3/sunholo/langfuse/prompts.py

@@ -1,44 +0,0 @@
-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):
-    """
-    Returns a string you can use with Langfuse PromptTemplate.from_template() 
-
-    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 }.
-
-    Example:
-
-    ```python
-    from sunholo.langfuse.prompts import load_prompt_from_yaml
-    from langchain_core.prompts import PromptTemplate
-    
-    """
-    config = ConfigManager(prefix)
-    if load_from_file:
-        
-        return config.promptConfig(key)
-
-
-    from langfuse import Langfuse
-
-    # Initialize Langfuse client
-    langfuse = Langfuse()
-
-    try:
-        if prefix is None:
-            langfuse_template = key
-        else:
-            langfuse_template = f"{prefix}-{key}"
-            
-        langfuse_prompt = langfuse.get_prompt(langfuse_template, cache_ttl_seconds=300)
-
-        return langfuse_prompt.get_langchain_prompt()
-    
-    except Exception as err:
-        log.warning(f"Could not find langfuse template: {langfuse_template} - {str(err)} - attempting to load from promptConfig")
-
-    return config.promptConfig(key)