sunholo 0.72.0__py3-none-any.whl → 0.73.3__py3-none-any.whl

sunholo/invoke/invoke_vac_utils.py

@@ -0,0 +1,151 @@
+import json
+import requests
+
+from pathlib import Path
+
+from ..logging import log
+from ..agents import send_to_qa
+from ..qna.parsers import parse_output
+from ..streaming import generate_proxy_stream
+
+def invoke_vac_qa(vac_input: dict, vac_name: str, chat_history=[], stream=False):
+    """
+    This lets VACs call other VAC Q&A endpoints within their code
+    """
+
+    if 'user_input' not in vac_input:
+        raise ValueError('vac_input must contain at least "user_input" key - got {vac_input}')
+
+    user_id = vac_input.get('user_id')
+    session_id = vac_input.get('session_id')
+    image_uri = vac_input.get('image_url') or vac_input.get('image_uri')
+
+    if not stream:
+        log.info(f'Batch invoke_vac_qa with {vac_input=}')
+        vac_response = send_to_qa(
+            vac_input["user_input"],
+            vector_name=vac_name,
+            chat_history=chat_history,
+            message_author=user_id,
+            #TODO: populate these
+            image_url=image_uri,
+            source_filters=None,
+            search_kwargs=None,
+            private_docs=None,
+            whole_document=False,
+            source_filters_and_or=False,
+            # system kwargs
+            configurable={
+                "vector_name": vac_name,
+            },
+            user_id=user_id,
+            session_id=session_id, 
+            message_source="sunholo.invoke_vac_qa.invoke")
+        
+        # ensures {'answer': answer}
+        answer = parse_output(vac_response)
+        chat_history.append({"name": "Human", "content": vac_input})
+        chat_history.append({"name": "AI", "content": answer})
+        answer["chat_history"] = chat_history
+        
+        return answer
+    
+    log.info(f"Streaming invoke_vac_qa with {vac_input=}")
+    def stream_response():
+        generate = generate_proxy_stream(
+                send_to_qa,
+                vac_input["user_input"],
+                vector_name=vac_name,
+                chat_history=chat_history,
+                generate_f_output=lambda x: x,  # Replace with actual processing function
+                stream_wait_time=0.5,
+                stream_timeout=120,
+                message_author=user_id,
+                #TODO: populate these
+                image_url=image_uri,
+                source_filters=None,
+                search_kwargs=None,
+                private_docs=None,
+                whole_document=False,
+                source_filters_and_or=False,
+                # system kwargs
+                configurable={
+                    "vector_name": vac_name,
+                },
+                user_id=user_id,
+                session_id=session_id, 
+                message_source="sunholo.invoke_vac_qa.stream"
+        )
+        for part in generate():
+            yield part
+
+    answer = ""
+
+    for token in stream_response():
+        if isinstance(token, bytes):
+            token = token.decode('utf-8')
+            yield token
+        if isinstance(token, dict):
+            # ?
+            pass
+        elif isinstance(token, str):
+            answer += token
+
+    if answer:
+        chat_history.append({"name": "Human", "content": vac_input})
+        chat_history.append({"name": "AI", "content": answer})
+
+    return chat_history
+
+def invoke_vac(service_url, data, vector_name=None, metadata=None, is_file=False):
+    """
+    This lets a VAC be invoked by directly calling its URL, used for file uploads
+    """
+    try:
+        if is_file:
+            log.info("Uploading file...")
+            # Handle file upload
+            if not isinstance(data, Path) or not data.is_file():
+                raise ValueError("For file uploads, 'data' must be a Path object pointing to a valid file.")
+            
+            files = {
+                'file': (data.name, open(data, 'rb')),
+            }
+            form_data = {
+                'vector_name': vector_name,
+                'metadata': json.dumps(metadata) if metadata else '',
+            }
+
+            response = requests.post(service_url, files=files, data=form_data)
+        else:
+            log.info("Uploading JSON...")
+            try:
+                if isinstance(data, dict):
+                    json_data = data
+                else:
+                    json_data = json.loads(data)
+            except json.JSONDecodeError as err:
+                log.error(f"[bold red]ERROR: invalid JSON: {str(err)} [/bold red]")
+                raise err
+            except Exception as err:
+                log.error(f"[bold red]ERROR: could not parse JSON: {str(err)} [/bold red]")
+                raise err
+
+            log.debug(f"Sending data: {data} or json_data: {json.dumps(json_data)}")
+            # Handle JSON data
+            headers = {"Content-Type": "application/json"}
+            response = requests.post(service_url, headers=headers, data=json.dumps(json_data))
+
+        response.raise_for_status()
+
+        the_data = response.json()
+        log.info(the_data)
+
+        return the_data
+    
+    except requests.exceptions.RequestException as e:
+        log.error(f"[bold red]ERROR: Failed to invoke VAC: {e}[/bold red]")
+        raise e
+    except Exception as e:
+        log.error(f"[bold red]ERROR: An unexpected error occurred: {e}[/bold red]")
+        raise e

sunholo/langfuse/prompts.py

@@ -1,8 +1,8 @@
 from ..logging import log
-from ..utils import load_config_key
+from ..utils import ConfigManager
 
 # Load the YAML file
-def load_prompt_from_yaml(key, prefix="sunholo", file_path=None):
+def load_prompt_from_yaml(key, prefix="sunholo", load_from_file=False):
     """
     Returns a string you can use with Langfuse PromptTemplate.from_template() 
 
@@ -17,6 +17,12 @@ def load_prompt_from_yaml(key, prefix="sunholo", file_path=None):
     from langchain_core.prompts import PromptTemplate
     
     """
+    config = ConfigManager(prefix)
+    if load_from_file:
+        
+        return config.promptConfig(key)
+
+
     from langfuse import Langfuse
 
     # Initialize Langfuse client
@@ -35,4 +41,4 @@ def load_prompt_from_yaml(key, prefix="sunholo", file_path=None):
     except Exception as err:
         log.warning(f"Could not find langfuse template: {langfuse_template} - {str(err)} - attempting to load from promptConfig")
 
-    return load_config_key(key, vector_name=prefix, kind="promptConfig")
+    return config.promptConfig(key)

sunholo/llamaindex/import_files.py

@@ -4,7 +4,7 @@ except ImportError:
     rag = None
 
 from ..logging import log
-from ..utils.config import load_config_key
+from ..utils import ConfigManager
 from ..vertex import init_vertex
 from .get_files import fetch_corpus
 from ..components import load_memories
@@ -41,7 +41,8 @@ def do_llamaindex(message_data, metadata, vector_name):
     if not rag:
         raise ValueError("Need to install vertexai module via `pip install sunholo[gcp]`")
 
-    gcp_config = load_config_key("gcp_config", vector_name=vector_name, kind="vacConfig")
+    config = ConfigManager(vector_name)
+    gcp_config = config.vacConfig("gcp_config")
     if not gcp_config:
         raise ValueError(f"Need config.{vector_name}.gcp_config to configure llamaindex on VertexAI")
 
@@ -81,7 +82,7 @@ def do_llamaindex(message_data, metadata, vector_name):
                 
                 corpuses.append(corpus)
     if not corpuses:
-        log.warning("Could not find a Vertex Llamaindex RAG corpus to import data to despite being in config")
+        log.info("No Vertex Llamaindex RAG corpus to import data")
         return None
     
     try:
@@ -93,8 +94,7 @@ def do_llamaindex(message_data, metadata, vector_name):
     log.info(f"Found llamaindex corpus: {corpuses}")
 
     # native support for cloud storage and drive links
-    chunker_config = load_config_key("chunker", vector_name=vector_name, kind="vacConfig")
-
+    chunker_config = config.vacConfig("chunker")
     
     if message_data.startswith("gs://") or message_data.startswith("https://drive.google.com"):
         log.info(f"rag.import_files for {message_data}")
@@ -115,7 +115,8 @@ def do_llamaindex(message_data, metadata, vector_name):
         
 
 def check_llamaindex_in_memory(vector_name):
-    memories = load_config_key("memory", vector_name=vector_name, kind="vacConfig")
+    memories = ConfigManager(vector_name).vacConfig("memory")
+
     for memory in memories:  # Iterate over the list
         for key, value in memory.items():  # Now iterate over the dictionary
             log.info(f"Found memory {key}")
@@ -130,7 +131,7 @@ def check_llamaindex_in_memory(vector_name):
 
 def llamaindex_chunker_check(message_data, metadata, vector_name):
     # llamaindex handles its own chunking/embedding
-    memories = load_config_key("memory", vector_name=vector_name, kind="vacConfig")
+    memories = ConfigManager(vector_name).vacConfig("memory")
     total_memories = len(memories)
     llama = None
     if check_llamaindex_in_memory(vector_name):

sunholo/streaming/langserve.py

@@ -158,11 +158,14 @@ def parse_json_data(json_data: dict):
     try:
         if isinstance(json_data, dict):
             content = json_data.get('content', None)
+            metadata = json_data.get('metadata', None)
             if content is not None: # content can be '' empty string
                 #log.debug(f'Yield content: {content}')
                 yield content
+            elif metadata is not None:
+                log.debug('Metadata:', metadata)
             else:
-                log.debug(f'No "content" key found, yielding all json data dict: {json_data}')
+                log.debug(f'No "content" or "metadata" key found, yielding all json data dict: {json_data}')
                 yield json_data # Yielding all JSON data
         elif isinstance(json_data, str):
             yield json_data

sunholo/utils/config.py

@@ -57,7 +57,7 @@ def load_all_configs():
     """
     from ..logging import log
 
-    if not os.getenv("_CONFIG_FOLDER", None):
+    if not os.getenv("_CONFIG_FOLDER"):
         log.debug("_CONFIG_FOLDER is not set, using os.getcwd() instead")
     else:
         log.debug(f"_CONFIG_FOLDER set to: {os.getenv('_CONFIG_FOLDER')}")

sunholo/utils/config_class.py

@@ -9,6 +9,9 @@ class ConfigManager:
     def __init__(self, vector_name: str):
         """
         Initialize the ConfigManager with a vector name.
+        Requires a local config/ folder holding your configuration files or the env var VAC_CONFIG_FOLDER to be set.
+
+        Read more at: https://dev.sunholo.com/docs/config
 
         Args:
             vector_name (str): The name of the vector in the configuration files.
@@ -16,14 +19,22 @@ class ConfigManager:
         Example:
         ```python
         # Usage example:
-        config = ConfigManager("myVector")
+        config = ConfigManager("my_vac")
         agent = config.vacConfig("agent")
         ```
         """
+        local_config_folder = os.path.join(os.getcwd(), "config")
+        if os.path.isdir(local_config_folder):
+            print(f"Found local config folder {local_config_folder} - will overwrite any global configurations")
+        else:
+            local_config_folder = None
+        if os.getenv("VAC_CONFIG_FOLDER") is None and local_config_folder is None:
+            raise ValueError(f"Must have either a local config/ folder in this dir ({os.getcwd()}/config/) or a folder specified via the VAC_CONFIG_FOLDER environment variable, or both.")
+
         self.vector_name = vector_name
         self.config_cache = {}
         self.config_folder = os.getenv("VAC_CONFIG_FOLDER", os.getcwd())
-        self.local_config_folder = os.path.join(os.getcwd(), "config")
+        self.local_config_folder = local_config_folder
         self.configs_by_kind = self.load_all_configs()
 
     def load_all_configs(self):
@@ -38,14 +49,15 @@ class ConfigManager:
 
         log.debug(f"Loading all configs from folder: {self.config_folder} and local folder: {self.local_config_folder}")
         global_configs_by_kind = self._load_configs_from_folder(self.config_folder)
-        local_configs_by_kind = self._load_configs_from_folder(self.local_config_folder)
 
-        # Merge local configs into global configs
-        for kind, local_config in local_configs_by_kind.items():
-            if kind in global_configs_by_kind:
-                global_configs_by_kind[kind] = self._merge_dicts(global_configs_by_kind[kind], local_config)
-            else:
-                global_configs_by_kind[kind] = local_config
+        if self.local_config_folder:
+            local_configs_by_kind = self._load_configs_from_folder(self.local_config_folder)
+            # Merge local configs into global configs
+            for kind, local_config in local_configs_by_kind.items():
+                if kind in global_configs_by_kind:
+                    global_configs_by_kind[kind] = self._merge_dicts(global_configs_by_kind[kind], local_config)
+                else:
+                    global_configs_by_kind[kind] = local_config
 
         return global_configs_by_kind
 

sunholo/vertex/extensions_class.py

@@ -10,8 +10,46 @@ from ..utils.parsers import validate_extension_id
 import base64
 import json
 from io import StringIO
+import os
 
 class VertexAIExtensions:
+    """
+    Example
+
+    ```python
+    from sunholo.vertex import VertexAIExtensions
+    vex = VertexAIExtensions()
+    vex.list_extensions()
+    # [{'resource_name': 'projects/374404277595/locations/us-central1/extensions/770924776838397952', 
+    #   'display_name': 'Code Interpreter', 
+    #   'description': 'N/A'}]
+    ```
+
+    Creating an extension example as per:
+    https://cloud.google.com/vertex-ai/generative-ai/docs/extensions/create-extension
+
+    ```python
+    ## validates before upload
+    vex.upload_openapi_file("your-extension-name.yaml")
+    vex.openapi_file_gcs
+    # 'gs://your-extensions-bucket/your-extension-name.yaml'
+
+    ## load in examples to be used by creation later
+    vex.load_tool_use_examples('your-examples.yaml')
+
+    vex.create_extension(
+        "My New Extension", 
+        description="Querying the VAC above my database", 
+        service_account='sa-serviceaccount@my-project.iam.gserviceaccount.com')
+    ```
+
+    Call the extension
+    ```python
+    operation_params = {"input": {"question":"This needs to be in same schema as your openapi spec"}
+    vex.execute_extension("an_operation_id_from_your_openai_spec", 
+                          operation_params = operation_params)
+    ```
+    """
     def __init__(self):
         if extensions is None:
             raise ImportError("VertexAIExtensions needs vertexai.previewextensions to be installed. Install via `pip install sunholo[gcp]`")
@@ -27,6 +65,10 @@ class VertexAIExtensions:
         """
         self.IMAGE_FILE_EXTENSIONS = set(["jpg", "jpeg", "png"])
         self.location = "us-central1"
+        self.openapi_file_gcs = None
+        self.tool_use_examples = None
+        self.manifest = {}
+        self.created_extensions = []
 
     def list_extensions(self):
         the_list = extensions.Extension.list()
@@ -40,92 +82,165 @@ class VertexAIExtensions:
             })
         
         return extensions_list
+    
+    def validate_openapi(self, filename):
+        try:
+            from openapi_spec_validator import validate
+            from openapi_spec_validator.readers import read_from_filename
+        except ImportError:
+            raise ImportError("Must have openapi-spec-validator installed - install via `pip install sunholo[tools]`")
+        
+        spec_dict, spec_url = read_from_filename(filename)
+        validate(spec_dict)
+    
+    def upload_to_gcs(self, filename):
+        if not os.getenv('EXTENSIONS_BUCKET'):
+            raise ValueError('Please specify env var EXTENSIONS_BUCKET for location to upload openapi spec')
         
+        from ..gcs.add_file import add_file_to_gcs
+        file_base = os.path.basename(filename)
 
-    def get_extension_import_config(self, display_name: str, description: str,
-                                    api_spec_gcs: dict, service_account_name: dict, tool_use_examples: list):
-        tool_use_examples = [
-            {
-                "extensionOperation": {
-                    "operationId": "say_hello",
-                },
-                "displayName": "Say hello in the requested language",
-                "query": "Say hello in French",
-                "requestParams": {
-                    "fields": [
-                        {
-                            "key": "apiServicePrompt",
-                            "value": {
-                                "string_value": "French",
-                            }
-                        }
-                    ]
-                },
-                "responseParams": {
-                    "fields": [
-                        {
-                            "key": "apiServiceOutput",
-                            "value": {
-                                "string_value": "bonjour",
-                            },
-                        }
-                    ],
-                },
-                "responseSummary": "Bonjour"
-            }
-        ]
-
-        return {
-            "displayName": display_name,
-            "description": description,
-            "manifest": {
-                "name": "EXTENSION_NAME_LLM",
-                "description": "DESCRIPTION_LLM",
+        self_uri = add_file_to_gcs(file_base, bucket_filepath=file_base)
+
+        return self_uri
+    
+    def upload_openapi_file(self, filename: str):
+        self.validate_openapi(filename)
+
+        self.openapi_file_gcs = self.upload_to_gcs(filename)
+    
+    def load_tool_use_examples(self, filename: str):
+        import yaml
+
+        with open(filename, 'r') as file:
+            self.tool_use_examples = yaml.safe_load(file)
+
+        # google.cloud.aiplatform_v1beta1.types.ToolUseExample
+        return self.tool_use_examples
+    
+
+    def update_tool_use_examples_via_patch(self):
+        import requests
+        import json
+        from google.auth import default
+        from google.auth.transport.requests import Request
+
+        extension = self.created_extension
+        if extension is None:
+            raise ValueError("Need to create the extension first")
+
+        # Get the access token using Google authentication
+        credentials, project_id = default()
+        credentials.refresh(Request())
+        access_token = credentials.token
+
+        ENDPOINT=f"{self.location}-aiplatform.googleapis.com"
+        URL=f"https://{ENDPOINT}/v1beta1"
+
+        extension_id = self.created_extension.resource_name
+
+        # Define the URL and extension ID
+        url = f"{URL}/{extension_id}"
+        log.info(f"PATCH {url}")
+        headers = {
+            "Authorization": f"Bearer {access_token}",
+            "Content-Type": "application/json"
+        }
+
+        # Define the payload
+        payload = {
+            "toolUseExamples": self.tool_use_examples['tool_use_examples']
+        }
+
+        # Make the PATCH request
+        response = requests.patch(
+            url,
+            headers=headers,
+            params={"update_mask": "toolUseExamples"},
+            data=json.dumps(payload)
+        )
+
+        # Check the response
+        if response.status_code == 200:
+            log.info("Tool use examples updated successfully.")
+        else:
+            log.info(f"Failed to update tool use examples. Status code: {response.status_code}, Response: {response.text}")
+        
+
+    def create_extension_manifest(self,
+                                  display_name,
+                                  description,
+                                  open_api_gcs_uri: str, 
+                                  service_account: str):
+
+        self.manifest = {
+                "name": display_name,
+                "description": description,
                 "apiSpec": {
-                    "openApiGcsUri": api_spec_gcs,
+                    "openApiGcsUri": open_api_gcs_uri,
                 },
                 "authConfig": {
                     "authType": "OAUTH",
-                    "oauthConfig": {"service_account": service_account_name}
+                    "oauthConfig": {"service_account": service_account}
                 }
-            },
-            "toolUseExamples": tool_use_examples,
         }
 
-    def create_extension_instance(self, display_name: str, description: str, open_api_gcs_uri: str,
-                                  llm_name: str = None, llm_description: str = None, runtime_config: dict = None, service_account: str = None):
+        return self.manifest
+
+    def create_extension(self,
+                         display_name: str,
+                         description: str,
+                         open_api_file: str = None,
+                         tool_example_file: str = None,
+                         runtime_config: dict = None,
+                         service_account: str = None):
+        
         project_id = get_gcp_project()
         extension_name = f"projects/{project_id}/locations/us-central1/extensions/{validate_extension_id(display_name)}"
 
+        if open_api_file:
+            self.upload_openapi_file(open_api_file)
+
+        manifest = self.create_extension_manifest(
+            display_name,
+            description,
+            open_api_gcs_uri = self.openapi_file_gcs, 
+            service_account = service_account, 
+        )
+
+        if tool_example_file:
+            self.load_tool_use_examples(tool_example_file)
+
         extension = extensions.Extension.create(
             extension_name=extension_name,
             display_name=display_name,
             description=description,
-            runtime_config=runtime_config or None,
-            manifest={
-                "name": llm_name or display_name,
-                "description": llm_description or description,
-                "api_spec": {
-                    "open_api_gcs_uri": open_api_gcs_uri
-                },
-                "auth_config": {
-                    "auth_type": "GOOGLE_SERVICE_ACCOUNT_AUTH",
-                    "google_service_account_config": service_account or {},
-                },
-            },
+            runtime_config=runtime_config or None, # sets things like what bucket will be used
+            manifest=manifest,
+            #tool_use_examples=self.tool_use_examples
         )
         log.info(f"Created Vertex Extension: {extension_name}")
+        
+        self.created_extension = extension
+
+        if tool_example_file:
+            self.update_tool_use_examples_via_patch()
 
-        return extension
+        return extension.resource_name
 
-    def execute_extension(self, operation_id: str, operation_params: dict, extension_id: str):
+    def execute_extension(self, operation_id: str, operation_params: dict, extension_id: str=None):
         init_vertex(location=self.location)
 
-        if not extension_id.startswith("projects/"):
-            project_id = get_gcp_project()
-            extension_name = f"projects/{project_id}/locations/{self.location}/extensions/{extension_id}"
-        else:
-            extension_name = extension_id
+        if not extension_id:
+            extension_name = self.created_extension.resource_name
+            if extension_name is None:
+                raise ValueError("Must specify extension_id or init one with class")
+        else:  
+            if not extension_id.startswith("projects/"):
+                project_id = get_gcp_project()
+                extension_name = f"projects/{project_id}/locations/{self.location}/extensions/{extension_id}"
+            else:
+                extension_name = extension_id
 
         extension = extensions.Extension(extension_name)
 

sunholo/vertex/memory_tools.py

@@ -1,6 +1,6 @@
 try:
     from vertexai.preview import rag
-    from vertexai.preview.generative_models import Tool, grounding, GenerationResponse
+    from vertexai.preview.generative_models import Tool, grounding
 except ImportError:
     rag = None
 

{sunholo-0.72.0.dist-info → sunholo-0.73.3.dist-info}/METADATA

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: sunholo
-Version: 0.72.0
+Version: 0.73.3
 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.72.0.tar.gz
+Download-URL: https://github.com/sunholo-data/sunholo-py/archive/refs/tags/v0.73.3.tar.gz
 Author: Holosun ApS
 Author-email: multivac@sunholo.com
 License: Apache License, Version 2.0
@@ -87,7 +87,7 @@ 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-aiplatform ; 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'
 Requires-Dist: google-cloud-service-control ; extra == 'gcp'
@@ -119,6 +119,7 @@ Requires-Dist: pytesseract ; extra == 'pipeline'
 Requires-Dist: tabulate ; extra == 'pipeline'
 Requires-Dist: unstructured[local-inference] ; extra == 'pipeline'
 Provides-Extra: tools
+Requires-Dist: openapi-spec-validator ; extra == 'tools'
 Requires-Dist: playwright ; extra == 'tools'
 
 ## Introduction