sunholo 0.139.1__py3-none-any.whl → 0.140.2__py3-none-any.whl

sunholo/agents/chat_history.py

@@ -1,6 +1,69 @@
 import json
 from ..custom_logging import log
 
+
+async def extract_chat_history_async(chat_history=None):
+    """
+    Extracts paired chat history between human and AI messages.
+    
+    For this lightweight processing, we use a simpler approach that minimizes overhead.
+    
+    Args:
+        chat_history (list): List of chat messages.
+    
+    Returns:
+        list: List of tuples with paired human and AI messages.
+    """
+    if not chat_history:
+        log.info("No chat history found")
+        return []
+
+    log.info(f"Extracting chat history: {chat_history}")
+    paired_messages = []
+    
+    # Handle special case of initial bot message
+    if chat_history and is_bot(chat_history[0]):
+        first_message = chat_history[0]
+        log.info(f"Extracting first_message: {first_message}")
+        blank_human_message = {"name": "Human", "content": "", "embeds": []}
+        
+        # Since create_message_element is so lightweight, we don't need async here
+        blank_element = create_message_element(blank_human_message)
+        bot_element = create_message_element(first_message)
+        
+        paired_messages.append((blank_element, bot_element))
+        chat_history = chat_history[1:]
+    
+    # Pre-process all messages in one batch (more efficient than one-by-one)
+    message_types = []
+    message_contents = []
+    
+    for message in chat_history:
+        is_human_msg = is_human(message)
+        is_bot_msg = is_bot(message)
+        
+        # Extract content for all messages at once
+        content = create_message_element(message)
+        
+        message_types.append((is_human_msg, is_bot_msg))
+        message_contents.append(content)
+    
+    # Pair messages efficiently
+    last_human_message = ""
+    for i, ((is_human_msg, is_bot_msg), content) in enumerate(zip(message_types, message_contents)):
+        if is_human_msg:
+            last_human_message = content
+            log.info(f"Extracted human message: {last_human_message}")
+        elif is_bot_msg:
+            ai_message = content
+            log.info(f"Extracted AI message: {ai_message}")
+            paired_messages.append((last_human_message, ai_message))
+            last_human_message = ""
+    
+    log.info(f"Paired messages: {paired_messages}")
+    return paired_messages
+
+
 def extract_chat_history(chat_history=None):
     """
     Extracts paired chat history between human and AI messages.

sunholo/agents/flask/vac_routes.py

@@ -8,6 +8,7 @@ import inspect
 import asyncio
 
 from ...agents import extract_chat_history, handle_special_commands
+from ..chat_history import extract_chat_history_async
 from ...qna.parsers import parse_output
 from ...streaming import start_streaming_chat, start_streaming_chat_async
 from ...archive import archive_qa
@@ -57,11 +58,12 @@ if __name__ == "__main__":
 ```
     
     """
-    def __init__(self, app, stream_interpreter, vac_interpreter=None, additional_routes=None):
+    def __init__(self, app, stream_interpreter: callable, vac_interpreter:callable=None, additional_routes:dict=None, async_stream:bool=False):
         self.app = app
         self.stream_interpreter = stream_interpreter
         self.vac_interpreter = vac_interpreter or partial(self.vac_interpreter_default)
         self.additional_routes = additional_routes if additional_routes is not None else []
+        self.async_stream = async_stream
         self.register_routes()
         
 
@@ -99,7 +101,15 @@ if __name__ == "__main__":
         self.app.route('/vac/streaming/<vector_name>', 
                        methods=['POST'], 
                        provide_automatic_options=False)(self.handle_stream_vac)
-
+        
+        if self.async_stream:  # Use async treatment
+            self.app.route('/vac/streaming/<vector_name>', 
+                        methods=['POST'], 
+                        provide_automatic_options=False)(self.handle_stream_vac_async)
+        else:
+            self.app.route('/vac/streaming/<vector_name>', 
+                        methods=['POST'], 
+                        provide_automatic_options=False)(self.handle_stream_vac)
         # Static VAC
         self.app.route('/vac/<vector_name>', 
                        methods=['POST'], 
@@ -332,6 +342,51 @@ if __name__ == "__main__":
 
         return response
 
+    async def handle_stream_vac_async(self, vector_name):
+        observed_stream_interpreter = self.stream_interpreter
+        is_async = inspect.iscoroutinefunction(self.stream_interpreter)
+
+        if not is_async:
+            raise ValueError(f"Stream interpreter must be async: {observed_stream_interpreter}")
+
+        # Use the async version of prep_vac
+        prep = await self.prep_vac_async(request, vector_name)
+        log.info(f"Processing prep: {prep}")
+        all_input = prep["all_input"]
+
+        log.info(f'Streaming data with: {all_input}')
+
+        async def generate_response_content():
+            try:
+                # Direct async handling without the queue/thread approach
+                async_gen = start_streaming_chat_async(
+                    question=all_input["user_input"],
+                    vector_name=vector_name,
+                    qna_func_async=observed_stream_interpreter,
+                    chat_history=all_input["chat_history"],
+                    wait_time=all_input["stream_wait_time"],
+                    timeout=all_input["stream_timeout"],
+                    **all_input["kwargs"]
+                )
+                
+                log.info(f"{async_gen=}")
+                async for chunk in async_gen:
+                    if isinstance(chunk, dict) and 'answer' in chunk:
+                        await archive_qa(chunk, vector_name)
+                        yield json.dumps(chunk)
+                    else:
+                        yield chunk
+
+            except Exception as e:
+                yield f"Streaming Error: {str(e)} {traceback.format_exc()}"
+
+        response = Response(generate_response_content(), content_type='text/plain; charset=utf-8')
+        response.headers['Transfer-Encoding'] = 'chunked'
+
+        log.debug(f"streaming response: {response}")
+
+        return response
+
     @staticmethod
     async def _async_generator_to_stream(async_gen_func):
         """Helper function to stream the async generator's values to the client."""
@@ -699,6 +754,66 @@ if __name__ == "__main__":
             "vac_config": vac_config
         }
 
+    async def prep_vac_async(self, request, vector_name):
+        """Async version of prep_vac."""
+        # Parse request data
+        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:
+                        # Make file upload async if possible
+                        image_uri, mime_type = await self.handle_file_upload_async(file, vector_name)
+                        data["image_uri"] = image_uri
+                        data["mime"] = mime_type
+                    except Exception as e:
+                        log.error(traceback.format_exc())
+                        return jsonify({'error': str(e), 'traceback': traceback.format_exc()}), 500
+                else:
+                    log.error("No file selected")
+                    return jsonify({"error": "No file selected"}), 400
+        else:
+            return jsonify({"error": "Unsupported content type"}), 400
+
+        log.info(f"vac/{vector_name} got data: {data}")
+
+        # Run these operations concurrently
+        tasks = []
+        
+        # Extract other data while configs load
+        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_param = data.pop('vector_name', vector_name)
+        data.pop('trace_id', None)  # to ensure not in kwargs
+        
+        # Task 3: Process chat history
+        chat_history_task = asyncio.create_task(extract_chat_history_async(chat_history))
+        tasks.append(chat_history_task)
+        
+        # Await all tasks concurrently
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+
+        paired_messages = results[0] if not isinstance(results[0], Exception) else []
+        
+        # Only create span after we have trace
+        all_input = {
+            'user_input': user_input, 
+            'vector_name': vector_name_param, 
+            'chat_history': paired_messages, 
+            'stream_wait_time': stream_wait_time,
+            'stream_timeout': stream_timeout,
+            'kwargs': data
+        }
+        
+        return {
+            "all_input": all_input
+        }
 
     def handle_file_upload(self, file, vector_name):
         try:

{sunholo-0.139.1.dist-info → sunholo-0.140.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sunholo
-Version: 0.139.1
+Version: 0.140.2
 Summary: AI DevOps - a package to help deploy GenAI to the Cloud.
 Author-email: Holosun ApS <multivac@sunholo.com>
 License: Apache License, Version 2.0

{sunholo-0.139.1.dist-info → sunholo-0.140.2.dist-info}/RECORD

@@ -2,7 +2,7 @@ sunholo/__init__.py,sha256=InRbX4V0-qdNHo9zYH3GEye7ASLR6LX8-SMvPV4Jsaw,1212
 sunholo/custom_logging.py,sha256=JXZTnXp_DixP3jwYfKw4LYRDS9IuTq7ctCgfZbI2rxA,22023
 sunholo/langchain_types.py,sha256=uZ4zvgej_f7pLqjtu4YP7qMC_eZD5ym_5x4pyvA1Ih4,1834
 sunholo/agents/__init__.py,sha256=X2I3pPkGeKWjc3d0QgSpkTyqD8J8JtrEWqwrumf1MMc,391
-sunholo/agents/chat_history.py,sha256=Gph_CdlP2otYnNdR1q1Umyyyvcad2F6K3LxU5yBQ9l0,5387
+sunholo/agents/chat_history.py,sha256=4jGCHBP8dZfUjSJPxgKyh6nOqhnHRn1x9U3CnGb0I5E,7624
 sunholo/agents/dispatch_to_qa.py,sha256=NHihwAoCJ5_Lk11e_jZnucVUGQyZHCB-YpkfMHBCpQk,8882
 sunholo/agents/langserve.py,sha256=C46ph2mnygr6bdHijYWYyfQDI9ylAF0_9Kx2PfcCJpU,4414
 sunholo/agents/pubsub.py,sha256=TscZN_6am6DfaQkC-Yl18ZIBOoLE-0nDSiil6GpQEh4,1344
@@ -15,7 +15,7 @@ sunholo/agents/fastapi/qna_routes.py,sha256=lKHkXPmwltu9EH3RMwmD153-J6pE7kWQ4BhB
 sunholo/agents/flask/__init__.py,sha256=poJDKMr2qj8qMb99JqCvCPSiEt1tj2tLQ3hKW3f2aVw,107
 sunholo/agents/flask/base.py,sha256=HLz3Z5efWaewTwSFEM6JH48NA9otoJBoVFJlARGk9L8,788
 sunholo/agents/flask/qna_routes.py,sha256=uwUD1yrzOPH27m2AXpiQrPk_2VfJOQOM6dAynOWQtoQ,22532
-sunholo/agents/flask/vac_routes.py,sha256=9bytTeoOJQOYxsPGLIXLItDmnbB9zDXmYM0lBIwDe8w,28335
+sunholo/agents/flask/vac_routes.py,sha256=RprhFJje5gTNU3ePGbCCPdBAdYs417VyXNlGe5UlR-g,33370
 sunholo/archive/__init__.py,sha256=qNHWm5rGPVOlxZBZCpA1wTYPbalizRT7f8X4rs2t290,31
 sunholo/archive/archive.py,sha256=PxVfDtO2_2ZEEbnhXSCbXLdeoHoQVImo4y3Jr2XkCFY,1204
 sunholo/auth/__init__.py,sha256=TeP-OY0XGxYV_8AQcVGoh35bvyWhNUcMRfhuD5l44Sk,91
@@ -169,9 +169,9 @@ sunholo/vertex/init.py,sha256=1OQwcPBKZYBTDPdyU7IM4X4OmiXLdsNV30C-fee2scQ,2875
 sunholo/vertex/memory_tools.py,sha256=tBZxqVZ4InTmdBvLlOYwoSEWu4-kGquc-gxDwZCC4FA,7667
 sunholo/vertex/safety.py,sha256=S9PgQT1O_BQAkcqauWncRJaydiP8Q_Jzmu9gxYfy1VA,2482
 sunholo/vertex/type_dict_to_json.py,sha256=uTzL4o9tJRao4u-gJOFcACgWGkBOtqACmb6ihvCErL8,4694
-sunholo-0.139.1.dist-info/licenses/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
-sunholo-0.139.1.dist-info/METADATA,sha256=vOG7X6ZpBgF3og9_BNDil-Loy2tAW38orcqYo3ObTTk,10067
-sunholo-0.139.1.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
-sunholo-0.139.1.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
-sunholo-0.139.1.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
-sunholo-0.139.1.dist-info/RECORD,,
+sunholo-0.140.2.dist-info/licenses/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
+sunholo-0.140.2.dist-info/METADATA,sha256=nMq7_Z9VKq4kPXXTvyeirWinNf5tEMmUe0HnIiFhYAc,10067
+sunholo-0.140.2.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+sunholo-0.140.2.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
+sunholo-0.140.2.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
+sunholo-0.140.2.dist-info/RECORD,,

{sunholo-0.139.1.dist-info → sunholo-0.140.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.4.0)
+Generator: setuptools (80.7.1)
 Root-Is-Purelib: true
 Tag: py3-none-any