simplex 1.2.4__py3-none-any.whl → 1.2.5__py3-none-any.whl

simplex/cli.py

@@ -0,0 +1,31 @@
+import click
+from .deploy import push_directory, run_directory
+import os
+
+@click.group()
+def cli():
+    """Simplex CLI tool"""
+    pass
+
+@cli.command()
+@click.argument('directory', type=click.Path(exists=True, file_okay=False, dir_okay=True))  
+def push(directory):
+    try:
+        push_directory(directory)
+    except Exception as e:
+        print(f"Error running job: {e}")
+        raise
+    
+    
+
+@cli.command()
+@click.argument('directory', type=click.Path(exists=True, file_okay=False, dir_okay=True))
+def run(directory):
+    try:
+        run_directory(directory)
+    except Exception as e:
+        print(f"Error running job: {e}")
+        raise
+
+def main():
+    cli() 

simplex/deploy/__init__.py

@@ -0,0 +1,3 @@
+from .push import push_directory, run_directory
+
+__all__ = ['push_directory', 'run_directory'] 

simplex/deploy/push.py

@@ -0,0 +1,208 @@
+import os
+import yaml
+import tempfile
+import zipfile
+from pathlib import Path
+from dotenv import load_dotenv
+import requests
+from typing import Optional
+from datetime import datetime, timedelta
+load_dotenv()  # This loads the .env file
+
+S3_URL = "https://u3mvtbirxf.us-east-1.awsapprunner.com"
+JOB_URL = "https://simplex--job-scheduler-app-handler.modal.run"
+
+def read_config(directory: str) -> dict:
+    """Read and validate the simplex.yaml configuration file"""
+    config_path = Path(directory) / "simplex.yaml"
+    if not config_path.exists():
+        raise FileNotFoundError(f"No simplex.yaml found in {directory}")
+    
+    with open(config_path) as f:
+        return yaml.safe_load(f)
+
+
+def create_archive(directory: str, config: dict) -> str:
+    """Create a temporary zip archive of the entire directory"""
+    with tempfile.NamedTemporaryFile(suffix='.zip', delete=False) as tmp:
+        with zipfile.ZipFile(tmp.name, 'w', zipfile.ZIP_DEFLATED) as zip_file:
+            base_path = Path(directory)
+            
+            # Walk through all files and directories
+            for root, dirs, files in os.walk(directory):
+                for file in files:
+                    file_path = Path(root) / file
+                    # Get path relative to the base directory
+                    relative_path = file_path.relative_to(base_path)
+                    # Add file to zip with its relative path
+                    zip_file.write(file_path, arcname=str(relative_path))
+                    
+        return tmp.name
+
+def push_directory(directory: str):
+    """Main function to handle parsing yaml and creating zip archive"""
+    config = read_config(directory)
+    archive_path = create_archive(directory, config)
+    
+    project_name = config.get('name')
+    if not project_name:
+        raise ValueError("Project name not specified in simplex.yaml")
+    
+    cron_schedule = config.get("cron_schedule", None)
+    if not cron_schedule:
+        raise ValueError("Cron schedule not specified in simplex.yaml")
+    
+    try:
+        s3_uri = upload_files_to_s3(archive_path, project_name)
+    except Exception as e:
+        print(f"Error uploading project: {e}")
+        raise
+    finally:
+        os.unlink(archive_path)
+
+    try:
+        create_job_scheduled(project_name, cron_schedule, s3_uri)
+    except Exception as e:
+        print(f"Error creating job: {e}")
+        raise
+    finally:
+        print("Successfully created job!")
+    
+    
+
+def upload_files_to_s3(archive_path: str, project_name: str):
+    # Read API key from environment
+    api_key = os.getenv('SIMPLEX_API_KEY')
+    if not api_key:
+        raise ValueError("SIMPLEX_API_KEY environment variable not set")
+
+    url = S3_URL + "/upload_files_to_s3"
+
+    try:
+        # Prepare the multipart form data
+        files = {
+            'zip_file': ('archive.zip', open(archive_path, 'rb'), 'application/zip')
+        }
+        data = {
+            'project_name': project_name,
+        }
+        headers = {
+            'x-api-key': api_key
+        }
+
+        # Make the POST request
+        response = requests.post(
+            url,
+            files=files,
+            data=data,
+            headers=headers
+        )
+    
+        # Check response
+        response.raise_for_status()
+        result = response.json()
+        print(f"Successfully uploaded project: {result['project_name']}")
+        return result['s3_uri']
+    except Exception as e:
+        print(f"Error uploading project: {e}")
+        raise
+
+def create_job_scheduled(project_name: str, cron_schedule: str, s3_uri: str):
+    """Create a new job via the API"""
+    # Read API key from environment
+    api_key = os.getenv('SIMPLEX_API_KEY')
+    if not api_key:
+        raise ValueError("SIMPLEX_API_KEY environment variable not set")
+
+    url = JOB_URL + "/api/v1/jobs/"
+
+    try:
+        headers = {
+            'Content-Type': 'application/json',
+            'X-API-Key': api_key
+        }
+
+        data = {
+            'name': project_name,
+            's3_uri': s3_uri,
+            'cron_schedule': cron_schedule
+        }
+
+        response = requests.post(
+            url,
+            json=data,
+            headers=headers
+        )
+
+        # Check response
+        response.raise_for_status()
+        result = response.json()
+        print(f"Successfully created job: {result['name']}")
+        return result
+
+    except Exception as e:
+        print(f"Error creating job: {e}")
+        raise
+
+    
+def create_job_immediately(project_name: str, s3_uri: str):
+    """Create a new job via the API"""
+    # Read API key from environment
+    api_key = os.getenv('SIMPLEX_API_KEY')
+    if not api_key:
+        raise ValueError("SIMPLEX_API_KEY environment variable not set")
+
+    url = JOB_URL + "/api/v1/jobs/"
+    
+
+    try:
+        headers = {
+            'Content-Type': 'application/json',
+            'X-API-Key': api_key
+        }
+
+        data = {
+            'name': project_name,
+            's3_uri': s3_uri,
+            'schedule_time': (datetime.utcnow() + timedelta(minutes=2)).strftime("%Y-%m-%dT%H:%M:%SZ")
+        }
+
+        response = requests.post(
+            url,
+            json=data,
+            headers=headers
+        )
+
+        # Check response
+        response.raise_for_status()
+        result = response.json()
+        print(f"Successfully created job: {result['name']}")
+        return result
+
+    except Exception as e:
+        print(f"Error creating job: {e}")
+        raise
+
+def run_directory(directory: str):
+    """Run a directory immediately"""
+    config = read_config(directory)
+    archive_path = create_archive(directory, config)
+    
+    project_name = config.get('name')
+    if not project_name:
+        raise ValueError("Project name not specified in simplex.yaml")
+    
+    try:
+        s3_uri = upload_files_to_s3(archive_path, project_name)
+    except Exception as e:
+        print(f"Error uploading project: {e}")
+        raise
+
+    finally:
+        os.unlink(archive_path)
+
+    try:
+        create_job_immediately(project_name, s3_uri)
+    except Exception as e:
+        print(f"Error creating job: {e}")
+        raise

simplex/simplex.py

@@ -1,324 +1,234 @@
-from playwright.sync_api import Page, sync_playwright, Browser
-from PIL import Image
-import requests
-from typing import List
-import io
+import os
+import requests 
+import atexit
 
-from .utils import center_bbox, screenshot_to_image
-
-BASE_URL = "https://u3mvtbirxf.us-east-1.awsapprunner.com"
+BASE_URL = "https://api.simplex.sh"
 
 class Simplex:
-    def __init__(self, api_key: str, browser: Browser = None):
-        """
-        Initialize Simplex instance
-        
-        Args:
-            api_key (str): API key for authentication
-            browser (optional): Browser instance (for Hyperbrowser integration)
-        """
+    def __init__(self, api_key: str):
         self.api_key = api_key
-        self.browser = browser
+        self.session_id = None
+        atexit.register(self.cleanup_session)
+
+    def cleanup_session(self):
+        if self.session_id:
+            try:
+                self.close_session(self.session_id)
+            except:
+                pass
+
+    def close_session(self):
+        response = requests.post(
+            f"{BASE_URL}/close",
+            headers={
+                'x-api-key': self.api_key
+            },
+            data={'session_id': self.session_id}
+        )
+        self.session_id = None
+        return response.json()
+
+    def create_session(self):
+        response = requests.post(
+            f"{BASE_URL}/create-session",
+            headers={
+                'x-api-key': self.api_key
+            }
+        )
+
+        response_json = response.json()
+        self.session_id = response_json['session_id']
+        livestream_url = response_json['livestream_url']
+
+        print(f"\nSession created successfully!")
+        print(f"Session ID: {self.session_id}")
+        print(f"Livestream URL: {livestream_url}\n")
+
+        return self.session_id, livestream_url
+
+    def goto(self, url: str, cdp_url: str = None):
+        if not cdp_url and not self.session_id:
+            raise ValueError(f"Must call create_session before calling action goto with url='{url}'")
         
-        if browser is None:
-            self.playwright = sync_playwright().start()
-            self.browser = self.playwright.chromium.launch(headless=True)
-            self.driver = self.browser.new_page()
+        if not url.startswith('http://') and not url.startswith('https://'):
+            url = 'https://' + url
+
+        data = {'url': url}
+
+        if cdp_url:
+            data['cdp_url'] = cdp_url
         else:
-            self.playwright = None
-            self.driver = self.browser.contexts[0].pages[0]
-            self.driver.set_default_navigation_timeout(0)
-            self.driver.set_default_timeout(0)
-
-    def extract_bbox(self, element_description: str, state: Image.Image | None = None, annotate: bool = True) -> List[int]:
-        """
-        Find an element in the screenshot using the element description
-
-        Args:
-            element_description (str): Description of the element to find
-            screenshot (PIL.Image.Image): Screenshot of the page
-        
-        Returns:
-            bounding_box (tuple): [x1, y1, x2, y2] bounding box of the found element
-        """
-        print(f"[SIMPLEX] Finding element \"{element_description}\"...")
-        if state is None:
-            state = self.take_stable_screenshot()
-
-        endpoint = f"{BASE_URL}/find-element"
-        
-        # Convert PIL Image to bytes
-        img_byte_arr = io.BytesIO()
-        state.save(img_byte_arr, format='PNG')
-        img_byte_arr = img_byte_arr.getvalue()
-        
-        # Prepare multipart form data
-        files = {
-            'image_data': ('screenshot.png', img_byte_arr, 'image/png'),
-            'element_description': (None, element_description),
-            'api_key': (None, self.api_key)
-        }        
-        print("[SIMPLEX] Sending screenshot to server...")
-        # Make the request
+            data['session_id'] = self.session_id
+
         response = requests.post(
-            endpoint,
-            files=files
+            f"{BASE_URL}/goto",
+            headers={
+                'x-api-key': self.api_key
+            },
+            data=data
         )
+        print(response.json())
+
+    def click(self, element_description: str, cdp_url: str = None):
+        if not cdp_url and not self.session_id:
+            raise ValueError(f"Must call create_session before calling action click with element_description='{element_description}'")
 
+        data = {'element_description': element_description}
 
-        # Print the results
-        print(response.status_code)
-        if response.status_code == 200:
-            res = response.json()
-            bbox = [int(res['x1']), int(res['y1']), int(res['x2']), int(res['y2'])]
-
-            # Add overlay directly to the page if driver exists
-            if hasattr(self, 'driver') and annotate:
-                # Create and inject overlay element
-                self.driver.evaluate("""
-                    (bbox) => {
-                        // Remove any existing overlay
-                        const existingOverlay = document.getElementById('simplex-bbox-overlay');
-                        if (existingOverlay) {
-                            existingOverlay.remove();
-                        }
-                        
-                        // Create new overlay
-                        const overlay = document.createElement('div');
-                        overlay.id = 'simplex-bbox-overlay';
-                        overlay.style.position = 'fixed';
-                        overlay.style.border = '2px dashed rgba(0, 255, 0, 1)';
-                        overlay.style.background = 'rgba(74, 144, 226, 0.1)';
-                        overlay.style.animation = 'marching-ants 0.5s linear infinite';
-                        overlay.style.left = bbox[0] + 'px';
-                        overlay.style.top = bbox[1] + 'px';
-                        overlay.style.width = (bbox[2] - bbox[0]) + 'px';
-                        overlay.style.height = (bbox[3] - bbox[1]) + 'px';
-                        overlay.style.pointerEvents = 'none';
-                        overlay.style.zIndex = '10000';
-                        overlay.style.margin = '0';
-                        overlay.style.padding = '0';
-                        
-                        // Add marching ants animation keyframes
-                        if (!document.querySelector('#marching-ants-keyframes')) {
-                            const style = document.createElement('style');
-                            style.id = 'marching-ants-keyframes';
-                            style.textContent = `
-                                @keyframes marching-ants {
-                                    0% { border-style: dashed; }
-                                    50% { border-style: solid; }
-                                    100% { border-style: dashed; }
-                                }
-                            `;
-                            document.head.appendChild(style);
-                        }
-                        
-                        document.body.appendChild(overlay);
-
-                        // Remove overlay after 3 second
-                        setTimeout(() => {
-                            overlay.remove();
-                        }, 2000);
-                    }
-                """, bbox)
-                self.driver.wait_for_selector('#simplex-bbox-overlay')
-            return bbox 
+        if cdp_url:
+            data['cdp_url'] = cdp_url
         else:
-            print("[SIMPLEX] Error:", response.text)
+            data['session_id'] = self.session_id
 
-    def step_to_action(self, step_description: str, state: Image.Image | None = None) -> List[List[str]]:
-        """
-        Convert a step description to an action
+        response = requests.post(
+            f"{BASE_URL}/click",
+            headers={
+                'x-api-key': self.api_key
+            },
+            data=data
+        )
+        print(response.json())
 
-        Args:
-            step_description (str): Description of the step to convert to action
-            screenshot (PIL.Image.Image): Screenshot of the page
-        
-        Returns:
-            action (List[List[str, str]]): List of actions to perform
-        """
-        if state is None:
-            state = self.take_stable_screenshot()
+    def type(self, text: str, cdp_url: str = None):
+        if not cdp_url and not self.session_id:
+            raise ValueError(f"Must call create_session before calling action type with text='{text}'")
+
+        data = {'text': text}
+
+        if cdp_url:
+            data['cdp_url'] = cdp_url
+        else:
+            data['session_id'] = self.session_id
 
-        endpoint = f"{BASE_URL}/step_to_action"
-        
-        # Convert PIL Image to bytes
-        img_byte_arr = io.BytesIO()
-        state.save(img_byte_arr, format='PNG')
-        img_byte_arr = img_byte_arr.getvalue()
-        
-        # Prepare form data
-        files = {
-            'image_data': ('screenshot.png', img_byte_arr, 'image/png'),
-            'step': (None, step_description),
-            'api_key': (None, self.api_key)
-        }
-        
-        # Make the request
         response = requests.post(
-            endpoint,
-            files=files
+            f"{BASE_URL}/type",
+            headers={
+                'x-api-key': self.api_key
+            },
+            data=data
         )
-        
-        # Handle response
-        if response.status_code == 200:
-            res = response.json()
-            actions = res.split('\n')
-            actions = [action.split(',') for action in actions]
-            actions = [[action.strip() for action in action_pair] for action_pair in actions]
-            return actions
+        print(response.json())
+
+    def press_enter(self, cdp_url: str = None):
+        if not cdp_url and not self.session_id:
+            raise ValueError("Must call create_session before calling action press_enter")
+
+        data = {}
+
+        if cdp_url:
+            data['cdp_url'] = cdp_url
         else:
-            print(f"[SIMPLEX] Error: {response.status_code}")
-            print(response.text)
-            return []
-        
-    def goto(self, url: str, new_tab: bool = False) -> None:
-        """
-        Navigate to a URL
-
-        Args:
-            url (str): URL to navigate to
-            new_tab (bool): Whether to open a new tab or use the current tab
-        """
-        if new_tab:
-            self.driver = self.browser.new_page()
-        self.driver.wait_for_load_state()
-        print(f"[SIMPLEX] Navigating to URL {url}...")
-        self.driver.goto(url)
-
-    def click(self, element_description: str, annotate: bool = True) -> None:
-        """
-        Click on an element
-        """
-        self.execute_action(["CLICK", element_description], annotate=annotate)
-
-    def type(self, text: str) -> None:
-        """
-        Type text into an element
-        """
-        self.execute_action(["TYPE", text])
-
-    def press_enter(self, annotate: bool = True) -> None:
-        """
-        Press enter
-        """
-        self.execute_action(["ENTER", ""], annotate=annotate)
-
-    def scroll(self, scroll_amount: int, annotate: bool = True) -> None:
-        """
-        Scroll the page
-        """
-        self.execute_action(["SCROLL", scroll_amount], annotate=annotate)
-
-    def wait(self, wait_time: int, annotate: bool = True) -> None:
-        """
-        Wait for a given amount of time
-        """
-        self.execute_action(["WAIT", wait_time], annotate=annotate)
-
-    def execute_action(self, action: List[List[str]], state: Image.Image | None = None, annotate: bool = True) -> None:
-        """
-        Execute an action with playwright driver
-
-        Args:
-            action (List[List[str]]): List of actions to perform
-        """
-        action_type, description = action
-        try:
-            if action_type == "CLICK":
-                bbox = self.extract_bbox(description, state, annotate=annotate)
-                center_x, center_y = center_bbox(bbox)
-                self.driver.mouse.click(center_x, center_y)
-                print(f"[SIMPLEX] Clicked on element \"{description}\"")
-            elif action_type == "TYPE":
-                self.driver.keyboard.type(description)
-                print(f"[SIMPLEX] Typed \"{description}\"")
-
-            elif action_type == "ENTER":
-                self.driver.keyboard.press("Enter")
-                print(f"[SIMPLEX] Pressed enter")
-
-            elif action_type == "SCROLL":
-                self.driver.mouse.wheel(0, int(description))
-                print(f"[SIMPLEX] Scrolled {description} pixels")
-
-            elif action_type == "WAIT":
-                self.driver.wait_for_timeout(int(description))
-                print(f"[SIMPLEX] Waited {description} seconds")
-
-        except Exception as e:
-            print(f"[SIMPLEX] Error executing action: {e}")
-            return None
-        
-    def do(self, step_description: str, annotate: bool = True) -> None:
-        """
-        Execute a step description
-        """
-        state = self.take_stable_screenshot()
-        actions = self.step_to_action(step_description, state)
-        for action in actions:
-            self.execute_action(action, annotate=annotate)
-    
-    def extract_text(self, element_description: str, state: Image.Image | None = None) -> List[str] | None:
-        """
-        Extract an element text from the page
-        """
-        print(f"[SIMPLEX] Finding element \"{element_description}\"...")
-        if state is None:
-            state = self.take_stable_screenshot()
-
-        endpoint = f"{BASE_URL}/extract-text"
-        
-        # Convert PIL Image to bytes
-        img_byte_arr = io.BytesIO()
-        state.save(img_byte_arr, format='PNG')
-        img_byte_arr = img_byte_arr.getvalue()
-        
-        # Prepare multipart form data
-        files = {
-            'image_data': ('screenshot.png', img_byte_arr, 'image/png'),
-            'element_description': (None, element_description),
-            'api_key': (None, self.api_key)
-        }        
-        print("[SIMPLEX] Sending screenshot to server...")
-
-        # Make the request
+            data['session_id'] = self.session_id
+
         response = requests.post(
-            endpoint,
-            files=files
+            f"{BASE_URL}/press-enter",
+            headers={
+                'x-api-key': self.api_key
+            },
+            data=data
         )
-        
-        # Print the results
-        if response.status_code == 200:
-            res = response.json()
-            text = res['text']
-            return text
+        print(response.json())
+
+    def extract_bbox(self, element_description: str, cdp_url: str = None):
+        if not cdp_url and not self.session_id:
+            raise ValueError(f"Must call create_session before calling action extract_bbox with element_description='{element_description}'")
+
+        data = {'element_description': element_description}
+
+        if cdp_url:
+            data['cdp_url'] = cdp_url
         else:
-            print("[SIMPLEX] Error:", response.text)
-            return None
-        
-    def extract_image(self, element_description: str, state: Image.Image | None = None) -> Image.Image | None:
-        """
-        Extract an element image from the page
-        """
-        if state is None:
-            state = self.take_stable_screenshot()
-            
-        bbox = self.extract_bbox(element_description, state)
-        cropped_state = state.crop((bbox[0], bbox[1], bbox[2], bbox[3]))
-        return cropped_state
-        
-        
-            
-    def take_stable_screenshot(self) -> Image.Image:
-        """
-        Take a screenshot after ensuring the page is in a stable state.
+            data['session_id'] = self.session_id
+
+        response = requests.get(
+            f"{BASE_URL}/extract-bbox",
+            headers={
+                'x-api-key': self.api_key
+            },
+            params=data
+        )
         
-        Returns:
-            PIL.Image.Image: Screenshot of the current page
-        """
-        print("[SIMPLEX] Taking screenshot of the page...")
-        self.driver.wait_for_load_state('networkidle')
-        return screenshot_to_image(self.driver.screenshot())
-            
-       
+        return response.json()
+
+    def extract_text(self, element_description: str, cdp_url: str = None, use_vision: bool = False):
+        if not cdp_url and not self.session_id:
+            raise ValueError(f"Must call create_session before calling action extract_text with element_description='{element_description}'")
+
+        data = {'element_description': element_description}
+
+        if cdp_url:
+            data['cdp_url'] = cdp_url
+        else:
+            data['session_id'] = self.session_id
+
+        if use_vision:
+            data['use_vision'] = use_vision
+
+        response = requests.get(    
+            f"{BASE_URL}/extract-text",
+            headers={
+                'x-api-key': self.api_key
+            },
+            params=data
+        )
+        return response.json()
+
+    def extract_image(self, element_description: str, cdp_url: str = None):
+        if not cdp_url and not self.session_id:
+            raise ValueError(f"Must call create_session before calling action extract_image with element_description='{element_description}'")
+
+        data = {'element_description': element_description}
+
+        if cdp_url:
+            data['cdp_url'] = cdp_url
+        else:
+            data['session_id'] = self.session_id
+
+        response = requests.get(
+            f"{BASE_URL}/extract-image",
+            headers={
+                'x-api-key': self.api_key
+            },
+            params=data
+        )
+        return response.json()
+
+    def scroll(self, pixels: int, cdp_url: str = None):
+        if not cdp_url and not self.session_id:
+            raise ValueError(f"Must call create_session before calling action scroll with pixels={pixels}")
+
+        data = {'pixels': pixels}
+
+        if cdp_url:
+            data['cdp_url'] = cdp_url
+        else:
+            data['session_id'] = self.session_id
+
+        response = requests.post(
+            f"{BASE_URL}/scroll",
+            headers={
+                'x-api-key': self.api_key
+            },
+            data=data
+        )
+        return response.json()
+
+    def wait(self, milliseconds: int, cdp_url: str = None):
+        if not cdp_url and not self.session_id:
+            raise ValueError(f"Must call create_session before calling action wait with milliseconds={milliseconds}")
+
+        data = {'milliseconds': milliseconds}
+
+        if cdp_url:
+            data['cdp_url'] = cdp_url
+        else:
+            data['session_id'] = self.session_id
+
+        response = requests.post(
+            f"{BASE_URL}/wait",
+            headers={
+                'x-api-key': self.api_key
+            },
+            data=data
+        )
+        return response.json()

{simplex-1.2.4.dist-info → simplex-1.2.5.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.2
 Name: simplex
-Version: 1.2.4
+Version: 1.2.5
 Summary: Official Python SDK for Simplex API
-Home-page: https://github.com/shreyka/simplex-python
+Home-page: https://simplex.sh
 Author: Simplex Labs, Inc.
 Author-email: founders@simplex.sh
 Classifier: Programming Language :: Python :: 3
@@ -10,7 +10,7 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
-Requires-Python: >=3.6
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: openai>=1.0.0
@@ -21,6 +21,14 @@ Requires-Dist: rich>=13.0.0
 Requires-Dist: prompt_toolkit>=3.0.0
 Requires-Dist: playwright>=1.0.0
 Requires-Dist: Pillow>=9.0.0
+Requires-Dist: PyYAML>=6.0.1
+Requires-Dist: boto3>=1.28.0
+Requires-Dist: requests>=2.31.0
+Requires-Dist: MainContentExtractor
+Requires-Dist: langchain_core
+Requires-Dist: langchain_community
+Requires-Dist: langchain_openai
+Requires-Dist: langchain_anthropic
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

simplex-1.2.5.dist-info/RECORD

@@ -0,0 +1,11 @@
+simplex/__init__.py,sha256=1mbM4XUk0FNW161WOkM4ayC1s_QSsaBEls6PZ0iBScY,74
+simplex/cli.py,sha256=PkHt3sBKYfu0Smil4aCMoZUD-JbPw8xsBewpFcBYDKM,675
+simplex/simplex.py,sha256=BsAp0UMjgL2MKjdT8akEjDIBajaaf_VCWyvIiDn4i4g,6990
+simplex/deploy/__init__.py,sha256=_JQ81F_Nu7hSAfMA691gzs6a4-8oZ-buJ9h3Au12BKw,96
+simplex/deploy/push.py,sha256=hRAbtFZaECKnBljaOLQ5nzJ6hk7tZgc1c7QdgxKQFoY,6123
+simplex-1.2.5.dist-info/LICENSE,sha256=Xh0SJjYZfNI71pCNMB40aKlBLLuOB0blx5xkTtufFNQ,1075
+simplex-1.2.5.dist-info/METADATA,sha256=aTiiF2h8Tgs1g20UWYBuEF3jGSnvzjRYnEhaE2GCCRw,1349
+simplex-1.2.5.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+simplex-1.2.5.dist-info/entry_points.txt,sha256=3veL2w3c5vxb3dm8I_M8Fs-370n1ZnvD8uu1nSsL7z8,45
+simplex-1.2.5.dist-info/top_level.txt,sha256=cbMH1bYpN0A3gP-ecibPRHasHoqB-01T_2BUFS8p0CE,8
+simplex-1.2.5.dist-info/RECORD,,

simplex/constants.py

@@ -1 +0,0 @@
-BASE_URL = "https://u3mvtbirxf.us-east-1.awsapprunner.com"

simplex/utils.py

@@ -1,12 +0,0 @@
-from typing import List
-from PIL import Image
-import io
-def center_bbox(bbox: List[int]) -> List[int]:
-    """
-    Calculate the center coordinates of a bounding box
-    """
-    return [(bbox[0] + bbox[2]) // 2, (bbox[1] + bbox[3]) // 2]
-
-
-def screenshot_to_image(screenshot: bytes) -> Image:
-    return Image.open(io.BytesIO(screenshot))

simplex-1.2.4.dist-info/RECORD

@@ -1,10 +0,0 @@
-simplex/__init__.py,sha256=1mbM4XUk0FNW161WOkM4ayC1s_QSsaBEls6PZ0iBScY,74
-simplex/constants.py,sha256=nIXF2oVNNNknXweXAlmE-KBM9QjJtYw9osXVYjvloN0,59
-simplex/simplex.py,sha256=m5vQxhVCyeU-h-cOVmpaAMoTATPJKdecfp1Fv51uaL0,12137
-simplex/utils.py,sha256=UrD4Ena3yk0POmxxyiqMszzPbTscTCJpMP4xZFDAuOc,339
-simplex-1.2.4.dist-info/LICENSE,sha256=Xh0SJjYZfNI71pCNMB40aKlBLLuOB0blx5xkTtufFNQ,1075
-simplex-1.2.4.dist-info/METADATA,sha256=YyDn-TaMU_3JQO9ZWFbRA214_Lak1zKmA8beIHl0zPI,1114
-simplex-1.2.4.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-simplex-1.2.4.dist-info/entry_points.txt,sha256=3veL2w3c5vxb3dm8I_M8Fs-370n1ZnvD8uu1nSsL7z8,45
-simplex-1.2.4.dist-info/top_level.txt,sha256=cbMH1bYpN0A3gP-ecibPRHasHoqB-01T_2BUFS8p0CE,8
-simplex-1.2.4.dist-info/RECORD,,