Added zone deletion endpoint to zone manager

vzucher · vzucher · commit dac165fb3f26 · 2025-11-21T11:29:34.000+01:00
diff --git a/src/brightdata/client.py b/src/brightdata/client.py
@@ -480,9 +480,41 @@ async def list_zones(self) -> List[Dict[str, Any]]:
                 self._zone_manager = ZoneManager(self.engine)
             return await self._zone_manager.list_zones()
 
+    async def delete_zone(self, zone_name: str) -> None:
+        """
+        Delete a zone from your Bright Data account.
+
+        Args:
+            zone_name: Name of the zone to delete
+
+        Raises:
+            ZoneError: If zone deletion fails or zone doesn't exist
+            AuthenticationError: If authentication fails
+            APIError: If API request fails
+
+        Example:
+            >>> # Delete a test zone
+            >>> await client.delete_zone("test_zone_123")
+            >>> print("Zone deleted successfully")
+            
+            >>> # With error handling
+            >>> try:
+            ...     await client.delete_zone("my_zone")
+            ... except ZoneError as e:
+            ...     print(f"Failed to delete zone: {e}")
+        """
+        async with self.engine:
+            if self._zone_manager is None:
+                self._zone_manager = ZoneManager(self.engine)
+            await self._zone_manager.delete_zone(zone_name)
+
     def list_zones_sync(self) -> List[Dict[str, Any]]:
         """Synchronous version of list_zones()."""
-        return asyncio.run(self.list_zones())
+        return self._run_async_with_cleanup(self.list_zones())
+
+    def delete_zone_sync(self, zone_name: str) -> None:
+        """Synchronous version of delete_zone()."""
+        return self._run_async_with_cleanup(self.delete_zone(zone_name))
 
 
     async def scrape_url_async(
diff --git a/src/brightdata/core/engine.py b/src/brightdata/core/engine.py
@@ -202,6 +202,16 @@ def get(
         """Make GET request. Returns context manager."""
         return self.request("GET", endpoint, params=params, headers=headers)
     
+    def delete(
+        self,
+        endpoint: str,
+        json_data: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+    ):
+        """Make DELETE request. Returns context manager."""
+        return self.request("DELETE", endpoint, json_data=json_data, params=params, headers=headers)
+    
     def post_to_url(
         self,
         url: str,
diff --git a/src/brightdata/core/zone_manager.py b/src/brightdata/core/zone_manager.py
@@ -310,3 +310,82 @@ async def list_zones(self) -> List[Dict[str, Any]]:
         except Exception as e:
             logger.error(f"Unexpected error listing zones: {e}")
             raise ZoneError(f"Unexpected error while listing zones: {str(e)}")
+
+    async def delete_zone(self, zone_name: str) -> None:
+        """
+        Delete a zone from your Bright Data account.
+
+        Args:
+            zone_name: Name of the zone to delete
+
+        Raises:
+            ZoneError: If zone deletion fails
+            AuthenticationError: If authentication fails
+            APIError: If API request fails
+
+        Example:
+            >>> zone_manager = ZoneManager(engine)
+            >>> await zone_manager.delete_zone("my_test_zone")
+            >>> print(f"Zone 'my_test_zone' deleted successfully")
+        """
+        if not zone_name or not isinstance(zone_name, str):
+            raise ZoneError("Zone name must be a non-empty string")
+
+        max_retries = 3
+        retry_delay = 1.0
+
+        for attempt in range(max_retries):
+            try:
+                logger.info(f"Attempting to delete zone: {zone_name}")
+                
+                # Prepare the payload for zone deletion
+                payload = {
+                    "zone": zone_name
+                }
+
+                async with self.engine.delete('/zone', json_data=payload) as response:
+                    if response.status == HTTP_OK:
+                        logger.info(f"Zone '{zone_name}' successfully deleted")
+                        return
+                    elif response.status in (HTTP_UNAUTHORIZED, HTTP_FORBIDDEN):
+                        error_text = await response.text()
+                        raise AuthenticationError(
+                            f"Authentication failed ({response.status}) deleting zone '{zone_name}': {error_text}"
+                        )
+                    elif response.status == HTTP_BAD_REQUEST:
+                        error_text = await response.text()
+                        # Check if zone doesn't exist
+                        if "not found" in error_text.lower() or "does not exist" in error_text.lower():
+                            raise ZoneError(
+                                f"Zone '{zone_name}' does not exist or has already been deleted"
+                            )
+                        raise ZoneError(
+                            f"Bad request ({HTTP_BAD_REQUEST}) deleting zone '{zone_name}': {error_text}"
+                        )
+                    else:
+                        error_text = await response.text()
+                        
+                        # Retry on server errors
+                        if attempt < max_retries - 1 and response.status >= HTTP_INTERNAL_SERVER_ERROR:
+                            logger.warning(
+                                f"Zone deletion failed (attempt {attempt + 1}/{max_retries}): "
+                                f"{response.status} - {error_text}"
+                            )
+                            await asyncio.sleep(retry_delay * (1.5 ** attempt))
+                            continue
+
+                        raise ZoneError(
+                            f"Failed to delete zone '{zone_name}' ({response.status}): {error_text}"
+                        )
+            except (AuthenticationError, ZoneError):
+                raise
+            except (aiohttp.ClientError, asyncio.TimeoutError, OSError) as e:
+                if attempt < max_retries - 1:
+                    logger.warning(
+                        f"Error deleting zone (attempt {attempt + 1}/{max_retries}): {e}"
+                    )
+                    await asyncio.sleep(retry_delay * (1.5 ** attempt))
+                    continue
+                raise ZoneError(f"Failed to delete zone '{zone_name}': {str(e)}")
+
+        raise ZoneError(f"Failed to delete zone '{zone_name}' after all retry attempts")
diff --git a/tests/enes/delete_zone.py b/tests/enes/delete_zone.py
@@ -0,0 +1,157 @@
+#!/usr/bin/env python3
+"""
+Demo script for zone deletion functionality.
+
+This script demonstrates:
+1. Listing all zones
+2. Creating a test zone
+3. Verifying it exists
+4. Deleting the test zone
+5. Verifying it's gone
+"""
+
+import os
+import sys
+import asyncio
+import time
+from pathlib import Path
+
+# Add parent directory to path
+sys.path.insert(0, str(Path(__file__).parent.parent.parent / "src"))
+
+from brightdata import BrightDataClient
+from brightdata.exceptions import ZoneError, AuthenticationError
+
+
+async def demo_delete_zone():
+    """Demonstrate zone deletion functionality."""
+    
+    print("\n" + "="*60)
+    print("ZONE DELETION DEMO")
+    print("="*60)
+    
+    # Check for API token
+    if not os.environ.get("BRIGHTDATA_API_TOKEN"):
+        print("\n❌ ERROR: No API token found")
+        print("Please set BRIGHTDATA_API_TOKEN environment variable")
+        return False
+    
+    # Create client
+    client = BrightDataClient(validate_token=False)
+    
+    # Create a unique test zone name
+    timestamp = str(int(time.time()))[-6:]
+    test_zone_name = f"test_delete_zone_{timestamp}"
+    
+    try:
+        async with client:
+            # Step 1: List initial zones
+            print("\n📊 Step 1: Listing current zones...")
+            initial_zones = await client.list_zones()
+            initial_zone_names = {z.get('name') for z in initial_zones}
+            print(f"✅ Found {len(initial_zones)} zones")
+            
+            # Step 2: Create a test zone
+            print(f"\n🔧 Step 2: Creating test zone '{test_zone_name}'...")
+            test_client = BrightDataClient(
+                auto_create_zones=True,
+                web_unlocker_zone=test_zone_name,
+                validate_token=False
+            )
+            
+            try:
+                async with test_client:
+                    # Trigger zone creation
+                    try:
+                        await test_client.scrape_url_async(
+                            url="https://example.com",
+                            zone=test_zone_name
+                        )
+                    except Exception as e:
+                        # Zone might be created even if scrape fails
+                        print(f"   ℹ️  Scrape error (expected): {e}")
+                
+                print(f"✅ Test zone '{test_zone_name}' created")
+            except Exception as e:
+                print(f"❌ Failed to create test zone: {e}")
+                return False
+            
+            # Wait a bit for zone to be fully registered
+            await asyncio.sleep(2)
+            
+            # Step 3: Verify zone exists
+            print(f"\n🔍 Step 3: Verifying zone '{test_zone_name}' exists...")
+            zones_after_create = await client.list_zones()
+            zone_names_after_create = {z.get('name') for z in zones_after_create}
+            
+            if test_zone_name in zone_names_after_create:
+                print(f"✅ Zone '{test_zone_name}' found in zone list")
+                # Print zone details
+                test_zone = next(z for z in zones_after_create if z.get('name') == test_zone_name)
+                print(f"   Type: {test_zone.get('type', 'unknown')}")
+                print(f"   Status: {test_zone.get('status', 'unknown')}")
+            else:
+                print(f"⚠️  Zone '{test_zone_name}' not found (might still be creating)")
+            
+            # Step 4: Delete the test zone
+            print(f"\n🗑️  Step 4: Deleting zone '{test_zone_name}'...")
+            try:
+                await client.delete_zone(test_zone_name)
+                print(f"✅ Zone '{test_zone_name}' deleted successfully")
+            except ZoneError as e:
+                print(f"❌ Failed to delete zone: {e}")
+                return False
+            except AuthenticationError as e:
+                print(f"❌ Authentication error: {e}")
+                return False
+            
+            # Wait a bit for deletion to propagate
+            await asyncio.sleep(2)
+            
+            # Step 5: Verify zone is gone
+            print(f"\n🔍 Step 5: Verifying zone '{test_zone_name}' is deleted...")
+            final_zones = await client.list_zones()
+            final_zone_names = {z.get('name') for z in final_zones}
+            
+            if test_zone_name not in final_zone_names:
+                print(f"✅ Confirmed: Zone '{test_zone_name}' no longer exists")
+            else:
+                print(f"⚠️  Zone '{test_zone_name}' still appears in list (deletion might be delayed)")
+            
+            # Summary
+            print("\n" + "="*60)
+            print("📈 SUMMARY:")
+            print(f"   Initial zones: {len(initial_zones)}")
+            print(f"   After creation: {len(zones_after_create)}")
+            print(f"   After deletion: {len(final_zones)}")
+            print(f"   Net change: {len(final_zones) - len(initial_zones)}")
+            
+            print("\n" + "="*60)
+            print("✅ DEMO COMPLETED SUCCESSFULLY")
+            print("="*60)
+            
+            return True
+            
+    except Exception as e:
+        print(f"\n❌ Unexpected error: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+def main():
+    """Main entry point."""
+    try:
+        success = asyncio.run(demo_delete_zone())
+        sys.exit(0 if success else 1)
+    except KeyboardInterrupt:
+        print("\n\n⚠️  Demo interrupted by user")
+        sys.exit(2)
+    except Exception as e:
+        print(f"\n❌ Fatal error: {e}")
+        sys.exit(3)
+
+
+if __name__ == "__main__":
+    main()
+
diff --git a/tests/enes/delete_zone_demo.py b/tests/enes/delete_zone_demo.py
