simplex 1.2.4__tar.gz → 1.2.6__tar.gz

{simplex-1.2.4 → simplex-1.2.6}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.2
 Name: simplex
-Version: 1.2.4
+Version: 1.2.6
 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.4 → simplex-1.2.6}/setup.py

@@ -2,8 +2,11 @@ from setuptools import setup, find_packages
 
 setup(
     name="simplex",
-    version="1.2.4",
+    version="1.2.6",
     packages=find_packages(),
+    package_data={
+        "simplex": ["browser_agent/dom/*.js"],  # Include JS files in the dom directory
+    },
     install_requires=[
         "openai>=1.0.0",
         "python-dotenv>=0.19.0",
@@ -13,6 +16,14 @@ setup(
         "prompt_toolkit>=3.0.0",
         "playwright>=1.0.0",
         "Pillow>=9.0.0",
+        "PyYAML>=6.0.1",
+        "boto3>=1.28.0",
+        "requests>=2.31.0",
+        "MainContentExtractor",
+        "langchain_core",
+        "langchain_community",
+        "langchain_openai",
+        "langchain_anthropic"
     ],
     entry_points={
         'console_scripts': [
@@ -24,7 +35,7 @@ setup(
     description="Official Python SDK for Simplex API",
     long_description=open("README.md").read(),
     long_description_content_type="text/markdown",
-    url="https://github.com/shreyka/simplex-python",
+    url="https://simplex.sh",
     classifiers=[
         "Programming Language :: Python :: 3",
         "License :: OSI Approved :: MIT License",
@@ -32,5 +43,5 @@ setup(
         "Development Status :: 4 - Beta",
         "Intended Audience :: Developers",
     ],
-    python_requires=">=3.6",
+    python_requires=">=3.9",
 ) 

simplex-1.2.6/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-1.2.6/simplex/deploy/__init__.py

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

simplex-1.2.6/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-1.2.6/simplex/simplex.py

@@ -0,0 +1,256 @@
+import os
+import requests 
+import atexit
+
+# BASE_URL = "https://api.simplex.sh"
+BASE_URL = "http://localhost:8000"
+
+class Simplex:
+    def __init__(self, api_key: str):
+        self.api_key = api_key
+        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 not url.startswith('http://') and not url.startswith('https://'):
+            url = 'https://' + url
+
+        data = {'url': url}
+
+        if cdp_url:
+            data['cdp_url'] = cdp_url
+        else:
+            data['session_id'] = self.session_id
+
+        response = requests.post(
+            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}
+
+        if cdp_url:
+            data['cdp_url'] = cdp_url
+        else:
+            data['session_id'] = self.session_id
+
+        response = requests.post(
+            f"{BASE_URL}/click",
+            headers={
+                'x-api-key': self.api_key
+            },
+            data=data
+        )
+        print(response.json())
+
+    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
+
+        response = requests.post(
+            f"{BASE_URL}/type",
+            headers={
+                'x-api-key': self.api_key
+            },
+            data=data
+        )
+        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:
+            data['session_id'] = self.session_id
+
+        response = requests.post(
+            f"{BASE_URL}/press-enter",
+            headers={
+                'x-api-key': self.api_key
+            },
+            data=data
+        )
+        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:
+            data['session_id'] = self.session_id
+
+        response = requests.get(
+            f"{BASE_URL}/extract-bbox",
+            headers={
+                'x-api-key': self.api_key
+            },
+            params=data
+        )
+        
+        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: float, 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}
+        print(data)
+
+        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()
+    
+    def run_agent(self, prompt: str, cdp_url: str = None):
+        if not cdp_url and not self.session_id:
+            raise ValueError(f"Must call create_session before calling action run_agent with and prompt='{prompt}'")
+
+        data = {'prompt': prompt}
+
+        if cdp_url:
+            data['cdp_url'] = cdp_url
+        else:
+            data['session_id'] = self.session_id
+
+        response = requests.post(
+            f"{BASE_URL}/run-agent",
+            headers={
+                'x-api-key': self.api_key
+            },
+            data=data
+        )
+        return response.json()

{simplex-1.2.4 → simplex-1.2.6}/simplex.egg-info/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.2
 Name: simplex
-Version: 1.2.4
+Version: 1.2.6
 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.4 → simplex-1.2.6}/simplex.egg-info/SOURCES.txt

@@ -3,13 +3,13 @@ README.md
 pyproject.toml
 setup.py
 simplex/__init__.py
-simplex/constants.py
+simplex/cli.py
 simplex/simplex.py
-simplex/utils.py
 simplex.egg-info/PKG-INFO
 simplex.egg-info/SOURCES.txt
 simplex.egg-info/dependency_links.txt
 simplex.egg-info/entry_points.txt
 simplex.egg-info/requires.txt
 simplex.egg-info/top_level.txt
-tests/test_local.py
+simplex/deploy/__init__.py
+simplex/deploy/push.py

simplex-1.2.6/simplex.egg-info/requires.txt

@@ -0,0 +1,16 @@
+openai>=1.0.0
+python-dotenv>=0.19.0
+tiktoken>=0.5.0
+click>=8.0.0
+rich>=13.0.0
+prompt_toolkit>=3.0.0
+playwright>=1.0.0
+Pillow>=9.0.0
+PyYAML>=6.0.1
+boto3>=1.28.0
+requests>=2.31.0
+MainContentExtractor
+langchain_core
+langchain_community
+langchain_openai
+langchain_anthropic

simplex-1.2.4/simplex/constants.py

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

simplex-1.2.4/simplex/simplex.py

@@ -1,324 +0,0 @@
-from playwright.sync_api import Page, sync_playwright, Browser
-from PIL import Image
-import requests
-from typing import List
-import io
-
-from .utils import center_bbox, screenshot_to_image
-
-BASE_URL = "https://u3mvtbirxf.us-east-1.awsapprunner.com"
-
-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)
-        """
-        self.api_key = api_key
-        self.browser = browser
-        
-        if browser is None:
-            self.playwright = sync_playwright().start()
-            self.browser = self.playwright.chromium.launch(headless=True)
-            self.driver = self.browser.new_page()
-        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
-        response = requests.post(
-            endpoint,
-            files=files
-        )
-
-
-        # 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 
-        else:
-            print("[SIMPLEX] Error:", response.text)
-
-    def step_to_action(self, step_description: str, state: Image.Image | None = None) -> List[List[str]]:
-        """
-        Convert a step description to an action
-
-        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()
-
-        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
-        )
-        
-        # 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
-        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
-        response = requests.post(
-            endpoint,
-            files=files
-        )
-        
-        # Print the results
-        if response.status_code == 200:
-            res = response.json()
-            text = res['text']
-            return text
-        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.
-        
-        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())
-            
-       

simplex-1.2.4/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/simplex.egg-info/requires.txt

@@ -1,8 +0,0 @@
-openai>=1.0.0
-python-dotenv>=0.19.0
-tiktoken>=0.5.0
-click>=8.0.0
-rich>=13.0.0
-prompt_toolkit>=3.0.0
-playwright>=1.0.0
-Pillow>=9.0.0

simplex-1.2.4/tests/test_local.py

@@ -1,283 +0,0 @@
-import sys
-import os
-sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-from simplex import Simplex
-
-from PIL import ImageDraw
-
-from playwright.sync_api import sync_playwright
-from PIL import Image
-import time
-import os
-from browserbase import Browserbase
-from hyperbrowser import Hyperbrowser
-from hyperbrowser.models.session import CreateSessionParams
-
-from dotenv import load_dotenv
-
-
-load_dotenv()
-
-
-def screenshot_tests():
-    simplex = Simplex(api_key=os.getenv("SIMPLEX_API_KEY"))
-    image = "/home/ubuntu/supreme-waffle/images/netflix.png"
-    screenshot = Image.open(image)
-
-    start_time = time.time()
-    bbox = simplex.find_element("dark mode icon", screenshot)
-    end_time = time.time()
-    print(f"Time taken: {end_time - start_time} seconds")
-    print(bbox)
-
-    start_time = time.time()
-    action = simplex.step_to_action("click and enter email address", screenshot)
-    end_time = time.time()
-    print(f"Time taken: {end_time - start_time} seconds")
-    print(action)
-
-
-
-
-
-def cgtrader_test():
-    assets = ["apple watch"]
-    urls = []
-
-    with sync_playwright() as p:
-        browser = p.chromium.launch(headless=False)
-        simplex = Simplex(api_key=os.getenv("SIMPLEX_API_KEY"), browser=browser)
-        simplex.goto("https://www.cgtrader.com/")
-
-        for asset in assets:
-            simplex.goto("https://www.cgtrader.com")
-            simplex.do(f"search for {asset}")  
-            simplex.do("click on search button")
-            simplex.do(f"click on the first product")
-            simplex.driver.wait_for_timeout(3000)
-
-            urls.append(simplex.driver.url)
-
-    print(urls)
-
-
-def test_find_element(): 
-    simplex = Simplex(api_key=os.getenv("SIMPLEX_API_KEY"))
-    simplex.goto("https://www.cgtrader.com/")
-
-    state = simplex.take_stable_screenshot()
-    bbox = simplex.find_element("search bar")
-
-    copy_image = state.copy()
-    draw = ImageDraw.Draw(copy_image)
-    draw.rectangle(bbox, outline='red', width=2)
-    copy_image.save("annotated_state.png")
-    
-
-    # Get the page HTML and device scale factor
-    html = simplex.driver.content()
-    scale_factor = simplex.driver.evaluate("window.devicePixelRatio")
-    
-    # Get viewport dimensions and other relevant settings
-    viewport_size = simplex.driver.viewport_size
-    zoom_level = simplex.driver.evaluate("document.documentElement.style.zoom || 1")
-    
-    # Debug print
-    print(f"Original bbox: {bbox}")
-    print(f"Scale factor: {scale_factor}")
-    print(f"Viewport size: {viewport_size}")
-    print(f"Zoom level: {zoom_level}")
-    
-    # Transform coordinates from screenshot to HTML
-    html_bbox = [
-        bbox[0] / scale_factor,
-        bbox[1] / scale_factor,
-        bbox[2] / scale_factor,
-        bbox[3] / scale_factor
-    ]
-    print(f"Transformed bbox: {html_bbox}")
-    
-    # Create HTML wrapper with matching viewport settings and scaled overlay
-    html_with_settings = f"""
-    <!DOCTYPE html>
-    <html>
-    <head>
-        <meta name="viewport" content="width=device-width, initial-scale=1">
-        <style>
-            body {{
-                margin: 0;
-                width: {viewport_size['width']}px;
-                height: {viewport_size['height']}px;
-                zoom: {zoom_level};
-            }}
-            .viewport-container {{
-                width: 100%;
-                height: 100%;
-                overflow: hidden;
-                position: relative;
-                transform-origin: top left;
-                transform: scale({1/scale_factor});
-            }}
-            #page-content {{
-                width: {viewport_size['width'] * scale_factor}px;
-                height: {viewport_size['height'] * scale_factor}px;
-                transform-origin: top left;
-            }}
-            #bbox-overlay {{
-                position: absolute;
-                border: 2px solid red;
-                left: {bbox[0]}px;
-                top: {bbox[1]}px;
-                width: {bbox[2] - bbox[0]}px;
-                height: {bbox[3] - bbox[1]}px;
-                pointer-events: none;
-                z-index: 10000;
-            }}
-        </style>
-    </head>
-    <body>
-        <div class="viewport-container">
-            <div id="page-content">
-                {html}
-            </div>
-            <div id="bbox-overlay"></div>
-        </div>
-    </body>
-    </html>
-    """
-
-    # Save the HTML with viewport settings
-    with open('screenshot_with_viewport.html', 'w') as f:
-        f.write(html_with_settings)
-
-
-def test_find_element_2():
-
-    simplex = Simplex(api_key=os.getenv("SIMPLEX_API_KEY"))
-    # simplex.goto("https://www.cgtrader.com/")
-    state = Image.open("nvidia-stock.png")
-    bbox = simplex.extract_bbox("nvidia stock graph", state)
-    print(bbox)
-
-    state.crop(bbox)
-    state.save("cropped_state.png")
-
-
-
-
-
-import requests
-def test_hyperbrowser_integration():
-    """Test Simplex integration with Hyperbrowser"""
-    import time
-    start_time = time.time()
-
-    bb = Browserbase(api_key=os.getenv("BROWSERBASE_API_KEY"))
-    session_start = time.time()
-    session = bb.sessions.create(project_id=os.getenv("BROWSERBASE_PROJECT_ID"))
-    print(session.id)
-    print(f"Session creation took {time.time() - session_start:.2f}s")
-
-    # Initialize Hyperbrowser client
-    # client = Hyperbrowser(api_key=os.getenv("HYPERBROWSER_API_KEY"))
-    
-    # Create session params with CAPTCHA solving enabled
-    session_params = CreateSessionParams(
-        solve_captchas=True,
-        use_stealth=True  # Recommended when solving CAPTCHAs
-    )
-    
-    # Create a new session with params
-    # session = client.sessions.create(session_params)
-    ws_endpoint = session.connect_url
-
-    try:
-        with sync_playwright() as p:
-            # Connect browser to Hyperbrowser session
-            browser_start = time.time()
-            browser = p.chromium.connect_over_cdp(ws_endpoint)
-            print(f"Browser connection took {time.time() - browser_start:.2f}s")
-            url = f"https://api.browserbase.com/v1/sessions/{session.id}/debug"
-            headers = {"X-BB-API-Key": os.getenv("BROWSERBASE_API_KEY")}
-            response = requests.get(url, headers=headers)
-            print(response.text)
-            print(response.json()["pages"][0]["debuggerUrl"])
-
-            # Initialize Simplex with the Hyperbrowser-connected page
-            simplex = Simplex(api_key=os.getenv("SIMPLEX_API_KEY"), browser=browser)
-            
-            # Test basic functionality
-            nav_start = time.time()
-            simplex.goto("https://www.turbosquid.com/")
-            print(f"Navigation took {time.time() - nav_start:.2f}s")
-            
-            # search_start = time.time()
-            # simplex.do("search for iphone")
-            # print(f"Search action took {time.time() - search_start:.2f}s")
-            
-            # Verify the search worked by finding the search results
-            find_start = time.time()
-            bbox = simplex.find_element("search results", annotate=True)
-            print(f"Finding results took {time.time() - find_start:.2f}s")
-            assert bbox is not None, "Search results not found"
-            
-    finally:
-        # Always stop the Hyperbrowser session
-        # client.sessions.stop(session.id)
-        browser.close()
-        print(f"Total test time: {time.time() - start_time:.2f}s")
-        
-
-
-def execute_action_test():
-    playwright = sync_playwright().start()
-    browser = playwright.chromium.launch(headless=False)
-    simplex = Simplex(api_key=os.getenv("SIMPLEX_API_KEY"), browser=browser)
-    simplex.goto("https://www.mit.edu/")
-    simplex.find_element('search bar')
-    
-    time.sleep(3)
-    
-    # Save HTML content
-    html_content = simplex.driver.content()
-    with open('page.html', 'w', encoding='utf-8') as f:
-        f.write(html_content)
-    
-    # Keep browser open until user interrupts with Ctrl+C
-    try:
-        print("Browser is kept open. Press Ctrl+C to exit...")
-        while True:
-            time.sleep(1)
-    except KeyboardInterrupt:
-        browser.close()
-        playwright.stop()
-
-
-def test_extract_text():
-    simplex = Simplex(api_key=os.getenv("SIMPLEX_API_KEY"))
-    simplex.goto("https://www.cgtrader.com/3d-models/electronics/other/apple-watch-ultra-2022-hq-3d-model")
-    time.sleep(2)
-    start = time.time()
-    text = simplex.extract_text("type of license")
-    end = time.time()
-    print(f"Time taken: {end - start:.2f}s")
-    print(text)
-
-
-def test_extract_image():
-    simplex = Simplex(api_key=os.getenv("SIMPLEX_API_KEY"))
-    state = Image.open("nvidia-stock.png")
-    image = simplex.extract_image("stock trends and market summary", state)
-    image.save("cropped_image.png")
-
-    print(type(simplex.driver))
-
-
-if __name__ == "__main__":
-    simplex = Simplex(api_key=os.getenv("SIMPLEX_API_KEY"))
-    simplex.goto("https://www.google.com")
-    simplex.click("search bar")
-
-    
-    
-