sunholo 0.60.0__tar.gz → 0.60.2__tar.gz

{sunholo-0.60.0 → sunholo-0.60.2}/PKG-INFO

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

{sunholo-0.60.0 → sunholo-0.60.2}/setup.py

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

{sunholo-0.60.0 → sunholo-0.60.2}/sunholo/agents/dispatch_to_qa.py

@@ -52,8 +52,12 @@ def prep_request_payload(user_input, chat_history, vector_name, stream, **kwargs
     agent = load_config_key("agent", vector_name=vector_name, kind="vacConfig")
     agent_type = load_config_key("agent_type", vector_name=vector_name, kind="vacConfig")
 
+    override_endpoint = kwargs.get("override_endpoint")
+    if override_endpoint:
+        log.info(f"Overriding endpoint with {override_endpoint}")
+
     # {'stream': '', 'invoke': ''}
-    endpoints = route_endpoint(vector_name)
+    endpoints = route_endpoint(vector_name, override_endpoint=override_endpoint)
 
     qna_endpoint = endpoints["stream"] if stream else endpoints["invoke"]
 

{sunholo-0.60.0 → sunholo-0.60.2}/sunholo/agents/flask/qna_routes.py

@@ -37,6 +37,10 @@ except ImportError as err:
 
 def register_qna_routes(app, stream_interpreter, vac_interpreter):
 
+    @app.route("/")
+    def home():
+        return jsonify("OK")
+
     @app.route('/vac/streaming/<vector_name>', methods=['POST'])
     @observe()
     def stream_qa(vector_name):

{sunholo-0.60.0 → sunholo-0.60.2}/sunholo/agents/route.py

@@ -35,13 +35,13 @@ def route_qna(vector_name):
     log.info(f'agent_url: {agent_url}')
     return agent_url
 
-def route_endpoint(vector_name):
+def route_endpoint(vector_name, override_endpoint=None):
 
     agent_type = load_config_key('agent_type', vector_name, kind="vacConfig")
     if not agent_type:
         agent_type = load_config_key('agent', vector_name, kind="vacConfig")
 
-    stem = route_qna(vector_name)
+    stem = route_qna(vector_name) if not override_endpoint else override_endpoint
 
     agent_config, _ = load_config('config/agent_config.yaml')
 

sunholo-0.60.2/sunholo/cli/chat_vac.py

@@ -0,0 +1,149 @@
+from ..agents import send_to_qa
+from ..streaming import generate_proxy_stream
+from ..utils.user_ids import generate_user_id
+
+from .run_proxy import clean_proxy_list, start_proxy
+
+import uuid
+
+def get_service_url(service_name):
+    proxies = clean_proxy_list()
+    if service_name in proxies:
+        port = proxies[service_name]['port']
+        return f"http://127.0.0.1:{port}"
+    else:
+        print(f"No proxy found running for service: {service_name} - attempting to connect")
+        return start_proxy(service_name)
+
+def stream_chat_session(service_name):
+
+    service_url = get_service_url(service_name)
+    user_id = generate_user_id()
+    chat_history = []
+    while True:
+        session_id = str(uuid.uuid4())
+        user_input = input("You: ")
+        if user_input.lower() in ["exit", "quit"]:
+            print("Exiting chat session.")
+            break
+
+        chat_history.append({"role": "Human", "content": user_input})
+
+        def stream_response():
+            generate = generate_proxy_stream(
+                send_to_qa,
+                user_input,
+                vector_name=service_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=None,
+                source_filters=None,
+                search_kwargs=None,
+                private_docs=None,
+                whole_document=False,
+                source_filters_and_or=False,
+                # system kwargs
+                configurable={
+                    "vector_name": service_name,
+                },
+                user_id=user_id,
+                session_id=session_id, 
+                message_source="cli",
+                override_endpoint=service_url
+            )
+            for part in generate():
+                yield part
+
+        response_started = False
+        vac_response = ""
+        for token in stream_response():
+            if not response_started:
+                print(f"VAC {service_name}: ", end='', flush=True)
+                response_started = True
+
+            if isinstance(token, bytes):
+                token = token.decode('utf-8')
+            print(token, end='', flush=True)
+            vac_response += token
+
+        chat_history.append({"role": "AI", "content": vac_response})
+        response_started = False
+        print()  # For new line after streaming ends
+
+def headless_mode(service_name, user_input, chat_history=None):
+    chat_history = chat_history or []
+    chat_history.append({"role": "Human", "content": user_input})
+    service_url = get_service_url(service_name)
+    user_id = generate_user_id()
+    session_id = str(uuid.uuid4())
+
+    def stream_response():
+        generate = generate_proxy_stream(
+                send_to_qa,
+                user_input,
+                vector_name=service_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=None,
+                source_filters=None,
+                search_kwargs=None,
+                private_docs=None,
+                whole_document=False,
+                source_filters_and_or=False,
+                # system kwargs
+                configurable={
+                    "vector_name": service_name,
+                },
+                user_id=user_id,
+                session_id=session_id, 
+                message_source="cli",
+                override_endpoint=service_url
+        )
+        for part in generate():
+            yield part
+
+    print(f"VAC {service_name}: ", end='', flush=True)
+    for token in stream_response():
+        if isinstance(token, bytes):
+            token = token.decode('utf-8')
+        print(token, end='', flush=True)
+
+    chat_history.append({"role": "AI", "content": token})
+    print()  # For new line after streaming ends
+
+    return chat_history
+
+
+def vac_command(args):
+    try:
+        service_url = get_service_url(args.service_name)
+    except ValueError as e:
+        print(f"ERROR: Could not start {args.service_name} proxy URL: {str(e)}")
+        return
+    print(f"== Starting VAC chat session with {args.service_name} via proxy URL: {service_url}")
+    if args.headless:
+        headless_mode(args.service_name, args.user_input, args.chat_history)
+    else:
+        stream_chat_session(args.service_name)
+
+def setup_vac_subparser(subparsers):
+    """
+    Sets up an argparse subparser for the 'vac' command.
+
+    Args:
+        subparsers: The subparsers object from argparse.ArgumentParser().
+    """
+    vac_parser = subparsers.add_parser('vac', help='Interact with deployed VAC services.')
+    vac_parser.add_argument('service_name', help='Name of the VAC service.')
+    vac_parser.add_argument('user_input', help='User input for the VAC service when in headless mode.', nargs='?', default=None)
+    vac_parser.add_argument('--headless', action='store_true', help='Run in headless mode.')
+    vac_parser.add_argument('--chat_history', help='Chat history for headless mode (as JSON string).', default=None)
+    vac_parser.set_defaults(func=vac_command)

{sunholo-0.60.0 → sunholo-0.60.2}/sunholo/cli/cli.py

@@ -1,10 +1,14 @@
 import argparse
+import logging
 
 from .configs import setup_list_configs_subparser
 from .deploy import setup_deploy_subparser
 from .cli_init import setup_init_subparser
 from .merge_texts import setup_merge_text_subparser
+from .run_proxy import setup_proxy_subparser
+from .chat_vac import setup_vac_subparser
 
+from ..logging import log
 
 def main(args=None):
     """
@@ -17,6 +21,8 @@ def main(args=None):
     ```
     """
     parser = argparse.ArgumentParser(description="sunholo CLI tool for deploying GenAI VACs")
+    parser.add_argument('--debug', action='store_true', help='Enable debug output')
+
     subparsers = parser.add_subparsers(title='commands', 
                                        description='Valid commands', 
                                        help='Commands', 
@@ -31,9 +37,20 @@ def main(args=None):
     setup_init_subparser(subparsers)
     # merge-text command
     setup_merge_text_subparser(subparsers)
+    # proxy command
+    setup_proxy_subparser(subparsers)
+    # vac command
+    setup_vac_subparser(subparsers)
 
     args = parser.parse_args(args)
 
+    if args.debug:
+        log.setLevel(logging.INFO)
+        logging.getLogger().setLevel(logging.INFO)
+    else:
+        log.setLevel(logging.WARNING)
+        logging.getLogger().setLevel(logging.WARNING)
+
     if hasattr(args, 'func'):
         args.func(args)
     else:

{sunholo-0.60.0 → sunholo-0.60.2}/sunholo/cli/cli_init.py

@@ -6,28 +6,9 @@ def init_project(args):
     """
     Initializes a new sunholo project with a basic configuration file and directory structure.
 
-**Explanation:**
-
-1. **Import Necessary Modules:**
-   - `os` for file system operations.
-   - `shutil` for copying files and directories.
-   - `log` from `sunholo.logging` for logging messages.
-   - `get_module_filepath` from `sunholo.utils.config` to get the absolute path of template files.
-
-2. **`init_project` Function:**
-   - Takes an `args` object from argparse, containing the `project_name`.
-   - Creates the project directory using `os.makedirs`.
-   - Copies template files from the `templates/project` directory to the new project directory using `shutil.copy` and `shutil.copytree`.
-   - Logs informative messages about the initialization process.
-
-3. **`setup_init_subparser` Function:**
-   - Sets up the `init` subcommand for the `sunholo` CLI.
-   - Adds an argument `project_name` to specify the name of the new project.
-   - Sets the `func` attribute to `init_project`, so the parser knows which function to call when the `init` command is used.
-
 **Template Files (`templates/project`):**
 
-You'll need to create a `templates/project` directory within your `sunholo` package and place the following template files in it:
+A `templates/project` directory is within the `sunholo` package with the following template files in it:
 
 * **`config/llm_config.yaml`:** A basic configuration file with placeholders for LLM settings, vector stores, etc.
 * **`config/cloud_run_urls.json`:** A template for Cloud Run URLs.
@@ -37,14 +18,13 @@ You'll need to create a `templates/project` directory within your `sunholo` pack
 
 **Usage:**
 
-After adding this code to your `cli.py` and creating the template files, users can initialize a new project using the following command:
+Users can initialize a new project using the following command:
 
 ```bash
 sunholo init my_genai_project
 ```
 
 This will create a new directory named `my_genai_project` with the template files, allowing users to start building their GenAI application.
-
     """
     project_name = args.project_name
     project_dir = os.path.join(os.getcwd(), project_name)
@@ -75,6 +55,6 @@ def setup_init_subparser(subparsers):
     """
     Sets up an argparse subparser for the 'init' command.
     """
-    init_parser = subparsers.add_parser('init', help='Initializes a new sunholo project.')
+    init_parser = subparsers.add_parser('init', help='Initializes a new Multivac project.')
     init_parser.add_argument('project_name', help='The name of the new project.')
     init_parser.set_defaults(func=init_project)

sunholo-0.60.2/sunholo/cli/run_proxy.py

@@ -0,0 +1,197 @@
+import subprocess
+import os
+import signal
+import json
+
+PROXY_TRACKER_FILE = '.vac_proxy_tracker.json'
+DEFAULT_PORT = 8080
+
+def create_hyperlink(url, text):
+    """
+    Creates a hyperlink for the console.
+
+    Args:
+        url (str): The URL for the hyperlink.
+        text (str): The text to display for the hyperlink.
+
+    Returns:
+        str: The formatted hyperlink.
+    """
+    return f"\033]8;;{url}\033\\{text}\033]8;;\033\\"
+
+
+def get_next_available_port(proxies, default_port):
+    """
+    Get the next available port starting from the default port.
+
+    Args:
+        proxies (dict): Current proxies with their assigned ports.
+        default_port (int): Default starting port.
+
+    Returns:
+        int: The next available port.
+    """
+    used_ports = {info["port"] for info in proxies.values()}
+    port = default_port
+    while port in used_ports:
+        port += 1
+    return port
+
+def check_gcloud():
+    """
+    Checks if gcloud is installed and authenticated.
+
+    Returns:
+        bool: True if gcloud is installed and authenticated, False otherwise.
+    """
+    try:
+        # Check if gcloud is installed
+        result = subprocess.run(["gcloud", "--version"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        if result.returncode != 0:
+            print("ERROR: gcloud is not installed or not found in PATH.")
+            return False
+
+        # Check if gcloud is authenticated
+        result = subprocess.run(["gcloud", "auth", "list"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        if result.returncode != 0 or "ACTIVE" not in result.stdout.decode():
+            print("ERROR: gcloud is not authenticated. Please run 'gcloud auth login'.")
+            return False
+
+        print("gcloud is installed and authenticated.")
+        return True
+    except Exception as e:
+        print(f"ERROR: An unexpected error occurred: {e}")
+        return False
+
+def is_process_running(pid):
+    try:
+        os.kill(pid, 0)
+        return True
+    except OSError:
+        print("WARNING: VAC Proxy lost connection")
+        return False
+
+def load_proxies():
+    if os.path.exists(PROXY_TRACKER_FILE):
+        with open(PROXY_TRACKER_FILE, 'r') as file:
+            return json.load(file)
+    return {}
+
+def clean_proxy_list():
+    proxies = load_proxies()
+    updated_proxies = {k: v for k, v in proxies.items() if is_process_running(v["pid"])}
+    if len(proxies) != len(updated_proxies):
+        save_proxies(updated_proxies)
+        
+    return updated_proxies
+
+def save_proxies(proxies):
+    with open(PROXY_TRACKER_FILE, 'w') as file:
+        json.dump(proxies, file, indent=4)
+
+def start_proxy(service_name, region, project, port=None):
+    """
+    Starts the gcloud proxy to the Cloud Run service and stores the PID.
+
+    Args:
+        service_name (str): Name of the Cloud Run service.
+        region (str): Region of the Cloud Run service.
+        project (str): GCP project of the Cloud Run service.
+        port (int, optional): Port to run the proxy on. If not provided, auto-assigns the next available port.
+    """
+    proxies = clean_proxy_list()
+
+    if service_name in proxies:
+        print(f"Proxy for service {service_name} is already running on port {proxies[service_name]['port']}.")
+        return
+
+    if not port:
+        port = get_next_available_port(proxies, DEFAULT_PORT)
+
+    command = [
+        "gcloud", "run", "services", "proxy", service_name,
+        "--region", region,
+        "--project", project,
+        "--port", str(port)
+    ]
+    with open(os.devnull, 'w') as devnull:
+        process = subprocess.Popen(command, stdout=devnull, stderr=devnull, preexec_fn=os.setpgrp)
+    
+    proxies[service_name] = {
+        "pid": process.pid,
+        "port": port
+    }
+    save_proxies(proxies)
+    
+    print(f"Proxy for {service_name} setup complete on port {port}")
+    list_proxies()
+
+    return f"http://127.0.0.1:{port}"
+
+
+def stop_proxy(service_name):
+    """
+    Stops the gcloud proxy to the Cloud Run service using the stored PID.
+
+    Args:
+        service_name (str): Name of the Cloud Run service.
+    """
+    proxies = clean_proxy_list()
+
+    if service_name not in proxies:
+        print(f"No proxy found for service: {service_name}")
+        return
+
+    pid = proxies[service_name]["pid"]
+    try:
+        os.kill(pid, signal.SIGTERM)
+        del proxies[service_name]
+        save_proxies(proxies)
+        print(f"Proxy for {service_name} stopped.")
+    except ProcessLookupError:
+        print(f"No process found with PID: {pid}")
+    except Exception as e:
+        print(f"Error stopping proxy for {service_name}: {e}")
+    
+    list_proxies()
+
+def list_proxies():
+    """
+    Lists all running proxies.
+    """
+    proxies = clean_proxy_list()
+    if not proxies:
+        print("No proxies currently running.")
+    else:
+        print("=== VAC Proxies Running ===")
+        for service_name, info in proxies.items():
+            url = f"http://127.0.0.1:{info['port']}"
+            hyperlink = create_hyperlink(url, url)
+            print(f"- VAC: {service_name} Port: {info['port']} PID: {info['pid']} URL: {hyperlink}")
+
+
+def setup_proxy_subparser(subparsers):
+    """
+    Sets up an argparse subparser for the 'proxy' command.
+
+    Args:
+        subparsers: The subparsers object from argparse.ArgumentParser().
+    """
+    proxy_parser = subparsers.add_parser('proxy', help='Set up or stop a proxy to the Cloud Run service.')
+    proxy_subparsers = proxy_parser.add_subparsers(dest='proxy_command', required=True)
+
+    start_parser = proxy_subparsers.add_parser('start', help='Start the proxy to the Cloud Run service.')
+    start_parser.add_argument('service_name', help='Name of the Cloud Run service.')
+    start_parser.add_argument('--region', default='europe-west1', help='Region of the Cloud Run service.')
+    start_parser.add_argument('--project', default='multivac-internal-dev', help='GCP project of the Cloud Run service.')
+    start_parser.add_argument('--port', type=int, help='Port to run the proxy on. Auto-assigns if not provided.')
+    start_parser.set_defaults(func=lambda args: start_proxy(args.service_name, args.region, args.project, args.port))
+
+    stop_parser = proxy_subparsers.add_parser('stop', help='Stop the proxy to the Cloud Run service.')
+    stop_parser.add_argument('service_name', help='Name of the Cloud Run service.')
+    stop_parser.set_defaults(func=lambda args: stop_proxy(args.service_name))
+
+    list_parser = proxy_subparsers.add_parser('list', help='List all running proxies.')
+    list_parser.set_defaults(func=lambda args: list_proxies())
+
+

{sunholo-0.60.0 → sunholo-0.60.2}/sunholo/components/retriever.py

@@ -48,7 +48,8 @@ def pick_retriever(vector_name, embeddings=None):
                 log.info(f"Found vectorstore {vectorstore}")
                 if embeddings is None:
                     embeddings = get_embeddings(vector_name)
-                vectorstore = pick_vectorstore(vectorstore, vector_name=vector_name, embeddings=embeddings)
+                read_only = value.get('readonly')
+                vectorstore = pick_vectorstore(vectorstore, vector_name=vector_name, embeddings=embeddings, read_only=read_only)
                 k_override = value.get('k', 3)
                 vs_retriever = vectorstore.as_retriever(search_kwargs=dict(k=k_override))
                 retriever_list.append(vs_retriever)

{sunholo-0.60.0 → sunholo-0.60.2}/sunholo/components/vectorstore.py

@@ -14,7 +14,7 @@
 import os
 from ..logging import log
 
-def pick_vectorstore(vs_str, vector_name, embeddings):
+def pick_vectorstore(vs_str, vector_name, embeddings, read_only=None):
     log.debug('Picking vectorstore')
         
     if vs_str == 'supabase':
@@ -23,8 +23,9 @@ def pick_vectorstore(vs_str, vector_name, embeddings):
 
         from ..database.database import setup_supabase
 
-        log.debug(f"Initiating Supabase store: {vector_name}")
-        setup_supabase(vector_name)
+        if not read_only:
+            log.debug(f"Initiating Supabase store: {vector_name}")
+            setup_supabase(vector_name)
 
         # init embedding and vector store
         supabase_url = os.getenv('SUPABASE_URL')
@@ -70,10 +71,14 @@ def pick_vectorstore(vs_str, vector_name, embeddings):
     elif vs_str == 'alloydb':
         from langchain_google_alloydb_pg import AlloyDBVectorStore
         from ..database.alloydb import create_alloydb_table, create_alloydb_engine
+        from ..database.database import get_vector_size
 
+        vector_size = get_vector_size(vector_name)
         engine = create_alloydb_engine(vector_name)
 
-        table_name = create_alloydb_table(vector_name, engine)
+        table_name = f"{vector_name}_vectorstore_{vector_size}"
+        if not read_only:
+            table_name = create_alloydb_table(vector_name, engine)
 
         log.info(f"Chose AlloyDB with table name {table_name}")
         vectorstore = AlloyDBVectorStore.create_sync(
@@ -106,21 +111,24 @@ def pick_vectorstore(vs_str, vector_name, embeddings):
         try:
             table = db.open_table(vector_name)
         except FileNotFoundError as err:
-            log.info(f"{err} - Could not open table for {vector_name} - creating new table")
-            init = f"Creating new table for {vector_name}"
-            table = db.create_table(
-                        vector_name,
-                        data=[
-                            {
-                                "vector": embeddings.embed_query(init),
-                                "text": init,
-                                "id": "1",
-                            }
-                        ],
-                        mode="overwrite",
-                    )
-
-        log.info(f"Inititaing LanceDB object for {vector_name} using {LANCEDB_BUCKET}")
+            if not read_only:
+                log.info(f"{err} - Could not open table for {vector_name} - creating new table")
+                init = f"Creating new table for {vector_name}"
+                table = db.create_table(
+                            vector_name,
+                            data=[
+                                {
+                                    "vector": embeddings.embed_query(init),
+                                    "text": init,
+                                    "id": "1",
+                                }
+                            ],
+                            mode="overwrite",
+                        )
+            else:
+                log.info(f"{err} - Could not create table for {vector_name} as read_only=True")
+
+        log.info(f"Initiating LanceDB object for {vector_name} using {LANCEDB_BUCKET}")
         vectorstore = LanceDB(
             connection=table,
             embedding=embeddings,

{sunholo-0.60.0 → sunholo-0.60.2}/sunholo/database/alloydb.py

@@ -178,7 +178,7 @@ def create_alloydb_table(vector_name, engine, type = "vectorstore", alloydb_conf
     try:
         if type == "vectorstore":
             from .database import get_vector_size
-            vector_size = get_vector_size(vector_name, config_file="config/llm_config.yaml")
+            vector_size = get_vector_size(vector_name)
             table_name = f"{vector_name}_{type}_{vector_size}"
             if table_name in alloydb_table_cache:
                 log.info(f"AlloyDB Table '{table_name}' exists in cache, skipping creation.")

{sunholo-0.60.0 → sunholo-0.60.2}/sunholo/logging.py

@@ -228,11 +228,16 @@ def setup_logging(logger_name=None, log_level=logging.INFO, project_id=None):
             project_id = get_gcp_project()
         # Instantiate the GoogleCloudLogging class
         gc_logger = GoogleCloudLogging(project_id, log_level=log_level, logger_name=logger_name)
+        # Setup logging and return the logger instance
+        return gc_logger.setup_logging()
     else:
-        return logger
+        if not logging.getLogger().hasHandlers():
+            logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+        log = logging.getLogger(logger_name)
+
+        return log
     
-    # Setup logging and return the logger instance
-    return gc_logger.setup_logging()
+
 
 
 

{sunholo-0.60.0 → sunholo-0.60.2}/sunholo/utils/config.py

@@ -191,7 +191,6 @@ def load_config_key(key: str, vector_name: str, kind: str=None):
     assert isinstance(vector_name, str), f"vector_name must be a string, got a {type(vector_name)}"
     
     configs_by_kind = load_all_configs()
-    log.info(f"configs by kind: {configs_by_kind}")
 
     if kind:
         log.info(f"Got kind: {kind} - applying to configs")

sunholo-0.60.2/sunholo/utils/user_ids.py

@@ -0,0 +1,10 @@
+import uuid
+import hashlib
+import platform
+import socket
+
+def generate_user_id():
+    data = f"{socket.gethostname()}-{platform.platform()}-{platform.processor()}"
+    hashed_id = hashlib.sha256(data.encode('utf-8')).hexdigest()
+    
+    return str(uuid.uuid5(uuid.NAMESPACE_DNS, hashed_id))

{sunholo-0.60.0 → sunholo-0.60.2}/sunholo.egg-info/PKG-INFO

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

{sunholo-0.60.0 → sunholo-0.60.2}/sunholo.egg-info/SOURCES.txt

@@ -43,11 +43,13 @@ sunholo/chunker/pdfs.py
 sunholo/chunker/publish.py
 sunholo/chunker/splitter.py
 sunholo/cli/__init__.py
+sunholo/cli/chat_vac.py
 sunholo/cli/cli.py
 sunholo/cli/cli_init.py
 sunholo/cli/configs.py
 sunholo/cli/deploy.py
 sunholo/cli/merge_texts.py
+sunholo/cli/run_proxy.py
 sunholo/components/__init__.py
 sunholo/components/llm.py
 sunholo/components/prompt.py
@@ -101,6 +103,7 @@ sunholo/utils/config.py
 sunholo/utils/config_schema.py
 sunholo/utils/gcp.py
 sunholo/utils/parsers.py
+sunholo/utils/user_ids.py
 sunholo/vertex/__init__.py
 sunholo/vertex/init_vertex.py
 test/test_dispatch_to_qa.py