sunholo 0.94.0__py3-none-any.whl → 0.95.0__py3-none-any.whl

sunholo/agents/flask/vac_routes.py

@@ -4,10 +4,12 @@ import datetime
 import uuid
 import random
 from functools import partial
+import inspect
+import asyncio
 
 from ...agents import extract_chat_history, handle_special_commands
 from ...qna.parsers import parse_output
-from ...streaming import start_streaming_chat
+from ...streaming import start_streaming_chat, start_streaming_chat_async
 from ...archive import archive_qa
 from ...custom_logging import log
 from ...utils import ConfigManager
@@ -183,10 +185,16 @@ if __name__ == "__main__":
 
         log.info(f"OpenAI response: {openai_response}")
         return jsonify(openai_response)
-
-
+    
     def handle_stream_vac(self, vector_name):
         observed_stream_interpreter = self.stream_interpreter
+
+        # Determine if the stream interpreter is async or sync
+        is_async = inspect.iscoroutinefunction(self.stream_interpreter)
+
+        if is_async:
+            log.info(f"Stream interpreter is async: {observed_stream_interpreter}")
+
         prep = self.prep_vac(request, vector_name)
         log.info(f"Processing prep: {prep}")
         trace = prep["trace"]
@@ -203,41 +211,88 @@ if __name__ == "__main__":
             generation = span.generation(
                 name="start_streaming_chat",
                 metadata=vac_config.configs_by_kind,
-                input = all_input,
+                input=all_input,
                 completion_start_time=str(int(datetime.datetime.now().timestamp())),
                 model=vac_config.vacConfig("model") or vac_config.vacConfig("llm")
             )
 
         def generate_response_content():
+            try:
+                if is_async:
+                    # Run the async version
+                    async def process_async():
+                        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"],
+                            trace_id=trace.id if trace else None,
+                            **all_input["kwargs"]
+                        )
+                        log.info(f"{async_gen=}")
+                        # Yield intermediate results as they become available
+                        async for chunk in async_gen:
+                            if isinstance(chunk, dict) and 'answer' in chunk:
+                                if trace:
+                                    chunk["trace_id"] = trace.id
+                                    chunk["trace_url"] = trace.get_trace_url()
+                                    generation.end(output=json.dumps(chunk))
+                                    span.end(output=json.dumps(chunk))
+                                    trace.update(output=json.dumps(chunk))
+                                
+                                archive_qa(chunk, vector_name)
+                                
+                                yield json.dumps(chunk)
+                            else:
+                                yield chunk
+
+                    try:
+                        loop = asyncio.get_running_loop()
+                        # Use the event loop to consume the async generator and yield results
+                        return [chunk for chunk in loop.run_until_complete(self._async_generator_to_list(process_async()))]
+                    except RuntimeError:
+                        # No running event loop, create a new one
+                        log.info("Creating new event loop")
+                        loop = asyncio.new_event_loop()
+                        asyncio.set_event_loop(loop)
+                        try:
+                            log.info(f"Run until complete loop for {process_async}")
+                            chunks = loop.run_until_complete(self._async_generator_to_list(process_async()))
+                            for chunk in chunks:
+                                yield chunk
+                        finally:
+                            loop.close()
 
-            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"],
-                                              trace_id=trace.id if trace else None,
-                                              #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_id"] = 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
-        
+                    log.info("sync streaming response")
+                    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"],
+                        trace_id=trace.id if trace else None,
+                        **all_input["kwargs"]
+                    ):
+                        if isinstance(chunk, dict) and 'answer' in chunk:
+                            if trace:
+                                chunk["trace_id"] = 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:
+                            yield chunk
+
+            except Exception as e:
+                yield f"Streaming Error: {str(e)} {traceback.format_exc()}"
+            
         # 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'  
@@ -250,6 +305,14 @@ if __name__ == "__main__":
             self.langfuse_eval_response(trace_id=trace.id, eval_percent=all_input.get('eval_percent'))
 
         return response
+
+    @staticmethod
+    async def _async_generator_to_list(async_gen):
+        """Helper function to collect an async generator's values into a list."""
+        result = []
+        async for item in async_gen:
+            result.append(item)
+        return result
     
     def langfuse_eval_response(self, trace_id, eval_percent=0.01):
         """
@@ -282,6 +345,7 @@ if __name__ == "__main__":
             log.info(f"Did not do Langfuse eval due to random sampling not passed: {eval_percent=}")
 
     def handle_process_vac(self, vector_name):
+        #TODO: handle async
         observed_vac_interpreter = self.vac_interpreter
         prep = self.prep_vac(request, vector_name)
         log.debug(f"Processing prep: {prep}")

sunholo/invoke/__init__.py

@@ -1,2 +1,3 @@
 from .invoke_vac_utils import invoke_vac
-from .direct_vac_func import direct_vac, direct_vac_stream
+from .direct_vac_func import direct_vac, direct_vac_stream
+from .async_class import AsyncTaskRunner

sunholo/invoke/async_class.py

@@ -1,142 +1,72 @@
 import asyncio
 import logging
-from typing import Callable, List, Any, Coroutine, Tuple
+import traceback
+from typing import Callable, List, Any, AsyncGenerator, Dict
+from tenacity import AsyncRetrying, retry_if_exception_type, wait_random_exponential, stop_after_attempt
 
-# Setup basic logging configuration
-logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 class AsyncTaskRunner:
-    """
-    Example async functions for testing
-    ```python
-    async def api_call_1(url, params):
-        await asyncio.sleep(1)
-        if "fail" in params:
-            raise ValueError(f"Error in api_call_1 with params: {params}")
-        return f"api_call_1 response from {url} with params {params}"
-
-    async def api_call_2(url, params):
-        await asyncio.sleep(2)
-        if "fail" in params:
-            raise ValueError(f"Error in api_call_2 with params: {params}")
-        return f"api_call_2 response from {url} with params {params}"
-
-    # Example usage in an existing async function
-    async def example_usage():
-        runner = AsyncTaskRunner()
-
-        runner.add_task(api_call_1, "http://example.com", {"key": "value"})
-        runner.add_task(api_call_2, "http://example.org", {"key": "fail"})
-
-        # Run all tasks within the existing event loop
-        results = await runner.run_async()
-        for result in results:
-            print(result)
-
-    # Example of calling run_sync() in a synchronous context
-    if __name__ == "__main__":
-        runner = AsyncTaskRunner()
-
-        runner.add_task(api_call_1, "http://example.com", {"key": "value"})
-        runner.add_task(api_call_2, "http://example.org", {"key": "fail"})
-
-        # Running in a synchronous context
-        results = runner.run_sync()
-        for result in results:
-            print(result)
-    ```
-
-    Example streaming fast and slow
-    
-    ```python
-    import asyncio
-    from typing import AsyncGenerator
-
-    # Example streaming function that simulates yielding chunks of data
-    async def stream_chunks(url: str, params: dict) -> AsyncGenerator[str, None]:
-        # Simulate streaming with a series of chunks
-        for i in range(5):
-            await asyncio.sleep(1)  # Simulate delay between chunks
-            yield f"Chunk {i+1} from {url} with params {params}"
-
-    # Example slow API call function
-    async def slow_api_call(url: str, params: dict) -> str:
-        await asyncio.sleep(5)  # Simulate a slow API response
-        return f"Slow API response from {url} with params {params}"
-
-    # Function to manage streaming and slow API call
-    async def process_api_calls(stream_url: str, stream_params: dict, slow_url: str, slow_params: dict) -> AsyncGenerator[str, None]:
-        # Create the AsyncTaskRunner instance
-        runner = AsyncTaskRunner()
-
-        # Add the slow API call as a task
-        runner.add_task(slow_api_call, slow_url, slow_params)
-
-        # Run the slow API call concurrently with the streaming
-        slow_api_result_task = asyncio.create_task(runner.run_async())
-
-        # Process the streaming chunks and yield them
-        async for chunk in stream_chunks(stream_url, stream_params):
-            yield chunk
-
-        # Wait for the slow API call to complete and get the result
-        slow_api_results = await slow_api_result_task
-
-        # Yield the slow API response after streaming is finished
-        for result in slow_api_results:
-            yield result
-
-    # Example usage in an existing async function
-    async def example_usage():
-        # Define the URLs and parameters for the calls
-        stream_url = "http://streaming.example.com"
-        stream_params = {"key": "stream_value"}
-        slow_url = "http://slowapi.example.com"
-        slow_params = {"key": "slow_value"}
-
-        # Process the API calls and stream the results
-        async for output in process_api_calls(stream_url, stream_params, slow_url, slow_params):
-            print(output)
-
-    # Running the example usage
-    if __name__ == "__main__":
-        asyncio.run(example_usage())
-    ```
-    """
-    def __init__(self):
+    def __init__(self, retry_enabled=False, retry_kwargs=None):
         self.tasks = []
-
-    def add_task(self, func: Callable[..., Coroutine], *args: Any):
-        """Adds a task (function and its arguments) to the list of tasks to be executed."""
+        self.retry_enabled = retry_enabled
+        self.retry_kwargs = retry_kwargs or {}
+    
+    def add_task(self, func: Callable[..., Any], *args: Any):
+        """Adds a task to the list of tasks to be executed."""
         logger.info(f"Adding task: {func.__name__} with args: {args}")
-        self.tasks.append(func(*args))
-
-    def add_group(self, functions: List[Callable[..., Coroutine]], *args: Any):
-        """Adds a group of functions that should run in parallel with the same arguments."""
-        group_tasks = [func(*args) for func in functions]
-        logger.info(f"Adding group of tasks with args: {args}")
-        self.tasks.append(asyncio.gather(*group_tasks, return_exceptions=True))
-
-    async def run_async(self) -> List[Any]:
-        """Runs all tasks using the current event loop and returns the results."""
-        logger.info("Running tasks asynchronously")
-        results = await asyncio.gather(*self.tasks, return_exceptions=True)
-        self._log_results(results)
-        return results
-
-    def run_sync(self) -> List[Any]:
-        """Runs all tasks synchronously (blocking) using a new event loop and returns the results."""
-        try:
-            logger.info("Running tasks synchronously")
-            loop = asyncio.get_running_loop()
-            return loop.run_until_complete(self.run_async())
-        except RuntimeError:
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-            results = loop.run_until_complete(self.run_async())
-            loop.close()
-            return results
+        self.tasks.append((func.__name__, func, args))
+    
+    async def run_async_as_completed(self) -> AsyncGenerator[Dict[str, Any], None]:
+        """Runs all tasks concurrently and yields results as they complete."""
+        logger.info("Running tasks asynchronously and yielding results as they complete")
+        tasks = {}
+        for name, func, args in self.tasks:
+            coro = self._task_wrapper(name, func, args)
+            task = asyncio.create_task(coro)
+            tasks[task] = name
+        
+        while tasks:
+            done, _ = await asyncio.wait(tasks.keys(), return_when=asyncio.FIRST_COMPLETED)
+            for task in done:
+                name = tasks.pop(task)
+                try:
+                    result = await task
+                    yield {name: result}
+                except Exception as e:
+                    logger.error(f"Task {name} resulted in an error: {e}\n{traceback.format_exc()}")
+                    yield {name: e}
+    
+    async def _task_wrapper(self, name: str, func: Callable[..., Any], args: Any) -> Any:
+        """Wraps the task function to process its output and handle retries."""
+        async def run_func():
+            gen = func(*args)
+            if hasattr(gen, '__aiter__'):
+                # If it's an async generator, consume it completely
+                output = ''
+                async for chunk in gen:
+                    output += chunk
+                return output
+            else:
+                # If it's a coroutine, await the result
+                return await gen
+
+        if self.retry_enabled:
+            retry_kwargs = {
+                'wait': wait_random_exponential(multiplier=1, max=60),
+                'stop': stop_after_attempt(5),
+                'retry': retry_if_exception_type(Exception),
+                **self.retry_kwargs
+            }
+            async for attempt in AsyncRetrying(**retry_kwargs):
+                with attempt:
+                    return await run_func()
+        else:
+            try:
+                return await run_func()
+            except Exception as e:
+                logger.error(f"Error in task {name}: {e}\n{traceback.format_exc()}")
+                raise
 
     def _log_results(self, results: List[Any]):
         """Logs the results of the task executions."""
@@ -144,5 +74,4 @@ class AsyncTaskRunner:
             if isinstance(result, Exception):
                 logger.error(f"Task resulted in an error: {result}")
             else:
-                logger.info(f"Task completed successfully: {result}")
-
+                logger.info(f"Task completed successfully: {result}")

sunholo/qna/parsers.py

@@ -54,7 +54,7 @@ def parse_output(bot_output):
     
     elif isinstance(bot_output, dict):
         if not bot_output.get("answer"):
-            raise ValueError(f"VAC output was not a string or a dict with the key 'answer' - got: {bot_output}")
+            raise ValueError(f"VAC output was not a string or a dict with the key 'answer' - got: {bot_output} {type(bot_output)}")
         else:
 
             return bot_output

sunholo/streaming/streaming.py

@@ -107,7 +107,7 @@ def start_streaming_chat(question,
     # parses out source_documents if not present etc.
     yield parse_output(final_result)
 
-async def start_streaming_chat_async(question, vector_name, qna_func, chat_history=[], wait_time=2, timeout=120, **kwargs): 
+async def start_streaming_chat_async(question, vector_name, qna_func_async, chat_history=[], wait_time=2, timeout=120, **kwargs): 
     """
     Asynchronously initiates a chat session that streams responses back to the caller in real-time. 
     This function manages the chat by starting a separate thread to handle the chat interaction, 
@@ -116,7 +116,7 @@ async def start_streaming_chat_async(question, vector_name, qna_func, chat_histo
     Parameters:
     - question (str): The initial question to start the chat with.
     - vector_name (str): The vector configuration that determines the behavior of the AI in the chat.
-    - qna_func (callable): The function that processes the chat and generates responses.
+    - qna_func_async (callable): The async function that processes the chat and generates responses.
     - chat_history (list, optional): A list of previous messages in the chat session to maintain context.
     - wait_time (int, optional): The interval in seconds between checking for new chat responses.
     - timeout (int, optional): The maximum time in seconds to wait for a new response before timing out.
@@ -154,9 +154,9 @@ async def start_streaming_chat_async(question, vector_name, qna_func, chat_histo
     The `start_streaming_chat_async` function is used in a coroutine that prints messages as they are generated.
     """
     
-    log.info(f"Streaming chat with wait time {wait_time} seconds and timeout {timeout} seconds and kwargs {kwargs}")
-    if not check_kwargs_support(qna_func):
-        yield "No **kwargs in qna_func - please add it"
+    log.info(f"Async Streaming chat with wait time {wait_time} seconds and timeout {timeout} seconds and kwargs {kwargs}")
+    if not check_kwargs_support(qna_func_async):
+        yield "No **kwargs in qna_func_async - please add it"
         
     content_buffer = ContentBuffer()
     chat_callback_handler = BufferStreamingStdOutCallbackHandler(content_buffer=content_buffer, tokens=".!?\n")
@@ -165,21 +165,21 @@ async def start_streaming_chat_async(question, vector_name, qna_func, chat_histo
     exception_queue = Queue()
     stop_event = Event()
 
-    def start_chat():
+    async def start_chat():
         try:
-            final_result = qna_func(question, vector_name, chat_history, callback=chat_callback_handler, **kwargs)
+            final_result = await qna_func_async(question, vector_name, chat_history, callback=chat_callback_handler, **kwargs)
             result_queue.put(final_result)
         except Exception as e:
             exception_queue.put(e)
 
-    chat_thread = Thread(target=start_chat)
-    chat_thread.start()
+    # Run start_chat asynchronously
+    chat_task = asyncio.create_task(start_chat())
 
     start = time.time()
 
     while not chat_callback_handler.stream_finished.is_set() and not stop_event.is_set():
         await asyncio.sleep(wait_time)  # Use asyncio.sleep for async compatibility
-        log.info(f"heartbeat - {round(time.time() - start, 2)} seconds")
+        log.info(f"async heartbeat - {round(time.time() - start, 2)} seconds")
         
         while not exception_queue.empty():
             exception = exception_queue.get_nowait()
@@ -197,15 +197,14 @@ async def start_streaming_chat_async(question, vector_name, qna_func, chat_histo
                 break
 
     stop_event.set()
-    chat_thread.join()
+    await chat_task  # Ensure the async task is awaited
 
     # Handle final result
     if not result_queue.empty():
         final_result = result_queue.get()
-        # Ensure parse_output is called outside of the async generator context if needed
-        parsed_final_result = parse_output(final_result)  # Assuming parse_output can handle final_result structure
-        if 'answer' in parsed_final_result:  # Yield final structured result if needed
-            yield f"###JSON_START###{json.dumps(parsed_final_result)}###JSON_END###"
+        parsed_final_result = parse_output(final_result)
+        if 'answer' in parsed_final_result:
+            yield json.dumps(parsed_final_result)
 
 
 

{sunholo-0.94.0.dist-info → sunholo-0.95.0.dist-info}/METADATA

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: sunholo
-Version: 0.94.0
+Version: 0.95.0
 Summary: Large Language Model DevOps - a package to help deploy LLMs to the Cloud.
 Home-page: https://github.com/sunholo-data/sunholo-py
-Download-URL: https://github.com/sunholo-data/sunholo-py/archive/refs/tags/v0.94.0.tar.gz
+Download-URL: https://github.com/sunholo-data/sunholo-py/archive/refs/tags/v0.95.0.tar.gz
 Author: Holosun ApS
 Author-email: multivac@sunholo.com
 License: Apache License, Version 2.0
@@ -72,6 +72,7 @@ Requires-Dist: rich ; extra == 'all'
 Requires-Dist: supabase ; extra == 'all'
 Requires-Dist: tabulate ; extra == 'all'
 Requires-Dist: tantivy ; extra == 'all'
+Requires-Dist: tenacity ; extra == 'all'
 Requires-Dist: tiktoken ; extra == 'all'
 Requires-Dist: unstructured[local-inference] ==0.14.9 ; extra == 'all'
 Requires-Dist: xlwings ; extra == 'all'
@@ -124,6 +125,7 @@ Requires-Dist: httpx ; extra == 'http'
 Requires-Dist: langfuse ; extra == 'http'
 Requires-Dist: python-socketio ; extra == 'http'
 Requires-Dist: requests ; extra == 'http'
+Requires-Dist: tenacity ; extra == 'http'
 Provides-Extra: iac
 Requires-Dist: python-hcl2 ; extra == 'iac'
 Provides-Extra: openai

{sunholo-0.94.0.dist-info → sunholo-0.95.0.dist-info}/RECORD

@@ -14,7 +14,7 @@ sunholo/agents/fastapi/qna_routes.py,sha256=lKHkXPmwltu9EH3RMwmD153-J6pE7kWQ4BhB
 sunholo/agents/flask/__init__.py,sha256=poJDKMr2qj8qMb99JqCvCPSiEt1tj2tLQ3hKW3f2aVw,107
 sunholo/agents/flask/base.py,sha256=FgSaCODyoTtlstJtsqlLPScdgRUtv9_plxftdzHdVFo,809
 sunholo/agents/flask/qna_routes.py,sha256=uwUD1yrzOPH27m2AXpiQrPk_2VfJOQOM6dAynOWQtoQ,22532
-sunholo/agents/flask/vac_routes.py,sha256=wMH0a53BFrBnksi4F34pEGJIJgRImxndPeMWGAjUQZw,24179
+sunholo/agents/flask/vac_routes.py,sha256=6Z8Eqt1SgfcmUf5V-7O3vYSXnGCBWQKWBUPj-NwX1RU,27269
 sunholo/archive/__init__.py,sha256=qNHWm5rGPVOlxZBZCpA1wTYPbalizRT7f8X4rs2t290,31
 sunholo/archive/archive.py,sha256=PxVfDtO2_2ZEEbnhXSCbXLdeoHoQVImo4y3Jr2XkCFY,1204
 sunholo/auth/__init__.py,sha256=TeP-OY0XGxYV_8AQcVGoh35bvyWhNUcMRfhuD5l44Sk,91
@@ -88,8 +88,8 @@ sunholo/genai/__init__.py,sha256=dBl6IA3-Fx6-Vx81r0XqxHlUq6WeW1iDX188dpChu8s,115
 sunholo/genai/init.py,sha256=yG8E67TduFCTQPELo83OJuWfjwTnGZsyACospahyEaY,687
 sunholo/genai/process_funcs_cls.py,sha256=1yDVh7Gi5qX0FMzV__8k3vn3BJ7AreX9CvPxM_QPFkU,24235
 sunholo/genai/safety.py,sha256=mkFDO_BeEgiKjQd9o2I4UxB6XI7a9U-oOFjZ8LGRUC4,1238
-sunholo/invoke/__init__.py,sha256=bELcqIjzKvaupcIN5OQmDgGx_8jARtH9T6PCe8UgcvE,99
-sunholo/invoke/async_class.py,sha256=vmLT6DqE1YaPd4W88_QzPQvSzsjwLUAwt23vGZm-BEs,5767
+sunholo/invoke/__init__.py,sha256=VOpsfhNf98az3at7bMaY1Fiw4UIZAS6zMmSqWd6_ksI,141
+sunholo/invoke/async_class.py,sha256=3QR_hFxyEEkksbXmXziDuC__dg4XWNghuw2ZUAPpQ3Q,3195
 sunholo/invoke/direct_vac_func.py,sha256=fuTJlH5PsqWhN_yVMaWisHCTZU1JEUz8I8yVbWsNUFE,4268
 sunholo/invoke/invoke_vac_utils.py,sha256=sJc1edHTHMzMGXjji1N67c3iUaP7BmAL5nj82Qof63M,2053
 sunholo/langfuse/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -111,13 +111,13 @@ sunholo/pubsub/__init__.py,sha256=DfTEk4zmCfqn6gFxRrqDO0pOrvXTDqH-medpgYO4PGw,11
 sunholo/pubsub/process_pubsub.py,sha256=rN2N4WM6PZkMKDrdT8pnEfTvsXACRyJFqIHJQCbuxLs,3088
 sunholo/pubsub/pubsub_manager.py,sha256=19w_N0LiG-wgVWvgJ13b8BUeN8ZzgSPXAhPmL1HRRSI,6966
 sunholo/qna/__init__.py,sha256=F8q1uR_HreoSX0IfmKY1qoSwIgXhO2Q8kuDSxh9_-EE,28
-sunholo/qna/parsers.py,sha256=or5BQ0M-bvYvozJ_ui_4OlRqDaihuLHr2AC_QxUvvPw,2475
+sunholo/qna/parsers.py,sha256=YpOaK5S_LxJ6FbliSYDc3AVOJ62RVduayoNnzi_p8CM,2494
 sunholo/qna/retry.py,sha256=yMw7RTkw-RXCzfENPJOt8c32mXlpvOR589EGkvK-6yI,2028
 sunholo/streaming/__init__.py,sha256=MpbydI2UYo_adttPQFkxNM33b-QRyNEbrKJx0C2AGPc,241
 sunholo/streaming/content_buffer.py,sha256=A9rVhlmLZxaFPvGYjVqCs5GfIsA1EMl_tyk-0VCDvo4,6462
 sunholo/streaming/langserve.py,sha256=hi7q8WY8DPKrALl9m_dOMxWOdE-iEuk7YW05SVDFIX8,6514
 sunholo/streaming/stream_lookup.py,sha256=hYg1DbdSE_QNJ8ZB-ynXJlWgvFjrGvwoUsGJu_E0pRQ,360
-sunholo/streaming/streaming.py,sha256=TNnjlMH4tC4vDqLICyeLCj2tj9EcTLLvyH6zDSpsxh4,16326
+sunholo/streaming/streaming.py,sha256=tMCAdB_piQXiiQLPkkYJwDiDxfg6UOBeto0d9C8m_Jk,16211
 sunholo/summarise/__init__.py,sha256=MZk3dblUMODcPb1crq4v-Z508NrFIpkSWNf9FIO8BcU,38
 sunholo/summarise/summarise.py,sha256=95A-6PXFGanjona8DvZPnnIHLbzZ2ip5hO0wOAJQhfw,3791
 sunholo/terraform/__init__.py,sha256=yixxEltc3n9UpZaVi05GlgS-YRq_DVGjUc37I9ajeP4,76
@@ -144,9 +144,9 @@ sunholo/vertex/init.py,sha256=1OQwcPBKZYBTDPdyU7IM4X4OmiXLdsNV30C-fee2scQ,2875
 sunholo/vertex/memory_tools.py,sha256=q_phxgGX2TG2j2MXNULF2xGzQnQPENwjPN9nZ_A9Gh0,7526
 sunholo/vertex/safety.py,sha256=S9PgQT1O_BQAkcqauWncRJaydiP8Q_Jzmu9gxYfy1VA,2482
 sunholo/vertex/type_dict_to_json.py,sha256=uTzL4o9tJRao4u-gJOFcACgWGkBOtqACmb6ihvCErL8,4694
-sunholo-0.94.0.dist-info/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
-sunholo-0.94.0.dist-info/METADATA,sha256=WzxVoYlzQITMFyMSG8aGXvkAaIoE2XVwOzXgkLZDZPM,7806
-sunholo-0.94.0.dist-info/WHEEL,sha256=cVxcB9AmuTcXqmwrtPhNK88dr7IR_b6qagTj0UvIEbY,91
-sunholo-0.94.0.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
-sunholo-0.94.0.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
-sunholo-0.94.0.dist-info/RECORD,,
+sunholo-0.95.0.dist-info/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
+sunholo-0.95.0.dist-info/METADATA,sha256=Ot1yshHTv-QqO_hNg1O7TElzvyDaopq3Ohij0_cyQJg,7889
+sunholo-0.95.0.dist-info/WHEEL,sha256=5Mi1sN9lKoFv_gxcPtisEVrJZihrm_beibeg5R6xb4I,91
+sunholo-0.95.0.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
+sunholo-0.95.0.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
+sunholo-0.95.0.dist-info/RECORD,,

{sunholo-0.94.0.dist-info → sunholo-0.95.0.dist-info}/WHEEL

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