fleet-python 0.2.7__py3-none-any.whl → 0.2.9__py3-none-any.whl

examples/example_sync.py

@@ -11,6 +11,9 @@ def main():
     environments = flt.env.list_envs()
     print("Environments:", len(environments))
 
+    instances = flt.env.list_instances()
+    print("Instances:", len(instances))
+
     # Create a new instance
     env = flt.env.make("hubspot:v1.2.7")
     print("New Instance:", env.instance_id)

examples/gemini_example.py

@@ -0,0 +1,432 @@
+import os
+import json
+import argparse
+from typing import List, Dict, Any, Optional, Tuple, TypedDict
+from pathlib import Path
+from google import genai
+from google.genai import types
+import fleet as flt
+from dotenv import load_dotenv
+import base64
+import re
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+load_dotenv()
+
+# Initialize Gemini client
+client = genai.Client(api_key=os.getenv("GEMINI_API_KEY"))
+MODEL = "gemini-2.5-pro"
+
+
+class Problem(TypedDict):
+    id: str
+    problem: str
+    category: str
+    difficulty: str
+    verifier_func: str
+
+
+class GeminiAgent:
+    def __init__(
+        self,
+        browser: flt.FleetPlaywrightWrapper,
+        model: str = MODEL,
+        print_steps: bool = True,
+        debug: bool = False,
+    ):
+        self.browser = browser
+        self.model = model
+        self.print_steps = print_steps
+        self.debug = debug
+        self.conversation_history = []
+        self.last_action = None  # Track the last action performed
+
+    @property
+    def page(self):
+        """Access the underlying Playwright page object."""
+        return self.browser._page if hasattr(self.browser, "_page") else None
+
+    def debug_print(self, *args):
+        if self.debug:
+            print("[DEBUG]", *args)
+
+    def take_screenshot(self) -> str:
+        return self.browser.screenshot()
+
+    def execute_action(self, action: Dict[str, Any]) -> Dict[str, Any]:
+        action_type = action.get("type")
+        params = action.get("parameters", {})
+
+        if self.print_steps:
+            print(f"Action: {action_type}({params})")
+
+        try:
+            if action_type == "click":
+                self.browser.click(
+                    x=params.get("x", params.get("coordinate", [0, 0])[0]),
+                    y=params.get("y", params.get("coordinate", [0, 0])[1]),
+                )
+                # Small delay to ensure click is registered and element is focused
+                time.sleep(0.2)
+                self.last_action = {"type": "click", "target": params}
+            elif action_type == "type":
+                self.browser.type(text=params.get("text", ""))
+                self.last_action = {"type": "type", "text": params.get("text", "")}
+            elif action_type == "key":
+                # FleetPlaywrightWrapper expects keypress with a list of keys
+                key = params.get("key", "")
+                self.browser.keypress([key])
+                self.last_action = {"type": "key", "key": key}
+            elif action_type == "scroll":
+                # FleetPlaywrightWrapper expects scroll(x, y, scroll_x, scroll_y)
+                x = params.get("x", params.get("coordinate", [0, 0])[0])
+                y = params.get("y", params.get("coordinate", [0, 0])[1])
+                direction = params.get("direction", "down")
+                amount = params.get("amount", 5)
+
+                # Convert direction and amount to scroll_x and scroll_y
+                scroll_x = 0
+                scroll_y = 0
+                if direction == "down":
+                    scroll_y = amount * 100
+                elif direction == "up":
+                    scroll_y = -amount * 100
+                elif direction == "right":
+                    scroll_x = amount * 100
+                elif direction == "left":
+                    scroll_x = -amount * 100
+
+                self.browser.scroll(x=x, y=y, scroll_x=scroll_x, scroll_y=scroll_y)
+                self.last_action = {"type": "scroll"}
+            elif action_type == "wait":
+                time.sleep(params.get("seconds", 1))
+                self.last_action = {"type": "wait"}
+            elif action_type == "navigate":
+                # Use the browser's goto method
+                url = params.get("url", "")
+                if url:
+                    self.browser.goto(url)
+                self.last_action = {"type": "navigate", "url": url}
+            else:
+                return {
+                    "success": False,
+                    "error": f"Unknown action type: {action_type}",
+                }
+
+            return {"success": True}
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+
+    def create_prompt_with_screenshot(
+        self, task: str, screenshot_b64: str
+    ) -> List[Any]:
+        # Add context about last action
+        last_action_context = ""
+        if self.last_action:
+            if self.last_action["type"] == "click":
+                last_action_context = f"\n\nIMPORTANT: You just clicked at coordinates {self.last_action['target']}. If you clicked on a text input field, search bar, or any editable element, you MUST now use the 'type' action to enter text. Do not click the same element again."
+            elif self.last_action["type"] == "type":
+                last_action_context = f"\n\nYou just typed: '{self.last_action['text']}'. You may now need to press Enter or click a button to submit."
+
+        prompt_text = (
+            "You are an AI agent that can interact with web browsers. "
+            f"Your task is to: {task}\n\n"
+            "You can see the current state of the browser in the screenshot provided."
+            f"{last_action_context}\n\n"
+            "You can perform the following actions:\n"
+            '- click: Click at specific coordinates {"type": "click", "parameters": {"x": x, "y": y}}\n'
+            '- type: Type text into the currently focused element {"type": "type", "parameters": {"text": "text to type"}}\n'
+            '- key: Press a special key {"type": "key", "parameters": {"key": "Enter"}} (e.g., "Enter", "Tab", "Escape")\n'
+            '- scroll: Scroll the page {"type": "scroll", "parameters": {"x": x, "y": y, "direction": "down", "amount": 5}} (direction: up/down/left/right)\n'
+            '- wait: Wait for a number of seconds {"type": "wait", "parameters": {"seconds": 1}}\n\n'
+            "CRITICAL RULES:\n"
+            "1. After clicking on ANY text input, search bar, or form field, you MUST type in the next step\n"
+            "2. Never click the same element twice in a row\n"
+            "3. If you mention searching for something in your reasoning, you must actually type the search query\n"
+            "4. Common workflow: click search bar → type query → press Enter\n\n"
+            "Analyze the screenshot and decide what action to take next. Respond with a JSON object containing:\n"
+            '- "reasoning": Your analysis of the current state and what needs to be done\n'
+            '- "action": The action to perform (as described above)\n'
+            '- "completed": true if the task is complete, false otherwise\n\n'
+            "Example responses:\n"
+            "{\n"
+            '  "reasoning": "I can see a search bar at the top. I need to click on it first to focus it.",\n'
+            '  "action": {"type": "click", "parameters": {"x": 450, "y": 30}},\n'
+            '  "completed": false\n'
+            "}\n\n"
+            "{\n"
+            '  "reasoning": "I just clicked on the search bar and it should now be focused. I need to type my search query for PHI encryption ticket.",\n'
+            '  "action": {"type": "type", "parameters": {"text": "PHI encryption"}},\n'
+            '  "completed": false\n'
+            "}\n\n"
+            "{\n"
+            '  "reasoning": "I typed the search query. Now I need to press Enter to execute the search.",\n'
+            '  "action": {"type": "key", "parameters": {"key": "Enter"}},\n'
+            '  "completed": false\n'
+            "}"
+        )
+
+        return [
+            prompt_text,
+            types.Part.from_bytes(
+                data=base64.b64decode(screenshot_b64), mime_type="image/png"
+            ),
+        ]
+
+    def solve_task(self, task: str, max_steps: int = 30) -> Tuple[bool, str]:
+        steps = 0
+
+        try:
+            while steps < max_steps:
+                steps += 1
+
+                # Take screenshot
+                screenshot = self.take_screenshot()
+
+                # Create prompt with current state
+                prompt_parts = self.create_prompt_with_screenshot(task, screenshot)
+
+                # Get Gemini's response
+                response = client.models.generate_content(
+                    model=self.model,
+                    contents=prompt_parts,
+                    config=types.GenerateContentConfig(
+                        response_mime_type="application/json",
+                        temperature=0.1,  # Lower temperature for more deterministic behavior
+                    ),
+                )
+
+                # Parse response
+                try:
+                    result = json.loads(response.text)
+                    self.debug_print(f"Step {steps}: {result}")
+
+                    if self.print_steps:
+                        print(
+                            f"Step {steps}: {result.get('reasoning', 'No reasoning provided')}"
+                        )
+
+                    # Debug: Print the full action if in debug mode
+                    if self.debug and "action" in result:
+                        print(f"[DEBUG] Full action: {result['action']}")
+
+                    # Check if task is completed
+                    if result.get("completed", False):
+                        return True, "Task completed successfully"
+
+                    # Execute the action
+                    if "action" in result:
+                        action_result = self.execute_action(result["action"])
+                        if not action_result["success"]:
+                            self.debug_print(
+                                f"Action failed: {action_result.get('error')}"
+                            )
+                    else:
+                        print(f"[WARNING] No action in response: {result}")
+
+                    # Small delay to let the page update
+                    time.sleep(0.5)
+
+                except json.JSONDecodeError as e:
+                    self.debug_print(f"Failed to parse Gemini response: {e}")
+                    self.debug_print(f"Response text: {response.text}")
+                    # Try to extract any useful information from the response
+                    print(
+                        f"[ERROR] Invalid JSON response from Gemini: {response.text[:200]}..."
+                    )
+                    continue
+
+            return False, f"Max steps ({max_steps}) reached without completing the task"
+
+        except Exception as e:
+            return False, f"Error during task execution: {str(e)}"
+
+
+def extract_function_name(function_str: str) -> str:
+    match = re.search(r"(?:async\s+)?def\s+(\w+)\s*\(", function_str)
+    if match:
+        return match.group(1)
+    raise ValueError(f"No function name found in {function_str}")
+
+
+def evaluate_problem(
+    problem: Problem,
+    problem_idx: int,
+    total_problems: int,
+    env_key: str,
+    max_steps: int = 30,
+) -> Tuple[str, bool, Optional[str]]:
+    env = None
+    browser = None
+
+    try:
+        # Create environment
+        env = flt.env.make(env_key)
+        print(
+            f"[Problem {problem_idx + 1}/{total_problems}] Created environment for {problem['id']}: {env.urls.app}"
+        )
+
+        # Create browser wrapper
+        browser = flt.FleetPlaywrightWrapper(env)
+        browser.start()
+
+        # Create agent
+        agent = GeminiAgent(browser, print_steps=True, debug=False)
+
+        # Solve the problem
+        print(
+            f"[Problem {problem_idx + 1}/{total_problems}] Solving {problem['id']}..."
+        )
+        success, message = agent.solve_task(problem["problem"], max_steps=max_steps)
+
+        if not success:
+            print(
+                f"[Problem {problem_idx + 1}/{total_problems}] Failed to solve: {message}"
+            )
+            # return problem["id"], False, message
+
+        # Verify the solution
+        function_name = extract_function_name(problem["verifier_func"])
+        print(
+            f"[Problem {problem_idx + 1}/{total_problems}] Verifying {function_name} ({problem['id']})..."
+        )
+        response = env.verify_raw(problem["verifier_func"], function_name)
+
+        print(
+            f"[Problem {problem_idx + 1}/{total_problems}] Result for {problem['id']}: {'✓' if response.success else '✗'}"
+        )
+
+        return problem["id"], response.success, None
+
+    except Exception as e:
+        print(
+            f"[Problem {problem_idx + 1}/{total_problems}] Fatal error processing {problem['id']}: {e}"
+        )
+        return problem["id"], False, str(e)
+    finally:
+        # Clean up
+        if browser:
+            browser.close()
+        if env:
+            env.close()
+
+
+def interactive_mode():
+    # Create a Fleet environment instance
+    instance = flt.env.make("hubspot")
+
+    # Create the browser wrapper
+    browser = flt.FleetPlaywrightWrapper(instance)
+    browser.start()
+
+    try:
+        agent = GeminiAgent(browser, print_steps=True, debug=False)
+
+        print("Gemini Agent Interactive Mode")
+        print("Type your task or 'quit' to exit")
+        print("-" * 60)
+
+        while True:
+            try:
+                user_input = input("\n> ")
+                if user_input.lower() in ["quit", "exit", "q"]:
+                    break
+
+                success, message = agent.solve_task(user_input)
+                print(f"\nResult: {'Success' if success else 'Failed'} - {message}")
+
+            except KeyboardInterrupt:
+                print("\nShutting down...")
+                break
+            except Exception as e:
+                print(f"Error: {e}")
+
+    finally:
+        browser.close()
+        instance.close()
+
+
+def evaluate_from_json(json_file: str, max_concurrent: int = 3, max_steps: int = 30):
+    file_path = Path(json_file)
+    if not file_path.exists():
+        raise FileNotFoundError(f"Error: File '{json_file}' not found")
+
+    with open(json_file, "r") as f:
+        data = json.load(f)
+    problems: List[Problem] = data["problems"]
+
+    print(f"Loaded {len(problems)} problems from '{json_file}'")
+    print(f"Running with max {max_concurrent} concurrent tasks")
+    print("-" * 60)
+
+    # Process problems with thread pool for concurrency
+    results = []
+    with ThreadPoolExecutor(max_workers=max_concurrent) as executor:
+        # Submit all tasks
+        future_to_problem = {
+            executor.submit(
+                evaluate_problem, problem, idx, len(problems), "fira:v1.3.1", max_steps
+            ): (problem, idx)
+            for idx, problem in enumerate(problems)
+        }
+
+        # Collect results as they complete
+        for future in as_completed(future_to_problem):
+            result = future.result()
+            results.append(result)
+
+    # Display results
+    print("\n" + "=" * 60)
+    print("EVALUATION RESULTS")
+    print("=" * 60)
+
+    successes = 0
+    for problem_id, success, error in results:
+        status = "✓ PASS" if success else "✗ FAIL"
+        print(f"{status} | {problem_id}")
+        if error and not success:
+            print(f"      └─ Error: {error}")
+        if success:
+            successes += 1
+
+    print("-" * 60)
+    print(f"Total problems: {len(problems)}")
+    print(f"Successes: {successes}")
+    print(f"Failures: {len(problems) - successes}")
+    print(f"Success rate: {successes / len(problems):.2%}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Gemini Agent for Fleet SDK")
+    parser.add_argument(
+        "--eval", type=str, help="Path to JSON file with problems to evaluate"
+    )
+    parser.add_argument(
+        "--max-concurrent",
+        type=int,
+        default=3,
+        help="Maximum number of concurrent evaluations (default: 3)",
+    )
+    parser.add_argument(
+        "--max-steps",
+        type=int,
+        default=30,
+        help="Maximum steps per problem (default: 30)",
+    )
+    parser.add_argument(
+        "--interactive", action="store_true", help="Run in interactive mode"
+    )
+
+    args = parser.parse_args()
+
+    if args.eval:
+        evaluate_from_json(args.eval, args.max_concurrent, args.max_steps)
+    elif args.interactive:
+        interactive_mode()
+    else:
+        raise ValueError("No arguments provided")
+
+
+if __name__ == "__main__":
+    main()

examples/json_tasks_example.py

@@ -2,7 +2,7 @@ import re
 import asyncio
 import argparse
 import json
-from typing import TypedDict, List
+from typing import TypedDict, List, Optional, Tuple
 from pathlib import Path
 import fleet as flt
 from nova_act import NovaAct, ActResult
@@ -12,6 +12,7 @@ load_dotenv()
 
 
 MAX_STEPS = 30
+MAX_CONCURRENT_TASKS = 5  # Limit concurrent tasks to avoid overwhelming the system
 
 
 class Problem(TypedDict):
@@ -29,6 +30,67 @@ def extract_function_name(function_str: str) -> str | None:
     raise ValueError(f"No function name found in {function_str}")
 
 
+async def process_problem(
+    problem: Problem, problem_idx: int, total_problems: int, env_key: str
+) -> Tuple[str, bool, Optional[str]]:
+    env = None
+    try:
+        # Create a new environment instance for this problem
+        env = await flt.env.make_async(env_key)
+        print(
+            f"[Problem {problem_idx + 1}/{total_problems}] Created environment for {problem['id']}: {env.urls.app}"
+        )
+
+        # Run NovaAct in a thread (since it's synchronous)
+        def run_nova() -> ActResult:
+            with NovaAct(starting_page=env.urls.app, headless=True) as nova:
+                return nova.act(problem["problem"], max_steps=MAX_STEPS)
+
+        try:
+            print(
+                f"[Problem {problem_idx + 1}/{total_problems}] Solving {problem['id']}..."
+            )
+            await asyncio.to_thread(run_nova)
+        except Exception as e:
+            print(
+                f"[Problem {problem_idx + 1}/{total_problems}] Error during solving {problem['id']}: {e}"
+            )
+            error_msg = str(e)
+        else:
+            error_msg = None
+
+        # Verify the solution
+        function_name = extract_function_name(problem["verifier_func"])
+        print(
+            f"[Problem {problem_idx + 1}/{total_problems}] Verifying {function_name} ({problem['id']})..."
+        )
+        response = await env.verify_raw(problem["verifier_func"], function_name)
+
+        print(
+            f"[Problem {problem_idx + 1}/{total_problems}] Result for {problem['id']}: {'✓' if response.success else '✗'}"
+        )
+
+        return problem["id"], response.success, error_msg
+
+    except Exception as e:
+        print(
+            f"[Problem {problem_idx + 1}/{total_problems}] Fatal error processing {problem['id']}: {e}"
+        )
+        return problem["id"], False, str(e)
+    finally:
+        # Clean up the environment
+        if env:
+            try:
+                await env.close()
+                print(
+                    f"[Problem {problem_idx + 1}/{total_problems}] Closed environment for {problem['id']}"
+                )
+            except Exception as e:
+                print(
+                    f"[Problem {problem_idx + 1}/{total_problems}] Error closing environment for {problem['id']}: {e}"
+                )
+
+
 async def main():
     parser = argparse.ArgumentParser(
         description="Load and display Jira problems from JSON file"
@@ -36,49 +98,66 @@ async def main():
     parser.add_argument(
         "json_file", type=str, help="Path to the JSON file containing problems"
     )
+    parser.add_argument(
+        "--max-concurrent",
+        type=int,
+        default=MAX_CONCURRENT_TASKS,
+        help=f"Maximum number of concurrent tasks (default: {MAX_CONCURRENT_TASKS})",
+    )
     args = parser.parse_args()
 
     file_path = Path(args.json_file)
     if not file_path.exists():
         raise FileNotFoundError(f"Error: File '{args.json_file}' not found")
 
-    env = await flt.env.make_async("fira:v1.2.7")
-    print(f"New Instance: {env.urls.app}")
-
-    successes = 0
-
     try:
         with open(args.json_file, "r") as f:
             data = json.load(f)
         problems: List[Problem] = data["problems"]
 
         print(f"Loaded {len(problems)} problems from '{args.json_file}'")
-
-        for i, problem in enumerate(problems):
-            print(f"Solving problem {i + 1} of {len(problems)}: {problem['id']}")
-            await env.reset()
-
-            def run_nova() -> ActResult:
-                with NovaAct(starting_page=env.urls.app, headless=True) as nova:
-                    return nova.act(problem["problem"], max_steps=MAX_STEPS)
-
-            try:
-                await asyncio.to_thread(run_nova)
-            except Exception as e:
-                print(f"Error: {e}")
-
-            function_name = extract_function_name(problem["verifier_func"])
-            print(f"Verifying {function_name} ({problem['id']})...")
-            response = await env.verify_raw(problem["verifier_func"], function_name)
-            print(response)
-            if response.success:
+        print(f"Running with max {args.max_concurrent} concurrent tasks")
+        print("-" * 60)
+
+        # Create a semaphore to limit concurrent tasks
+        semaphore = asyncio.Semaphore(args.max_concurrent)
+
+        async def process_with_semaphore(
+            problem: Problem, idx: int
+        ) -> Tuple[str, bool, Optional[str]]:
+            async with semaphore:
+                return await process_problem(problem, idx, len(problems), "fira:v1.2.7")
+
+        # Process all problems concurrently (with semaphore limiting)
+        tasks = [
+            process_with_semaphore(problem, i) for i, problem in enumerate(problems)
+        ]
+
+        results = await asyncio.gather(*tasks)
+
+        # Count successes and display summary
+        print("\n" + "=" * 60)
+        print("EVALUATION RESULTS")
+        print("=" * 60)
+
+        successes = 0
+        for problem_id, success, error in results:
+            status = "✓ PASS" if success else "✗ FAIL"
+            print(f"{status} | {problem_id}")
+            if error and not success:
+                print(f"      └─ Error: {error}")
+            if success:
                 successes += 1
 
+        print("-" * 60)
+        print(f"Total problems: {len(problems)}")
         print(f"Successes: {successes}")
-        print(f"Total: {len(problems)}")
-        print(f"Success rate: {successes / len(problems)}")
-    finally:
-        await env.close()
+        print(f"Failures: {len(problems) - successes}")
+        print(f"Success rate: {successes / len(problems):.2%}")
+
+    except Exception as e:
+        print(f"Fatal error: {e}")
+        raise
 
 
 if __name__ == "__main__":

fleet/_async/client.py

@@ -99,7 +99,9 @@ class AsyncFleet:
         response = await self.client.request("GET", f"/v1/env/{env_key}")
         return EnvironmentModel(**response.json())
 
-    async def make(self, env_key: str) -> AsyncEnvironment:
+    async def make(
+        self, env_key: str, region: Optional[str] = None
+    ) -> AsyncEnvironment:
         if ":" in env_key:
             env_key_part, version = env_key.split(":", 1)
             if not version.startswith("v"):
@@ -108,7 +110,7 @@ class AsyncFleet:
             env_key_part = env_key
             version = None
 
-        request = InstanceRequest(env_key=env_key_part, version=version)
+        request = InstanceRequest(env_key=env_key_part, version=version, region=region)
         response = await self.client.request(
             "POST", "/v1/env/instances", json=request.model_dump()
         )
@@ -116,10 +118,14 @@ class AsyncFleet:
         await instance.instance.load()
         return instance
 
-    async def instances(self, status: Optional[str] = None) -> List[AsyncEnvironment]:
+    async def instances(
+        self, status: Optional[str] = None, region: Optional[str] = None
+    ) -> List[AsyncEnvironment]:
         params = {}
         if status:
             params["status"] = status
+        if region:
+            params["region"] = region
 
         response = await self.client.request("GET", "/v1/env/instances", params=params)
         return [AsyncEnvironment(**instance_data) for instance_data in response.json()]

fleet/_async/env/client.py

@@ -3,16 +3,18 @@ from ..models import Environment as EnvironmentModel
 from typing import List, Optional
 
 
-async def make_async(env_key: str) -> AsyncEnvironment:
-    return await AsyncFleet().make(env_key)
+async def make_async(env_key: str, region: Optional[str] = None) -> AsyncEnvironment:
+    return await AsyncFleet().make(env_key, region=region)
 
 
 async def list_envs_async() -> List[EnvironmentModel]:
     return await AsyncFleet().list_envs()
 
 
-async def list_instances_async(status: Optional[str] = None) -> List[AsyncEnvironment]:
-    return await AsyncFleet().instances(status=status)
+async def list_instances_async(
+    status: Optional[str] = None, region: Optional[str] = None
+) -> List[AsyncEnvironment]:
+    return await AsyncFleet().instances(status=status, region=region)
 
 
 async def get_async(instance_id: str) -> AsyncEnvironment:

fleet/client.py

@@ -99,7 +99,9 @@ class Fleet:
         response = self.client.request("GET", f"/v1/env/{env_key}")
         return EnvironmentModel(**response.json())
 
-    def make(self, env_key: str) -> Environment:
+    def make(
+        self, env_key: str, region: Optional[str] = None
+    ) -> Environment:
         if ":" in env_key:
             env_key_part, version = env_key.split(":", 1)
             if not version.startswith("v"):
@@ -108,7 +110,7 @@ class Fleet:
             env_key_part = env_key
             version = None
 
-        request = InstanceRequest(env_key=env_key_part, version=version)
+        request = InstanceRequest(env_key=env_key_part, version=version, region=region)
         response = self.client.request(
             "POST", "/v1/env/instances", json=request.model_dump()
         )
@@ -116,10 +118,14 @@ class Fleet:
         instance.instance.load()
         return instance
 
-    def instances(self, status: Optional[str] = None) -> List[Environment]:
+    def instances(
+        self, status: Optional[str] = None, region: Optional[str] = None
+    ) -> List[Environment]:
         params = {}
         if status:
             params["status"] = status
+        if region:
+            params["region"] = region
 
         response = self.client.request("GET", "/v1/env/instances", params=params)
         return [Environment(**instance_data) for instance_data in response.json()]

fleet/env/__init__.py

@@ -1,15 +1,17 @@
 """Fleet env module - convenience functions for environment management."""
 
-from .client import make, list_envs, get
+from .client import make, list_envs, get, list_instances
 
 # Import async versions from _async
-from .._async.env.client import make_async, list_envs_async, get_async
+from .._async.env.client import make_async, list_envs_async, get_async, list_instances_async
 
 __all__ = [
     "make",
     "list_envs", 
+    "list_instances",
     "get",
     "make_async",
     "list_envs_async",
+    "list_instances_async",
     "get_async",
 ]

fleet/env/client.py

@@ -3,16 +3,18 @@ from ..models import Environment as EnvironmentModel
 from typing import List, Optional
 
 
-def make(env_key: str) -> Environment:
-    return Fleet().make(env_key)
+def make(env_key: str, region: Optional[str] = None) -> Environment:
+    return Fleet().make(env_key, region=region)
 
 
 def list_envs() -> List[EnvironmentModel]:
     return Fleet().list_envs()
 
 
-def list_instances(status: Optional[str] = None) -> List[Environment]:
-    return Fleet().instances(status=status)
+def list_instances(
+    status: Optional[str] = None, region: Optional[str] = None
+) -> List[Environment]:
+    return Fleet().instances(status=status, region=region)
 
 
 def get(instance_id: str) -> Environment:

{fleet_python-0.2.7.dist-info → fleet_python-0.2.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fleet-python
-Version: 0.2.7
+Version: 0.2.9
 Summary: Python SDK for Fleet environments
 Author-email: Fleet AI <nic@fleet.so>
 License: Apache-2.0

{fleet_python-0.2.7.dist-info → fleet_python-0.2.9.dist-info}/RECORD

@@ -1,26 +1,27 @@
 examples/dsl_example.py,sha256=3Eu5924a8x61nuSGXqGz8XjPLNKKH8Ye7lSYHSvixtk,5361
 examples/example.py,sha256=FFPfM5Oso7IP9Q8aELpof1J41zslELdHHJhAAck9vLk,1008
 examples/example_client.py,sha256=70HKEhz_Gb79YcvKQauCPdS08AAwjo9unt2dh1jN_Oo,1030
-examples/example_sync.py,sha256=sW8pMU1WsEecGlc_NeQ8BAS1YxOud4iG6MafWGnFeTg,885
-examples/json_tasks_example.py,sha256=EhsJKVWoJFcrqhIIKF5lVrnIqpZDtizQqYblJaOZtmk,2400
+examples/example_sync.py,sha256=Kj_Mj2G88ADdQ2Pw_JQqJNbnpZrfMGSNR9paRQhSHLY,967
+examples/gemini_example.py,sha256=8mDXGGCaodyK6uXgpWhxi-DQ5OA-GFW12Gfwh0b3EDY,16177
+examples/json_tasks_example.py,sha256=3ub2LLiC6hXpVEH1175QxCmfCD3Blfo3yoG85uV5CS8,5334
 examples/nova_act_example.py,sha256=hZLpObVsiXKQzqGwMZVMf4A2j_z4TYE-YO9pgNmaKPk,836
 examples/openai_example.py,sha256=I2vk_SJN9BkSRQCYRJfbtGJ-HJ2xzQj-lOjwqmLos5M,8234
 examples/openai_simple_example.py,sha256=I42ytIwv0INgDO39pp1MOQSqsJz2YYH8GeNNBaUtq3A,1748
 examples/quickstart.py,sha256=1VT39IRRhemsJgxi0O0gprdpcw7HB4pYO97GAYagIcg,3788
 fleet/__init__.py,sha256=p-0zZMxKoD6dlQ9IGQ753QQWuwcw-RPl4E6HezhKfV4,2111
 fleet/base.py,sha256=t4xkgazl8kEP05JFjNByyf39RvvASRP0GsvxuoqKPY0,1395
-fleet/client.py,sha256=xPLlHS14Q2F8jn8e5lSLMUFE6o6ro7oM0XclOjVrxE4,4759
+fleet/client.py,sha256=Qn2DEXqO21POxhT1Gg5hZhTEeR3EVe6huocdw_o9MZo,4919
 fleet/exceptions.py,sha256=yG3QWprCw1OnF-vdFBFJWE4m3ftBLBng31Dr__VbjI4,2249
 fleet/models.py,sha256=Jf6Zmk689TPXhTSnVENK_VCw0VsujWzEWsN3T29MQ0k,3713
 fleet/playwright.py,sha256=BmRvez5DUa0ttAQB084hPAyt9_8WxdzCGBGF-GZbTuQ,8593
 fleet/_async/__init__.py,sha256=AJWCnuo7XKja4yBb8fK2wX7ntciLXQrpzdRHwjTRP6M,62
 fleet/_async/base.py,sha256=hUch1I5oUPgaCXR3IpJ8f_PjigifAZg2-LR7BJdZSo8,1413
-fleet/_async/client.py,sha256=T15EwovKCCshr4sF_HeHNdnbIUFoyZqjrN6_tU5o4aY,5010
+fleet/_async/client.py,sha256=Do5HPlhGw7iYpqlJ1eVmdwF_RATv9yAFAvENO_XwUq0,5170
 fleet/_async/exceptions.py,sha256=yG3QWprCw1OnF-vdFBFJWE4m3ftBLBng31Dr__VbjI4,2249
 fleet/_async/models.py,sha256=Jf6Zmk689TPXhTSnVENK_VCw0VsujWzEWsN3T29MQ0k,3713
 fleet/_async/playwright.py,sha256=2r4ywuv2ZqT0Qu3-k8A7V4YijeAOHnN8HiqJreLEYGI,8924
 fleet/_async/env/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fleet/_async/env/client.py,sha256=CO2KuD6FFkP1SdOJ2ehwBKrCdLEFsz5tj3jPR5tVu4U,596
+fleet/_async/env/client.py,sha256=JPFTWRjyFkUVYFodQ4bRlafH5GRu34LckeFSmb8YdZo,692
 fleet/_async/instance/__init__.py,sha256=jIt-7EEJ0WM_ipheT_s0lniCbLei6yUdN0qQv1bMJ3E,524
 fleet/_async/instance/base.py,sha256=QgcCTHdcqhi5VQi6_a1uuR-uO2_2Z19-RwVPp1k266A,947
 fleet/_async/instance/client.py,sha256=qmX5g6lPrq0b3BQ6LvTApeyquTtCse98Cu_Kwc72y6A,5653
@@ -29,8 +30,8 @@ fleet/_async/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3
 fleet/_async/resources/base.py,sha256=203gD54NP1IvjuSqFo-f7FvrkhtjChggtzrxJK7xf2E,667
 fleet/_async/resources/browser.py,sha256=x11y4aKHogIEv83FByHtExerjV-cDWI3U62349Guq_Q,1368
 fleet/_async/resources/sqlite.py,sha256=sRiII_qJ8X6-FSemlBsXThz4ZPjkNy9wDT8g5UAz2XM,1501
-fleet/env/__init__.py,sha256=_lvYBqieXWmvU_dyPi2seSpLO3AZh5kdprdqFeefkzk,338
-fleet/env/client.py,sha256=LVHXnC19bl0zEW20qykC63wJ0nO9gETF6z0_74dCdCo,479
+fleet/env/__init__.py,sha256=dlh41oWCKwg1-wUsy1c4lCA34hRKlBjfGpgEXO96TyY,426
+fleet/env/client.py,sha256=kS6Qx466i37CA6gU-LR18p7c16OzL7rb80Gsa7ggcrM,575
 fleet/instance/__init__.py,sha256=Hr8xPPoqzKOViXZXWmaL6dQ7NOBn-GooTGzoIvGmiE4,514
 fleet/instance/base.py,sha256=U-qW1EQVBo6yvMpP1JeKiPRhCjZ3y3aTsYFhLPNOTtQ,929
 fleet/instance/client.py,sha256=2EcuBpq21kUHCFommYdS9Ya-unLn-e8mrdAZBIZea3Q,5467
@@ -43,10 +44,10 @@ fleet/verifiers/__init__.py,sha256=mRMN8x0gDWFJ1MRLqdBtQw0gn_q8kDV3lMLyoiEf1yY,2
 fleet/verifiers/code.py,sha256=NJ4OLZnpqLkI1lXY7-5m2GuZklLxMzHUCnRMVyN2_OI,25
 fleet/verifiers/db.py,sha256=tssmvJjDHuBIy8qlL_P5-UdmEFUw2DZcqLsWZ8ot3Xw,27766
 fleet/verifiers/sql_differ.py,sha256=dmiGCFXVMEMbAX519OjhVqgA8ZvhnvdmC1BVpL7QCF0,6490
-fleet_python-0.2.7.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+fleet_python-0.2.9.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
 scripts/fix_sync_imports.py,sha256=b7tRvShgOFqyildqs1qI-Io0gaHappykBI-PSWWqUwE,2941
 scripts/unasync.py,sha256=--Fmaae47o-dZ1HYgX1c3Nvi-rMjcFymTRlJcWWnmpw,725
-fleet_python-0.2.7.dist-info/METADATA,sha256=hWvnoVCE-orcwesjDjMAm01Cjs5XWYpYXLfN9d7Hg44,4321
-fleet_python-0.2.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fleet_python-0.2.7.dist-info/top_level.txt,sha256=_3DSmTohvSDf3AIP_BYfGzhwO1ECFwuzg83X-wHCx3Y,23
-fleet_python-0.2.7.dist-info/RECORD,,
+fleet_python-0.2.9.dist-info/METADATA,sha256=UEzKyrhsKU7cZtJFwwvBt2za7-inTrtEB2M6utTmq3Q,4321
+fleet_python-0.2.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fleet_python-0.2.9.dist-info/top_level.txt,sha256=_3DSmTohvSDf3AIP_BYfGzhwO1ECFwuzg83X-wHCx3Y,23
+fleet_python-0.2.9.dist-info/RECORD,,