sunholo 0.76.9__tar.gz → 0.77.0__tar.gz

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

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

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

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

sunholo-0.77.0/sunholo/gcs/download_folder.py

@@ -0,0 +1,50 @@
+import os
+
+try:
+    from google.cloud import storage 
+except ImportError:
+    storage = None
+
+from ..logging import log
+
+def download_files_from_gcs(bucket_name: str, source_folder: str, destination_folder: str=None):
+    """
+    Download all files from a specified folder in a Google Cloud Storage bucket to a local directory.
+    
+    Parameters:
+    - bucket_name: The name of the GCS bucket.
+    - source_folder: The folder (prefix) in the GCS bucket to download files from.
+    - destination_folder: The local directory to save the downloaded files, or os.getcwd() if None
+    """
+    try:
+        storage_client = storage.Client()
+    except Exception as err:
+        log.error(f"Error creating storage client: {str(err)}")
+        return None
+
+    # Get the bucket
+    bucket = storage_client.bucket(bucket_name)
+
+    # List blobs in the specified folder
+    blobs = bucket.list_blobs(prefix=source_folder)
+
+    if not destination_folder:
+        destination_folder = os.getcwd()
+
+    # Ensure the destination folder exists
+    os.makedirs(destination_folder, exist_ok=True)
+
+    for blob in blobs:
+        # Skip if the blob is a directory
+        if blob.name.endswith('/'):
+            continue
+        
+        # Define the local path
+        local_path = os.path.join(destination_folder, os.path.relpath(blob.name, source_folder))
+        
+        # Ensure the local folder exists
+        os.makedirs(os.path.dirname(local_path), exist_ok=True)
+
+        # Download the blob to a local file
+        blob.download_to_filename(local_path)
+        log.info(f"Downloaded {blob.name} to {local_path}")

{sunholo-0.76.9 → sunholo-0.77.0}/sunholo/vertex/__init__.py

@@ -2,5 +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
+from .extensions_call import get_extension_content, parse_extension_input, dynamic_extension_call
 

{sunholo-0.76.9 → sunholo-0.77.0}/sunholo/vertex/extensions_call.py

@@ -2,6 +2,106 @@ from .extensions_class import VertexAIExtensions
 from ..utils import ConfigManager
 from ..logging import log
 import collections.abc
+import json
+
+from .genai_functions import genai_structured_output
+
+def dynamic_extension_call(question, vac, project_id:str=None, model_name:str="models/gemini-1.5-pro", **kwargs):
+    config = ConfigManager(vac)
+
+    extensions = config.vacConfig('extensions')
+    if not extensions:
+        log.warning("No extensions founded for vac: {vac}")
+
+        return None
+    
+    responses = []
+    for tool in extensions:
+
+        call_json = parse_extension_input(question, 
+                                          extension_id=tool.get('extension_id'),
+                                          extension_display_name=tool.get('extension_display_name'),
+                                          config=config,
+                                          project_id=project_id,
+                                          model_name=model_name,
+                                          **kwargs)
+        if call_json:
+            question = call_json.pop('question')
+            extension_output = get_extension_content(question=question,
+                                                     config=config,
+                                                     project_id=project_id,
+                                                     **call_json)
+            responses.append(extension_output)
+        else:
+            log.warning(f"No json found for extension {tool}")
+    
+    return responses
+
+def parse_extension_input(
+        question: str, 
+        extension_id: str=None, 
+        extension_display_name:str=None, 
+        config: ConfigManager=None, 
+        project_id:str=None, 
+        model_name:str="models/gemini-1.5-pro", 
+        **kwargs):
+    """
+    Takes a question and kwargs and makes an LLM call to extract parameters for an extension call.
+    If no parameters are found, returns None
+    Once parameters are extracted, makes the call to the extension via get_extenstion_content()
+
+    Example:
+    Assuming an OpenAPI configuration file as follows:
+    
+    """
+
+    extensions = config.vacConfig('extensions')
+    ve = VertexAIExtensions(project_id)
+
+    for ext in extensions:
+        if extension_id == ext.get("extension_id") or extension_display_name == ext.get("extension_display_name"):
+            extension = ve.get_extension(extension_id=extension_id, extension_display_name=extension_display_name)
+            break
+    
+    if not extension:
+        raise ValueError(f"No extension found matching {extension_id=} or {extension_display_name=}")
+    
+    openapi_spec = ve.get_openapi_spec()
+    log.info(f"OpenAPI Spec: {openapi_spec}")
+
+    if not openapi_spec:
+        raise ValueError(f"No input schema detected for {extension=}")
+
+    model = genai_structured_output(
+        openapi_spec, 
+        system_prompt="You are an assistant that must only parse your input into the provided json schema output. Do not attempt to answer any questions or do anything else other than extracting data into the output schema", 
+        model_name=model_name, 
+        **kwargs)
+
+    contents = [
+        "The user question may contain information that can be used to populate the output schema",
+        "As a minimum the question key should container the user question in 'question', but also examine the content and see if you can fill in the rest of the output schema fields",
+        f"User Question to parse: {question}"
+    ]
+
+    tokens = model.count_tokens(contents)
+    log.info(f"Used [{tokens}] in prompt")
+
+    json_response = model.generate_content(contents)
+
+    log.debug(f"parsed_extension_input returns: {json_response=}")
+
+    try:
+        json_object = json.loads(json_response.text)
+        log.info(f"Got valid json: {json_object}")
+
+        return json_object
+    
+    except Exception as err:
+        log.error(f"Failed to parse GenAI output to JSON: {json_response=} - {str(err)}")
+
+        return None 
+
 
 def get_extension_content(question: str, config: ConfigManager, project_id:str=None, **kwargs):
     """
@@ -23,8 +123,8 @@ def get_extension_content(question: str, config: ConfigManager, project_id:str=N
         vac:
             my_vac:
                 extensions:
-                - extension_id: 8524997435263549440
-                  operation_id: post_our_new_energy_invoke_one_generic
+                - extension_id: 8524997435263549440 # or extension_display_name:
+                  operation_id: post_extension_invoke_one_generic
                   vac: our_generic
                   operation_params:
                     input:
@@ -281,4 +381,13 @@ def extract_nested_value(data, key):
 
 if __name__ == "__main__":
     config = ConfigManager("one_ai")
-    get_extension_content("What are PPAs in france like?", config=config)
+    #get_extension_content("What are PPAs in france like?", config=config)
+    parse_extension_input("What are PPAs in france like?", 
+                          extension_display_name="Our New Energy Database2",
+                          config=config)
+    parse_extension_input("What are PPas in france like? Look in files within the PPA/ or /PPA2 folder, returning the whole documents", 
+                          extension_display_name="Our New Energy Database2", 
+                          config=config, model_name="models/gemini-1.5-pro")
+# {'question': 'What are PPas in france like? Look in files within the PPA/ or /PPA2 folder, returning the whole documents', 
+# 'chat_history': [], 'source_filters': ['PPA/', '/PPA2'], 
+# 'source_filters_and_or': False, 'search_kwargs': {}, 'private_docs': [], 'whole_document': True}

{sunholo-0.76.9 → sunholo-0.77.0}/sunholo/vertex/extensions_class.py

@@ -6,13 +6,13 @@ except ImportError:
 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
 from io import StringIO
 import os
+import re
 
 class VertexAIExtensions:
     """
@@ -74,6 +74,7 @@ class VertexAIExtensions:
         self.bucket_name = os.getenv('EXTENSIONS_BUCKET')
         self.project_id = project_id or get_gcp_project()
         self.access_token = None
+        self.current_extension = None
         init_vertex(location=self.location, project_id=self.project_id)
 
     def list_extensions(self):
@@ -111,7 +112,7 @@ class VertexAIExtensions:
 
         return self_uri
     
-    def upload_openapi_file(self, filename: str, vac:str=None):
+    def upload_openapi_file(self, filename: str, extension_name:str, vac:str=None):
         if vac:
             from ..agents.route import route_vac
             import yaml
@@ -130,8 +131,19 @@ class VertexAIExtensions:
         if not self.bucket_name:
             raise ValueError('Please specify env var EXTENSIONS_BUCKET for location to upload openapi spec')
         
-        self.openapi_file_gcs = self.upload_to_gcs(filename)
-    
+        upload_name = f"{extension_name}/{filename}"
+
+        self.openapi_file_gcs = self.upload_to_gcs(upload_name)
+
+    def get_openapi_spec(self, extension_id: str=None, extension_display_name:str=None):
+        """
+        Gets the openapi spec file for an extension
+        """
+        if not self.current_extension:
+            self.current_extension = self.get_extension(extension_id=extension_id, extension_display_name=extension_display_name)
+
+        return self.current_extension.api_spec()
+        
     def load_tool_use_examples(self, filename: str):
         import yaml
 
@@ -155,7 +167,7 @@ class VertexAIExtensions:
         import requests
         import json
 
-        extension = self.created_extension
+        extension = self.created_extension or self.current_extension
         if extension is None:
             raise ValueError("Need to create the extension first")
 
@@ -214,6 +226,38 @@ class VertexAIExtensions:
 
         return self.manifest
 
+    def validate_extension_id(self, ext_id: str):
+        """
+        Ensures the passed string fits the criteria for an extension ID.
+        If not, changes it so it will be.
+
+        Criteria:
+        - Length should be 4-63 characters.
+        - Valid characters are lowercase letters, numbers, and hyphens ("-").
+        - Should start with a number or a lowercase letter.
+
+        Args:
+            ext_id (str): The extension ID to validate and correct.
+
+        Returns:
+            str: The validated and corrected extension ID.
+        """
+        # Replace invalid characters
+        ext_id = re.sub(r'[^a-z0-9-]', '-', ext_id.lower())
+        
+        # Ensure it starts with a number or a lowercase letter
+        if not re.match(r'^[a-z0-9]', ext_id):
+            ext_id = 'a' + ext_id
+        
+        # Trim to 63 characters
+        ext_id = ext_id[:63]
+        
+        # Pad to at least 4 characters
+        while len(ext_id) < 4:
+            ext_id += 'a'
+        
+        return ext_id
+
     def create_extension(self,
                          display_name: str,
                          description: str,
@@ -225,7 +269,7 @@ class VertexAIExtensions:
                          vac: str = None):
         
         log.info(f"Creating extension within {self.project_id=}")
-        extension_name = f"projects/{self.project_id}/locations/us-central1/extensions/{validate_extension_id(display_name)}"
+        extension_name = f"projects/{self.project_id}/locations/us-central1/extensions/{self.validate_extension_id(display_name)}"
 
         if bucket_name:
             log.info(f"Setting extension bucket name to {bucket_name}")
@@ -238,7 +282,7 @@ class VertexAIExtensions:
                 raise NameError(f"display_name {display_name} already exists.  Delete it or rename your new extension")
 
         if open_api_file:
-            self.upload_openapi_file(open_api_file, vac)
+            self.upload_openapi_file(open_api_file, self.validate_extension_id(display_name), vac)
 
         manifest = self.create_extension_manifest(
             display_name,
@@ -261,20 +305,25 @@ class VertexAIExtensions:
         log.info(f"Created Vertex Extension: {extension_name}")
         
         self.created_extension = extension
+        self.current_extension = extension
 
         if tool_example_file:
             self.update_tool_use_examples_via_patch()
 
         return extension.resource_name
-
-    def execute_extension(
-            self, 
-            operation_id: str, 
-            operation_params: dict, 
-            extension_id: str=None, 
+    
+    def get_extension(
+            self,
+            extension_id: str=None,
             extension_display_name: str=None,
-            vac: str=None):
+    ):
+        """
+        Resolves the extension_id from the Display Name if not given.
+
+        Returns: 
+        Extension object
 
+        """
         if extension_display_name:
             exts = self.list_extensions()
             for ext in exts:
@@ -293,8 +342,20 @@ class VertexAIExtensions:
             extension_name = self.created_extension.resource_name
             if not extension_name:
                 raise ValueError("Must specify extension_id or extension_name - both were None")
+        
+        self.current_extension = extensions.Extension(extension_name)
+
+        return self.current_extension
+
+    def execute_extension(
+            self, 
+            operation_id: str, 
+            operation_params: dict, 
+            extension_id: str=None, 
+            extension_display_name: str=None,
+            vac: str=None):
 
-        extension = extensions.Extension(extension_name)
+        extension = self.get_extension(extension_id=extension_id, extension_display_name=extension_display_name)
 
         auth_config=None
         if not is_running_on_cloudrun():
@@ -314,14 +375,14 @@ class VertexAIExtensions:
         else:
             log.warning("No vac configuration and not running locally so no authentication being set for this extension API call")
 
-        log.info(f"Executing extension {extension_name=} with {operation_id=} and {operation_params=}")
+        log.info(f"Executing extension {extension.display_name=} with {operation_id=} and {operation_params=}")
         response = extension.execute(
             operation_id=operation_id,
             operation_params=operation_params,
             runtime_auth_config=auth_config
         )
 
-        log.info(f"Extension {extension_name=} {response=}")
+        log.info(f"Extension {extension.display_name=} {response=}")
 
         return response
 

sunholo-0.77.0/sunholo/vertex/genai_functions.py

@@ -0,0 +1,61 @@
+try:
+    import google.generativeai as genai
+except ImportError:
+    genai = None
+
+from .init import init_genai
+from .safety import genai_safety
+from ..logging import log
+import json
+from .type_dict_to_json import describe_typed_dict, openapi_to_typed_dict, is_typed_dict
+
+def genai_structured_output(
+        openapi_spec, 
+        system_prompt: str = "", 
+        model_name: str = "models/gemini-1.5-pro",
+        **kwargs):
+    """
+    Generate AI function output with the specified configuration.
+    
+    Parameters:
+    - output_schema: The schema for the response output.
+    - system_prompt: Optional system prompt to guide the generation.
+    - model_name: The name of the model to use (default is 'models/gemini-1.5-flash').
+    - output_schema_json: The JSON schema with descriptions.
+    - **kwargs: Additional keyword arguments to customize the generation config.
+    
+    Returns:
+    - model: The configured generative model.
+    """
+    
+    init_genai()
+
+    # Generate the JSON schema with descriptions
+    output_schema, descriptions = openapi_to_typed_dict(openapi_spec, 'Input')
+
+    # Convert TypedDict to JSON schema if necessary
+    if is_typed_dict(output_schema):
+        output_schema_json = describe_typed_dict(output_schema, descriptions)
+
+    # Base generation configuration
+    generation_config = {
+        "response_mime_type": "application/json",
+        #"response_schema": output_schema, # didn't work yet as couldn't deal with Optional values
+        "temperature": 0.5
+    }
+    
+    # Merge additional kwargs into generation_config
+    generation_config.update(kwargs)
+
+    if output_schema_json:
+        system_prompt = f"{system_prompt}\n##OUTPUT JSON SCHEMA:\n{json.dumps(output_schema_json, indent=2)}\n"
+
+    model = genai.GenerativeModel(
+        model_name=model_name,
+        safety_settings=genai_safety(),
+        generation_config=generation_config,
+        system_instruction=system_prompt,
+        tool_config={'function_calling_config': 'ANY'} # pro models only
+    )
+    
+    return model

{sunholo-0.76.9 → sunholo-0.77.0}/sunholo/vertex/init.py

@@ -12,7 +12,7 @@ def init_genai():
     try:
         import google.generativeai as genai
     except ImportError:
-        raise ImportError("google.generativeai not installed, please install via 'pip install sunholo[gcp]")
+        raise ImportError("google.generativeai not installed, please install via 'pip install sunholo'[gcp]'")
     
     GOOGLE_API_KEY=os.getenv('GOOGLE_API_KEY')
     if not GOOGLE_API_KEY:

sunholo-0.77.0/sunholo/vertex/type_dict_to_json.py

@@ -0,0 +1,127 @@
+import typing
+from typing_extensions import TypedDict, Any, Dict
+    
+# Type mapping for OpenAPI types to Python types
+type_mapping = {
+    'string': str,
+    'integer': int,
+    'number': float,
+    'boolean': bool,
+    'array': list,
+    'object': dict
+}
+
+def resolve_ref(openapi_spec: Dict[str, Any], ref: str) -> Dict[str, Any]:
+    """
+    Resolve a $ref in the OpenAPI spec.
+    
+    Parameters:
+    - openapi_spec: The OpenAPI specification.
+    - ref: The reference string.
+    
+    Returns:
+    - The resolved schema.
+    """
+    ref_path = ref.lstrip('#/').split('/')
+    resolved = openapi_spec
+    for part in ref_path:
+        resolved = resolved.get(part)
+        if resolved is None:
+            raise ValueError(f"Reference {ref} could not be resolved at part {part}")
+    return resolved
+
+def openapi_to_typed_dict(openapi_spec: Dict[str, Any], schema_name: str) -> Any:
+    """
+    Convert an OpenAPI schema to a TypedDict dynamically.
+    
+    Parameters:
+    - openapi_spec: The OpenAPI specification.
+    - schema_name: The name of the schema to convert.
+    
+    Returns:
+    - A dynamically created TypedDict class and field descriptions.
+    """
+    schema = openapi_spec['components']['schemas'][schema_name]
+    properties = schema['properties']
+    required = schema.get('required', [])
+    annotations = {}
+    descriptions = {}
+
+    def process_property(key: str, value: Dict[str, Any]) -> Any:
+        """Process an individual property and update annotations and descriptions."""
+        if '$ref' in value:
+            value = resolve_ref(openapi_spec, value['$ref'])
+        
+        field_type = value.get('type')
+        if field_type in type_mapping:
+            annotations[key] = type_mapping[field_type]
+        elif field_type == 'array':
+            item_ref = value['items'].get('$ref')
+            item_type = value['items'].get('type')
+            if item_ref:
+                item_schema = resolve_ref(openapi_spec, item_ref)
+                item_typed_dict, _ = openapi_to_typed_dict(openapi_spec, item_schema['title'])
+                annotations[key] = typing.List[item_typed_dict]
+            elif item_type in type_mapping:
+                annotations[key] = typing.List[type_mapping[item_type]]
+            else:
+                annotations[key] = typing.List[dict]
+        elif field_type == 'object':
+            annotations[key] = dict
+            nested_properties = value.get('properties', {})
+            nested_required = value.get('required', [])
+            nested_annotations = {}
+            for nested_key, nested_value in nested_properties.items():
+                nested_annotations[nested_key] = process_property(nested_key, nested_value)
+            annotations[key] = TypedDict(f"{key.capitalize()}Nested", nested_annotations, total=False)
+            for nested_key in nested_required:
+                annotations[key].__annotations__[nested_key] = nested_annotations[nested_key]
+        
+        descriptions[key] = value.get('description', '')
+        return annotations[key]
+
+    for key, value in properties.items():
+        process_property(key, value)
+
+    typed_dict_cls = TypedDict(schema_name, annotations, total=False)
+    for key in required:
+        typed_dict_cls.__annotations__[key] = annotations[key]
+
+    return typed_dict_cls, descriptions
+
+def describe_typed_dict(typed_dict_cls: Any, descriptions: Dict[str, str]) -> Dict[str, Any]:
+    """
+    Generate a dictionary with field descriptions.
+    
+    Parameters:
+    - typed_dict_cls: The TypedDict class.
+    - descriptions: The dictionary containing field descriptions.
+    
+    Returns:
+    - A dictionary with field descriptions.
+    """
+    schema = {
+        "type": "object",
+        "properties": {},
+        "required": []
+    }
+    for key, value in typed_dict_cls.__annotations__.items():
+        description = descriptions.get(key, "")
+        property_schema = {
+            "type": value.__name__.lower() if isinstance(value, type) else "object",
+            "description": description
+        }
+        if typing.get_origin(value) is list:
+            item_type = typing.get_args(value)[0]
+            property_schema["items"] = {"type": item_type.__name__.lower()}
+        elif typing.get_origin(value) is dict:
+            property_schema["properties"] = describe_typed_dict(value, descriptions)["properties"]
+        schema["properties"][key] = property_schema
+        if key in typed_dict_cls.__required_keys__:
+            schema["required"].append(key)
+    return schema
+
+
+def is_typed_dict(cls):
+    """Check if a class is a TypedDict."""
+    return isinstance(cls, type) and issubclass(cls, dict) and hasattr(cls, '__annotations__')

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

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

{sunholo-0.76.9 → sunholo-0.77.0}/sunholo.egg-info/SOURCES.txt

@@ -86,6 +86,7 @@ sunholo/embedder/__init__.py
 sunholo/embedder/embed_chunk.py
 sunholo/gcs/__init__.py
 sunholo/gcs/add_file.py
+sunholo/gcs/download_folder.py
 sunholo/gcs/download_url.py
 sunholo/gcs/metadata.py
 sunholo/invoke/__init__.py
@@ -133,8 +134,10 @@ sunholo/utils/version.py
 sunholo/vertex/__init__.py
 sunholo/vertex/extensions_call.py
 sunholo/vertex/extensions_class.py
+sunholo/vertex/genai_functions.py
 sunholo/vertex/init.py
 sunholo/vertex/memory_tools.py
 sunholo/vertex/safety.py
+sunholo/vertex/type_dict_to_json.py
 tests/test_chat_history.py
 tests/test_config.py