sunholo 0.99.12__py3-none-any.whl → 0.100.0__py3-none-any.whl

sunholo/gcs/add_file.py

@@ -40,6 +40,9 @@ def handle_base64_image(base64_data: str, vector_name: str, extension: str):
     """
     
     model = ConfigManager(vector_name).vacConfig("llm")
+    if "," not in base64_data:
+        raise ValueError(f"Invalid Base64 image data: Missing metadata header {base64_data}")
+
     if model.startswith("openai"):  # pass it to gpt directly
         return base64_data, base64_data.split(",", 1)
 

sunholo/invoke/async_class.py

@@ -9,40 +9,52 @@ class AsyncTaskRunner:
         self.tasks = []
         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."""
         log.info(f"Adding task: {func.__name__} with args: {args}")
         self.tasks.append((func.__name__, func, args))
-    
-    async def run_async_as_completed(self, callback=None) -> AsyncGenerator[Dict[str, Any], None]:
-        """
-        Runs all tasks concurrently and yields results as they complete, while periodically sending heartbeat messages.
 
-        Args:
-            callback: The callback object that will receive heartbeat messages.
+    async def run_async_as_completed(self) -> AsyncGenerator[Dict[str, Any], None]:
         """
-        log.info("Running tasks asynchronously and yielding results as they complete")
+        Runs all tasks concurrently and yields results and heartbeats as they are produced.
+        """
+        log.info("Running tasks asynchronously and yielding results and heartbeats as they occur")
+        queue = asyncio.Queue()
+
         tasks = {}
         for name, func, args in self.tasks:
-            # Pass the callback down to _task_wrapper
-            coro = self._task_wrapper(name, func, args, callback)
+            coro = self._task_wrapper(name, func, args, queue)
             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:
-                name = tasks.pop(task)
-                try:
-                    result = await task
-                    yield {name: result}
-                except Exception as e:
-                    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, callback=None) -> Any:
+        while tasks or not queue.empty():
+            if not queue.empty():
+                message = await queue.get()
+                log.info(f"Found queue message: {message}")
+                yield message
+            else:
+                # Wait for either a message in the queue or a task to complete
+                done, _ = await asyncio.wait(
+                    list(tasks.keys()),
+                    timeout=0.1,
+                    return_when=asyncio.FIRST_COMPLETED
+                )
+                for task in done:
+                    name = tasks.pop(task)
+                    try:
+                        result = await task
+                        await queue.put({'type': 'task_complete', 'func_name': name, 'result': result})
+                    except Exception as e:
+                        log.error(f"Task {name} resulted in an error: {e}\n{traceback.format_exc()}")
+                        await queue.put({'type': 'task_error', 'func_name': name, 'error': e})
+
+        # After all tasks have completed, process any remaining messages in the queue
+        while not queue.empty():
+            message = await queue.get()
+            yield message
+
+    async def _task_wrapper(self, name: str, func: Callable[..., Any], args: Any, queue: asyncio.Queue) -> Any:
         """Wraps the task function to process its output and handle retries, while managing heartbeat updates."""
         async def run_func():
             if asyncio.iscoroutinefunction(func):
@@ -52,10 +64,8 @@ class AsyncTaskRunner:
                 # If the function is sync, run it in a thread to prevent blocking
                 return await asyncio.to_thread(func, *args)
 
-        # Start the heartbeat task if a callback is provided
-        heartbeat_task = None
-        if callback:
-            heartbeat_task = asyncio.create_task(self._send_heartbeat(callback, name))
+        # Start the heartbeat task
+        heartbeat_task = asyncio.create_task(self._send_heartbeat(queue, name))
 
         try:
             if self.retry_enabled:
@@ -76,38 +86,49 @@ class AsyncTaskRunner:
                     raise
         finally:
             # Stop the heartbeat task
-            if heartbeat_task:
-                heartbeat_task.cancel()
-                try:
-                    await heartbeat_task  # Ensure the heartbeat task is properly canceled
-                except asyncio.CancelledError:
-                    pass
+            heartbeat_task.cancel()
+            # Let the heartbeat_task finish in the background without awaiting it
+            try:
+                await asyncio.shield(heartbeat_task)  # Ensure cancellation is handled cleanly
+            except asyncio.CancelledError:
+                pass
 
             # Send a message indicating task completion to update the spinner's state
-            if callback:
-                completion_html = (
-                    f'<div style="display: none;" data-complete-id="{name}-spinner"></div>'
-                )
-                await callback.async_on_llm_new_token(token=completion_html)
+            completion_html = (
+                f'<div style="display: none;" data-complete-id="{name}-spinner"></div>'
+            )
+            await queue.put({'type': 'heartbeat', 'func_name': name, 'token': completion_html})
 
-    async def _send_heartbeat(self, callback, func_name, interval=2):
+    async def _send_heartbeat(self, queue: asyncio.Queue, func_name: str, interval=2):
         """
-        Sends a single spinner at the start and keeps the task alive.
-
-        Args:
-            callback: The callback to notify that the task is still working.
-            func_name: The name of the task function.
-            interval: How frequently to send heartbeat messages (in seconds).
+        Sends a periodic heartbeat to keep the task alive and update the spinner with elapsed time.
         """
         # Send the initial spinner HTML
         spinner_html = (
             f'<div id="{func_name}-spinner" class="spinner-container">'
             f'  <div class="spinner"></div>'
-            f'  <span class="completed">✔️ Task {func_name} completed!</span>'
+            f'  <span class="elapsed-time">Task {func_name} is still running... 0s elapsed</span>'
             f'</div>'
         )
-        await callback.async_on_llm_new_token(token=spinner_html)
+        log.info(f"Heartbeat started for task {func_name}")
+
+        await queue.put({'type': 'heartbeat', 'func_name': func_name, 'token': spinner_html})
+
+        # Keep track of elapsed time
+        elapsed_time = 0
 
         # Keep sending heartbeats until task completes
         while True:
-            await asyncio.sleep(interval)  # Sleep for the interval but do not send multiple messages
+            try:
+                await asyncio.sleep(interval)  # Sleep for the interval
+                elapsed_time += interval  # Increment elapsed time
+                log.info(f"Sending heartbeat for {func_name}: {elapsed_time}s elapsed")
+                # Update spinner with the elapsed time
+                update_html = (
+                    f'<div style="display: none;" data-update-id="{func_name}-spinner">'
+                    f'<span class="elapsed-time">Task {func_name} is still running... {elapsed_time}s elapsed</span>'
+                    f'</div>'
+                )
+                await queue.put({'type': 'heartbeat', 'func_name': func_name, 'token': update_html})
+            except asyncio.CancelledError:
+                break  # Exit the loop if the heartbeat task is canceled

sunholo/streaming/content_buffer.py

@@ -16,6 +16,7 @@ from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
 from langchain.schema import LLMResult
 
 import threading
+import asyncio
 import re
 from ..custom_logging import log
 
@@ -39,6 +40,8 @@ class ContentBuffer:
         that the buffer has been created.
         """
         self.content = ""
+        self.lock = asyncio.Lock()  # Use an async lock to ensure atomic writes
+        self.content_available = asyncio.Event()
         log.debug("Content buffer initialized")
     
     def write(self, text: str):
@@ -61,7 +64,9 @@ class ContentBuffer:
 
         Adds the given text to the existing content of the buffer.
         """
-        self.content += text
+        async with self.lock:
+            self.content += text
+            self.content_available.set()
     
     def read(self) -> str:
         """
@@ -81,7 +86,9 @@ class ContentBuffer:
         Returns:
             str: The content of the buffer.
         """
-        return self.content
+        async with self.lock:
+            content = self.content
+            return content
 
     def clear(self):
         """
@@ -97,7 +104,10 @@ class ContentBuffer:
 
         Empties the buffer content, resetting it to an empty string.
         """
-        self.content = ""
+        async with self.lock:
+            self.content = ""
+            log.debug("Content buffer cleared")
+            self.content_available.clear()
 
 
 class BufferStreamingStdOutCallbackHandler(StreamingStdOutCallbackHandler):
@@ -137,11 +147,20 @@ class BufferStreamingStdOutCallbackHandler(StreamingStdOutCallbackHandler):
         self.tokens = tokens
         self.buffer = ""
         self.stream_finished = threading.Event()
+
         self.in_code_block = False
         self.in_question_block = False
         self.question_buffer = ""
         log.info("Starting to stream LLM")
 
+    def _is_heartbeat_token(self, token: str) -> bool:
+        """Detects if the token is a heartbeat message."""
+        return token.startswith('[[HEARTBEAT]]') and token.endswith('[[/HEARTBEAT]]')
+
+    def _strip_heartbeat_markers(self, token: str) -> str:
+        """Removes the [[HEARTBEAT]] markers from the token."""
+        return token[len('[[HEARTBEAT]]'):-len('[[/HEARTBEAT]]')]
+
     def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
         """
         Processes a new token from the LLM output.
@@ -155,32 +174,21 @@ class BufferStreamingStdOutCallbackHandler(StreamingStdOutCallbackHandler):
         patterns are detected.
         """
         log.debug(f"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:
-            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
+        # Check if the token is a heartbeat message
+        if self._is_heartbeat_token(token):
+            # Strip the [[HEARTBEAT]] markers and write immediately
+            heartbeat_content = self._strip_heartbeat_markers(token)
+            log.info(f"Heartbeat token detected, writing immediately: {heartbeat_content}")
+            self.content_buffer.write(heartbeat_content)
+        else:
+            self.buffer += token
 
-        if '```' in token:
-            self.in_code_block = not self.in_code_block
+            if '```' in token:
+                self.in_code_block = not self.in_code_block
 
-        if not self.in_code_block:
-            await self._async_process_buffer()
+            if not self.in_code_block:
+                self._process_buffer()
 
     def _process_buffer(self):
         """
@@ -200,24 +208,6 @@ 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.
@@ -237,6 +227,90 @@ class BufferStreamingStdOutCallbackHandler(StreamingStdOutCallbackHandler):
         self.stream_finished.set()
         log.info("Streaming LLM response ended successfully")
 
+
+
+class BufferStreamingStdOutCallbackHandlerAsync(StreamingStdOutCallbackHandler):
+    """
+    An async callback handler for streaming LLM output to a content buffer.
+
+    This class handles the streaming of output from a large language model (LLM),
+    processes tokens from the model output, and writes them to a ContentBuffer.
+    It supports handling different types of tokens and keeps track of code blocks
+    and questions.
+
+    Attributes:
+        content_buffer (ContentBuffer): The buffer to which content is streamed.
+        tokens (str): Tokens that indicate the end of a statement, for buffer flushing.
+        buffer (str): Temporary storage for accumulating streamed tokens.
+        stream_finished (asyncio.Event): Signals when the streaming is finished.
+        in_code_block (bool): Indicates whether the current context is a code block.
+    """
+
+    def __init__(self, content_buffer: ContentBuffer, tokens: str = ".?!\n", *args, **kwargs):
+        """
+        Initializes a new BufferStreamingStdOutCallbackHandler instance.
+
+        Args:
+            content_buffer (ContentBuffer): The buffer to which content will be written.
+            tokens (str): Tokens that indicate the end of a statement (default: ".?!\n").
+            *args: Additional positional arguments.
+            **kwargs: Additional keyword arguments.
+
+        Sets up the callback handler with the given content buffer and tokens.
+        Initializes tracking variables for code blocks, buffer content, and the finished signal.
+        """
+        super().__init__(*args, **kwargs)
+        self.content_buffer = content_buffer
+        self.tokens = tokens
+        self.buffer = ""
+        self.stream_finished = asyncio.Event()  # Use asyncio.Event for async compatibility
+        self.in_code_block = False
+        log.info("Starting to stream LLM")
+
+    async def async_on_llm_new_token(self, token: str, **kwargs: Any) -> None:
+        log.debug(f"async_on_llm_new_token: {token}")
+
+        # Check if the token is a heartbeat message
+        if self._is_heartbeat_token(token):
+            # Strip the [[HEARTBEAT]] markers and write immediately
+            heartbeat_content = self._strip_heartbeat_markers(token)
+            log.info(f"Heartbeat token detected, writing immediately: {heartbeat_content}")
+            await self.content_buffer.async_write(heartbeat_content)
+        else:
+            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 _is_heartbeat_token(self, token: str) -> bool:
+        """Detects if the token is a heartbeat message."""
+        return token.startswith('[[HEARTBEAT]]') and token.endswith('[[/HEARTBEAT]]')
+
+    def _strip_heartbeat_markers(self, token: str) -> str:
+        """Removes the [[HEARTBEAT]] markers from the token."""
+        return token[len('[[HEARTBEAT]]'):-len('[[/HEARTBEAT]]')]
+
+    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 = ""
+
     async def async_on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
         """
         Asynchronously handles the end of LLM streaming.
@@ -251,4 +325,5 @@ class BufferStreamingStdOutCallbackHandler(StreamingStdOutCallbackHandler):
             log.info("Flushing remaining LLM response buffer")
 
         self.stream_finished.set()
-        log.info("Streaming LLM response ended successfully")
+        log.info("Streaming LLM response ended successfully")
+

sunholo/streaming/streaming.py

@@ -17,7 +17,7 @@ import json
 import time
 import asyncio
 
-from .content_buffer import ContentBuffer, BufferStreamingStdOutCallbackHandler
+from .content_buffer import ContentBuffer, BufferStreamingStdOutCallbackHandler, BufferStreamingStdOutCallbackHandlerAsync
 
 from ..qna.parsers import parse_output
 
@@ -159,7 +159,7 @@ async def start_streaming_chat_async(question, vector_name, qna_func_async, chat
         yield "No **kwargs in qna_func_async - please add it"
         
     content_buffer = ContentBuffer()
-    chat_callback_handler = BufferStreamingStdOutCallbackHandler(content_buffer=content_buffer, tokens=".!?\n")
+    chat_callback_handler = BufferStreamingStdOutCallbackHandlerAsync(content_buffer=content_buffer, tokens=".!?\n")
 
     result_queue = Queue()
     exception_queue = Queue()
@@ -179,32 +179,26 @@ async def start_streaming_chat_async(question, vector_name, qna_func_async, chat
     await asyncio.sleep(0)
 
     # Read and yield any initial content from the content buffer
-    content_to_send = content_buffer.read()
+    content_to_send = await content_buffer.async_read()
     if content_to_send:
         log.info(f"Initial content: {content_to_send}")
         yield content_to_send
-        content_buffer.clear()
-
-    start = time.time()
+        await content_buffer.async_clear()
 
     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"async heartbeat - {round(time.time() - start, 2)} seconds")
-        
-        while not exception_queue.empty():
-            exception = exception_queue.get_nowait()
-            raise exception
+        try:
+            await asyncio.wait_for(content_buffer.content_available.wait(), timeout=timeout)
+        except asyncio.TimeoutError:
+            log.warning(f"Content production has timed out after {timeout} seconds")
+            break
 
-        content_to_send = content_buffer.read()
+        content_to_send = await content_buffer.async_read()
         if content_to_send:
-            log.info(f"==\n{content_to_send}")
+            log.info(f"Content to send: {content_to_send}")
             yield content_to_send
-            content_buffer.clear()
-            start = time.time()
+            await content_buffer.async_clear()
         else:
-            if time.time() - start > timeout:
-                log.warning(f"Content production has timed out after {timeout} seconds")
-                break
+            log.debug("Content available event set but no content found.")
 
     stop_event.set()
     await chat_task  # Ensure the async task is awaited
@@ -217,8 +211,6 @@ async def start_streaming_chat_async(question, vector_name, qna_func_async, chat
             yield json.dumps(parsed_final_result)
 
 
-
-
 def generate_proxy_stream(stream_to_f, user_input, vector_name, chat_history, generate_f_output, **kwargs):
     """
     Generator function for proxying and processing streaming output from an underlying model.

{sunholo-0.99.12.dist-info → sunholo-0.100.0.dist-info}/METADATA

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

{sunholo-0.99.12.dist-info → sunholo-0.100.0.dist-info}/RECORD

@@ -80,7 +80,7 @@ sunholo/embedder/embed_chunk.py,sha256=_FdO4-9frUJlDPqXv2Ai49ejUrrMTMGti3D7bfJGf
 sunholo/excel/__init__.py,sha256=AqTMN9K4qJYi4maEgoORc5oxDVGO_eqmwzDaVP37JgY,56
 sunholo/excel/plugin.py,sha256=rl3FoECZ6Ts8KKExPrbPwr3u3CegZfsevmcjgUXAlhE,4033
 sunholo/gcs/__init__.py,sha256=SZvbsMFDko40sIRHTHppA37IijvJTae54vrhooEF5-4,90
-sunholo/gcs/add_file.py,sha256=oSUCrTS_bdKJ-WcK8SAUCGEkS2noVbBhUBLwJRNxtpQ,8245
+sunholo/gcs/add_file.py,sha256=XuntzdFz9b0flMArgUe-4DSaPI7zdBw8hlsG1rsRQmc,8371
 sunholo/gcs/download_folder.py,sha256=ijJTnS595JqZhBH8iHFErQilMbkuKgL-bnTCMLGuvlA,1614
 sunholo/gcs/download_url.py,sha256=q1NiJSvEhdNrmU5ZJ-sBCMC_J5CxzrajY8LRgdPOV_M,6130
 sunholo/gcs/metadata.py,sha256=oQLcXi4brsZ74aegWyC1JZmhlaEV270HS5_UWtAYYWE,898
@@ -89,7 +89,7 @@ sunholo/genai/init.py,sha256=yG8E67TduFCTQPELo83OJuWfjwTnGZsyACospahyEaY,687
 sunholo/genai/process_funcs_cls.py,sha256=MF3wm-N-zoYvme4I8ffXM9I7cog8OFyBnLu1e3A6eVc,26695
 sunholo/genai/safety.py,sha256=mkFDO_BeEgiKjQd9o2I4UxB6XI7a9U-oOFjZ8LGRUC4,1238
 sunholo/invoke/__init__.py,sha256=o1RhwBGOtVK0MIdD55fAIMCkJsxTksi8GD5uoqVKI-8,184
-sunholo/invoke/async_class.py,sha256=N45IX9732TijQ1LcgOiBiPTiZg1srKnNU46EY0NbDzo,4946
+sunholo/invoke/async_class.py,sha256=6AQ3d1-8F0lG9y3pXli1IsJW7eDqGLxoIFxYnmjbmn0,6067
 sunholo/invoke/direct_vac_func.py,sha256=GXSCMkC6vOWGUtQjxy-ZpTrMvJa3CgcW-y9mDpJwWC8,9533
 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=HLj-EJcCxxFwPcEZ4Xu3Ns0tDT6awkTe5QY9S7bMnjg,9162
+sunholo/streaming/content_buffer.py,sha256=0oNltM8jBU_3-728--DGdXfS278C2s1xwdcbWthGFks,12810
 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=Z_M6rn6XZUMfQggiQ79dw5HD7xaodvq0UGS34C5dHbQ,16549
+sunholo/streaming/streaming.py,sha256=FUdcotNbLQg2VV_mHnHloLJNL2gDQYAYsaNiHjzaT2I,16467
 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=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.99.12.dist-info/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
-sunholo-0.99.12.dist-info/METADATA,sha256=DBqgk8OurecnulKJbbQ6r2NNv-e9X-YI4lR9rpKKQYA,8312
-sunholo-0.99.12.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-sunholo-0.99.12.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
-sunholo-0.99.12.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
-sunholo-0.99.12.dist-info/RECORD,,
+sunholo-0.100.0.dist-info/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
+sunholo-0.100.0.dist-info/METADATA,sha256=3E-fkTmyUzOkUNGCshJmLpnirzeSiKHaRk8oYec-xQQ,8312
+sunholo-0.100.0.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+sunholo-0.100.0.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
+sunholo-0.100.0.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
+sunholo-0.100.0.dist-info/RECORD,,