sunholo 0.76.7__tar.gz → 0.76.9__tar.gz

{sunholo-0.76.7 → sunholo-0.76.9}/PKG-INFO

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

{sunholo-0.76.7 → sunholo-0.76.9}/setup.py

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

{sunholo-0.76.7 → sunholo-0.76.9}/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.9/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.7 → sunholo-0.76.9}/sunholo/vertex/extensions_class.py

@@ -276,11 +276,11 @@ class VertexAIExtensions:
             vac: str=None):
 
         if extension_display_name:
-            extensions = self.list_extensions()
-            for extension in extensions:
-                if extension.get('display_name') == extension_display_name:
+            exts = self.list_extensions()
+            for ext in exts:
+                if ext.get('display_name') == extension_display_name:
                     log.info(f"Found extension_id for '{extension_display_name}'")
-                    extension_id = extension['resource_name']
+                    extension_id = ext['resource_name']
                     break
         
         if extension_id:

{sunholo-0.76.7 → sunholo-0.76.9}/sunholo.egg-info/PKG-INFO

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

{sunholo-0.76.7 → sunholo-0.76.9}/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