pihole6api 0.1.8__py3-none-any.whl → 0.1.9__py3-none-any.whl

pihole6api/conn.py

@@ -4,48 +4,89 @@ from urllib.parse import urljoin
 import warnings
 import time
 import json
+import logging
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
 
 # Suppress InsecureRequestWarning
 urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
 warnings.simplefilter("ignore", category=urllib3.exceptions.InsecureRequestWarning)
 
+# Configure logging
+logger = logging.getLogger("pihole6api")
+
 class PiHole6Connection:
-    def __init__(self, base_url, password):
+    def __init__(self, base_url, password, max_retries=3, retry_delay=1, 
+                 connection_timeout=10, disable_connection_pooling=False):
         """
         Initialize the Pi-hole connection client.
 
         :param base_url: The base URL of the Pi-hole API (e.g., "http://pi.hole/api/")
         :param password: The password for authentication (or an application password)
+        :param max_retries: Maximum number of retry attempts for failed requests
+        :param retry_delay: Base delay in seconds between retries (will use exponential backoff)
+        :param connection_timeout: Connection timeout in seconds
+        :param disable_connection_pooling: If True, disable connection pooling to prevent connection reuse issues
         """
         self.base_url = base_url.rstrip("/") + "/api/"
         self.password = password
         self.session_id = None
         self.csrf_token = None
         self.validity = None
-
+        self.max_retries = max_retries
+        self.retry_delay = retry_delay
+        self.connection_timeout = connection_timeout
+        self.disable_connection_pooling = disable_connection_pooling
+        
+        # Create a session for connection reuse
+        self.session = requests.Session()
+        
+        # Configure retry strategy
+        retry_strategy = Retry(
+            total=max_retries,
+            backoff_factor=retry_delay,
+            status_forcelist=[429, 500, 502, 503, 504],
+            allowed_methods=["GET", "POST", "PUT", "DELETE", "PATCH"]
+        )
+        
+        # Configure adapter with retry strategy
+        adapter = HTTPAdapter(
+            max_retries=retry_strategy,
+            pool_connections=1 if disable_connection_pooling else 10,
+            pool_maxsize=1 if disable_connection_pooling else 10
+        )
+        
+        # Mount the adapter to both HTTP and HTTPS
+        self.session.mount("http://", adapter)
+        self.session.mount("https://", adapter)
+        
+        # Set timeout
+        self.session.timeout = connection_timeout
+        
         # Authenticate upon initialization
         self._authenticate()
 
     def _authenticate(self):
         """Authenticate with the Pi-hole API and store session ID and CSRF token.
         
-        Retries up to three times (with a one-second pause between attempts)
-        before raising an exception.
+        Retries up to max_retries times with exponential backoff before raising an exception.
         """
         auth_url = urljoin(self.base_url, "auth")
         payload = {"password": self.password}
-        max_attempts = 3
         last_exception = None
 
-        for attempt in range(1, max_attempts + 1):
-            response = requests.post(auth_url, json=payload, verify=False)
+        for attempt in range(1, self.max_retries + 1):
             try:
+                logger.debug(f"Authentication attempt {attempt}/{self.max_retries}")
+                response = self.session.post(auth_url, json=payload, verify=False, timeout=self.connection_timeout)
+                
                 if response.status_code == 200:
                     data = response.json()
                     if "session" in data and data["session"]["valid"]:
                         self.session_id = data["session"]["sid"]
                         self.csrf_token = data["session"]["csrf"]
                         self.validity = data["session"]["validity"]
+                        logger.debug("Authentication successful")
                         return  # Successful authentication
                     else:
                         last_exception = Exception("Authentication failed: Invalid session response")
@@ -58,11 +99,16 @@ class PiHole6Connection:
                     last_exception = Exception(f"Authentication failed: {error_msg}")
             except Exception as e:
                 last_exception = e
+                logger.warning(f"Authentication attempt {attempt} failed: {str(e)}")
 
-            if attempt < max_attempts:
-                time.sleep(1)  # Pause before retrying
+            if attempt < self.max_retries:
+                # Calculate exponential backoff delay
+                current_delay = self.retry_delay * (2 ** (attempt - 1))
+                logger.debug(f"Retrying authentication in {current_delay} seconds...")
+                time.sleep(current_delay)
 
         # All attempts failed; raise the last captured exception.
+        logger.error(f"All authentication attempts failed: {str(last_exception)}")
         raise last_exception
 
     def _get_headers(self):
@@ -84,21 +130,9 @@ class PiHole6Connection:
         request_data = None if files else data
         form_data = data if files else None  # Ensure correct encoding
 
-        response = requests.request(
-            method,
-            url,
-            headers=headers,
-            params=params,
-            json=request_data,
-            files=files,
-            data=form_data,
-            verify=False
-        )
-
-        if response.status_code == 401:
-            self._authenticate()
-            headers = self._get_headers()
-            response = requests.request(
+        try:
+            logger.debug(f"Sending {method} request to {url}")
+            response = self.session.request(
                 method,
                 url,
                 headers=headers,
@@ -106,28 +140,55 @@ class PiHole6Connection:
                 json=request_data,
                 files=files,
                 data=form_data,
-                verify=False
+                verify=False,
+                timeout=self.connection_timeout
             )
 
-        # Handle 4xx responses gracefully
-        if 400 <= response.status_code < 500:
+            if response.status_code == 401:
+                logger.warning("Session expired, re-authenticating")
+                self._authenticate()
+                headers = self._get_headers()
+                response = self.session.request(
+                    method,
+                    url,
+                    headers=headers,
+                    params=params,
+                    json=request_data,
+                    files=files,
+                    data=form_data,
+                    verify=False,
+                    timeout=self.connection_timeout
+                )
+
+            # Handle 4xx responses gracefully
+            if 400 <= response.status_code < 500:
+                try:
+                    return response.json()
+                except requests.exceptions.JSONDecodeError:
+                    return {"error": f"HTTP {response.status_code}: {response.reason}"}
+
+            response.raise_for_status()
+
+            if is_binary:
+                return response.content  # Return raw binary content (e.g., for file exports)
+
+            if not response.content.strip():
+                return {}  # Handle empty response
+
             try:
-                return response.json()
+                return response.json()  # Attempt to parse JSON
             except requests.exceptions.JSONDecodeError:
-                return {"error": f"HTTP {response.status_code}: {response.reason}"}
-
-        response.raise_for_status()
-
-        if is_binary:
-            return response.content  # Return raw binary content (e.g., for file exports)
-
-        if not response.content.strip():
-            return {}  # Handle empty response
-
-        try:
-            return response.json()  # Attempt to parse JSON
-        except requests.exceptions.JSONDecodeError:
-            return response.text  # Return raw text as fallback
+                return response.text  # Return raw text as fallback
+                
+        except requests.exceptions.ConnectionError as e:
+            logger.error(f"Connection error: {str(e)}")
+            raise Exception(f"Connection error: {str(e)}")
+        except requests.exceptions.Timeout as e:
+            logger.error(f"Request timed out: {str(e)}")
+            raise Exception(f"Request timed out: {str(e)}")
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Request error: {str(e)}")
+            raise Exception(f"Request error: {str(e)}")
 
     def get(self, endpoint, params=None, is_binary=False):
         """Send a GET request."""
@@ -150,12 +211,19 @@ class PiHole6Connection:
         return self._do_call("PATCH", endpoint, data=data)
     
     def exit(self):
-        """Delete the current session."""
-        response = self.delete("auth")
-
-        # Clear stored session info
-        self.session_id = None
-        self.csrf_token = None
-        self.validity = None
+        """Delete the current session and close connections."""
+        try:
+            response = self.delete("auth")
+        except Exception as e:
+            logger.warning(f"Error during session exit: {str(e)}")
+            response = {"error": str(e)}
+        finally:
+            # Clear stored session info
+            self.session_id = None
+            self.csrf_token = None
+            self.validity = None
+            
+            # Close the session to release connections
+            self.session.close()
 
         return response

{pihole6api-0.1.8.dist-info → pihole6api-0.1.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pihole6api
-Version: 0.1.8
+Version: 0.1.9
 Summary: Python API Client for Pi-hole 6
 Author-email: Shane Barbetta <shane@barbetta.me>
 License: MIT

{pihole6api-0.1.8.dist-info → pihole6api-0.1.9.dist-info}/RECORD

@@ -3,7 +3,7 @@ pihole6api/actions.py,sha256=8CBkr8nYfT8yfdCO6F9M9nompaYcFdsaYGiEa1eVDCw,693
 pihole6api/client.py,sha256=HYdRh3CSZJ0srbkpjIVnLo-iy1avqKDUne5ji2Aq394,2013
 pihole6api/client_management.py,sha256=n8Ra_6pRL3Q9jlIK3kIK9bmh74MTfxgYnOHYaUwYGNs,2590
 pihole6api/config.py,sha256=NdBHOudz147oIs5YVR3U4WLvqk3hU3HlZHnshy1NK4g,4680
-pihole6api/conn.py,sha256=60Q9paDCD6Bwmdg_G9mOUr86Hzj9G-dhMwL7F3NvLB8,5837
+pihole6api/conn.py,sha256=vR7nTlJKIu0r_hL4ccCQl1zvjdivtwYNYXexRqYPMog,9334
 pihole6api/dhcp.py,sha256=1A3z-3q9x51-6MOC3JMl7yR_5pHmRxZtMWtPqzWxYm0,629
 pihole6api/dns_control.py,sha256=mxV3AIuGCsx0-1ibpMXor9QUGd_fDFfeaUENPhIK_TY,853
 pihole6api/domain_management.py,sha256=vxhQSG5F8EFDGqtiNkF0H_KOWFMerXaAuJZT0nMa8ec,3492
@@ -12,8 +12,8 @@ pihole6api/group_management.py,sha256=Iip2Na4pUYgC5K9cwOWv_OPD6qdXRzWCmlS-fJlBMj
 pihole6api/list_management.py,sha256=CooTeF4EmNPFwnzGoLbHFMhCePJ-ojvRGx7Sxzayy-U,4170
 pihole6api/metrics.py,sha256=QWqV_7SytMPGEBEZOxsIfxTa6lM9Ksrvlf2BXjDKZmA,7991
 pihole6api/network_info.py,sha256=E1qQ7DsCb7qplt0oQIyKhUY12ExNF6bv6thm9rbNqwY,1953
-pihole6api-0.1.8.dist-info/licenses/LICENSE,sha256=hpO6J6J9O1VZxZeHQTxKMTmuobaHbApiZxp279I4xNU,1062
-pihole6api-0.1.8.dist-info/METADATA,sha256=LqrKT8Vpxgqtithi4sPa80xMEIBWmpKGUrAYN7G3nyQ,3790
-pihole6api-0.1.8.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-pihole6api-0.1.8.dist-info/top_level.txt,sha256=Qrh46lxEC54rBR8T53em-tuZLWbmi1SDwL1rOhsgrME,11
-pihole6api-0.1.8.dist-info/RECORD,,
+pihole6api-0.1.9.dist-info/licenses/LICENSE,sha256=hpO6J6J9O1VZxZeHQTxKMTmuobaHbApiZxp279I4xNU,1062
+pihole6api-0.1.9.dist-info/METADATA,sha256=KKHIb02db_On_j5n_Mj_gBZqcmju--Hn21ESdjqnEYI,3790
+pihole6api-0.1.9.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+pihole6api-0.1.9.dist-info/top_level.txt,sha256=Qrh46lxEC54rBR8T53em-tuZLWbmi1SDwL1rOhsgrME,11
+pihole6api-0.1.9.dist-info/RECORD,,