black formatter

Author: davidteather

.sphinx/conf.py

@@ -10,13 +10,13 @@
 import os
 import sys
 
-sys.path.insert(0, os.path.abspath('../'))
-pyproject = toml.load('../pyproject.toml')
+sys.path.insert(0, os.path.abspath("../"))
+pyproject = toml.load("../pyproject.toml")
 
-project = 'ProxyProviders'
-copyright = '2025, David Teather'
-author = 'David Teather'
-release = pyproject['project']['version']
+project = "ProxyProviders"
+copyright = "2025, David Teather"
+author = "David Teather"
+release = pyproject["project"]["version"]
 
 # -- General configuration ---------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration
@@ -33,20 +33,19 @@
 
 autosummary_generate = True
 
-autodoc_default_flags = ['members', 'undoc-members', 'show-inheritance']
-autodoc_member_order = 'bysource'
+autodoc_default_flags = ["members", "undoc-members", "show-inheritance"]
+autodoc_member_order = "bysource"
 
 templates_path = ["_templates"]
 exclude_patterns = ["docs", "Thumbs.db", ".DS_Store"]
 
 napoleon_google_docstring = True
 
 
-
 # -- Options for HTML output -------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
 
 html_theme = "sphinx_rtd_theme"
 html_baseurl = "https://davidteather.github.io/proxyproviders/"
 
-source_suffix = {".rst": "restructuredtext", ".md": "markdown", ".txt": "rst"}
+source_suffix = {".rst": "restructuredtext", ".md": "markdown", ".txt": "rst"}

examples/request_with_proxy_provider.py

@@ -17,9 +17,10 @@ def request_with_proxy(provider: ProxyProvider):
     r = requests.get("https://httpbin.org/ip", proxies=requests_proxy)
     return r.json()
 
+
 webshare = Webshare(api_key="your_api_key")
 brightdata = BrightData(api_key="your_api_key", zone="your_zone")
 
 print(f"Your IP: {request_with_proxy(None)}")
 print(f"Webshare: {request_with_proxy(webshare)}")
-print(f"BrightData: {request_with_proxy(brightdata)}")
+print(f"BrightData: {request_with_proxy(brightdata)}")

proxyproviders/exceptions.py

@@ -1,27 +1,35 @@
 from typing import Optional
+
 """
 All custom exceptions for the ProxyProvider classes are defined here.
 """
 
+
 class ProxyProviderException(Exception):
     """Base class for all ProxyProvider errors."""
+
     pass
 
+
 class ProxyFetchException(ProxyProviderException):
     """Raised when there is an error fetching proxies from the provider."""
+
     def __init__(self, message: str, status_code: Optional[int] = None):
         self.message = message
         self.status_code = status_code
         super().__init__(self.message)
 
+
 class ProxyConversionException(ProxyProviderException):
     """Raised when there is an error converting proxy data to a standardized format."""
+
     pass
 
+
 class ProxyInvalidResponseException(ProxyProviderException):
     """Raised when the provider returns an invalid response."""
+
     def __init__(self, response: str):
         self.response = response
         self.message = f"Invalid response received: {response}"
         super().__init__(self.message)
-        

proxyproviders/models/proxy.py

@@ -2,33 +2,34 @@
 from typing import Optional, List
 from datetime import datetime
 
+
 @dataclass
 class Proxy:
     """Our shared data model for a proxy object across all providers."""
-    
+
     id: str
     """A unique identifier for the proxy"""
-    
+
     username: str
     """The username required for authenticating with the proxy"""
-    
+
     password: str
     """The password required for authenticating with the proxy"""
-    
+
     proxy_address: str
     """The IP address or domain name of the proxy"""
-    
+
     port: int
     """The port number through which the proxy connection is established"""
-    
+
     country_code: Optional[str] = None
     """The country code where the proxy is located, e.g., 'US', 'FR'. Optional"""
-    
+
     city_name: Optional[str] = None
     """The city name where the proxy is located, e.g., 'New York', 'Paris'. Optional"""
-    
+
     created_at: Optional[datetime] = None
     """The timestamp when the proxy was created. Optional"""
-    
+
     protocols: Optional[List[str]] = None
     """A list of connection protocols supported by the proxy, e.g., ['http', 'https']"""

proxyproviders/providers/brightdata.py

@@ -1,15 +1,16 @@
 import requests
 from typing import List, Dict, Optional
 from ..proxy_provider import ProxyProvider, ProxyConfig
-from ..exceptions import ProxyFetchException,ProxyInvalidResponseException
+from ..exceptions import ProxyFetchException, ProxyInvalidResponseException
 from ..models.proxy import Proxy
 import threading
 
+
 class BrightData(ProxyProvider):
     """BrightData (formerly luminati) is a proxy provider that offers residential and datacenter proxies.
 
     Create an account `here <https://get.brightdata.com/davidteather>`_ (affiliate link).
-    
+
     You can find your API key in the account settings `here <https://brightdata.com/cp/setting/users>`_ then create "add token" with scope "limit" (`BrightData article <https://docs.brightdata.com/general/account/api-token>`_ for more info)
 
     The BrightData API documentation is `here <https://docs.brightdata.com/api-reference/account-management-api/Get_active_Zones?playground=open>`_
@@ -36,12 +37,20 @@ class BrightData(ProxyProvider):
         proxy_provider = BrightData(api_key="your-api-key", zone="my_zone", use_super_proxy=False)
         proxies = proxy_provider.list_proxies() # returns multiple proxies for each IP in the zone (potentially thousands)
     """
+
     _BASE_URL = "https://api.brightdata.com"
     _SUPER_PROXY_ADDRESS = "brd.superproxy.io"
     _SUPER_PROXY_PORT = 33335
-    _PROTOCOLS: List[str] = ["http", "https"] # BrightData supports both HTTP and HTTPS
-
-    def __init__(self, api_key: str, zone: str, username_suffix: Optional[str] = None, use_super_proxy: Optional[bool] = True, config: Optional[ProxyConfig] = None):
+    _PROTOCOLS: List[str] = ["http", "https"]  # BrightData supports both HTTP and HTTPS
+
+    def __init__(
+        self,
+        api_key: str,
+        zone: str,
+        username_suffix: Optional[str] = None,
+        use_super_proxy: Optional[bool] = True,
+        config: Optional[ProxyConfig] = None,
+    ):
         super().__init__(config)
         self.api_key = api_key
         self.zone = zone
@@ -57,15 +66,17 @@ def _fetch_proxies(self) -> List[Proxy]:
 
         if self.use_super_proxy:
             # Let the super proxy handle the IP rotation
-           return [Proxy(
-                id="super",
-                username=username,
-                password=passwords["passwords"][0],
-                proxy_address=self._SUPER_PROXY_ADDRESS,
-                port=self._SUPER_PROXY_PORT,
-                protocols=self._PROTOCOLS,
-            )]
-        
+            return [
+                Proxy(
+                    id="super",
+                    username=username,
+                    password=passwords["passwords"][0],
+                    proxy_address=self._SUPER_PROXY_ADDRESS,
+                    port=self._SUPER_PROXY_PORT,
+                    protocols=self._PROTOCOLS,
+                )
+            ]
+
         proxies = []
 
         # Fetch all IPs in the zone, and create a proxy for each
@@ -75,22 +86,23 @@ def _fetch_proxies(self) -> List[Proxy]:
         for ip in ips:
             ip_targeted_username = username + f"-ip-{ip['ip']}"
 
-            proxies.append(Proxy(
-                id=ip["ip"],
-                username=ip_targeted_username,
-                password=passwords["passwords"][0],
-                proxy_address=self._SUPER_PROXY_ADDRESS,
-                port=self._SUPER_PROXY_PORT,
-                country_code=ip["country"],
-                protocols=self._PROTOCOLS,
-            ))
+            proxies.append(
+                Proxy(
+                    id=ip["ip"],
+                    username=ip_targeted_username,
+                    password=passwords["passwords"][0],
+                    proxy_address=self._SUPER_PROXY_ADDRESS,
+                    port=self._SUPER_PROXY_PORT,
+                    country_code=ip["country"],
+                    protocols=self._PROTOCOLS,
+                )
+            )
 
         return proxies
 
-
     def get_active_zones(self) -> Dict:
         """Fetches active zones from BrightData API.
-        
+
         Response:
 
         .. code-block:: json
@@ -104,27 +116,26 @@ def get_active_zones(self) -> Dict:
 
         """
         return self._make_request("/zone/get_active_zones", "GET")
-    
+
     def get_zone_username(self, zone: str) -> str:
         """Fetches zone username for the given zone ID from BrightData API.
-        
+
         Note: this isn't directly an API endpoint, I'm sort of reconstructing some things here and it seems to behave a little weird.
 
         :param zone: The zone ID to fetch username for
         """
 
         data = self._make_request(f"/status", "GET", params={"zone": zone})
-        
+
         customer = data.get("customer")
         if not customer:
             raise ProxyInvalidResponseException("Failed to fetch customer data")
-        
-        return f"brd-customer-{customer}-zone-{zone}"
 
+        return f"brd-customer-{customer}-zone-{zone}"
 
     def get_zone_passwords(self, zone: str) -> Dict:
         """Fetches zone passwords from BrightData API.
-        
+
         :param zone: The zone ID to fetch passwords for
 
         Response:
@@ -141,10 +152,10 @@ def get_zone_passwords(self, zone: str) -> Dict:
 
         """
         return self._make_request(f"/zone/passwords", "GET", params={"zone": zone})
-    
+
     def list_all_ips_in_zone(self, zone: str, country: Optional[str] = None) -> Dict:
         """Fetches all IPs in a zone from BrightData API.
-        
+
         :param zone: The zone ID to fetch IPs for
         :param country: Optional 2-letter country code to filter IPs by
 
@@ -159,13 +170,23 @@ def list_all_ips_in_zone(self, zone: str, country: Optional[str] = None) -> Dict
                     "country": "US",
                 }
             ]
-        
+
         """
-        return self._make_request(f"/zone/route_ips", "GET", params={"zone": zone, "list_countries": True, "country": country})
-                   
-    def _make_request(self, path: str, method: str, params: Optional[Dict] = None, json: Optional[Dict] = None) -> Dict:
+        return self._make_request(
+            f"/zone/route_ips",
+            "GET",
+            params={"zone": zone, "list_countries": True, "country": country},
+        )
+
+    def _make_request(
+        self,
+        path: str,
+        method: str,
+        params: Optional[Dict] = None,
+        json: Optional[Dict] = None,
+    ) -> Dict:
         """Makes a request to the BrightData API.
-        
+
         :param path: The path to the endpoint
         :param method: The HTTP method to use
         :param params: Optional parameters to include in the request
@@ -177,15 +198,20 @@ def _make_request(self, path: str, method: str, params: Optional[Dict] = None, j
         }
 
         url = f"{self._BASE_URL}{path}"
-        response = requests.request(method, url, headers=headers, params=params, json=json)
+        response = requests.request(
+            method, url, headers=headers, params=params, json=json
+        )
 
         if response.status_code != 200:
-            raise ProxyFetchException(f"Failed to fetch from BrightData, got status code {response.status_code}, text: {response.text}")
+            raise ProxyFetchException(
+                f"Failed to fetch from BrightData, got status code {response.status_code}, text: {response.text}"
+            )
 
-        try:    
+        try:
             data = response.json()
         except Exception as e:
-            raise ProxyInvalidResponseException(f"Failed to parse response: {str(e)}") from e
-        
+            raise ProxyInvalidResponseException(
+                f"Failed to parse response: {str(e)}"
+            ) from e
 
-        return data
+        return data