sunholo 0.140.8__tar.gz → 0.140.10__tar.gz

{sunholo-0.140.8/src/sunholo.egg-info → sunholo-0.140.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sunholo
-Version: 0.140.8
+Version: 0.140.10
 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.140.8 → sunholo-0.140.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sunholo"
-version = "0.140.8"
+version = "0.140.10"
 description = "AI DevOps - a package to help deploy GenAI to the Cloud."
 readme = "README.md"
 requires-python = ">=3.10"

{sunholo-0.140.8 → sunholo-0.140.10}/src/sunholo/agents/flask/vac_routes.py

@@ -286,30 +286,20 @@ if __name__ == "__main__":
             log.warning(f"Background trace finalization failed: {e}")
 
     def handle_stream_vac(self, vector_name):
-        request_start = time.time()
         observed_stream_interpreter = self.stream_interpreter
         is_async = inspect.iscoroutinefunction(self.stream_interpreter)
 
         if is_async:
             log.info(f"Stream interpreter is async: {observed_stream_interpreter}")
 
-        # Call prep_vac and handle errors properly
-        try:
-            prep = self.prep_vac(request, vector_name)
-        except Exception as e:
-            log.error(f"prep_vac failed: {e}")
-            error_response = {'error': f'Prep error: {str(e)}'}
-            return jsonify(error_response), 500
-        
-        log.info(f"Processing prep completed in {time.time() - request_start:.3f}s")
-        
-        trace = prep.get("trace")
-        span = prep.get("span")
+        prep = self.prep_vac(request, vector_name)
+        log.info(f"Processing prep: {prep}")
+        trace = prep["trace"]
+        span = prep["span"]
         vac_config = prep["vac_config"]
         all_input = prep["all_input"]
 
-        log.info(f'Starting stream with: {all_input["user_input"][:100]}...')
-        
+        log.info(f'Streaming data with: {all_input}')
         if span:
             span.update(
                 name="start_streaming_chat",
@@ -320,7 +310,7 @@ if __name__ == "__main__":
         def generate_response_content():
             try:
                 if is_async:
-                    from queue import Queue
+                    from queue import Queue, Empty
                     result_queue = Queue()
                     import threading
 
@@ -337,7 +327,7 @@ if __name__ == "__main__":
                                     trace_id=trace.id if trace else None,
                                     **all_input["kwargs"]
                                 )
-                                
+                                log.info(f"{async_gen=}")
                                 async for chunk in async_gen:
                                     if isinstance(chunk, dict) and 'answer' in chunk:
                                         if trace:
@@ -350,12 +340,9 @@ if __name__ == "__main__":
                                     else:
                                         result_queue.put(chunk)
                             except Exception as e:
-                                error_msg = f"Streaming Error: {str(e)} {traceback.format_exc()}"
-                                log.error(error_msg)
-                                result_queue.put(error_msg)
+                                result_queue.put(f"Streaming Error: {str(e)} {traceback.format_exc()}")
                             finally:
                                 result_queue.put(None)  # Sentinel
-                        
                         asyncio.run(process_async())
 
                     thread = threading.Thread(target=run_async)
@@ -370,7 +357,7 @@ if __name__ == "__main__":
 
                     thread.join()
                 else:
-                    log.info("Starting sync streaming response")
+                    log.info("sync streaming response")
                     for chunk in start_streaming_chat(
                         question=all_input["user_input"],
                         vector_name=vector_name,
@@ -394,19 +381,17 @@ if __name__ == "__main__":
                             yield chunk
 
             except Exception as e:
-                error_msg = f"Streaming Error: {str(e)} {traceback.format_exc()}"
-                log.error(error_msg)
-                yield error_msg
+                yield f"Streaming Error: {str(e)} {traceback.format_exc()}"
 
-        # Create streaming response
+        # 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.info(f"Streaming response created in {time.time() - request_start:.3f}s")
-        
-        # Do final trace operations in background (don't block the response)
+        log.debug(f"streaming response: {response}")
         if trace:
-            _thread_pool.submit(self._finalize_trace_background, trace, span, response, all_input)
+            span.end(output=response)
+            trace.update(output=response)
+            self.langfuse_eval_response(trace_id=trace.id, eval_percent=all_input.get('eval_percent'))
 
         return response
 
@@ -780,14 +765,6 @@ if __name__ == "__main__":
         except Exception as e:
             raise ValueError(f"Unable to find vac_config for {vector_name} - {str(e)}")
 
-        # Initialize trace variables
-        trace = None
-        span = None
-        if self.add_langfuse_eval:
-            trace_id = data.get('trace_id')
-            # Create trace in background - don't block
-            trace_future = _thread_pool.submit(self._create_langfuse_trace_background, request, vector_name, trace_id)
-
         # Extract data (keep original logic)
         user_input = data.pop('user_input').strip()
         stream_wait_time = data.pop('stream_wait_time', 7)
@@ -811,7 +788,7 @@ if __name__ == "__main__":
             finally:
                 data.pop("_upload_future", None)
 
-        # Build final input
+        # BUILD all_input BEFORE trace creation (this was moved inside try/catch by mistake)
         all_input = {
             'user_input': user_input, 
             'vector_name': vector_name_param, 
@@ -822,8 +799,15 @@ if __name__ == "__main__":
             'kwargs': data
         }
 
-        # Try to get trace result if available (don't block long)
+        # Initialize trace variables
+        trace = None
+        span = None
         if self.add_langfuse_eval:
+            trace_id = data.get('trace_id')
+            # Create trace in background - don't block
+            trace_future = _thread_pool.submit(self._create_langfuse_trace_background, request, vector_name, trace_id)
+
+            # Try to get trace result if available (don't block long)
             try:
                 trace = trace_future.result(timeout=0.1)  # Very short timeout
                 if trace:
@@ -853,67 +837,6 @@ 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_cached(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:
             file.save(file.filename)

{sunholo-0.140.8 → sunholo-0.140.10/src/sunholo.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sunholo
-Version: 0.140.8
+Version: 0.140.10
 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