sunholo 0.71.10__py3-none-any.whl → 0.71.12__py3-none-any.whl

sunholo/discovery_engine/discovery_engine_client.py

@@ -87,8 +87,14 @@ class DiscoveryEngineClient:
             location=self.location,
             collection=collection,
         )
+    
+    def create_data_store(self, type="chunk", chunk_size: int = 500, collection: str = "default_collection"):
+        if type == "chunk":
+            return self.create_data_store_chunk(chunk_size, collection)
+        else:
+            raise NotImplementedError("Not done yet - non-chunk data stores.")
 
-    def create_data_store(
+    def create_data_store_chunk(
         self, chunk_size: int = 500,
         collection: str = "default_collection"
     ) -> str:
@@ -166,7 +172,6 @@ class DiscoveryEngineClient:
         num_next_chunks: int = 3,
         page_size: int = 10,
         parse_chunks_to_string: bool = True,
-        doc_or_chunks: str = "CHUNKS",  # or DOCUMENTS
         serving_config: str = "default_serving_config",
     ):
         """Retrieves chunks or documents based on a query.
@@ -178,6 +183,7 @@ class DiscoveryEngineClient:
             num_next_chunks (int, optional): Number of next chunks to return for context (default is 3).
             page_size (int, optional): The maximum number of results to return per page (default is 10).
             parse_chunks_to_string: If True will put chunks in one big string, False will return object
+            serving_config: The resource name of the Search serving config 
 
         Returns:
             discoveryengine.SearchResponse: The search response object containing the search results.
@@ -198,12 +204,13 @@ class DiscoveryEngineClient:
             serving_config
         )
 
+
         search_request = discoveryengine.SearchRequest(
             serving_config=serving_config_path,
             query=query,
             page_size=page_size, 
             content_search_spec=discoveryengine.SearchRequest.ContentSearchSpec(
-                search_result_mode=doc_or_chunks,  # CHUNKS or DOCUMENTS
+                search_result_mode="CHUNKS", 
                 chunk_spec=discoveryengine.SearchRequest.ContentSearchSpec.ChunkSpec(
                     num_previous_chunks=num_previous_chunks,
                     num_next_chunks=num_next_chunks,
@@ -270,7 +277,9 @@ class DiscoveryEngineClient:
         search_tier=None,
         search_add_ons=None,
     ) -> str:
-
+        """
+        You only need this if calling Data Store via Vertex Tools.
+        """
         # The full resource name of the collection
         # e.g. projects/{project}/locations/{location}/collections/default_collection
         parent = self.data_store_path()
@@ -300,8 +309,13 @@ class DiscoveryEngineClient:
         )
 
         # Make the request
-        operation = self.engine_client.create_engine(request=request)
+        try:
+            operation = self.engine_client.create_engine(request=request)
+        except AlreadyExists as err:
+            log.info(f"Engine already exists: - {str(err)}")
 
+            return engine_id
+        
         log.info(f"Waiting for create vertex ai search operation to complete: {operation.operation.name}")
         response = operation.result()
 

sunholo/tools/web_browser.py

@@ -0,0 +1,169 @@
+import os
+import base64
+import json
+from datetime import datetime
+try:
+    from playwright.sync_api import sync_playwright
+except ImportError:
+    sync_playwright = None
+
+class BrowseWebWithImagePromptsBot:
+    """
+    Examples:
+
+    ```python
+    class ProductionBot(BrowseWebWithImagePromptsBot):
+        def send_prompt_to_llm(self, prompt, 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,
+                "screenshot": screenshot_base64
+            }
+            response = requests.post(api_url, headers=headers, data=json.dumps(data))
+            return response.text  # Assuming the response is in JSON format
+
+    @app.route('/run-bot', methods=['POST'])
+    def run_bot():
+        data = request.json
+        session_id = data.get('session_id')
+        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', "")
+        
+        bot = ProductionBot(session_id=session_id, website_name=website_name, browser_type=browser_type, headless=True)
+        
+        # Check if initial instructions are provided
+        initial_instructions = data.get('instructions')
+        if initial_instructions:
+            bot.execute_instructions(initial_instructions)
+        
+        # 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 final screenshot
+        bot.take_screenshot()
+        
+        bot.close()
+        
+        return jsonify({"status": "completed", "new_instructions": new_instructions})
+
+    if __name__ == "__main__":
+        app.run(host='0.0.0.0', port=8080)
+    ```
+    """
+    def __init__(self, session_id, website_name, browser_type='chromium', headless=True):
+        if not sync_playwright:
+            raise ImportError("playright needed for BrowseWebWithImagePromptsBot class - install via `pip install sunholo[tools]`")
+        self.session_id = session_id
+        self.website_name = website_name
+        self.browser_type = browser_type
+        self.screenshot_dir = f"{website_name}_{session_id}"
+        os.makedirs(self.screenshot_dir, exist_ok=True)
+        self.cookie_file = os.path.join(self.screenshot_dir, "cookies.json")
+        self.playwright = sync_playwright().start()
+        
+        if browser_type == 'chromium':
+            self.browser = self.playwright.chromium.launch(headless=headless)
+        elif browser_type == 'firefox':
+            self.browser = self.playwright.firefox.launch(headless=headless)
+        elif browser_type == 'webkit':
+            self.browser = self.playwright.webkit.launch(headless=headless)
+        else:
+            raise ValueError(f"Unsupported browser type: {browser_type}")
+        
+        self.context = self.browser.new_context()
+        self.page = self.context.new_page()
+        self.load_cookies()
+
+    def load_cookies(self):
+        if os.path.exists(self.cookie_file):
+            with open(self.cookie_file, 'r') as f:
+                cookies = json.load(f)
+                self.context.add_cookies(cookies)
+
+    def save_cookies(self):
+        cookies = self.context.cookies()
+        with open(self.cookie_file, 'w') as f:
+            json.dump(cookies, f)
+
+    def navigate(self, url):
+        self.page.goto(url)
+
+    def click(self, selector):
+        self.page.click(selector)
+
+    def scroll(self, direction='down', amount=1):
+        for _ in range(amount):
+            if direction == 'down':
+                self.page.evaluate("window.scrollBy(0, window.innerHeight)")
+            elif direction == 'up':
+                self.page.evaluate("window.scrollBy(0, -window.innerHeight)")
+            elif direction == 'left':
+                self.page.evaluate("window.scrollBy(-window.innerWidth, 0)")
+            elif direction == 'right':
+                self.page.evaluate("window.scrollBy(window.innerWidth, 0)")
+
+    def type_text(self, selector, text):
+        self.page.fill(selector, text)
+
+    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 get_latest_screenshot_path(self):
+        screenshots = sorted(
+            [f for f in os.listdir(self.screenshot_dir) if f.startswith('screenshot_')],
+            key=lambda x: os.path.getmtime(os.path.join(self.screenshot_dir, x)),
+            reverse=True
+        )
+        if screenshots:
+            return os.path.join(self.screenshot_dir, screenshots[0])
+        return None
+
+    def create_prompt_vars(self, current_action_description, next_goal):
+        prompt = {
+            "current_action_description": current_action_description,
+            "next_goal": next_goal,
+        }
+        return prompt
+
+    def send_screenshot_to_llm(self, screenshot_path, current_action_description="", next_goal=""):
+        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)
+        response = self.send_prompt_to_llm(prompt_vars, encoded_image)  # Sending prompt and image separately
+        return json.loads(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)`")
+
+    def close(self):
+        self.save_cookies()
+        self.browser.close()
+        self.playwright.stop()
+
+    def execute_instructions(self, instructions):
+        for instruction in instructions:
+            action = instruction['action']
+            if action == 'navigate':
+                self.navigate(instruction['url'])
+            elif action == 'click':
+                self.click(instruction['selector'])
+            elif action == 'scroll':
+                self.scroll(instruction.get('direction', 'down'), 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)
+

sunholo/vertex/__init__.py

@@ -1,3 +1,3 @@
 from .init import init_vertex
 from .memory_tools import get_vertex_memories, print_grounding_response, get_google_search_grounding
-from .safety import vertex_safety
+from .safety import vertex_safety, genai_safety

sunholo/vertex/memory_tools.py

@@ -88,6 +88,10 @@ def get_vertex_memories(vector_name):
 
                 try:
                     project_id = value.get('project_id') or get_gcp_project()
+                    if value.get('chunks'):
+                        log.warning("Data stores for chunks do not work with Tools yet, call data store directly instead")
+                        continue
+
                     de = DiscoveryEngineClient(vector_name, project_id=project_id)
                     log.info(f"Found vectorstore {vectorstore}")
 

sunholo/vertex/safety.py

@@ -1,10 +1,37 @@
-try:
-    from vertexai.generative_models import (
+
+
+def genai_safety(threshold: str = "BLOCK_ONLY_HIGH"):
+    """
+    BLOCK_ONLY_HIGH - block when high probability of unsafe content is detected
+    BLOCK_MEDIUM_AND_ABOVE - block when medium or high probability of content is detected
+    BLOCK_LOW_AND_ABOVE - block when low, medium, or high probability of unsafe content is detected
+    BLOCK_NONE - no block, but need to be on an allow list to use
+    """
+    from google.generativeai.types import (
         HarmCategory,
-        HarmBlockThreshold,
+        HarmBlockThreshold
     )
-except ImportError:
-    pass
+
+    if threshold == 'BLOCK_ONLY_HIGH':
+        thresh = HarmBlockThreshold.BLOCK_ONLY_HIGH
+    elif threshold == 'BLOCK_MEDIUM_AND_ABOVE':
+        thresh = HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE
+    elif threshold == 'BLOCK_LOW_AND_ABOVE':
+        thresh = HarmBlockThreshold.BLOCK_LOW_AND_ABOVE
+    elif threshold == 'BLOCK_NONE':
+        thresh = HarmBlockThreshold.BLOCK_NONE
+    else:
+        raise ValueError("Invalid threshold")
+
+    safety_settings = {
+        HarmCategory.HARM_CATEGORY_HARASSMENT: thresh,
+        HarmCategory.HARM_CATEGORY_HATE_SPEECH: thresh,
+        HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: thresh,
+        HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: thresh,
+    }
+
+    return safety_settings
+
 
 def vertex_safety(threshold: str = "BLOCK_ONLY_HIGH"):
     """
@@ -13,6 +40,10 @@ def vertex_safety(threshold: str = "BLOCK_ONLY_HIGH"):
     BLOCK_LOW_AND_ABOVE - block when low, medium, or high probability of unsafe content is detected
     BLOCK_NONE - no block, but need to be on an allow list to use
     """
+    from vertexai.generative_models import (
+        HarmCategory,
+        HarmBlockThreshold,
+    )
 
     if threshold == 'BLOCK_ONLY_HIGH':
         thresh = HarmBlockThreshold.BLOCK_ONLY_HIGH

{sunholo-0.71.10.dist-info → sunholo-0.71.12.dist-info}/METADATA

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: sunholo
-Version: 0.71.10
+Version: 0.71.12
 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.71.10.tar.gz
+Download-URL: https://github.com/sunholo-data/sunholo-py/archive/refs/tags/v0.71.12.tar.gz
 Author: Holosun ApS
 Author-email: multivac@sunholo.com
 License: Apache License, Version 2.0
@@ -124,6 +124,16 @@ This is the Sunholo Python project, a comprehensive toolkit for working with lan
 
 Please refer to the website for full documentation at https://dev.sunholo.com/
 
+## Tests via pytest
+
+If loading from GitHub, run tests:
+
+```bash
+pip install pytest
+pip install . --use-feature=in-tree-build
+pytest tests
+```
+
 ## Demos
 
 Using https://github.com/charmbracelet/vhs

{sunholo-0.71.10.dist-info → sunholo-0.71.12.dist-info}/RECORD

@@ -63,7 +63,7 @@ sunholo/database/sql/sb/setup.sql,sha256=CvoFvZQev2uWjmFa3aj3m3iuPFzAAJZ0S7Qi3L3
 sunholo/discovery_engine/__init__.py,sha256=qUKWzuHApDRJIUoynukVdGRBEq8eC9T7l9a3bWckgI0,59
 sunholo/discovery_engine/chunker_handler.py,sha256=H1HHDqWMCkchJER1_oU9TOLxqf2PygiMO6CL3uKZP64,4563
 sunholo/discovery_engine/create_new.py,sha256=7oZG78T6lW0EspRzlo7-qRyXFSuFxDn2dfSAVEaqlqY,978
-sunholo/discovery_engine/discovery_engine_client.py,sha256=-e3rzmqYcVmb-Q7scq-ae1NF7hQGfJCIU1ym2Cu2u6g,17167
+sunholo/discovery_engine/discovery_engine_client.py,sha256=YYsFeaW41l8jmWCruQnYxJGKEYBZ7dduTBDhdxI63hQ,17719
 sunholo/embedder/__init__.py,sha256=sI4N_CqgEVcrMDxXgxKp1FsfsB4FpjoXgPGkl4N_u4I,44
 sunholo/embedder/embed_chunk.py,sha256=d_dIzeNF630Q0Ar-u1hxos60s0tLIImJccAvuo_LTIw,6814
 sunholo/gcs/__init__.py,sha256=DtVw_AZwQn-IguR5BJuIi2XJeF_FQXizhJikzRNrXiE,50
@@ -96,6 +96,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/utils/__init__.py,sha256=G11nN_6ATjxpuMfG_BvcUr9UU8onPIgkpTK6CjOcbr8,48
 sunholo/utils/api_key.py,sha256=Ct4bIAQZxzPEw14hP586LpVxBAVi_W9Serpy0BK-7KI,244
 sunholo/utils/big_context.py,sha256=gJIP7_ZL-YSLhOMq8jmFTMqH1wq8eB1NK7oKPeZAq2s,5578
@@ -107,15 +109,15 @@ sunholo/utils/parsers.py,sha256=z98cQ1v2_ScnqHxCtApNeAN2the8MdvS6RpKL6vWyOU,5287
 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
-sunholo/vertex/__init__.py,sha256=dZa4xWYo-KU6br7SHZJPzfB4T6ICGkw_FshDs1tvnCA,165
+sunholo/vertex/__init__.py,sha256=36ogRu_aP2OqPniHjtd6Pb0iBtHpBBkvX692eU42J20,179
 sunholo/vertex/extensions.py,sha256=d-Ikt9gHFf-jUMPmyU-xHwYe22QtEyr90Ua1LDKgTws,11026
 sunholo/vertex/extensions_class.py,sha256=0-XMrMvfhMN380ZdGXl11Mt7R9kCu9rB4Vduiflk8QA,9202
 sunholo/vertex/init.py,sha256=RLjQppTUwubWgwf2PoAke-EtcwlVkFPaPMYvUsMw1KQ,2029
-sunholo/vertex/memory_tools.py,sha256=sipBI7TFttbYzobSWS_1TzWFVTPnJckz3NvLVbTepMc,6345
-sunholo/vertex/safety.py,sha256=3meAX0HyGZYrH7rXPUAHxtI_3w_zoy_RX7Shtkoa660,1275
-sunholo-0.71.10.dist-info/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
-sunholo-0.71.10.dist-info/METADATA,sha256=LIiaYAQSZmRw9v6rhqq3i-GZjIP_K9zZItlJ-j9cxW0,6615
-sunholo-0.71.10.dist-info/WHEEL,sha256=mguMlWGMX-VHnMpKOjjQidIo1ssRlCFu4a4mBpz1s2M,91
-sunholo-0.71.10.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
-sunholo-0.71.10.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
-sunholo-0.71.10.dist-info/RECORD,,
+sunholo/vertex/memory_tools.py,sha256=FLTbNX_YbpxxUxZHAsXEihlUgLELfLOfxsdEkwDm_GI,6546
+sunholo/vertex/safety.py,sha256=S9PgQT1O_BQAkcqauWncRJaydiP8Q_Jzmu9gxYfy1VA,2482
+sunholo-0.71.12.dist-info/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
+sunholo-0.71.12.dist-info/METADATA,sha256=7ELMJTOfh4YUo1BPQV2khVCSZbBuWoVc3reFFo6robc,6759
+sunholo-0.71.12.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
+sunholo-0.71.12.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
+sunholo-0.71.12.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
+sunholo-0.71.12.dist-info/RECORD,,

{sunholo-0.71.10.dist-info → sunholo-0.71.12.dist-info}/WHEEL

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