sunholo 0.95.1__py3-none-any.whl → 0.95.3__py3-none-any.whl

sunholo/agents/flask/vac_routes.py

@@ -185,11 +185,9 @@ 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:
@@ -219,52 +217,53 @@ if __name__ == "__main__":
         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()
-
+                    from queue import Queue, Empty
+                    result_queue = Queue()
+                    import threading
+
+                    def run_async():
+                        async def process_async():
+                            try:
+                                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=}")
+                                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)
+                                        result_queue.put(json.dumps(chunk))
+                                    else:
+                                        result_queue.put(chunk)
+                            except Exception as e:
+                                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)
+                    thread.start()
+
+                    # Read from the queue and yield results
+                    while True:
+                        chunk = result_queue.get()
+                        if chunk is None:
+                            break
+                        yield chunk
+
+                    thread.join()
                 else:
                     log.info("sync streaming response")
                     for chunk in start_streaming_chat(
@@ -286,16 +285,16 @@ if __name__ == "__main__":
                                 generation.end(output=json.dumps(chunk))
                                 span.end(output=json.dumps(chunk))
                                 trace.update(output=json.dumps(chunk))
-                            return json.dumps(chunk)
+                            yield 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'  
+        response.headers['Transfer-Encoding'] = 'chunked'
 
         log.debug(f"streaming response: {response}")
         if trace:
@@ -307,12 +306,10 @@ if __name__ == "__main__":
         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
+    async def _async_generator_to_stream(async_gen_func):
+        """Helper function to stream the async generator's values to the client."""
+        async for item in async_gen_func():
+            yield item
     
     def langfuse_eval_response(self, trace_id, eval_percent=0.01):
         """

sunholo/agents/route.py

@@ -65,14 +65,14 @@ def route_endpoint(vector_name=None, method = 'post', override_endpoint=None, co
     
     agents_config = config.agentConfig(agent_type)
     
-    log.info(f"agents_config: {agents_config}")
+    log.debug(f"agents_config: {agents_config}")
     if method not in agents_config:
         raise ValueError(f"Invalid method '{method}' for agent configuration.")
 
     # 'post' or 'get'
     endpoints_config = agents_config[method]
 
-    log.info(f"endpoints_config: {endpoints_config}")
+    log.debug(f"endpoints_config: {endpoints_config}")
     # Replace placeholders in the config
     endpoints = {}
     for key, value in endpoints_config.items():

sunholo/genai/process_funcs_cls.py

@@ -351,7 +351,7 @@ class GenAIFunctionProcessor:
             log.error(f"Error initializing model: {str(err)}")
             return None
 
-    def run_agent_loop(self, chat, content, callback, guardrail_max=10):
+    def run_agent_loop(self, chat, content, callback, guardrail_max=10, loop_return=3):
         """
         Runs the agent loop, sending messages to the orchestrator, processing responses, and executing functions.
 
@@ -360,12 +360,13 @@ class GenAIFunctionProcessor:
             content: The initial content to send to the agent.
             callback: The callback object for handling intermediate responses.
             guardrail_max (int): The maximum number of iterations for the loop.
+            loop_return (int): The number of last loop iterations to return. Default 3 will return last 3 iterations. If loop_return > guardrail_max then all iterations are returned.
 
         Returns:
             tuple: (big_text, usage_metadata) from the loop execution.
         """
         guardrail = 0
-        big_text = ""
+        big_result = []
         usage_metadata = {
             "prompt_token_count": 0,
             "candidates_token_count": 0,
@@ -422,7 +423,6 @@ class GenAIFunctionProcessor:
                     if hasattr(chunk, 'text') and isinstance(chunk.text, str):
                         token = chunk.text
                         token_queue.append(token)
-                        big_text += token
                         this_text += token
                     else:
                         log.info("skipping chunk with no text")
@@ -486,18 +486,17 @@ class GenAIFunctionProcessor:
                         else:
                             token += f"{fn_result}\n--- end ---\n"
                     
-                    big_text += token
                     this_text += token
                     token_queue.append(token)
             else:
                 token = "\nNo function executions were found\n"
                 token_queue.append(token)
-                big_text += token
                 this_text += token
 
             if this_text:
                 content.append(f"Agent: {this_text}")    
                 log.info(f"[{guardrail}] Updated content:\n{this_text}")
+                big_result.append(this_text)
             else:
                 log.warning(f"[{guardrail}] No content created this loop")
                 content.append(f"Agent: No response was found for loop [{guardrail}]")
@@ -523,7 +522,8 @@ class GenAIFunctionProcessor:
             callback.on_llm_new_token(token=token)
         
         usage_metadata["functions_called"] = functions_called
-        #usage_metadata["function_results"] = function_results
+
+        big_text = "\n".join(big_result[loop_return:])
 
         return big_text, usage_metadata
 

sunholo/invoke/async_class.py

@@ -1,11 +1,9 @@
 import asyncio
-import logging
+from ..custom_logging import log
 import traceback
 from typing import Callable, List, Any, AsyncGenerator, Dict
 from tenacity import AsyncRetrying, retry_if_exception_type, wait_random_exponential, stop_after_attempt
 
-logger = logging.getLogger(__name__)
-
 class AsyncTaskRunner:
     def __init__(self, retry_enabled=False, retry_kwargs=None):
         self.tasks = []
@@ -14,18 +12,19 @@ class AsyncTaskRunner:
     
     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}")
+        log.info(f"Adding task: {func.__name__} with args: {args}")
         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")
+        log.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
         
+        log.info(f"Start async run with {len(self.tasks)} runners")
         while tasks:
             done, _ = await asyncio.wait(tasks.keys(), return_when=asyncio.FIRST_COMPLETED)
             for task in done:
@@ -34,7 +33,7 @@ class AsyncTaskRunner:
                     result = await task
                     yield {name: result}
                 except Exception as e:
-                    logger.error(f"Task {name} resulted in an error: {e}\n{traceback.format_exc()}")
+                    log.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:
@@ -65,13 +64,13 @@ class AsyncTaskRunner:
             try:
                 return await run_func()
             except Exception as e:
-                logger.error(f"Error in task {name}: {e}\n{traceback.format_exc()}")
+                log.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."""
         for result in results:
             if isinstance(result, Exception):
-                logger.error(f"Task resulted in an error: {result}")
+                log.error(f"Task resulted in an error: {result}")
             else:
-                logger.info(f"Task completed successfully: {result}")
+                log.info(f"Task completed successfully: {result}")

sunholo/streaming/content_buffer.py

@@ -51,6 +51,17 @@ class ContentBuffer:
         Adds the given text to the existing content of the buffer.
         """
         self.content += text
+
+    async def async_write(self, text: str):
+        """
+        Asynchronously writes text to the content buffer.
+
+        Args:
+            text (str): The text to be added to the buffer.
+
+        Adds the given text to the existing content of the buffer.
+        """
+        self.content += text
     
     def read(self) -> str:
         """
@@ -63,6 +74,15 @@ class ContentBuffer:
         """   
         return self.content
 
+    async def async_read(self) -> str:
+        """
+        Asynchronously reads the entire content from the buffer.
+
+        Returns:
+            str: The content of the buffer.
+        """
+        return self.content
+
     def clear(self):
         """
         Clears the content buffer.
@@ -71,7 +91,15 @@ class ContentBuffer:
         """
         self.content = ""
 
-    
+    async def async_clear(self):
+        """
+        Asynchronously clears the content buffer.
+
+        Empties the buffer content, resetting it to an empty string.
+        """
+        self.content = ""
+
+
 class BufferStreamingStdOutCallbackHandler(StreamingStdOutCallbackHandler):
     """
     A callback handler for streaming LLM output to a content buffer.
@@ -136,6 +164,24 @@ class BufferStreamingStdOutCallbackHandler(StreamingStdOutCallbackHandler):
         if not self.in_code_block:
             self._process_buffer()
 
+    async def async_on_llm_new_token(self, token: str, **kwargs: Any) -> None:
+        """
+        Asynchronously processes a new token from the LLM output.
+
+        Args:
+            token (str): The new token generated by the LLM.
+            **kwargs: Additional keyword arguments.
+        """
+        log.debug(f"async_on_llm_new_token: {token}")
+        
+        self.buffer += token
+
+        if '```' in token:
+            self.in_code_block = not self.in_code_block
+
+        if not self.in_code_block:
+            await self._async_process_buffer()
+
     def _process_buffer(self):
         """
         Processes the buffer content and writes to the content buffer.
@@ -154,6 +200,24 @@ class BufferStreamingStdOutCallbackHandler(StreamingStdOutCallbackHandler):
                 self.content_buffer.write(self.buffer)
                 self.buffer = ""
 
+    async def _async_process_buffer(self):
+        """
+        Asynchronously processes the buffer content and writes to the content buffer.
+
+        If the buffer ends with a numbered list pattern or specified tokens, the buffer is flushed
+        to the content buffer. Otherwise, the buffer is left intact for further accumulation.
+        """
+        matches = list(re.finditer(r'\n(\d+\.\s)', self.buffer))
+        if matches:
+            last_match = matches[-1]
+            start_of_last_match = last_match.start() + 1
+            await self.content_buffer.async_write(self.buffer[:start_of_last_match])
+            self.buffer = self.buffer[start_of_last_match:]
+        else:
+            if any(self.buffer.endswith(t) for t in self.tokens):
+                await self.content_buffer.async_write(self.buffer)
+                self.buffer = ""
+
     def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
         """
         Handles the end of LLM streaming.
@@ -172,3 +236,19 @@ class BufferStreamingStdOutCallbackHandler(StreamingStdOutCallbackHandler):
 
         self.stream_finished.set()
         log.info("Streaming LLM response ended successfully")
+
+    async def async_on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
+        """
+        Asynchronously handles the end of LLM streaming.
+
+        Args:
+            response (LLMResult): The result returned by the LLM.
+            **kwargs: Additional keyword arguments.
+        """
+        if self.buffer:
+            await self.content_buffer.async_write(self.buffer)
+            self.buffer = ""
+            log.info("Flushing remaining LLM response buffer")
+
+        self.stream_finished.set()
+        log.info("Streaming LLM response ended successfully")

sunholo/streaming/streaming.py

@@ -175,6 +175,16 @@ async def start_streaming_chat_async(question, vector_name, qna_func_async, chat
     # Run start_chat asynchronously
     chat_task = asyncio.create_task(start_chat())
 
+     # Allow the event loop to process the scheduled tasks
+    await asyncio.sleep(0)
+
+    # Read and yield any initial content from the content buffer
+    content_to_send = content_buffer.read()
+    if content_to_send:
+        log.info(f"Initial content: {content_to_send}")
+        yield content_to_send
+        content_buffer.clear()
+
     start = time.time()
 
     while not chat_callback_handler.stream_finished.is_set() and not stop_event.is_set():

{sunholo-0.95.1.dist-info → sunholo-0.95.3.dist-info}/METADATA

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

{sunholo-0.95.1.dist-info → sunholo-0.95.3.dist-info}/RECORD

@@ -5,7 +5,7 @@ sunholo/agents/chat_history.py,sha256=Gph_CdlP2otYnNdR1q1Umyyyvcad2F6K3LxU5yBQ9l
 sunholo/agents/dispatch_to_qa.py,sha256=Z2q0ygYxfgBr-EGydq_H5y4Y-bKlY4ZCBCwkGpYwjFY,8766
 sunholo/agents/langserve.py,sha256=C46ph2mnygr6bdHijYWYyfQDI9ylAF0_9Kx2PfcCJpU,4414
 sunholo/agents/pubsub.py,sha256=TscZN_6am6DfaQkC-Yl18ZIBOoLE-0nDSiil6GpQEh4,1344
-sunholo/agents/route.py,sha256=Mo-YOHDsHOiQXfb6VmCH0BPThAD-0jZGIkIKAHxSDdc,2986
+sunholo/agents/route.py,sha256=mV8tGABbSqcg3PQL02MgQOs41gKEHLMyIJJJcTuFdbE,2988
 sunholo/agents/special_commands.py,sha256=YhN8_E4cGZVvagN5_fouaxZiVbxr7PEhSzoFcvTKH54,6501
 sunholo/agents/swagger.py,sha256=2tzGmpveUMmTREykZvVnDj3j295wyOMu7mUFDnXdY3c,10671
 sunholo/agents/fastapi/__init__.py,sha256=S_pj4_bTUmDGoq_exaREHlOKThi0zTuGT0VZY0YfODQ,88
@@ -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=6Z8Eqt1SgfcmUf5V-7O3vYSXnGCBWQKWBUPj-NwX1RU,27269
+sunholo/agents/flask/vac_routes.py,sha256=6DzeqPzZV3U_djm1SNaWZbNaGelRtrZjMtrOF4T7MJs,27119
 sunholo/archive/__init__.py,sha256=qNHWm5rGPVOlxZBZCpA1wTYPbalizRT7f8X4rs2t290,31
 sunholo/archive/archive.py,sha256=PxVfDtO2_2ZEEbnhXSCbXLdeoHoQVImo4y3Jr2XkCFY,1204
 sunholo/auth/__init__.py,sha256=TeP-OY0XGxYV_8AQcVGoh35bvyWhNUcMRfhuD5l44Sk,91
@@ -86,10 +86,10 @@ sunholo/gcs/download_url.py,sha256=q1NiJSvEhdNrmU5ZJ-sBCMC_J5CxzrajY8LRgdPOV_M,6
 sunholo/gcs/metadata.py,sha256=oQLcXi4brsZ74aegWyC1JZmhlaEV270HS5_UWtAYYWE,898
 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/process_funcs_cls.py,sha256=OCLa_yPjVlE7wY1v54SY0M6b5lpU2l3guRHb-qYOk2A,24359
 sunholo/genai/safety.py,sha256=mkFDO_BeEgiKjQd9o2I4UxB6XI7a9U-oOFjZ8LGRUC4,1238
 sunholo/invoke/__init__.py,sha256=VOpsfhNf98az3at7bMaY1Fiw4UIZAS6zMmSqWd6_ksI,141
-sunholo/invoke/async_class.py,sha256=3QR_hFxyEEkksbXmXziDuC__dg4XWNghuw2ZUAPpQ3Q,3195
+sunholo/invoke/async_class.py,sha256=NYuQU-LIhnJEmierbSwmwxXfNzmEhqDZCSx5BZDEYA8,3225
 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
@@ -114,10 +114,10 @@ sunholo/qna/__init__.py,sha256=F8q1uR_HreoSX0IfmKY1qoSwIgXhO2Q8kuDSxh9_-EE,28
 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/content_buffer.py,sha256=HLj-EJcCxxFwPcEZ4Xu3Ns0tDT6awkTe5QY9S7bMnjg,9162
 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=tMCAdB_piQXiiQLPkkYJwDiDxfg6UOBeto0d9C8m_Jk,16211
+sunholo/streaming/streaming.py,sha256=Z_M6rn6XZUMfQggiQ79dw5HD7xaodvq0UGS34C5dHbQ,16549
 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=x3_ESOhgMpf-gNpiOzmP7YQI0l0FAoLtbAVP2K2N0OA,7724
 sunholo/vertex/safety.py,sha256=S9PgQT1O_BQAkcqauWncRJaydiP8Q_Jzmu9gxYfy1VA,2482
 sunholo/vertex/type_dict_to_json.py,sha256=uTzL4o9tJRao4u-gJOFcACgWGkBOtqACmb6ihvCErL8,4694
-sunholo-0.95.1.dist-info/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
-sunholo-0.95.1.dist-info/METADATA,sha256=eGcN3ki323hTYiSMUNGlgJCDQI_r1hxVLHbwksnSdXg,7889
-sunholo-0.95.1.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-sunholo-0.95.1.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
-sunholo-0.95.1.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
-sunholo-0.95.1.dist-info/RECORD,,
+sunholo-0.95.3.dist-info/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
+sunholo-0.95.3.dist-info/METADATA,sha256=BIKn4TOl_j1DzdCYb_MLEfd-3nI3aUhaofHrGXlDSbc,7889
+sunholo-0.95.3.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+sunholo-0.95.3.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
+sunholo-0.95.3.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
+sunholo-0.95.3.dist-info/RECORD,,