feat: add playwright proxy formatter

Author: davidteather

proxyproviders/models/proxy.py

@@ -19,6 +19,9 @@ class ProxyFormat(Enum):
     AIOHTTP = "aiohttp"
     """AIOHTTP format, for use in aiohttp library HTTP calls"""
 
+    PLAYWRIGHT = "playwright"
+    """Playwright format, for use in Playwright browser automation"""
+
     URL = "url"
     """URL format, for use in URL strings"""
 
@@ -90,29 +93,51 @@ def format(
             >>> proxy.format(ProxyFormat.HTTPX)
             {'http://': 'http://user:[email protected]:8080', 'https://': 'http://user:[email protected]:8080'}
         """
+        # Convert to ProxyFormat enum, handling both string and enum inputs
         if isinstance(format_type, str):
-            format_type = ProxyFormat(format_type)
+            try:
+                format_type = ProxyFormat(format_type)
+            except ValueError:
+                raise ValueError(
+                    f"Invalid format type: '{format_type}'. Valid options are: {[f.value for f in ProxyFormat]}"
+                )
+        elif not isinstance(format_type, ProxyFormat):
+            raise ValueError(
+                f"Invalid format type: {type(format_type).__name__}. Expected ProxyFormat enum or string."
+            )
+
+        format_handlers = {
+            ProxyFormat.URL: lambda: self.to_url(kwargs.get("protocol", "http")),
+            ProxyFormat.REQUESTS: lambda: self._format_requests(kwargs),
+            ProxyFormat.CURL: lambda: ["-x", self.to_url("http")],
+            ProxyFormat.HTTPX: lambda: self._format_httpx(),
+            ProxyFormat.AIOHTTP: lambda: self.to_url("http"),
+            ProxyFormat.PLAYWRIGHT: lambda: self._format_playwright(),
+        }
+
+        handler = format_handlers.get(format_type)
+        if handler is None:
+            raise ValueError(f"Unsupported format: {format_type}")
 
-        if format_type == ProxyFormat.URL:
-            protocol = kwargs.get("protocol", "http")
-            return self.to_url(protocol)
+        return handler()
 
-        elif format_type == ProxyFormat.REQUESTS:
-            protocols = kwargs.get("protocols", self.protocols or ["http", "https"])
-            proxy_url = self.to_url("http")
-            return {protocol: proxy_url for protocol in protocols}
+    def _format_requests(self, kwargs):
+        """Format proxy for requests library."""
+        protocols = kwargs.get("protocols", self.protocols or ["http", "https"])
+        proxy_url = self.to_url("http")
+        return {protocol: proxy_url for protocol in protocols}
 
-        elif format_type == ProxyFormat.CURL:
-            return ["-x", self.to_url("http")]
+    def _format_httpx(self):
+        """Format proxy for httpx library."""
+        proxy_url = self.to_url("http")
+        return {"http://": proxy_url, "https://": proxy_url}
 
-        elif format_type == ProxyFormat.HTTPX:
-            # httpx uses 'http://' and 'https://' as keys
-            proxy_url = self.to_url("http")
-            return {"http://": proxy_url, "https://": proxy_url}
+    def _format_playwright(self):
+        """Format proxy for Playwright."""
+        playwright_proxy = {"server": f"{self.proxy_address}:{self.port}"}
 
-        elif format_type == ProxyFormat.AIOHTTP:
-            # aiohttp takes a single URL string
-            return self.to_url("http")
+        if self.username and self.password:
+            playwright_proxy["username"] = self.username
+            playwright_proxy["password"] = self.password
 
-        else:
-            raise ValueError(f"Unsupported format: {format_type}")
+        return playwright_proxy

tests/test_proxy_model.py

@@ -141,6 +141,62 @@ def test_format_aiohttp(self, sample_proxy):
         expected = "http://testuser:[email protected]:8080"
         assert result == expected
 
+    def test_format_playwright_with_auth(self, sample_proxy):
+        """Test format for Playwright with authentication."""
+        result = sample_proxy.format(ProxyFormat.PLAYWRIGHT)
+        expected = {
+            "server": "192.168.1.100:8080",
+            "username": "testuser",
+            "password": "testpass",
+        }
+        assert result == expected
+
+    def test_format_playwright_without_auth(self, sample_proxy_no_protocols):
+        """Test format for Playwright with authentication (sample_proxy_no_protocols has auth)."""
+        result = sample_proxy_no_protocols.format(ProxyFormat.PLAYWRIGHT)
+        expected = {
+            "server": "10.0.0.1:3128",
+            "username": "user2",
+            "password": "pass2",
+        }
+        assert result == expected
+
+    def test_format_playwright_empty_credentials(self):
+        """Test format for Playwright with empty username/password."""
+        proxy = Proxy(
+            id="no-auth",
+            username="",
+            password="",
+            proxy_address="192.168.1.1",
+            port=8080,
+        )
+        result = proxy.format(ProxyFormat.PLAYWRIGHT)
+        expected = {"server": "192.168.1.1:8080"}
+        assert result == expected
+
+    def test_format_playwright_none_credentials(self):
+        """Test format for Playwright with None username/password."""
+        proxy = Proxy(
+            id="none-auth",
+            username=None,
+            password=None,
+            proxy_address="192.168.1.1",
+            port=8080,
+        )
+        result = proxy.format(ProxyFormat.PLAYWRIGHT)
+        expected = {"server": "192.168.1.1:8080"}
+        assert result == expected
+
+    def test_format_playwright_string_format(self, sample_proxy):
+        """Test format for Playwright using string format."""
+        result = sample_proxy.format("playwright")
+        expected = {
+            "server": "192.168.1.100:8080",
+            "username": "testuser",
+            "password": "testpass",
+        }
+        assert result == expected
+
     def test_format_string_enum(self, sample_proxy):
         """Test format with string instead of enum."""
         result = sample_proxy.format("requests")
@@ -152,7 +208,7 @@ def test_format_string_enum(self, sample_proxy):
 
     def test_format_unsupported_format(self, sample_proxy):
         """Test format with unsupported format type."""
-        with pytest.raises(ValueError, match="is not a valid ProxyFormat"):
+        with pytest.raises(ValueError, match="Invalid format type"):
             sample_proxy.format("unsupported")
 
     def test_format_proxy_with_limited_protocols(self):
@@ -237,3 +293,7 @@ def test_all_format_types_work(self, sample_proxy):
         # AIOHTTP format returns string
         aiohttp_result = sample_proxy.format(ProxyFormat.AIOHTTP)
         assert isinstance(aiohttp_result, str)
+
+        # PLAYWRIGHT format returns dict
+        playwright_result = sample_proxy.format(ProxyFormat.PLAYWRIGHT)
+        assert isinstance(playwright_result, dict)