sunholo 0.67.10__py3-none-any.whl → 0.68.1__py3-none-any.whl

sunholo/agents/chat_history.py

@@ -103,7 +103,7 @@ def create_message_element(message: dict):
     if 'text' in message:  # This is a Slack or Google Chat message
         log.info(f"Found text element - {message['text']}")
         return message['text']
-    elif 'content' in message: # Discord message
+    elif 'content' in message: # Discord or OpenAI history message
         log.info(f"Found content element - {message['content']}")
         return message['content']
     else:  
@@ -130,6 +130,8 @@ def is_human(message: dict):
         return message["name"] == "Human"
     elif 'sender' in message:  # Google Chat
         return message['sender']['type'] == 'HUMAN'
+    elif 'role' in message:
+        return message['role'] == 'user'
     else:
         # Slack: Check for the 'user' field and absence of 'bot_id' field
         return 'user' in message and 'bot_id' not in message
@@ -174,5 +176,7 @@ def is_ai(message: dict):
         return message["name"] == "AI"
     elif 'sender' in message:  # Google Chat
         return message['sender']['type'] == 'BOT'
+    elif 'role' in message:
+        return message['role'] == 'assistant'
     else:
         return 'bot_id' in message  # Slack

sunholo/agents/flask/qna_routes.py

@@ -258,7 +258,12 @@ def register_qna_routes(app, stream_interpreter, vac_interpreter):
             # the header forwarded
             auth_header = request.headers.get('X-Forwarded-Authorization')
             if auth_header:
-                api_key = auth_header.split(' ')[1]  # Assuming "Bearer <api_key>"
+                
+                if auth_header.startswith('Bearer '):
+                    api_key = auth_header.split(' ')[1]  # Assuming "Bearer <api_key>"
+                else:
+                    return jsonify({'error': 'Invalid authorization header does not start with "Bearer " - got: {auth_header}'}), 401
+                
                 endpoints_host = os.getenv('_ENDPOINTS_HOST')
                 if not endpoints_host:
                     return jsonify({'error': '_ENDPOINTS_HOST environment variable not found'}), 401
@@ -425,8 +430,9 @@ def register_qna_routes(app, stream_interpreter, vac_interpreter):
                 return make_openai_response(user_message, vector_name, 'ERROR: could not find an answer')
 
         except Exception as err:
-            log.error(f"OpenAI response error: {err}")
-            return jsonify({'error': f'QNA_ERROR: An error occurred: {str(err)} traceback: {traceback.format_exc()}'}), 500
+            log.error(f"OpenAI response error: {str(err)} traceback: {traceback.format_exc()}")
+            
+            return make_openai_response(user_message, vector_name, f'ERROR: {str(err)}')
 
 
 def create_langfuse_trace(request, vector_name):

sunholo/agents/flask/vac_routes.py

@@ -0,0 +1,501 @@
+import json
+import traceback
+import datetime
+import uuid
+
+from ...agents import extract_chat_history, handle_special_commands
+from ...qna.parsers import parse_output
+from ...streaming import start_streaming_chat
+from ...archive import archive_qa
+from ...logging import log
+from ...utils.config import load_config
+from ...utils.version import sunholo_version
+import os
+from ...gcs.add_file import add_file_to_gcs, handle_base64_image
+from ..swagger import validate_api_key
+from datetime import datetime, timedelta
+
+try:
+    from flask import request, jsonify, Response
+except ImportError:
+    pass
+
+try:
+    from langfuse.decorators import langfuse_context, observe
+except ImportError:
+    pass    
+
+# Cache dictionary to store validated API keys
+api_key_cache = {}
+cache_duration = timedelta(minutes=5)  # Cache duration
+
+class VACRoutes:
+    """
+**Usage Example:**
+
+```python
+from agents.flask import VACRoutes
+
+app = Flask(__name__)
+
+def stream_interpreter(question, vector_name, chat_history, **kwargs):
+    # Implement your streaming logic
+    ...
+
+def vac_interpreter(question, vector_name, chat_history, **kwargs):
+    # Implement your static VAC logic
+    ...
+
+vac_routes = VACRoutes(app, stream_interpreter, vac_interpreter)
+
+if __name__ == "__main__":
+    app.run(debug=True)
+```
+    
+    """
+    def __init__(self, app, stream_interpreter, vac_interpreter):
+        self.app = app
+        self.stream_interpreter = stream_interpreter
+        self.vac_interpreter = vac_interpreter
+        self.register_routes()
+
+    def register_routes(self):
+        """
+        Registers all the VAC routes for the Flask application.
+        """
+        # Basic routes
+        self.app.route("/", methods=['GET'])(self.home)
+        self.app.route("/health", methods=['GET'])(self.health)
+
+        # Streaming VAC
+        self.app.route('/vac/streaming/<vector_name>', methods=['POST'])(self.handle_stream_vac)
+
+        # Static VAC
+        self.app.route('/vac/<vector_name>', methods=['POST'])(self.handle_process_vac)
+
+        # Authentication middleware
+        self.app.before_request(self.check_authentication)
+
+        # OpenAI health endpoint
+        self.app.route('/openai/health', methods=['GET', 'POST'])(self.openai_health_endpoint)
+
+        # OpenAI compatible endpoint
+        self.app.route('/openai/v1/chat/completions', methods=['POST'])(self.handle_openai_compatible_endpoint)
+        self.app.route('/openai/v1/chat/completions/<vector_name>', methods=['POST'])(self.handle_openai_compatible_endpoint)
+
+    def home(self):
+        return jsonify("OK")
+
+    def health(self):
+        return jsonify({"status": "healthy"})
+    
+    def make_openai_response(self, user_message, vector_name, answer):
+        response_id = str(uuid.uuid4())
+        log.info("openai response: Q: {user_message} to VECTOR_NAME: {vector_name} - A: {answer}")
+        openai_response = {
+            "id": response_id,
+            "object": "chat.completion",
+            "created": str(int(datetime.now().timestamp())),
+            "model": vector_name,
+            "system_fingerprint": sunholo_version(),
+            "choices": [{
+                "index": 0,
+                "message": {
+                    "role": "assistant",
+                    "content": answer,
+                },
+                "logprobs": None,
+                "finish_reason": "stop"
+            }],
+            "usage": {
+                "prompt_tokens": len(user_message.split()),
+                "completion_tokens": len(answer.split()),
+                "total_tokens": len(user_message.split()) + len(answer.split())
+            }
+        }
+
+        log.info(f"OpenAI response: {openai_response}")
+        return jsonify(openai_response)
+
+
+    def handle_stream_vac(self, vector_name):
+        observed_stream_interpreter = observe()(self.stream_interpreter)
+        prep = self.prep_vac(request, vector_name)
+        log.debug(f"Processing prep: {prep}")
+        trace = prep["trace"]
+        span = prep["span"]
+        command_response = prep["command_response"]
+        vac_config = prep["vac_config"]
+        all_input = prep["all_input"]
+
+        if command_response:
+            return jsonify(command_response)
+
+        log.info(f'Streaming data with: {all_input}')
+        if span:
+            generation = span.generation(
+                name="start_streaming_chat",
+                metadata=vac_config,
+                input = all_input,
+                completion_start_time=datetime.datetime.now(),
+                model=vac_config.get("model") or vac_config.get("llm")
+            )
+
+        def generate_response_content():
+
+            for chunk in start_streaming_chat(question=all_input["user_input"],
+                                                vector_name=vector_name,
+                                                qna_func=observed_stream_interpreter,
+                                                chat_history=all_input["chat_history"],
+                                                wait_time=all_input["stream_wait_time"],
+                                                timeout=all_input["stream_timeout"],
+                                                #kwargs
+                                                **all_input["kwargs"]
+                                                ):
+                if isinstance(chunk, dict) and 'answer' in chunk:
+                    # When we encounter the dictionary, we yield it as a JSON string
+                    # and stop the generator.
+                    if trace:
+                        chunk["trace"] = trace.id
+                        chunk["trace_url"] = trace.get_trace_url()
+                    archive_qa(chunk, vector_name)
+                    if trace:
+                        generation.end(output=json.dumps(chunk))
+                        span.end(output=json.dumps(chunk))
+                        trace.update(output=json.dumps(chunk))
+
+                    return json.dumps(chunk)
+            
+                else:
+                    # Otherwise, we yield the plain text chunks as they come in.
+                    yield chunk
+        
+        # Here, the generator function will handle streaming the content to the client.
+        response = Response(generate_response_content(), content_type='text/plain; charset=utf-8')
+        response.headers['Transfer-Encoding'] = 'chunked'  
+
+        log.debug(f"streaming response: {response}")
+        if trace:
+            generation.end(output=response)
+            span.end(output=response)
+            trace.update(output=response)
+
+        return response
+
+    def handle_process_vac(self, vector_name):
+        observed_vac_interpreter = observe()(self.vac_interpreter)
+        prep = self.prep_vac(request, vector_name)
+        log.debug(f"Processing prep: {prep}")
+        trace = prep["trace"]
+        span = prep["span"]
+        command_response = prep["command_response"]
+        vac_config = prep["vac_config"]
+        all_input = prep["all_input"]
+
+        if command_response:
+            return jsonify(command_response)
+
+        try:
+            if span:
+                generation = span.generation(
+                    name="vac_interpreter",
+                    metadata=vac_config,
+                    input = all_input,
+                    model=vac_config.get("model") or vac_config.get("llm")
+                )
+            bot_output = observed_vac_interpreter(
+                question=all_input["user_input"],
+                vector_name=vector_name,
+                chat_history=all_input["chat_history"],
+                **all_input["kwargs"]
+            )
+            if span:
+                generation.end(output=bot_output)
+            # {"answer": "The answer", "source_documents": [{"page_content": "The page content", "metadata": "The metadata"}]}
+            bot_output = parse_output(bot_output)
+            if trace:
+                bot_output["trace"] = trace.id
+                bot_output["trace_url"] = trace.get_trace_url()
+            archive_qa(bot_output, vector_name)
+            log.info(f'==LLM Q:{all_input["user_input"]} - A:{bot_output}')
+
+
+        except Exception as err: 
+            bot_output = {'answer': f'QNA_ERROR: An error occurred while processing /vac/{vector_name}: {str(err)} traceback: {traceback.format_exc()}'}
+    
+        if trace:
+            span.end(output=jsonify(bot_output))
+            trace.update(output=jsonify(bot_output)) 
+
+        # {'answer': 'output'}
+        return jsonify(bot_output)
+
+    def check_authentication(self):
+        if request.path.startswith('/openai/'):
+            log.debug(f'Request headers: {request.headers}')
+            # the header forwarded
+            auth_header = request.headers.get('X-Forwarded-Authorization')
+            if auth_header:
+                
+                if auth_header.startswith('Bearer '):
+                    api_key = auth_header.split(' ')[1]  # Assuming "Bearer <api_key>"
+                else:
+                    return jsonify({'error': 'Invalid authorization header does not start with "Bearer " - got: {auth_header}'}), 401
+                
+                endpoints_host = os.getenv('_ENDPOINTS_HOST')
+                if not endpoints_host:
+                    return jsonify({'error': '_ENDPOINTS_HOST environment variable not found'}), 401
+                
+                # Check cache first
+                current_time = datetime.now()
+                if api_key in api_key_cache:
+                    cached_result, cache_time = api_key_cache[api_key]
+                    if current_time - cache_time < cache_duration:
+                        if not cached_result:
+                            return jsonify({'error': 'Invalid cached API key'}), 401
+                        else:
+                            return  # Valid API key, continue to the endpoint
+                    else:
+                        # Cache expired, remove from cache
+                        del api_key_cache[api_key]
+                
+                # Validate API key
+                is_valid = validate_api_key(api_key, endpoints_host)
+                # Update cache
+                api_key_cache[api_key] = (is_valid, current_time)
+                
+                if not is_valid:
+                    return jsonify({'error': 'Invalid API key'}), 401
+            else:
+                return jsonify({'error': 'Missing Authorization header'}), 401
+
+    def openai_health_endpoint():
+            return jsonify({'message': 'Success'})
+
+    def handle_openai_compatible_endpoint(self, vector_name=None):
+        data = request.get_json()
+        log.info(f'openai_compatible_endpoint got data: {data} for vector: {vector_name}')
+
+        vector_name = vector_name or data.pop('model', None)
+        messages = data.pop('messages', None)
+        chat_history = data.pop('chat_history', None)
+        stream = data.pop('stream', False)
+
+        if not messages:
+            return jsonify({"error": "No messages provided"}), 400
+
+        user_message = None
+        image_uri = None
+        mime_type = None
+
+        for msg in reversed(messages):
+            if msg['role'] == 'user':
+                if isinstance(msg['content'], list):
+                    for content_item in msg['content']:
+                        if content_item['type'] == 'text':
+                            user_message = content_item['text']
+                        elif content_item['type'] == 'image_url':
+                            base64_data = content_item['image_url']['url']
+                            image_uri, mime_type = handle_base64_image(base64_data, vector_name)
+                else:
+                    user_message = msg['content']
+                break
+
+        if not user_message:
+            return jsonify({"error": "No user message provided"}), 400
+        else:
+            log.info(f"User message: {user_message}")
+    
+        paired_messages = extract_chat_history(chat_history)
+        command_response = handle_special_commands(user_message, vector_name, paired_messages)
+
+        if command_response is not None:
+
+            return self.make_openai_response(user_message, vector_name, command_response)
+    
+        if image_uri:
+            data["image_uri"] = image_uri
+            data["mime"] = mime_type
+
+        all_input = {
+            "user_input": user_message,
+            "chat_history": chat_history,
+            "kwargs": data
+        }
+
+        observed_stream_interpreter = observe()(self.stream_interpreter)
+
+        response_id = str(uuid.uuid4())
+        
+        def generate_response_content():
+            for chunk in start_streaming_chat(question=user_message,
+                                            vector_name=vector_name,
+                                            qna_func=observed_stream_interpreter,
+                                            chat_history=all_input["chat_history"],
+                                            wait_time=all_input.get("stream_wait_time", 1),
+                                            timeout=all_input.get("stream_timeout", 60),
+                                            **all_input["kwargs"]
+                                            ):
+                if isinstance(chunk, dict) and 'answer' in chunk:
+                    openai_chunk = {
+                        "id": response_id,
+                        "object": "chat.completion.chunk",
+                        "created": str(int(datetime.now().timestamp())),
+                        "model": vector_name,
+                        "system_fingerprint": sunholo_version(),
+                        "choices": [{
+                            "index": 0,
+                            "delta": {"content": chunk['answer']},
+                            "logprobs": None,
+                            "finish_reason": None
+                        }]
+                    }
+                    yield json.dumps(openai_chunk) + "\n"
+                else:
+                    log.info(f"Unknown chunk: {chunk}")
+
+            final_chunk = {
+                "id": response_id,
+                "object": "chat.completion.chunk",
+                "created": str(int(datetime.now().timestamp())),
+                "model": vector_name,
+                "system_fingerprint": sunholo_version(),
+                "choices": [{
+                    "index": 0,
+                    "delta": {},
+                    "logprobs": None,
+                    "finish_reason": "stop"
+                }]
+            }
+            yield json.dumps(final_chunk) + "\n"
+
+        if stream:
+            log.info("Streaming openai chunks")
+            return Response(generate_response_content(), content_type='text/plain; charset=utf-8')
+
+        try:
+            observed_vac_interpreter = observe()(self.vac_interpreter)
+            bot_output = observed_vac_interpreter(
+                question=user_message,
+                vector_name=vector_name,
+                chat_history=all_input["chat_history"],
+                **all_input["kwargs"]
+            )
+            bot_output = parse_output(bot_output)
+
+            log.info(f"Bot output: {bot_output}")
+            if bot_output:
+                return self.make_openai_response(user_message, vector_name, bot_output.get('answer', ''))
+            else:
+                return self.make_openai_response(user_message, vector_name, 'ERROR: could not find an answer')
+
+        except Exception as err:
+            log.error(f"OpenAI response error: {str(err)} traceback: {traceback.format_exc()}")
+        
+            return self.make_openai_response(user_message, vector_name, f'ERROR: {str(err)}')
+
+
+    def create_langfuse_trace(self, request, vector_name):
+        try:
+            from langfuse import Langfuse
+            langfuse = Langfuse()
+        except ImportError as err:
+            print(f"No langfuse installed for agents.flask.register_qna_routes, install via `pip install sunholo[http]` - {str(err)}")
+            
+            return None
+
+        user_id = request.headers.get("X-User-ID")
+        session_id = request.headers.get("X-Session-ID")
+        message_source = request.headers.get("X-Message-Source")
+
+        package_version = sunholo_version()
+        tags = [package_version]
+        if message_source:
+            tags.append(message_source)
+
+        return langfuse.trace(
+            name = f"/vac/{vector_name}",
+            user_id = user_id,
+            session_id = session_id,
+            tags = tags,
+            release = f"sunholo-v{package_version}"
+        )
+
+    def prep_vac(self, request, vector_name):
+        trace = self.create_langfuse_trace(request, vector_name)
+        span = None
+
+        if request.content_type.startswith('application/json'):
+            data = request.get_json()
+        elif request.content_type.startswith('multipart/form-data'):
+            data = request.form.to_dict()
+            if 'file' in request.files:
+                file = request.files['file']
+                if file.filename != '':
+                    log.info(f"Found file: {file.filename} to upload to GCS")
+                    try:
+                        image_uri, mime_type = self.handle_file_upload(file, vector_name)
+                        data["image_uri"] = image_uri
+                        data["mime"] = mime_type
+                    except Exception as e:
+                        return jsonify({'error': str(e), 'traceback': traceback.format_exc()}), 500
+                else:
+                    return jsonify({"error": "No file selected"}), 400
+        else:
+            return jsonify({"error": "Unsupported content type"}), 400
+
+        log.info(f"vac/{vector_name} got data: {data}")
+
+        config, _ = load_config("config/llm_config.yaml")
+        vac_configs = config.get("vac")
+        if vac_configs:
+            vac_config = vac_configs[vector_name]
+
+        if trace:
+            trace.update(input=data, metadata=vac_config)
+
+        user_input = data.pop('user_input').strip()
+        stream_wait_time = data.pop('stream_wait_time', 7)
+        stream_timeout = data.pop('stream_timeout', 120)
+        chat_history = data.pop('chat_history', None)
+        vector_name = data.pop('vector_name', vector_name)
+
+        paired_messages = extract_chat_history(chat_history)
+
+        all_input = {'user_input': user_input, 
+                     'vector_name': vector_name, 
+                     'chat_history': paired_messages, 
+                     'stream_wait_time': stream_wait_time,
+                     'stream_timeout': stream_timeout,
+                     'kwargs': data}
+
+        if trace:
+            span = trace.span(
+                name="VAC",
+                metadata=vac_config,
+                input = all_input
+            )
+        command_response = handle_special_commands(user_input, vector_name, paired_messages)
+        if command_response is not None:
+            if trace:
+                trace.update(output=jsonify(command_response))
+    
+        return {
+            "trace": trace,
+            "span": span,
+            "command_response": command_response,
+            "all_input": all_input,
+            "vac_config": vac_config
+        }
+
+
+    def handle_file_upload(self, file, vector_name):
+        try:
+            file.save(file.filename)
+            image_uri = add_file_to_gcs(file.filename, vector_name)
+            os.remove(file.filename)  # Clean up the saved file
+            return image_uri, file.mimetype
+        except Exception as e:
+            raise Exception(f'File upload failed: {str(e)}')
+
+

sunholo/components/retriever.py

@@ -54,10 +54,15 @@ def pick_retriever(vector_name, embeddings=None):
 
                 embeddings = embeddings or get_embeddings(vector_name)
                 read_only = value.get('read_only')
-                vectorstore = pick_vectorstore(vectorstore, 
-                                               vector_name=vector_name, 
-                                               embeddings=embeddings, 
-                                               read_only=read_only)
+                try:
+                    vectorstore = pick_vectorstore(vectorstore, 
+                                                vector_name=vector_name, 
+                                                embeddings=embeddings, 
+                                                read_only=read_only)
+                except Exception as e:
+                    log.error(f"Failed to pick_vectorstore {vectorstore} for {vector_name} - {str(e)} - skipping")
+                    continue
+                
                 k_override = value.get('k', 3)
                 vs_retriever = vectorstore.as_retriever(search_kwargs=dict(k=k_override))
                 retriever_list.append(vs_retriever)

sunholo/database/alloydb.py

@@ -1,10 +1,7 @@
 import os
 try:
-    import pg8000
-    import sqlalchemy
     from sqlalchemy.exc import DatabaseError, ProgrammingError
     from asyncpg.exceptions import DuplicateTableError
-    from google.cloud.alloydb.connector import Connector
     from langchain_google_alloydb_pg import AlloyDBEngine, Column, AlloyDBLoader, AlloyDBDocumentSaver
     from google.cloud.alloydb.connector import IPTypes
 except ImportError:
@@ -12,9 +9,12 @@ except ImportError:
     pass
 
 from .database import get_vector_size
+from .alloydb_client import AlloyDBClient
+
 from ..logging import log
 from ..utils.config import load_config_key
 
+
 def create_alloydb_engine(vector_name):
 
     if not AlloyDBEngine:
@@ -49,183 +49,6 @@ def create_alloydb_engine(vector_name):
 
     return engine
 
-class AlloyDBClient:
-    """
-    A class to manage interactions with an AlloyDB instance.
-
-    Example Usage:
-
-    ```python
-    client = AlloyDBClient(
-        project_id="your-project-id",
-        region="your-region",
-        cluster_name="your-cluster-name",
-        instance_name="your-instance-name",
-        user="your-db-user",
-        password="your-db-password"
-    )
-
-    # Create a database
-    client.execute_sql("CREATE DATABASE my_database")
-
-    # Execute other SQL statements
-    client.execute_sql("CREATE TABLE my_table (id INT, name VARCHAR(50))")
-    ```
-    """
-
-    def __init__(self, 
-                 project_id: str, 
-                 region: str, 
-                 cluster_name:str, 
-                 instance_name:str, 
-                 user:str, 
-                 password=None, 
-                 db="postgres"):
-        """Initializes the AlloyDB client.
-         - project_id (str): GCP project ID where the AlloyDB instance resides.
-         - region (str): The region where the AlloyDB instance is located.
-         - cluster_name (str): The name of the AlloyDB cluster.
-         - instance_name (str): The name of the AlloyDB instance.
-         - user (str): The database user name.
-         - password (str): The database user's password.
-         - db_name (str): The name of the database.
-        """
-        self.connector = Connector()
-        self.inst_uri = self._build_instance_uri(project_id, region, cluster_name, instance_name)
-        self.engine = self._create_engine(self.inst_uri, user, password, db)
-
-    def _build_instance_uri(self, project_id, region, cluster_name, instance_name):
-        return f"projects/{project_id}/locations/{region}/clusters/{cluster_name}/instances/{instance_name}"
-
-    def _create_engine(self, inst_uri, user, password, db):
-        def getconn() -> pg8000.dbapi.Connection:
-            conn = self.connector.connect(
-                inst_uri,
-                "pg8000",
-                user=user,
-                password=password,
-                db=db,
-                enable_iam_auth=True,
-            )
-            return conn
-
-        engine = sqlalchemy.create_engine(
-            "postgresql+pg8000://", 
-            isolation_level="AUTOCOMMIT", 
-            creator=getconn
-        )
-        engine.dialect.description_encoding = None
-        log.info(f"Created AlloyDB engine for {inst_uri} and user: {user}")
-        return engine
-
-    def execute_sql(self, sql_statement):
-        """Executes a given SQL statement with error handling.
-
-         - sql_statement (str): The SQL statement to execute.
-         - Returns: The result of the execution, if any.
-        """
-        sql_ = sqlalchemy.text(sql_statement)
-        result = None
-        with self.engine.connect() as conn:
-            try:
-                log.info(f"Executing SQL statement: {sql_}")
-                result = conn.execute(sql_)
-            except DatabaseError as e:
-                if "already exists" in str(e):
-                    log.warning(f"Error ignored: {str(e)}. Assuming object already exists.")
-                else:
-                    raise  
-            finally:
-                conn.close()
-
-        return result
-
-    @staticmethod
-    def _and_or_ilike(sources, search_type="OR", operator="ILIKE"):
-        unique_sources = set(sources)
-        # Choose the delimiter based on the search_type argument
-        delimiter = ' AND ' if search_type.upper() == "AND" else ' OR '
-
-        # Build the conditional expressions based on the chosen delimiter
-        conditions = delimiter.join(f"TRIM(source) {operator} '%{source}%'" for source in unique_sources)
-        if not conditions:
-            log.warning("Alloydb doc query found no like_patterns")
-            return []
-        
-        return conditions
-
-    def delete_sources_from_alloydb(self, sources, vector_name):
-        """
-        Deletes from both vectorstore and docstore
-        """
-
-        vector_length = get_vector_size(vector_name)
-
-        conditions = self._and_or_ilike(sources, operator="=")
-
-        if not conditions:
-            log.warning("No conditions were specified, not deleting whole table!")
-            return False
-
-        query = f"""
-            DELETE FROM {vector_name}_docstore
-            WHERE {conditions};
-            DELETE FROM {vector_name}_vectorstore_{vector_length}
-            WHERE {conditions}
-        """
-
-        return self.execute_sql(query)
-
-    def create_database(self, database_name):
-        self.execute_sql(f'CREATE DATABASE "{database_name}"')
-
-    def fetch_owners(self):
-        owners = self.execute_sql('SELECT table_schema, table_name, privilege_type FROM information_schema.table_privileges')
-        for row in owners:
-            print(f"Schema: {row[0]}, Table: {row[1]}, Privilege: {row[2]}")
-        return owners
-
-    def create_schema(self, schema_name="public"):
-        self.execute_sql(f'CREATE SCHEMA IF NOT EXISTS {schema_name};')
-
-    def grant_permissions(self, schema_name, users):
-        for user in users:
-            self.execute_sql(f'GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA {schema_name} TO "{user}";')
-            self.execute_sql(f'GRANT USAGE, CREATE ON SCHEMA {schema_name} TO "{user}";')
-            self.execute_sql(f'ALTER DEFAULT PRIVILEGES IN SCHEMA {schema_name} GRANT SELECT, INSERT, UPDATE, DELETE ON TABLES TO "{user}";')
-            self.execute_sql(f'GRANT USAGE ON SCHEMA information_schema TO "{user}";')
-            self.execute_sql(f'GRANT SELECT ON information_schema.columns TO "{user}";')
-
-    def create_docstore_tables(self, vector_names, users):
-        for vector_name in vector_names:
-            table_name = f"{vector_name}_docstore"
-            sql = f'''
-            CREATE TABLE IF NOT EXISTS "{table_name}" 
-            (page_content TEXT, doc_id UUID, source TEXT, images_gsurls JSONB, chunk_metadata JSONB, langchain_metadata JSONB)
-            '''
-            self.execute_sql(sql)
-
-            for user in users:
-                self.execute_sql(f'GRANT SELECT, INSERT, UPDATE, DELETE ON TABLE "{table_name}" TO "{user}";')
-
-            vectorstore_id = f"{vector_name}_vectorstore_1536"
-            sql = f'''
-            CREATE TABLE IF NOT EXISTS "{vectorstore_id}" (
-            langchain_id UUID NOT NULL,
-            content TEXT NOT NULL,
-            embedding vector NOT NULL,
-            source TEXT,
-            langchain_metadata JSONB,
-            docstore_doc_id UUID,
-            eventTime TIMESTAMPTZ
-            );
-            '''
-            self.execute_sql(sql)
-
-            for user in users:
-                self.execute_sql(f'GRANT SELECT, INSERT, UPDATE, DELETE ON TABLE {vectorstore_id} TO "{user}";')
-
-
 alloydb_table_cache = {}  # Our cache, initially empty  # noqa: F841
 def create_alloydb_table(vector_name, engine, type = "vectorstore", alloydb_config=None, username=None):
     global alloydb_table_cache
@@ -240,9 +63,6 @@ def create_alloydb_table(vector_name, engine, type = "vectorstore", alloydb_conf
 
                 return table_name
             
-            alloydb_table_cache[table_name] = True 
-            return table_name
-            
             log.info(f"# Creating AlloyDB table {table_name}")
             try:
                 engine.init_vectorstore_table(

sunholo/database/alloydb_client.py

@@ -0,0 +1,196 @@
+try:
+    import pg8000
+    import sqlalchemy
+    from sqlalchemy.exc import DatabaseError, ProgrammingError
+    from google.cloud.alloydb.connector import Connector
+except ImportError:
+    AlloyDBEngine = None
+    pass
+
+from .database import get_vector_size
+from ..logging import log
+
+class AlloyDBClient:
+    """
+    A class to manage interactions with an AlloyDB instance.
+
+    Example Usage:
+
+    ```python
+    client = AlloyDBClient(
+        project_id="your-project-id",
+        region="your-region",
+        cluster_name="your-cluster-name",
+        instance_name="your-instance-name",
+        user="your-db-user",
+        password="your-db-password"
+    )
+
+    # Create a database
+    client.execute_sql("CREATE DATABASE my_database")
+
+    # Execute other SQL statements
+    client.execute_sql("CREATE TABLE my_table (id INT, name VARCHAR(50))")
+    ```
+    """
+
+    def __init__(self, 
+                 project_id: str, 
+                 region: str, 
+                 cluster_name:str, 
+                 instance_name:str, 
+                 user:str, 
+                 password=None, 
+                 db="postgres"):
+        """Initializes the AlloyDB client.
+         - project_id (str): GCP project ID where the AlloyDB instance resides.
+         - region (str): The region where the AlloyDB instance is located.
+         - cluster_name (str): The name of the AlloyDB cluster.
+         - instance_name (str): The name of the AlloyDB instance.
+         - user (str): The database user name.
+         - password (str): The database user's password.
+         - db_name (str): The name of the database.
+        """
+        self.connector = Connector()
+        self.inst_uri = self._build_instance_uri(project_id, region, cluster_name, instance_name)
+        self.engine = self._create_engine(self.inst_uri, user, password, db)
+
+    def _build_instance_uri(self, project_id, region, cluster_name, instance_name):
+        return f"projects/{project_id}/locations/{region}/clusters/{cluster_name}/instances/{instance_name}"
+
+    def _create_engine(self, inst_uri, user, password, db):
+        def getconn() -> pg8000.dbapi.Connection:
+            conn = self.connector.connect(
+                inst_uri,
+                "pg8000",
+                user=user,
+                password=password,
+                db=db,
+                enable_iam_auth=True,
+            )
+            return conn
+
+        engine = sqlalchemy.create_engine(
+            "postgresql+pg8000://", 
+            isolation_level="AUTOCOMMIT", 
+            creator=getconn
+        )
+        engine.dialect.description_encoding = None
+        log.info(f"Created AlloyDB engine for {inst_uri} and user: {user}")
+        return engine
+
+    def execute_sql(self, sql_statement):
+        """Executes a given SQL statement with error handling.
+
+         - sql_statement (str): The SQL statement to execute.
+         - Returns: The result of the execution, if any.
+        """
+        sql_ = sqlalchemy.text(sql_statement)
+        result = None
+        with self.engine.connect() as conn:
+            try:
+                log.info(f"Executing SQL statement: {sql_}")
+                result = conn.execute(sql_)
+            except DatabaseError as e:
+                if "already exists" in str(e):
+                    log.warning(f"Error ignored: {str(e)}. Assuming object already exists.")
+                else:
+                    raise  
+            finally:
+                conn.close()
+
+        return result
+
+    @staticmethod
+    def _and_or_ilike(sources, search_type="OR", operator="ILIKE"):
+        unique_sources = set(sources)
+        # Choose the delimiter based on the search_type argument
+        delimiter = ' AND ' if search_type.upper() == "AND" else ' OR '
+
+        # Build the conditional expressions based on the chosen delimiter
+        conditions = delimiter.join(f"TRIM(source) {operator} '%{source}%'" for source in unique_sources)
+        if not conditions:
+            log.warning("Alloydb doc query found no like_patterns")
+            return []
+        
+        return conditions
+
+    def delete_sources_from_alloydb(self, sources, vector_name):
+        """
+        Deletes from both vectorstore and docstore
+        """
+
+        vector_length = get_vector_size(vector_name)
+
+        conditions = self._and_or_ilike(sources, operator="=")
+
+        if not conditions:
+            log.warning("No conditions were specified, not deleting whole table!")
+            return False
+
+        query = f"""
+            DELETE FROM {vector_name}_docstore
+            WHERE {conditions};
+            DELETE FROM {vector_name}_vectorstore_{vector_length}
+            WHERE {conditions}
+        """
+
+        return self.execute_sql(query)
+
+    def create_database(self, database_name):
+        self.execute_sql(f'CREATE DATABASE "{database_name}"')
+
+    def fetch_owners(self):
+        owners = self.execute_sql('SELECT table_schema, table_name, privilege_type FROM information_schema.table_privileges')
+        for row in owners:
+            print(f"Schema: {row[0]}, Table: {row[1]}, Privilege: {row[2]}")
+        return owners
+
+    def create_schema(self, schema_name="public"):
+        self.execute_sql(f'CREATE SCHEMA IF NOT EXISTS {schema_name};')
+
+    def grant_schema_permissions(self, schema_name, users):
+        for user in users:
+            self.execute_sql(f'GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA {schema_name} TO "{user}";')
+            self.execute_sql(f'GRANT USAGE, CREATE ON SCHEMA {schema_name} TO "{user}";')
+            self.execute_sql(f'ALTER DEFAULT PRIVILEGES IN SCHEMA {schema_name} GRANT SELECT, INSERT, UPDATE, DELETE ON TABLES TO "{user}";')
+            self.execute_sql(f'GRANT USAGE ON SCHEMA information_schema TO "{user}";')
+            self.execute_sql(f'GRANT SELECT ON information_schema.columns TO "{user}";')
+    
+    def grant_table_permissions(self, table_name, users):
+        for user in users:
+            self.execute_sql(f'GRANT SELECT, INSERT, UPDATE, DELETE ON TABLE "{table_name}" TO "{user}";')
+    
+    def create_tables(self, vector_name, users):
+        self.create_docstore_table(vector_name, users)
+        self.create_vectorstore_table(vector_name, users)
+
+    def create_docstore_table(self, vector_name: str, users):
+        table_name = f"{vector_name}_vectorstore"
+        sql = f'''
+        CREATE TABLE IF NOT EXISTS "{table_name}" 
+        (page_content TEXT, doc_id UUID, source TEXT, images_gsurls JSONB, chunk_metadata JSONB, langchain_metadata JSONB)
+        '''
+        self.execute_sql(sql)
+
+        self.grant_table_permissions(table_name, users)
+
+    def create_vectorstore_table(self, vector_name: str, users):
+        from .database import get_vector_size
+        vector_size = get_vector_size(vector_name)
+        vectorstore_id = f"{vector_name}_{type}_{vector_size}"
+
+        sql = f'''
+        CREATE TABLE IF NOT EXISTS "{vectorstore_id}" (
+        langchain_id UUID NOT NULL,
+        content TEXT NOT NULL,
+        embedding vector NOT NULL,
+        source TEXT,
+        langchain_metadata JSONB,
+        docstore_doc_id UUID,
+        eventTime TIMESTAMPTZ
+        );
+        '''
+        self.execute_sql(sql)
+
+        self.grant_table_permissions(vectorstore_id, users)

sunholo/gcs/add_file.py

@@ -26,6 +26,10 @@ from ..utils.config import load_config_key
 
 
 def handle_base64_image(base64_data, vector_name):
+    model = load_config_key("llm", vector_name, "vacConfig")
+    if model.startswith("openai"): # pass it to gpt directly
+        return base64_data, base64_data.split(",",1)
+    
     try:
         header, encoded = base64_data.split(",", 1)
         data = base64.b64decode(encoded)

{sunholo-0.67.10.dist-info → sunholo-0.68.1.dist-info}/METADATA

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

{sunholo-0.67.10.dist-info → sunholo-0.68.1.dist-info}/RECORD

@@ -1,7 +1,7 @@
 sunholo/__init__.py,sha256=0CdpufyRKWyZe7J7UKigL6j_qOorM-p0OjHIAuf9M38,864
 sunholo/logging.py,sha256=00VGGArfWHbJuHHSJ4kXhHTggWnRfbVYMcZNOYIsqnA,11787
 sunholo/agents/__init__.py,sha256=Hb4NXy2rN-83Z0-UDRwX-LXv2R29lcbSFPf8G6q4fZg,380
-sunholo/agents/chat_history.py,sha256=bkII7PNEbGCaobu2Rnr2rM9dim3BCK0kM-tiWhoI1tw,5219
+sunholo/agents/chat_history.py,sha256=8iX1bgvRW6fdp6r_DQR_caPHYrZ_9QJJgPxCiSDf3q8,5380
 sunholo/agents/dispatch_to_qa.py,sha256=nFNdxhkr7rVYuUwVoBCBNYBI2Dke6-_z_ZApBEWb_cU,8291
 sunholo/agents/langserve.py,sha256=FdhQjorAY2bMn2rpuabNT6bU3uqSKWrl8DjpH3L_V7k,4375
 sunholo/agents/pubsub.py,sha256=5hbbhbBGyVWRpt2sAGC5FEheYH1mCCwVUhZEB1S7vGg,1337
@@ -13,7 +13,8 @@ sunholo/agents/fastapi/base.py,sha256=clk76cHbUAvU0OYJrRfCWX_5f0ACbhDsIzYBhI3wyo
 sunholo/agents/fastapi/qna_routes.py,sha256=DgK4Btu5XriOC1JaRQ4G_nWEjJfnQ0J5pyLanF6eF1g,3857
 sunholo/agents/flask/__init__.py,sha256=uqfHNw2Ru3EJ4dJEcbp86h_lkquBQPMxZbjhV_xe3rs,72
 sunholo/agents/flask/base.py,sha256=FgSaCODyoTtlstJtsqlLPScdgRUtv9_plxftdzHdVFo,809
-sunholo/agents/flask/qna_routes.py,sha256=tEsJRnnGoz_cOEaPtPpCCD920jZpLypLK58UzIxe1Ac,21659
+sunholo/agents/flask/qna_routes.py,sha256=oDZzI0FllRD5GZI_C8EbKvvBSrgRlvmpwQc7lp54Krs,21926
+sunholo/agents/flask/vac_routes.py,sha256=l2-w7x437F0Uu3QvwNueEYPtnKuIee6bHJ7LUMt_tkY,19520
 sunholo/archive/__init__.py,sha256=qNHWm5rGPVOlxZBZCpA1wTYPbalizRT7f8X4rs2t290,31
 sunholo/archive/archive.py,sha256=C-UhG5x-XtZ8VheQp92IYJqgD0V3NFQjniqlit94t18,1197
 sunholo/auth/__init__.py,sha256=4owDjSaWYkbTlPK47UHTOC0gCWbZsqn4ZIEw5NWZTlg,28
@@ -44,10 +45,11 @@ sunholo/cli/sun_rich.py,sha256=UpMqeJ0C8i0pkue1AHnnyyX0bFJ9zZeJ7HBR6yhuA8A,54
 sunholo/cli/swagger.py,sha256=absYKAU-7Yd2eiVNUY-g_WLl2zJfeRUNdWQ0oH8M_HM,1564
 sunholo/components/__init__.py,sha256=IDoylb74zFKo6NIS3RQqUl0PDFBGVxM1dfUmO7OJ44U,176
 sunholo/components/llm.py,sha256=T4we3tGmqUj4tPwxQr9M6AXv_BALqZV_dRSvINan-oU,10374
-sunholo/components/retriever.py,sha256=SKb19WxYSdOmy3hAnIai_UnSj-B-Q5S2s7g5xsTAq4g,6149
+sunholo/components/retriever.py,sha256=jltG91N5r2P9RWKPW8A8tU3ilghciBczxapauW83Ir8,6377
 sunholo/components/vectorstore.py,sha256=BxtMF_wX8Zrexr67P07OTSJPjucTewmcPM5OQwIXHPM,5630
 sunholo/database/__init__.py,sha256=Zz0Shcq-CtStf9rJGIYB_Ybzb8rY_Q9mfSj-nviM490,241
-sunholo/database/alloydb.py,sha256=UeWbk_DAqivquMGibX_tz8v1Jza9qnf4SWThNBG2Dh4,17327
+sunholo/database/alloydb.py,sha256=d9W0pbZB0jTVIGF5OVaQ6kXHo-X3-6e9NpWNmV5e9UY,10464
+sunholo/database/alloydb_client.py,sha256=AYA0SSaBy-1XEfeZI97sMGehfrwnfbwZ8sE0exzI2E0,7254
 sunholo/database/database.py,sha256=UDHkceiEvJmS3esQX2LYEjEMrHcogN_JHuJXoVWCH3M,7354
 sunholo/database/lancedb.py,sha256=2rAbJVusMrm5TPtVTsUtmwn0z1iZ_wvbKhc6eyT6ClE,708
 sunholo/database/static_dbs.py,sha256=aOyU3AJ-Dzz3qSNjbuN2293cfYw5PhkcQuQxdwPMJ4w,435
@@ -61,7 +63,7 @@ sunholo/database/sql/sb/setup.sql,sha256=CvoFvZQev2uWjmFa3aj3m3iuPFzAAJZ0S7Qi3L3
 sunholo/embedder/__init__.py,sha256=sI4N_CqgEVcrMDxXgxKp1FsfsB4FpjoXgPGkl4N_u4I,44
 sunholo/embedder/embed_chunk.py,sha256=P744zUQJgqrjILunzaqtTerB9AwoXFU6tXBtz4rjWgQ,6673
 sunholo/gcs/__init__.py,sha256=DtVw_AZwQn-IguR5BJuIi2XJeF_FQXizhJikzRNrXiE,50
-sunholo/gcs/add_file.py,sha256=ILU3Nq-rYjL0Ini9op6jBYtXCDl3iTO61ZA1q2zykJQ,5537
+sunholo/gcs/add_file.py,sha256=y2s7ZZBiJD3pu1TqRAy0s1SRGvHvzJqSDaYD-MFFh1c,5717
 sunholo/gcs/download_url.py,sha256=8XSEf8byfubqs5CMQeF_tn9wxqwUTq3n9mo5mLNIUTA,4801
 sunholo/gcs/metadata.py,sha256=C9sMPsHsq1ETetdQCqB3EBs3Kws8b8QHS9L7ei_v5aw,891
 sunholo/langfuse/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -105,9 +107,9 @@ sunholo/vertex/__init__.py,sha256=JvHcGFuv6R_nAhY2AdoqqhMpJ5ugeWPZ_svGhWrObBk,13
 sunholo/vertex/init.py,sha256=JDMUaBRdednzbKF-5p33qqLit2LMsvgvWW-NRz0AqO0,1801
 sunholo/vertex/memory_tools.py,sha256=8F1iTWnqEK9mX4W5RzCVKIjydIcNp6OFxjn_dtQ3GXo,5379
 sunholo/vertex/safety.py,sha256=3meAX0HyGZYrH7rXPUAHxtI_3w_zoy_RX7Shtkoa660,1275
-sunholo-0.67.10.dist-info/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
-sunholo-0.67.10.dist-info/METADATA,sha256=N4lheJkc7di64bOevGMEgiA2K5-1DdIxT1ZNx-ie38o,6157
-sunholo-0.67.10.dist-info/WHEEL,sha256=mguMlWGMX-VHnMpKOjjQidIo1ssRlCFu4a4mBpz1s2M,91
-sunholo-0.67.10.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
-sunholo-0.67.10.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
-sunholo-0.67.10.dist-info/RECORD,,
+sunholo-0.68.1.dist-info/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
+sunholo-0.68.1.dist-info/METADATA,sha256=q-b64zlvui5obJWngf1tAHgH56I3d9Hr_LgkOSNtbcE,6155
+sunholo-0.68.1.dist-info/WHEEL,sha256=mguMlWGMX-VHnMpKOjjQidIo1ssRlCFu4a4mBpz1s2M,91
+sunholo-0.68.1.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
+sunholo-0.68.1.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
+sunholo-0.68.1.dist-info/RECORD,,