sunholo 0.73.3__py3-none-any.whl → 0.74.1__py3-none-any.whl

sunholo/cli/chat_vac.py

@@ -183,6 +183,10 @@ def stream_chat_session(service_url, service_name, stream=True):
             read_file = None
             read_file_count = None
             continue
+
+        if user_input.lower().startswith("!"):
+            console.print("[bold red]Could find no valid chat command for you, sorry[/bold red]")
+            continue
         
         if read_file:
             user_input = f"<user added file>{read_file}</user added file>\n{user_input}"

sunholo/tools/__init__.py

@@ -0,0 +1 @@
+from .web_browser import BrowseWebWithImagePromptsBot

sunholo/tools/web_browser.py

@@ -2,23 +2,78 @@ import os
 import base64
 import json
 from datetime import datetime
+import urllib.parse
+
+from ..logging import log
+
+from ..utils.parsers import get_clean_website_name
+
 try:
-    from playwright.sync_api import sync_playwright
+    from playwright.sync_api import sync_playwright, Response
 except ImportError:
     sync_playwright = None
+    Response = None
 
 class BrowseWebWithImagePromptsBot:
     """
-    Examples:
+    BrowseWebWithImagePromptsBot is a base class for creating bots that interact with web pages using Playwright.
+    The bot can perform actions such as navigating, clicking, scrolling, typing text, and taking screenshots.
+    It also supports cookie management to maintain session state across interactions.
+
+    Methods:
+    - __init__(session_id, website_name, browser_type='chromium', headless=True):
+        Initializes the bot with the given session ID, website name, browser type, and headless mode.
+        Supported browser types: 'chromium', 'firefox', 'webkit'.
+
+    - load_cookies():
+        Loads cookies from a file and adds them to the browser context.
+
+    - save_cookies():
+        Saves the current cookies to a file.
+
+    - navigate(url):
+        Navigates to the specified URL.
+
+    - click(selector):
+        Clicks on the element specified by the selector.
+
+    - scroll(direction='down', amount=1):
+        Scrolls the page in the specified direction ('down', 'up', 'left', 'right') by the specified amount.
+
+    - type_text(selector, text):
+        Types the specified text into the element specified by the selector.
+
+    - take_screenshot():
+        Takes a screenshot and saves it with a timestamp in the session-specific directory. Returns the path to the screenshot.
+
+    - get_latest_screenshot_path():
+        Retrieves the path to the most recent screenshot in the session-specific directory.
+
+    - create_prompt_vars(current_action_description, session_goal):
+        Creates a dictionary of prompt variables from the current action description and session goal.
+
+    - send_screenshot_to_llm(screenshot_path, current_action_description="", session_goal=""):
+        Encodes the screenshot in base64, creates prompt variables, and sends them to the LLM. Returns the new instructions from the LLM.
+
+    - send_prompt_to_llm(prompt_vars, screenshot_base64):
+        Abstract method to be implemented by subclasses. Sends the prompt variables and screenshot to the LLM and returns the response.
+
+    - close():
+        Saves cookies, closes the browser, and stops Playwright.
+
+    - execute_instructions(instructions):
+        Executes the given set of instructions, takes a screenshot after each step, and sends the screenshot to the LLM for further instructions.
+
+    Example usage:
 
     ```python
     class ProductionBot(BrowseWebWithImagePromptsBot):
-        def send_prompt_to_llm(self, prompt, screenshot_base64):
+        def send_prompt_to_llm(self, prompt_vars, screenshot_base64):
             # Implement the actual logic to send the prompt and screenshot to the LLM and return the response
             api_url = "https://api.example.com/process"  # Replace with the actual LLM API endpoint
             headers = {"Content-Type": "application/json"}
             data = {
-                "prompt": prompt,
+                "prompt": prompt_vars,
                 "screenshot": screenshot_base64
             }
             response = requests.post(api_url, headers=headers, data=json.dumps(data))
@@ -31,7 +86,7 @@ class BrowseWebWithImagePromptsBot:
         website_name = data.get('website_name')
         browser_type = data.get('browser_type', 'chromium')
         current_action_description = data.get('current_action_description', "")
-        next_goal = data.get('next_goal', "")
+        session_goal = data.get('session_goal', "")
         
         bot = ProductionBot(session_id=session_id, website_name=website_name, browser_type=browser_type, headless=True)
         
@@ -39,12 +94,13 @@ class BrowseWebWithImagePromptsBot:
         initial_instructions = data.get('instructions')
         if initial_instructions:
             bot.execute_instructions(initial_instructions)
+        else:
+            bot.execute_instructions([{'action':'navigate', 'url': website_name}])
         
-        # Take initial screenshot and send to LLM if no instructions provided
-        if not initial_instructions:
-            screenshot_path = bot.take_screenshot()
-            new_instructions = bot.send_screenshot_to_llm(screenshot_path, current_action_description, next_goal)
-            bot.execute_instructions(new_instructions)
+        # Take initial screenshot and send to LLM
+        screenshot_path = bot.take_screenshot()
+        new_instructions = bot.send_screenshot_to_llm(screenshot_path, current_action_description, session_goal)
+        bot.execute_instructions(new_instructions)
         
         # Take final screenshot
         bot.take_screenshot()
@@ -57,15 +113,26 @@ class BrowseWebWithImagePromptsBot:
         app.run(host='0.0.0.0', port=8080)
     ```
     """
-    def __init__(self, session_id, website_name, browser_type='chromium', headless=True):
+#class BrowseWebWithImagePromptsBot:
+    def __init__(self, session_id, website_name, browser_type='chromium', headless=True, max_steps=10):
+        try:
+            from playwright.sync_api import sync_playwright
+        except ImportError as err:
+            print(err)
+            sync_playwright = None
+
         if not sync_playwright:
             raise ImportError("playright needed for BrowseWebWithImagePromptsBot class - install via `pip install sunholo[tools]`")
-        self.session_id = session_id
+        
+        self.session_id = session_id or datetime.now().strftime("%Y%m%d%H%M%S")
         self.website_name = website_name
         self.browser_type = browser_type
-        self.screenshot_dir = f"{website_name}_{session_id}"
+        self.max_steps = max_steps
+        self.steps = 0
+        self.screenshot_dir = f"browser_tool/{get_clean_website_name(website_name)}/{session_id}"
         os.makedirs(self.screenshot_dir, exist_ok=True)
         self.cookie_file = os.path.join(self.screenshot_dir, "cookies.json")
+        self.action_log_file = os.path.join(self.screenshot_dir, "action_log.json")
         self.playwright = sync_playwright().start()
         
         if browser_type == 'chromium':
@@ -80,6 +147,9 @@ class BrowseWebWithImagePromptsBot:
         self.context = self.browser.new_context()
         self.page = self.context.new_page()
         self.load_cookies()
+        self.action_log = []
+        self.session_goal = None
+        self.session_screenshots = []
 
     def load_cookies(self):
         if os.path.exists(self.cookie_file):
@@ -91,33 +161,176 @@ class BrowseWebWithImagePromptsBot:
         cookies = self.context.cookies()
         with open(self.cookie_file, 'w') as f:
             json.dump(cookies, f)
+    
+    def save_action_log(self):
+        with open(self.action_log_file, 'w') as f:
+            json.dump(self.action_log, f)
+    
+    def load_action_log(self):
+        if os.path.exists(self.action_log_file):
+            with open(self.action_log_file, 'r') as f:
+                action_log = json.load(f)
+                self.action_log = action_log
 
     def navigate(self, url):
-        self.page.goto(url)
+        def handle_response(response: Response): # type: ignore
+                status = response.status
+                url = response.url
+                if 300 <= status < 400:
+                    log.info(f"Redirecting from {url}")
+        try:
+            self.page.on("response", handle_response)
+
+            previous_url = self.page.url
+
+            response = self.page.goto(url)
+            status = response.status
+            if status != 200:
+                log.error(f"Failed to navigate to {url}: HTTP {status}")
+                self.action_log.append(f"Tried to navigate to {url} but failed: HTTP {status} - browsing back to {previous_url}")
+                url = previous_url
+                self.page.goto(previous_url)
+  
+            self.page.wait_for_load_state()
+            log.info(f'Navigated to {url}')
+            self.action_log.append(f"Navigated to {url}")
+
+        except Exception as err:
+            log.warning(f"navigate failed with {str(err)}")
+            self.action_log.append(f"Tried to navigate to {url} but got an error")
 
-    def click(self, selector):
-        self.page.click(selector)
+    def get_locator(self, selector, by_text=True):
+        if by_text:
+            elements = self.page.locator(f"text={selector}").all()
+            if elements:
+                return elements[0]
+            else:
+                log.warning(f"No elements found with text: {selector}")
+                return None
+        else:
+            return self.page.locator(selector)
+
+    def click(self, selector, by_text=True):
+        (x,y)=(0,0)
+
+        element = self.get_locator(selector, by_text=by_text)
+        if element is None:
+            self.action_log.append(f"Tried to click on text {selector} but it was not a valid location to click")
+            return (x,y)
+
+        try:
+            bounding_box = element.bounding_box()
+            if bounding_box:
+                x = bounding_box['x'] + bounding_box['width'] / 2
+                y = bounding_box['y'] + bounding_box['height'] / 2
+        except Exception as err:
+            log.warning(f"Could not do bounding box - {str(err)}")
+        
+        try:
+            element.click()
+            self.page.wait_for_load_state()
+            log.info(f"Clicked on element with selector {selector} at {x=},{y=}")
+            self.action_log.append(f"Clicked on element with selector {selector} at {x=},{y=}")
+
+            return (x,y)
+        
+        except Exception as err:
+            log.warning(f"click failed with {str(err)}")
+            self.action_log.append(f"Tried to click on element with selector {selector} at {x=},{y=} but got an error")  
 
-    def scroll(self, direction='down', amount=1):
-        for _ in range(amount):
+            return (x,y)          
+
+    def scroll(self, direction='down', amount=100):
+        try:
             if direction == 'down':
-                self.page.evaluate("window.scrollBy(0, window.innerHeight)")
+                self.page.mouse.wheel(0, amount)
             elif direction == 'up':
-                self.page.evaluate("window.scrollBy(0, -window.innerHeight)")
+                self.page.mouse.wheel(0, -amount)
             elif direction == 'left':
-                self.page.evaluate("window.scrollBy(-window.innerWidth, 0)")
+                self.page.mouse.wheel(-amount, 0)
             elif direction == 'right':
-                self.page.evaluate("window.scrollBy(window.innerWidth, 0)")
+                self.page.mouse.wheel(amount, 0)
+            self.page.wait_for_timeout(500)
+            log.info(f"Scrolled {direction} by {amount} pixels")
+            self.action_log.append(f"Scrolled {direction} by {amount} pixels")
+        except Exception as err:
+            log.warning(f"Scrolled failed with {str(err)}")
+            self.action_log.append(f"Tried to scroll {direction} by {amount} pixels but got an error")
+
+    def type_text(self, selector, text, by_text=True):
+        (x,y)=(0,0)
+        element = self.get_locator(selector, by_text=by_text)
+        if element is None:
+            self.action_log.append(f"Tried to type {text} via website text: {selector} but it was not a valid location to add text")
+            return (x,y)
+
+        try:
+            bounding_box = element.bounding_box()
+            if bounding_box:
+                x = bounding_box['x'] + bounding_box['width'] / 2
+                y = bounding_box['y'] + bounding_box['height'] / 2
+        except Exception as err:
+            log.warning(f"Could not do bounding box - {str(err)}")
+        
+        try:
+            element.fill(text)
+            self.page.wait_for_load_state()
+            log.info(f"Typed text '{text}' into element with selector {selector} at {x=},{y=}")
+            self.action_log.append(f"Typed text '{text}' into element with selector {selector} at {x=},{y=}")
 
-    def type_text(self, selector, text):
-        self.page.fill(selector, text)
+            return (x, y)
+        
+        except Exception as err:
+            log.warning(f"Typed text failed with {str(err)}")
+            self.action_log.append(f"Tried to type text '{text}' into element with selector {selector} at {x=},{y=} but got an error")
+
+            return (x, y)
+
+    def take_screenshot(self, final=False, full_page=False, mark_action=None):
+        timestamp = datetime.now().strftime("%Y%m%d%H%M%S")
+        parsed_url = urllib.parse.urlparse(self.page.url)
+
+        url_path = parsed_url.path
+        if url_path == "/":
+            url_path = "index.html"
+        if final:
+            screenshot_path = os.path.join(self.screenshot_dir, f"final/{timestamp}_{url_path}.png")
+        else:
+            screenshot_path = os.path.join(self.screenshot_dir, f"{timestamp}_{url_path}.png")
+        self.page.screenshot(path=screenshot_path, full_page=full_page)
+        
+        if mark_action:
+            self.mark_screenshot(screenshot_path, mark_action)
+
+        log.info(f"Screenshot {self.page.url} taken and saved to {screenshot_path}")
+        #self.action_log.append(f"Screenshot {self.page.url} taken and saved to {screenshot_path}")
+        self.session_screenshots.append(screenshot_path)
 
-    def take_screenshot(self):
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        screenshot_path = os.path.join(self.screenshot_dir, f"screenshot_{timestamp}.png")
-        self.page.screenshot(path=screenshot_path)
         return screenshot_path
 
+    def mark_screenshot(self, screenshot_path, mark_action):
+        """
+        Marks the screenshot with the specified action.
+
+        Parameters:
+            screenshot_path (str): The path to the screenshot.
+            mark_action (dict): Action details for marking the screenshot.
+        """
+        from PIL import Image, ImageDraw
+
+        image = Image.open(screenshot_path)
+        draw = ImageDraw.Draw(image)
+        
+        if mark_action['type'] == 'click':
+            x, y = mark_action['position']
+            radius = 10
+            draw.ellipse((x-radius, y-radius, x+radius, y+radius), outline='red', width=3)
+        elif mark_action['type'] == 'type':
+            x, y = mark_action['position']
+            draw.rectangle((x-5, y-5, x+5, y+5), outline='blue', width=3)
+        
+        image.save(screenshot_path)
+
     def get_latest_screenshot_path(self):
         screenshots = sorted(
             [f for f in os.listdir(self.screenshot_dir) if f.startswith('screenshot_')],
@@ -128,42 +341,139 @@ class BrowseWebWithImagePromptsBot:
             return os.path.join(self.screenshot_dir, screenshots[0])
         return None
 
-    def create_prompt_vars(self, current_action_description, next_goal):
+    def create_prompt_vars(self, last_message):
         prompt = {
-            "current_action_description": current_action_description,
-            "next_goal": next_goal,
+            "last_actions": self.action_log,
+            "session_goal": self.session_goal,
+            "last_message": last_message
         }
         return prompt
+    
+    def check_llm_response(self, response):
+        if isinstance(response, dict):
+            output = response
+        elif isinstance(response, str):
+            output = json.loads(response)
+
+        #TODO: more validation
+        log.info(f'Response: {output=}')
+
+        if 'status' not in output:
+            log.error(f'Response did not contain status')
+
+        if 'new_instructions' not in output:
+            log.warning(f'Response did not include new_instructions')
+        
+        if 'message' not in output:
+            log.warning(f'Response did not include message')
+
+        return output        
 
-    def send_screenshot_to_llm(self, screenshot_path, current_action_description="", next_goal=""):
+    def send_screenshot_to_llm(self, screenshot_path, last_message):
         with open(screenshot_path, "rb") as image_file:
             encoded_image = base64.b64encode(image_file.read()).decode('utf-8')
         
-        prompt_vars = self.create_prompt(current_action_description, next_goal)
+        prompt_vars = self.create_prompt_vars(last_message)
         response = self.send_prompt_to_llm(prompt_vars, encoded_image)  # Sending prompt and image separately
-        return json.loads(response)
+        
+        return self.check_llm_response(response)
 
     def send_prompt_to_llm(self, prompt_vars, screenshot_base64):
-        raise NotImplementedError("This method should be implemented by subclasses: `def send_prompt_to_llm(self, prompt_vars, screenshot_base64)`")
+        raise NotImplementedError("""
+This method should be implemented by subclasses: `def send_prompt_to_llm(self, prompt_vars, screenshot_base64)`")
+        prompt = {
+            "last_actions": self.action_log,
+            "session_goal": self.session_goal,
+        }
+""")
 
     def close(self):
         self.save_cookies()
         self.browser.close()
         self.playwright.stop()
 
-    def execute_instructions(self, instructions):
+    def execute_instructions(self, instructions: list, last_message: str=None):
+        if not instructions: 
+            log.info("No instructions found, returning immediately")
+            return
+        
+        if self.steps >= self.max_steps:
+            log.warning(f"Reached the maximum number of steps: {self.max_steps}")
+            return
+        
+        if not isinstance(instructions, list):
+            log.error(f"{instructions} {type(instructions)}")
         for instruction in instructions:
+            mark_action = None
+            if not isinstance(instruction, dict):
+                log.error(f"{instruction} {type(instruction)}")
             action = instruction['action']
             if action == 'navigate':
                 self.navigate(instruction['url'])
             elif action == 'click':
-                self.click(instruction['selector'])
+                x,y = self.click(instruction['selector'])
+                if (x,y) != (0,0):
+                    mark_action = {'type':'click', 'position': (x,y)}
             elif action == 'scroll':
-                self.scroll(instruction.get('direction', 'down'), instruction.get('amount', 1))
+                self.scroll(instruction.get('direction', 'down'), 
+                            int(instruction.get('amount', 1))
+                            )
             elif action == 'type':
-                self.type_text(instruction['selector'], instruction['text'])
-            screenshot_path = self.take_screenshot()
-            new_instructions = self.send_screenshot_to_llm(screenshot_path, instruction.get('description', ''), instruction.get('next_goal', ''))
-            if new_instructions:
-                self.execute_instructions(new_instructions)
+                x,y = self.type_text(instruction['selector'], instruction['text'])
+                if (x,y) != (0,0):
+                    mark_action = {'type':'type', 'position': (x,y)}
+            self.steps += 1
+            if self.steps >= self.max_steps:
+                log.warning(f"Reached the maximum number of steps: {self.max_steps}")
+                return
+            
+        screenshot_path = self.take_screenshot(mark_action=mark_action)
+        next_browser_instructions = self.send_screenshot_to_llm(
+                screenshot_path, 
+                last_message=last_message)
+            
+        return next_browser_instructions
+    
+    def start_session(self, instructions, session_goal):
+            self.session_goal = session_goal
+
+            if not instructions:
+                instructions = [{'action': 'navigate', 'url': self.website_name}]
+
+            next_instructions = self.execute_instructions(instructions)
+
+            in_session = True
+            while in_session:
+                if next_instructions and 'status' in next_instructions:
+                    if next_instructions['status'] == 'in-progress':
+                        log.info(f'Browser message: {next_instructions.get('message')}')
+                        if 'new_instructions' not in next_instructions:
+                            log.error('Browser status: "in-progress" but no new_instructions')
+                        last_message = next_instructions['message']
+                        self.action_log.append(last_message)
+                        next_instructions = self.execute_instructions(
+                            next_instructions['new_instructions'], 
+                            last_message=last_message)
+                    else:
+                        log.info(f'Session finished due to status={next_instructions["status"]}')
+                        in_session=False
+                        break
+                else:
+                    log.info('Session finished due to next_instructions being empty')
+                    in_session=False
+                    break
+            
+            log.info("Session finished")
+            final_path = self.take_screenshot(final=True)
+            self.close()
+            self.save_action_log()
+            
+            return {
+                "website": self.website_name,
+                "log": self.action_log,
+                "next_instructions": next_instructions,
+                "session_screenshots": self.session_screenshots,
+                "final_page": final_path,
+                "session_goal": self.session_goal
+            }
 

sunholo/utils/parsers.py

@@ -13,6 +13,7 @@
 #   limitations under the License.
 import re
 import hashlib
+import urllib.parse
 
 def validate_extension_id(ext_id):
     """
@@ -183,4 +184,8 @@ def escape_braces(text):
     # Replace single braces with double braces
     text = re.sub(r'(?<!{){(?!{)', '{{', text)  # Replace '{' with '{{' if not already double braced
     text = re.sub(r'(?<!})}(?!})', '}}', text)  # Replace '}' with '}}' if not already double braced
-    return text
+    return text
+
+def get_clean_website_name(url):
+    parsed_url = urllib.parse.urlparse(url)
+    return parsed_url.netloc

{sunholo-0.73.3.dist-info → sunholo-0.74.1.dist-info}/METADATA

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: sunholo
-Version: 0.73.3
+Version: 0.74.1
 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.73.3.tar.gz
+Download-URL: https://github.com/sunholo-data/sunholo-py/archive/refs/tags/v0.74.1.tar.gz
 Author: Holosun ApS
 Author-email: multivac@sunholo.com
 License: Apache License, Version 2.0
@@ -58,6 +58,7 @@ Requires-Dist: pg8000 ; extra == 'all'
 Requires-Dist: pgvector ; extra == 'all'
 Requires-Dist: pillow ; extra == 'all'
 Requires-Dist: playwright ; extra == 'all'
+Requires-Dist: psutil ; extra == 'all'
 Requires-Dist: psycopg2-binary ; extra == 'all'
 Requires-Dist: pypdf ; extra == 'all'
 Requires-Dist: python-socketio ; extra == 'all'
@@ -67,7 +68,7 @@ Requires-Dist: supabase ; extra == 'all'
 Requires-Dist: tabulate ; extra == 'all'
 Requires-Dist: tantivy ; extra == 'all'
 Requires-Dist: tiktoken ; extra == 'all'
-Requires-Dist: unstructured[local-inference] ; extra == 'all'
+Requires-Dist: unstructured[local-inference] ==0.14.9 ; extra == 'all'
 Provides-Extra: anthropic
 Requires-Dist: langchain-anthropic >=0.1.13 ; extra == 'anthropic'
 Provides-Extra: cli
@@ -114,10 +115,11 @@ Requires-Dist: tiktoken ; extra == 'openai'
 Provides-Extra: pipeline
 Requires-Dist: GitPython ; extra == 'pipeline'
 Requires-Dist: lark ; extra == 'pipeline'
+Requires-Dist: psutil ; extra == 'pipeline'
 Requires-Dist: pypdf ; extra == 'pipeline'
 Requires-Dist: pytesseract ; extra == 'pipeline'
 Requires-Dist: tabulate ; extra == 'pipeline'
-Requires-Dist: unstructured[local-inference] ; extra == 'pipeline'
+Requires-Dist: unstructured[local-inference] ==0.14.9 ; extra == 'pipeline'
 Provides-Extra: tools
 Requires-Dist: openapi-spec-validator ; extra == 'tools'
 Requires-Dist: playwright ; extra == 'tools'

{sunholo-0.73.3.dist-info → sunholo-0.74.1.dist-info}/RECORD

@@ -33,7 +33,7 @@ sunholo/chunker/pdfs.py,sha256=daCZ1xjn1YvxlifIyxskWNpLJLe-Q9D_Jq12MWx3tZo,2473
 sunholo/chunker/publish.py,sha256=tiO615A2uo_ZjzdFDzNH1PL_1kJeLMUQwLJ4w67rNIc,2932
 sunholo/chunker/splitter.py,sha256=jtGfi_ZdhVdyFhfw0e4ynEpmwIyrxQtV63OituYWy6o,6729
 sunholo/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sunholo/cli/chat_vac.py,sha256=9NNdIt0pWLZandxtav9Eu7ru9WOBHjh1TN1oP3pqMbM,22852
+sunholo/cli/chat_vac.py,sha256=MjwGJQUJOkHV4vLAlhyYVQ02JoI5pE7zaLSSaBfcTco,23019
 sunholo/cli/cli.py,sha256=u70fcSQzQx2iPvE23SVCVYRFabmZ-XtgEd6vHcrABi0,3725
 sunholo/cli/cli_init.py,sha256=JMZ9AX2cPDZ-_mv3adiv2ToFVNyRPtjk9Biszl1kiR0,2358
 sunholo/cli/configs.py,sha256=QUM9DvKOdZmEQRM5uI3Nh887T0YDiSMr7O240zTLqws,4546
@@ -98,8 +98,8 @@ sunholo/streaming/stream_lookup.py,sha256=uTTUjf96mV7OCc-Sc8N09Fpu5g0T_mD_HbSziv
 sunholo/streaming/streaming.py,sha256=9z6pXINEopuL_Z1RnmgXAoZJum9dzyuOxqYtEYnjf8w,16405
 sunholo/summarise/__init__.py,sha256=MZk3dblUMODcPb1crq4v-Z508NrFIpkSWNf9FIO8BcU,38
 sunholo/summarise/summarise.py,sha256=C3HhjepTjUhUC8FLk4jMQIBvq1BcORniwuTFHjPVhVo,3784
-sunholo/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sunholo/tools/web_browser.py,sha256=NgsAeVcndl-vMAbAfIzDJ8eRfCh5LDZan16OCNEKFmI,7094
+sunholo/tools/__init__.py,sha256=5NuYpwwTX81qGUWvgwfItoSLXteNnp7KjgD7IPZUFjI,53
+sunholo/tools/web_browser.py,sha256=ElwIBtVptyYcPd0wo7WXLNYCC02FJL_Lv3cfTzOJpnQ,19663
 sunholo/utils/__init__.py,sha256=Hv02T5L2zYWvCso5hzzwm8FQogwBq0OgtUbN_7Quzqc,89
 sunholo/utils/api_key.py,sha256=Ct4bIAQZxzPEw14hP586LpVxBAVi_W9Serpy0BK-7KI,244
 sunholo/utils/big_context.py,sha256=gJIP7_ZL-YSLhOMq8jmFTMqH1wq8eB1NK7oKPeZAq2s,5578
@@ -108,7 +108,7 @@ sunholo/utils/config_class.py,sha256=uyAsPXdxOY47CbQ8RifhUDL2BlxWP2QI-DIWBNlv6yk
 sunholo/utils/config_schema.py,sha256=Wv-ncitzljOhgbDaq9qnFqH5LCuxNv59dTGDWgd1qdk,4189
 sunholo/utils/gcp.py,sha256=uueODEpA-P6O15-t0hmcGC9dONLO_hLfzSsSoQnkUss,4854
 sunholo/utils/gcp_project.py,sha256=0ozs6tzI4qEvEeXb8MxLnCdEVoWKxlM6OH05htj7_tc,1325
-sunholo/utils/parsers.py,sha256=z98cQ1v2_ScnqHxCtApNeAN2the8MdvS6RpKL6vWyOU,5287
+sunholo/utils/parsers.py,sha256=aCIT08VjVbu8E3BAxepIiqFQa8zwu4bTgEstU_qjyg8,5414
 sunholo/utils/timedelta.py,sha256=BbLabEx7_rbErj_YbNM0MBcaFN76DC4PTe4zD2ucezg,493
 sunholo/utils/user_ids.py,sha256=SQd5_H7FE7vcTZp9AQuQDWBXd4FEEd7TeVMQe1H4Ny8,292
 sunholo/utils/version.py,sha256=P1QAJQdZfT2cMqdTSmXmcxrD2PssMPEGM-WI6083Fck,237
@@ -117,9 +117,9 @@ sunholo/vertex/extensions_class.py,sha256=4PsUM9dSYrIPpq9bZ3K2rL9MRb_rlqAgnMsW0o
 sunholo/vertex/init.py,sha256=-w7b9GKsyJnAJpYHYz6_zBUtmeJeLXlEkgOfwoe4DEI,2715
 sunholo/vertex/memory_tools.py,sha256=pomHrDKqvY8MZxfUqoEwhdlpCvSGP6KmFJMVKOimXjs,6842
 sunholo/vertex/safety.py,sha256=S9PgQT1O_BQAkcqauWncRJaydiP8Q_Jzmu9gxYfy1VA,2482
-sunholo-0.73.3.dist-info/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
-sunholo-0.73.3.dist-info/METADATA,sha256=oZNyJJifnIAdT0EMyILv8u5vKUaR4lzyPUmNcXU9bvw,6909
-sunholo-0.73.3.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
-sunholo-0.73.3.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
-sunholo-0.73.3.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
-sunholo-0.73.3.dist-info/RECORD,,
+sunholo-0.74.1.dist-info/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
+sunholo-0.74.1.dist-info/METADATA,sha256=6QFlkGilosGyFUklfh5uzkTD4ghMdfCNuzwyLmiSyCE,7010
+sunholo-0.74.1.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
+sunholo-0.74.1.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
+sunholo-0.74.1.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
+sunholo-0.74.1.dist-info/RECORD,,