sunholo 0.116.2__py3-none-any.whl → 0.118.1__py3-none-any.whl

sunholo/templates/agent/agent_service.py

@@ -0,0 +1,157 @@
+
+from sunholo.utils import ConfigManager
+from sunholo.vertex import (
+    init_genai,
+)
+
+from tools.your_agent import get_quarto, quarto_content, QuartoProcessor
+
+from my_log import log
+
+init_genai()
+
+# kwargs supports - image_uri, mime
+def vac_stream(question: str, vector_name:str, chat_history=[], callback=None, **kwargs):
+    
+    config=ConfigManager(vector_name)
+    processor = QuartoProcessor(config)
+
+    orchestrator = get_quarto(config, processor)
+    if not orchestrator:
+        msg = f"No quarto model could be configured for {vector_name}"
+        log.error(msg)
+        callback.on_llm_end(response=msg)
+        return {"answer": msg}
+
+    chat = orchestrator.start_chat()
+
+    guardrail = 0
+    guardrail_max = kwargs.get('max_steps', 10)
+    big_text = ""
+    usage_metadata = None
+    functions_called = []
+    result=None
+    last_responses=None
+    while guardrail < guardrail_max:
+
+        content = quarto_content(question, chat_history)
+        log.info(f"# Loop [{guardrail}] - {content=}")
+        response = chat.send_message(content, stream=True)
+        this_text = "" # reset for this loop
+        log.debug(f"[{guardrail}] {response}")
+
+        for chunk in response:
+            try:
+                log.debug(f"[{guardrail}] {chunk=}")
+                # Check if 'text' is an attribute of chunk and if it's a string
+                if hasattr(chunk, 'text') and isinstance(chunk.text, str):
+                    token = chunk.text
+                else:
+                    function_names = []
+                    try:
+                        for part in chunk.candidates[0].content.parts:
+                            if fn := part.function_call:
+                                params = {key: val for key, val in fn.args.items()}
+                                func_args = ",".join(f"{key}={value}" for key, value in params.items())
+                                log.info(f"Found function call: {fn.name}({func_args})")
+                                function_names.append(f"{fn.name}({func_args})")
+                                functions_called.append(f"{fn.name}({func_args})")
+                    except Exception as err:
+                        log.warning(f"{str(err)}")
+
+                    token = ""  # Handle the case where 'text' is not available
+                    
+                    if processor.last_api_requests_and_responses:
+                        if processor.last_api_requests_and_responses != last_responses:
+                            last_responses = processor.last_api_requests_and_responses
+                        for last_response in last_responses:
+                            result=None # reset for this function response
+                            if last_response:
+                                log.info(f"[{guardrail}] {last_response=}")
+                                
+                                # Convert the last_response to a string by extracting relevant information
+                                function_name = last_response[0]
+                                arguments = last_response[1]
+                                result = last_response[2]
+                                func_args = ",".join(f"{key}={value}" for key, value in arguments.items())
+
+                                if f"{function_name}({func_args})" not in function_names:
+                                    log.warning(f"skipping {function_name}({func_args}) as not in execution list")
+                                    continue
+
+                                token = f"\n## Loop [{guardrail}] Function call: {function_name}({func_args}):\n"
+
+                                if function_name == "decide_to_go_on":
+                                    token += f"# go_on={result}\n"
+                                else:
+                                    log.info("Adding result for: {function_name}")
+                                    token += result
+
+                callback.on_llm_new_token(token=token)
+                big_text += token
+                this_text += token
+                
+                if not usage_metadata:
+                    chunk_metadata = chunk.usage_metadata
+                    usage_metadata = {
+                        "prompt_token_count": chunk_metadata.prompt_token_count,
+                        "candidates_token_count": chunk_metadata.candidates_token_count,
+                        "total_token_count": chunk_metadata.total_token_count,
+                    }
+
+            except ValueError as err:
+                callback.on_llm_new_token(token=str(err))
+        
+        # change response to one with executed functions
+        response = processor.process_funcs(response)
+
+        if this_text:
+            chat_history.append(("<waiting for ai>", this_text))
+            log.info(f"[{guardrail}] Updated chat_history: {chat_history}")
+
+        go_on_check = processor.check_function_result("decide_to_go_on", False)
+        if go_on_check:
+            log.info("Breaking agent loop")
+            break
+        
+        guardrail += 1
+        if guardrail > guardrail_max:
+            log.warning("Guardrail kicked in, more than 10 loops")
+            break
+
+    callback.on_llm_end(response=big_text)
+    log.info(f"orchestrator.response: {big_text}")
+
+    metadata = {
+        "question:": question,
+        "chat_history": chat_history,
+        "usage_metadata": usage_metadata,
+        "functions_called": functions_called
+    }
+
+    return {"answer": big_text or "No answer was given", "metadata": metadata}
+
+
+def vac(question: str, vector_name: str, chat_history=[], **kwargs):
+    # Create a callback that does nothing for streaming if you don't want intermediate outputs
+    class NoOpCallback:
+        def on_llm_new_token(self, token):
+            pass
+        def on_llm_end(self, response):
+            pass
+
+    # Use the NoOpCallback for non-streaming behavior
+    callback = NoOpCallback()
+
+    # Pass all arguments to vac_stream and use the final return
+    result = vac_stream(
+        question=question, 
+        vector_name=vector_name, 
+        chat_history=chat_history, 
+        callback=callback, 
+        **kwargs
+    )
+
+    return result
+
+

sunholo/templates/agent/app.py

@@ -0,0 +1,16 @@
+import os
+
+from sunholo.agents import VACRoutes, create_app
+
+from vac_service import vac_stream, vac
+
+app = create_app(__name__)
+
+# Register the Q&A routes with the specific interpreter functions
+# creates /vac/<vector_name> and /vac/streaming/<vector_name>
+VACRoutes(app, vac_stream, vac)
+
+if __name__ == "__main__":
+    import os
+    app.run(host="0.0.0.0", port=int(os.environ.get("PORT", 8080)), debug=True)
+

sunholo/templates/agent/my_log.py

@@ -0,0 +1,3 @@
+from sunholo.custom_logging import setup_logging
+
+log = setup_logging("sunholo")

sunholo/templates/agent/tools/your_agent.py

@@ -0,0 +1,78 @@
+from sunholo.genai import GenAIFunctionProcessor
+from sunholo.utils import ConfigManager
+
+from my_log import log
+
+
+class QuartoProcessor(GenAIFunctionProcessor):
+    def construct_tools(self) -> dict:
+        tools = self.config.vacConfig("tools")
+        quarto_config = tools.get("quarto")
+        
+        def decide_to_go_on(go_on: bool):
+            """
+            Examine the chat history.  If the answer to the user's question has been answered, then go_on=False.
+            If the chat history indicates the answer is still being looked for, then go_on=True.
+            If there is no chat history, then go_on=True.
+            If there is an error that can't be corrected or solved by you, then go_on=False.
+            If there is an error but you think you can solve it by correcting your function arguments (such as an incorrect source), then go_on=True
+            If you want to ask the user a question or for some more feedback, then go_on=False.
+            
+            Args:
+                go_on: boolean Whether to continue searching or fetching from the AlloyDB database
+            
+            Returns:
+                boolean: True to carry on, False to continue
+            """
+            return go_on
+
+        def quarto_render() -> dict:
+            """
+            ...
+            
+            Args:
+            
+            
+            Returns:
+                
+            """
+            pass
+
+        return {
+            "quarto_render": quarto_render,
+            "decide_to_go_on": decide_to_go_on
+        }
+
+def quarto_content(question: str, chat_history=[]) -> str:
+    prompt_config = ConfigManager("quarto")
+    alloydb_template = prompt_config.promptConfig("quarto_template")
+    
+    conversation_text = ""
+    for human, ai in chat_history:
+        conversation_text += f"Human: {human}\nAI: {ai}\n"
+
+    return alloydb_template.format(the_question=question, chat_history=conversation_text[-10000:])
+
+
+def get_quarto(config:ConfigManager, processor:QuartoProcessor):
+
+    tools = config.vacConfig('tools')
+
+    if tools and tools.get('quarto'):
+        model_name = None
+        if config.vacConfig('llm') != "vertex":
+            model_name = 'gemini-1.5-flash'
+        alloydb_model = processor.get_model(
+            system_instruction=(
+                    "You are a helpful Quarto agent that helps users create and render Quarto documents. "
+                    "When you think the answer has been given to the satisfaction of the user, or you think no answer is possible, or you need user confirmation or input, you MUST use the decide_to_go_on(go_on=False) function"
+                    "When you want to ask the question to the user, mark the go_on=False in the function"
+                ),
+            model_name=model_name
+        )
+
+        if alloydb_model:
+            return alloydb_model
+
+    log.error("Error initializing quarto model")    
+    return None

sunholo/templates/agent/vac_service.py

@@ -0,0 +1,73 @@
+from my_log import log
+from sunholo.utils import ConfigManager
+
+# VAC specific imports 
+
+#TODO: Developer to update to their own implementation
+from sunholo.vertex import init_vertex, get_vertex_memories
+from vertexai.preview.generative_models import GenerativeModel
+
+#TODO: change this to a streaming VAC function
+def vac_stream(question: str, vector_name, chat_history=[], callback=None, **kwargs):
+
+    rag_model = create_model(vector_name)
+
+    # streaming model calls
+    response = rag_model.generate_content(question, stream=True)
+    for chunk in response:
+        try:
+            callback.on_llm_new_token(token=chunk.text)
+        except ValueError as err:
+            callback.on_llm_new_token(token=str(err))
+    
+    callback.on_llm_end(response=response)
+    log.info(f"rag_model.response: {response}")
+
+    metadata = {
+        "chat_history": chat_history
+    }
+
+    return {"answer": response.text, "metadata": metadata}
+
+
+
+#TODO: change this to a batch VAC function
+def vac(question: str, vector_name: str, chat_history=[], **kwargs):
+    # Create a callback that does nothing for streaming if you don't want intermediate outputs
+    class NoOpCallback:
+        def on_llm_new_token(self, token):
+            pass
+        def on_llm_end(self, response):
+            pass
+
+    # Use the NoOpCallback for non-streaming behavior
+    callback = NoOpCallback()
+
+    # Pass all arguments to vac_stream and use the final return
+    result = vac_stream(
+        question=question, 
+        vector_name=vector_name, 
+        chat_history=chat_history, 
+        callback=callback, 
+        **kwargs
+    )
+
+    return result
+
+
+# TODO: common model setup to both batching and streaming
+def create_model(vac):
+    config = ConfigManager(vac)
+
+    init_vertex()
+    corpus_tools = get_vertex_memories(config)
+
+    model = config.vacConfig("model")
+
+    # Create a gemini-pro model instance
+    # https://ai.google.dev/api/python/google/generativeai/GenerativeModel#streaming
+    rag_model = GenerativeModel(
+        model_name=model or "gemini-1.5-flash", tools=[corpus_tools]
+    )
+
+    return rag_model

sunholo/templates/project/app.py

@@ -0,0 +1,17 @@
+import os
+
+from sunholo.agents import VACRoutes, create_app
+
+from vac_service import vac_stream
+
+app = create_app(__name__)
+
+# Register the Q&A routes with the specific interpreter functions
+# creates endpoints /vac/streaming/<vector_name> and /vac/<vector_name> etc.
+VACRoutes(app, vac_stream)
+
+# start via `python app.py`
+if __name__ == "__main__":
+    import os
+    app.run(host="0.0.0.0", port=int(os.environ.get("PORT", 8080)), debug=True)
+

sunholo/templates/project/my_log.py

@@ -0,0 +1,3 @@
+from sunholo.custom_logging import setup_logging
+
+log = setup_logging("sunholo")

sunholo/templates/project/vac_service.py

@@ -0,0 +1,71 @@
+from my_log import log
+from sunholo.utils import ConfigManager
+
+# VAC specific imports 
+
+#TODO: Developer to update to their own implementation
+from sunholo.genai import init_genai, genai_safety
+import google.generativeai as genai
+
+#TODO: change this to a streaming VAC function for your use case
+def vac_stream(question: str, vector_name:str, chat_history=[], callback=None, **kwargs):
+
+    model = create_model(vector_name)
+
+    # create chat history for genai model
+    # https://ai.google.dev/api/generate-content
+    contents = []
+    for human, ai in chat_history:
+        if human:
+            contents.append({"role":"user", "parts":[{"text": human}]})
+        
+        if ai:
+            contents.append({"role":"model", "parts":[{"text": ai}]})
+
+
+    # the user question at the end of contents list
+    contents.append({"role":"user", "parts":[{"text": question}]})
+
+    log.info(contents)
+    # streaming model calls
+    response = model.generate_content(contents, stream=True)
+    chunks=""
+    for chunk in response:
+        if chunk and chunk.text:
+            try:
+                callback.on_llm_new_token(token=chunk.text)
+                chunks += chunk.text
+            except ValueError as err:
+                callback.on_llm_new_token(token=str(err))
+    
+    # stream has finished, full response is also returned
+    callback.on_llm_end(response=response)
+    log.info(f"model.response: {response}")
+
+    metadata = {
+        "question": question,
+        "vector_name": vector_name,
+        "chat_history": chat_history
+    }
+
+    # to not return this dict at the end of the stream, pass stream_only: true in request
+    return {"answer": chunks, "metadata": metadata}
+
+
+# TODO: example model setup function
+def create_model(vac):
+    config = ConfigManager(vac)
+
+    init_genai()
+
+    # get a setting from the config vacConfig object (returns None if not found)
+    model = config.vacConfig("model")
+
+    # Create a gemini-flash model instance
+    # https://ai.google.dev/api/python/google/generativeai/GenerativeModel#streaming
+    genai_model = genai.GenerativeModel(
+        model_name=model or "gemini-1.5-flash",
+         safety_settings=genai_safety()
+    )
+
+    return genai_model

sunholo/templates/system_services/app.py

@@ -0,0 +1,49 @@
+import os
+import traceback
+
+# app.py
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse
+
+from my_log import log
+
+app = FastAPI()
+
+@app.get("/")
+def home():
+    """Simple endpoint to indicate that the app is running."""
+    return {"message": "Hello, service!"}
+
+@app.post("/system_service/<param>")
+async def system_service(request: Request):
+    """
+    Pubsub message parsed and sent to Langfuse ID server
+    """
+    data = await request.json()
+
+    try:
+        #TODO: add stuff here
+        meta = ""
+        return {"status": "success", "message": meta}
+    except Exception as err:
+        log.error(f'EVAL_ERROR: Error when sending {data} to /pubsub_to_langfuse: {str(err)} traceback: {traceback.format_exc()}')
+        return JSONResponse(status_code=200, content={"status": "error", "message": f'{str(err)} traceback: {traceback.format_exc()}'})
+
+@app.post("/test_endpoint")
+async def test_me(request: Request):
+    """
+    Endpoint to send trace_ids directly for evals then sent to Langfuse ID server
+    """
+    data = await request.json()
+
+    try:
+        #TODO: do something here
+        meta = ""
+        return {"status": "success", "message": meta}
+    except Exception as err:
+        log.error(f'EVAL_ERROR: Error when sending {data} to /direct_evals: {str(err)} traceback: {traceback.format_exc()}')
+        return JSONResponse(status_code=500, content={"status": "error", "message": f'{str(err)} traceback: {traceback.format_exc()}'})
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=int(os.environ.get("PORT", 8080)), debug=True)

sunholo/templates/system_services/my_log.py

@@ -0,0 +1,3 @@
+from sunholo.custom_logging import setup_logging
+
+log = setup_logging("system")

sunholo/utils/big_context.py

@@ -43,7 +43,7 @@ def load_gitignore_patterns(gitignore_path):
     """
     with open(gitignore_path, 'r') as f:
         patterns = [line.strip() for line in f if line.strip() and not line.startswith('#')]
-    patterns.extend(["*.git/*", "*.terraform/*"])
+    patterns.extend([".git/", ".terraform/"]) # More precise pattern matching
     return patterns
 
 def should_ignore(file_path, patterns):
@@ -62,11 +62,18 @@ def should_ignore(file_path, patterns):
         True
     """
     rel_path = os.path.relpath(file_path)
-
+    
     for pattern in patterns:
-        if fnmatch(rel_path, pattern) or fnmatch(os.path.basename(rel_path), pattern):
+        # Handle directory patterns ending with /
+        if pattern.endswith('/'):
+            if any(part == pattern[:-1] for part in rel_path.split(os.sep)):
+                print(f"Ignoring {rel_path}")
+                return True
+        # Handle file patterns
+        elif fnmatch(rel_path, pattern):
+            print(f"Ignoring {rel_path}")
             return True
-
+    
     return False
 
 

{sunholo-0.116.2.dist-info → sunholo-0.118.1.dist-info}/METADATA

@@ -1,12 +1,11 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: sunholo
-Version: 0.116.2
+Version: 0.118.1
 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.116.2.tar.gz
-Author: Holosun ApS
-Author-email: multivac@sunholo.com
+Author-email: Holosun ApS <multivac@sunholo.com>
 License: Apache License, Version 2.0
+Project-URL: Homepage, https://github.com/sunholo-data/sunholo-py
+Project-URL: Download, https://github.com/sunholo-data/sunholo-py/archive/refs/tags/v0.118.0.tar.gz
 Keywords: llms,devops,google_cloud_platform
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
@@ -16,6 +15,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: aiohttp
@@ -24,6 +24,9 @@ Requires-Dist: pydantic
 Requires-Dist: requests
 Requires-Dist: ruamel.yaml
 Requires-Dist: tenacity
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
 Provides-Extra: all
 Requires-Dist: aiohttp; extra == "all"
 Requires-Dist: anthropic[vertex]; extra == "all"
@@ -47,6 +50,7 @@ Requires-Dist: google-cloud-pubsub; extra == "all"
 Requires-Dist: google-cloud-discoveryengine; extra == "all"
 Requires-Dist: google-cloud-texttospeech; extra == "all"
 Requires-Dist: google-generativeai>=0.7.1; extra == "all"
+Requires-Dist: google-genai; extra == "all"
 Requires-Dist: gunicorn; extra == "all"
 Requires-Dist: httpcore; extra == "all"
 Requires-Dist: httpx; extra == "all"
@@ -64,6 +68,7 @@ Requires-Dist: langchain-unstructured; extra == "all"
 Requires-Dist: langfuse; extra == "all"
 Requires-Dist: mcp; extra == "all"
 Requires-Dist: numpy; extra == "all"
+Requires-Dist: opencv-python; extra == "all"
 Requires-Dist: pg8000; extra == "all"
 Requires-Dist: pgvector; extra == "all"
 Requires-Dist: pillow; extra == "all"
@@ -118,9 +123,9 @@ Requires-Dist: unstructured[all-docs,local-inference]; extra == "pipeline"
 Provides-Extra: gcp
 Requires-Dist: anthropic[vertex]; extra == "gcp"
 Requires-Dist: google-api-python-client; extra == "gcp"
-Requires-Dist: google-cloud-alloydb-connector[pg8000]; extra == "gcp"
 Requires-Dist: google-auth-httplib2; extra == "gcp"
 Requires-Dist: google-auth-oauthlib; extra == "gcp"
+Requires-Dist: google-cloud-alloydb-connector[pg8000]; extra == "gcp"
 Requires-Dist: google-cloud-aiplatform>=1.58.0; extra == "gcp"
 Requires-Dist: google-cloud-bigquery; extra == "gcp"
 Requires-Dist: google-cloud-build; extra == "gcp"
@@ -130,6 +135,7 @@ Requires-Dist: google-cloud-logging; extra == "gcp"
 Requires-Dist: google-cloud-pubsub; extra == "gcp"
 Requires-Dist: google-cloud-discoveryengine; extra == "gcp"
 Requires-Dist: google-cloud-texttospeech; extra == "gcp"
+Requires-Dist: google-genai; extra == "gcp"
 Requires-Dist: google-generativeai>=0.8.3; extra == "gcp"
 Requires-Dist: langchain-google-genai>=2.0.0; extra == "gcp"
 Requires-Dist: langchain_google_alloydb_pg>=0.2.2; extra == "gcp"
@@ -164,6 +170,8 @@ Provides-Extra: tts
 Requires-Dist: google-cloud-texttospeech; extra == "tts"
 Requires-Dist: numpy; extra == "tts"
 Requires-Dist: sounddevice; extra == "tts"
+Provides-Extra: video
+Requires-Dist: opencv-python; extra == "video"
 
 [![PyPi Version](https://img.shields.io/pypi/v/sunholo.svg)](https://pypi.python.org/pypi/sunholo/)