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

pihole6api/client.py

@@ -10,6 +10,7 @@ from .config import PiHole6Configuration
 from .network_info import PiHole6NetworkInfo
 from .actions import PiHole6Actions
 from .dhcp import PiHole6Dhcp
+import importlib.metadata
 
 class PiHole6Client:
     def __init__(self, base_url, password):
@@ -45,4 +46,18 @@ class PiHole6Client:
     
     def close_session(self):
         """Close the Pi-hole session by calling the exit method in the connection."""
-        return self.connection.exit()
+        return self.connection.exit()
+
+    def version(self):
+        """
+        Get the project information from package metadata.
+        
+        :return: Dictionary containing version, description, and project URL
+        """
+        metadata = importlib.metadata.metadata("pihole6api")
+        
+        return {
+            "version": metadata["Version"],
+            "description": metadata["Summary"],
+            "project_url": metadata["Project-URL"]
+        }

pihole6api/conn.py

@@ -4,65 +4,113 @@ 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"]:
+                    if "session" in data and data["session"]["valid"] and data["session"]["validity"] > 0:
                         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:
+                        if data.get("session"):
+                            logger.error(data["session"].get("message", "API failed without message"))
                         last_exception = Exception("Authentication failed: Invalid session response")
                 else:
                     # Try to extract an error message from the response
                     try:
-                        error_msg = response.json().get("error", {}).get("message", "Unknown error")
+                        error_msg = response.json().get("session", {}).get("message", "Unknown error")
                     except (json.decoder.JSONDecodeError, ValueError):
                         error_msg = f"HTTP {response.status_code}: {response.reason}"
                     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 +132,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 +142,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 +213,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/domain_management.py

@@ -85,3 +85,18 @@ class PiHole6DomainManagement:
         :param kind: Kind of domain ("exact" or "regex")
         """
         return self.connection.delete(f"domains/{domain_type}/{kind}/{domain}")
+
+    def get_all_domains(self):
+        """
+        Get all white and blacklisted domains
+        """
+        try:
+            # Get whiteliste domains
+            whitelist = self.connection.get("domains/allow/exact")
+            # Get blackliste domains
+            blacklist = self.connection.get("domains/deny/exact")
+
+            return {"whitelist": whitelist, "blacklist": blacklist}
+        except Exception as e:
+            print(f"Error fetching domains: {e}")
+            return None

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pihole6api
-Version: 0.1.8
+Version: 0.2.0
 Summary: Python API Client for Pi-hole 6
 Author-email: Shane Barbetta <shane@barbetta.me>
 License: MIT
@@ -132,6 +132,14 @@ client.actions.restart_dns()
 | `network_info`      | View network devices, interfaces, routes |
 | `actions`           | Flush logs, restart services |
 
+## Contributing
+
+Please check [CONTRIBUTING.md](CONTRIBUTING.md) for contribution guidelines.
+
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md) for a list of changes.
+
 ## License
 
 This project is license under the [MIT license](LICENSE).

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

@@ -1,19 +1,19 @@
 pihole6api/__init__.py,sha256=OKDAH2I6UjXcBmcj6rn5aNg5J60GCUBVFJ-_t83GiVQ,898
 pihole6api/actions.py,sha256=8CBkr8nYfT8yfdCO6F9M9nompaYcFdsaYGiEa1eVDCw,693
-pihole6api/client.py,sha256=HYdRh3CSZJ0srbkpjIVnLo-iy1avqKDUne5ji2Aq394,2013
+pihole6api/client.py,sha256=8sco9wFCAmF1WTRG72W5Af4fZIoTjvCXXmj-O51MY88,2472
 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=2JYPgHUmhPSuNdrMaWkEtf2lnqDJ8--g05CYntOBJvQ,9523
 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
+pihole6api/domain_management.py,sha256=5oJebojAAEEvZtJgxeuK4FazcMxmiB1NpAgStqdUv-E,3988
 pihole6api/ftl_info.py,sha256=FINHFotI1sQgkL0OPaNqW-rk4h1ua6QHnRh5gFXXRIE,3210
 pihole6api/group_management.py,sha256=Iip2Na4pUYgC5K9cwOWv_OPD6qdXRzWCmlS-fJlBMjU,2372
 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.2.0.dist-info/licenses/LICENSE,sha256=hpO6J6J9O1VZxZeHQTxKMTmuobaHbApiZxp279I4xNU,1062
+pihole6api-0.2.0.dist-info/METADATA,sha256=oL9701CfySKOOVdWglV7rEmpVBAMMRAr_KSckcTFyGw,3956
+pihole6api-0.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pihole6api-0.2.0.dist-info/top_level.txt,sha256=Qrh46lxEC54rBR8T53em-tuZLWbmi1SDwL1rOhsgrME,11
+pihole6api-0.2.0.dist-info/RECORD,,

{pihole6api-0.1.8.dist-info → pihole6api-0.2.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any