sunholo 0.76.6__tar.gz → 0.76.8__tar.gz

{sunholo-0.76.6 → sunholo-0.76.8}/PKG-INFO

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

{sunholo-0.76.6 → sunholo-0.76.8}/setup.py

@@ -1,7 +1,7 @@
 from setuptools import setup, find_packages
 
 # Define your base version
-version = '0.76.6'
+version = '0.76.8'
 
 setup(
     name='sunholo',

{sunholo-0.76.6 → sunholo-0.76.8}/sunholo/auth/run.py

@@ -66,7 +66,7 @@ def get_cloud_run_token(vector_name):
             }
     log.info(f"Authenticating for run_url {run_url} from {caller_frame.f_code.co_name}")
     id_token = get_id_token(run_url)
-    log.info(f"id_token {id_token}")
+    #log.info(f"id_token {id_token}")
     return id_token
 
 def get_header(vector_name) -> Optional[dict]:

{sunholo-0.76.6 → sunholo-0.76.8}/sunholo/azure/event_grid.py

@@ -12,9 +12,10 @@ def process_azure_blob_event(events: list) -> tuple:
         tuple: A tuple containing the blob URL, attributes as metadata, and the vector name.
         
     Example of Event Grid schema:
+    ```
     {
-        "topic": "/subscriptions/{subscription-id}/resourceGroups/{resource-group}/providers/Microsoft.Storage/storageAccounts/{storage-account}",
-        "subject": "/blobServices/default/containers/{container}/blobs/{blob}",
+        "topic": "/subscriptions/subscription-id/resourceGroups/resource-group/providers/Microsoft.Storage/storageAccounts/storage-account",
+        "subject": "/blobServices/default/containers/container/blobs/blob",
         "eventType": "Microsoft.Storage.BlobCreated",
         "eventTime": "2021-01-01T12:34:56.789Z",
         "id": "event-id",
@@ -26,8 +27,8 @@ def process_azure_blob_event(events: list) -> tuple:
             "contentType": "application/octet-stream",
             "contentLength": 524288,
             "blobType": "BlockBlob",
-            "url": "https://{storage-account}.blob.core.windows.net/{container}/{blob}",
-            "sequencer": "0000000000000000000000000000000000000000000000000000000000000000",
+            "url": "https://storage-account.blob.core.windows.net/container/blob",
+            "sequencer": "0000000000000000000000000",
             "storageDiagnostics": {
                 "batchId": "batch-id"
             }
@@ -35,6 +36,7 @@ def process_azure_blob_event(events: list) -> tuple:
         "dataVersion": "",
         "metadataVersion": "1"
     }
+    ```
     """
     storage_blob_created_event = "Microsoft.Storage.BlobCreated"
     

{sunholo-0.76.6 → sunholo-0.76.8}/sunholo/vertex/__init__.py

@@ -2,3 +2,5 @@ from .init import init_vertex, init_genai
 from .memory_tools import get_vertex_memories, print_grounding_response, get_google_search_grounding
 from .safety import vertex_safety, genai_safety
 from .extensions_class import VertexAIExtensions
+from .extensions_call import get_extension_content
+

sunholo-0.76.8/sunholo/vertex/extensions_call.py

@@ -0,0 +1,284 @@
+from .extensions_class import VertexAIExtensions
+from ..utils import ConfigManager
+from ..logging import log
+import collections.abc
+
+def get_extension_content(question: str, config: ConfigManager, project_id:str=None, **kwargs):
+    """
+    Fetches content from extensions based on the provided question and configuration.
+    
+    Args:
+        question (str): The question to be processed by the extensions.
+        config (ConfigManager): The configuration manager instance.
+        **kwargs: Additional parameters to be passed to the extension.
+
+    Returns:
+        list: A list of responses from the extensions.
+
+    Example:
+        Assuming a YAML configuration file as follows:
+        
+        ```yaml
+        kind: vacConfig
+        vac:
+            my_vac:
+                extensions:
+                - extension_id: 8524997435263549440
+                  operation_id: post_our_new_energy_invoke_one_generic
+                  vac: our_generic
+                  operation_params:
+                    input:
+                      question: ""
+                      chat_history: []
+                      source_filters: []
+                      source_filters_and_or: false
+                      search_kwargs:
+                        k: 0
+                        filter: ""
+                        fetch_k: 0
+                      private_docs: []
+                      whole_document: false
+        ```
+
+        The function can be called as:
+
+        ```python
+        config = ConfigManager()
+        question = "What is the capital of France?"
+
+        responses = get_extension_content(
+            question=question,
+            config=config,
+            input={
+                "chat_history": [{"role": "user", "content": "Hello"}],
+                "source_filters": ["PPA/"],
+                "search_kwargs": {"k": 50, "filter": "source ILIKE '%GermanPolicyforPPA/%'", "fetch_k": 100}
+            }
+        )
+        ```
+
+        In this example, `operation_params` will be updated to:
+
+        ```python
+        {
+            "input": {
+                "question": "What is the capital of France?",
+                "chat_history": [{"role": "user", "content": "Hello"}],
+                "source_filters": ["PPA/"],
+                "source_filters_and_or": false,
+                "search_kwargs": {
+                    "k": 50,
+                    "filter": "source ILIKE '%GermanPolicyforPPA/%'",
+                    "fetch_k": 100
+                },
+                "private_docs": [],
+                "whole_document": false
+            }
+        }
+        ```
+    """
+    extensions = config.vacConfig('extensions')
+    responses = []
+    for tool in extensions:
+        try:
+            ve = VertexAIExtensions(project_id)
+            
+            # Merge operation_params from tool config and **kwargs
+            operation_params = tool.get('operation_params', {})
+            log.info(f'{operation_params=}')
+            operation_params_input = update_nested_params(operation_params, kwargs)
+
+            # Update the question in operation_params if it exists
+            operation_params_input = inject_question(question, operation_params)
+
+            response = ve.execute_extension(
+                operation_id=tool['operation_id'],
+                operation_params=operation_params_input,
+                extension_id=tool.get('extension_id'),
+                extension_display_name=tool.get('extension_display_name'),
+                vac=tool.get('vac')
+            )
+
+            # Dynamically get keys for answer and metadata from YAML configuration
+            output_config = operation_params.get('output', {})
+            answer_key = output_config.get('answer', 'answer')
+            metadata_key = output_config.get('metadata', 'metadata')
+
+            # Extract answer and metadata based on the specified keys
+            log.info(f'{answer_key} {metadata_key}')
+
+            answer = extract_nested_value(response, answer_key)
+            metadata = extract_nested_value(response, metadata_key)
+
+            log.info(f'{answer=} {metadata=}')
+
+            if answer and metadata:
+                responses.append(f"{answer}\nMetadata: {metadata}")
+            elif answer:
+                responses.append(answer)
+
+        except Exception as err:
+            log.error(f'Could not find vertex-extension response: {str(err)}')
+            answer = None
+    
+    log.info(f'Vertex extension responses: {responses=}')
+
+    answers = "\n\n".join([resp for resp in responses if resp is not None])
+
+    return answers
+
+def update_nested_params(original, updates):
+    """
+    Recursively update nested dictionaries with new values.
+    
+    Args:
+        original (dict): The original dictionary to be updated.
+        updates (dict): The new values to be merged into the original dictionary.
+
+    Returns:
+        dict: The updated dictionary.
+
+    Example:
+        ```python
+        original = {
+            "param1": "value1",
+            "nested_param": {
+                "sub_param1": "sub_value1"
+            }
+        }
+
+        updates = {
+            "param1": "new_value1",
+            "nested_param": {
+                "sub_param1": "new_sub_value1"
+            }
+        }
+
+        updated_params = update_nested_params(original, updates)
+
+        # updated_params will be:
+        # {
+        #     "param1": "new_value1",
+        #     "nested_param": {
+        #         "sub_param1": "new_sub_value1"
+        #     }
+        # }
+        ```
+    """
+    for key, value in updates.items():
+        if isinstance(value, collections.abc.Mapping):
+            original[key] = update_nested_params(original.get(key, {}), value)
+        else:
+            original[key] = value
+    return original
+
+def inject_question(question, params):
+    """
+    Recursively injects the question into nested dictionaries where the key is 'question' and the value is empty.
+
+    Args:
+        question (str): The question to be injected.
+        params (dict): The dictionary where the question should be injected.
+
+    Returns:
+        dict: The dictionary with the question injected.
+
+    Example:
+        ```python
+        params = {
+            "input": {
+                "question": "",
+                "chat_history": [],
+                "source_filters": [],
+                "search_kwargs": {
+                    "k": 0,
+                    "filter": "",
+                    "fetch_k": 0
+                },
+                "private_docs": [],
+                "whole_document": false
+            }
+        }
+
+        question = "What is the capital of France?"
+
+        updated_params = inject_question(question, params)
+
+        # updated_params will be:
+        # {
+        #     "input": {
+        #         "question": "What is the capital of France?",
+        #         "chat_history": [],
+        #         "source_filters": [],
+        #         "search_kwargs": {
+        #             "k": 0,
+        #             "filter": "",
+        #             "fetch_k": 0
+        #         },
+        #         "private_docs": [],
+        #         "whole_document": false
+        #     }
+        # }
+        ```
+    """
+    if isinstance(params, collections.abc.Mapping):
+        for key, value in params.items():
+            if isinstance(value, collections.abc.Mapping):
+                params[key] = inject_question(question, value)
+            elif key == 'question' and not value:
+                params[key] = question
+    return params
+
+def extract_nested_value(data, key):
+    """
+    Recursively extract a value from nested dictionaries based on the specified key or a dot-separated key path.
+    If the key is not dot-separated, it will find the first occurrence of that key in the nested dictionaries.
+
+    Args:
+        data (dict): The dictionary to extract the value from.
+        key (str): The key or dot-separated key path to extract the value.
+
+    Returns:
+        Any: The extracted value, or None if the key or key path is not found.
+
+    Example:
+        ```python
+        data = {
+            "output": {
+                "content": "Some content",
+                "metadata": {"key1": "value1"}
+            }
+        }
+
+        value = extract_nested_value(data, "content")
+        # value will be "Some content"
+
+        value = extract_nested_value(data, "output.metadata")
+        # value will be {"key1": "value1"}
+        ```
+    """
+    def search_key(data, key):
+        if isinstance(data, dict):
+            if key in data:
+                return data[key]
+            for k, v in data.items():
+                if isinstance(v, dict):
+                    result = search_key(v, key)
+                    if result is not None:
+                        return result
+        return None
+
+    if '.' in key:
+        keys = key.split('.')
+        for k in keys:
+            if isinstance(data, dict) and k in data:
+                data = data[k]
+            else:
+                return None
+        return data
+    else:
+        return search_key(data, key)
+
+if __name__ == "__main__":
+    config = ConfigManager("one_ai")
+    get_extension_content("What are PPAs in france like?", config=config)

{sunholo-0.76.6 → sunholo-0.76.8}/sunholo/vertex/extensions_class.py

@@ -7,6 +7,7 @@ from .init import init_vertex
 from ..logging import log
 from ..utils.gcp_project import get_gcp_project
 from ..utils.parsers import validate_extension_id
+from ..utils.gcp import is_running_on_cloudrun
 from ..auth import get_local_gcloud_token, get_cloud_run_token
 import base64
 import json
@@ -271,27 +272,31 @@ class VertexAIExtensions:
             operation_id: str, 
             operation_params: dict, 
             extension_id: str=None, 
+            extension_display_name: str=None,
             vac: str=None):
 
-        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 extension_display_name:
+            extensions = self.list_extensions()
+            for extension in extensions:
+                if extension.get('display_name') == extension_display_name:
+                    log.info(f"Found extension_id for '{extension_display_name}'")
+                    extension_id = extension['resource_name']
+                    break
+        
+        if extension_id:
             extension_id = str(extension_id)
             if not extension_id.startswith("projects/"):
                 extension_name = f"projects/{self.project_id}/locations/{self.location}/extensions/{extension_id}"
             else:
                 extension_name = extension_id
+        else: 
+            extension_name = self.created_extension.resource_name
+            if not extension_name:
+                raise ValueError("Must specify extension_id or extension_name - both were None")
 
         extension = extensions.Extension(extension_name)
 
-        log.info(f"Executing extension {extension_name=} with {operation_id=} and {operation_params=}")
-
-        # local testing auth
-        from ..utils.gcp import is_running_on_cloudrun
-        auth_config=None # on cloud run it sorts itself out via default creds(?)
-
+        auth_config=None
         if not is_running_on_cloudrun():
             
             log.warning("Using local authentication via gcloud")
@@ -308,10 +313,8 @@ class VertexAIExtensions:
                 }
         else:
             log.warning("No vac configuration and not running locally so no authentication being set for this extension API call")
-        
-        if auth_config:
-            log.info(f"{auth_config=}")
 
+        log.info(f"Executing extension {extension_name=} with {operation_id=} and {operation_params=}")
         response = extension.execute(
             operation_id=operation_id,
             operation_params=operation_params,

{sunholo-0.76.6 → sunholo-0.76.8}/sunholo.egg-info/PKG-INFO

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

{sunholo-0.76.6 → sunholo-0.76.8}/sunholo.egg-info/SOURCES.txt

@@ -131,6 +131,7 @@ sunholo/utils/timedelta.py
 sunholo/utils/user_ids.py
 sunholo/utils/version.py
 sunholo/vertex/__init__.py
+sunholo/vertex/extensions_call.py
 sunholo/vertex/extensions_class.py
 sunholo/vertex/init.py
 sunholo/vertex/memory_tools.py