rndc-python 0.1.1__tar.gz → 0.2.0__tar.gz

{rndc_python-0.1.1 → rndc_python-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: rndc-python
-Version: 0.1.1
+Version: 0.2.0
 Summary: Python client for ISC BIND's RNDC
 Project-URL: Homepage, https://github.com/davidgroves/rndc-python
 Project-URL: Repository, https://github.com/davidgroves/rndc-python
@@ -67,10 +67,10 @@ The package includes a CLI tool `rndc-python-cli`:
 rndc-python-cli -s 127.0.0.1 -p 953 -a sha256 -k <base64-secret> status
 
 # Using environment variables
-export ZPAPI_RNDC_HOST=127.0.0.1
-export ZPAPI_RNDC_PORT=953
-export ZPAPI_RNDC_ALGORITHM=sha256
-export ZPAPI_RNDC_SECRET=<base64-secret>
+export RNDC_HOST=127.0.0.1
+export RNDC_PORT=953
+export RNDC_ALGORITHM=sha256
+export RNDC_SECRET=<base64-secret>
 rndc-python-cli status
 
 # Mix of both (CLI options override env vars)
@@ -81,13 +81,13 @@ rndc-python-cli --port 954 reload
 
 The client can read its settings from environment variables (or a `.env` file):
 
-- `ZPAPI_RNDC_HOST`
-- `ZPAPI_RNDC_PORT`
-- `ZPAPI_RNDC_ALGORITHM` (e.g. `hmac-sha256`)
-- `ZPAPI_RNDC_SECRET`
-- `ZPAPI_RNDC_TIMEOUT`
-- `ZPAPI_RNDC_MAX_RETRIES`
-- `ZPAPI_RNDC_RETRY_DELAY`
+- `RNDC_HOST`
+- `RNDC_PORT`
+- `RNDC_ALGORITHM` (e.g. `hmac-sha256`)
+- `RNDC_SECRET`
+- `RNDC_TIMEOUT`
+- `RNDC_MAX_RETRIES`
+- `RNDC_RETRY_DELAY`
 
 You can also configure the client directly in Python:
 

{rndc_python-0.1.1 → rndc_python-0.2.0}/README.md

@@ -27,10 +27,10 @@ The package includes a CLI tool `rndc-python-cli`:
 rndc-python-cli -s 127.0.0.1 -p 953 -a sha256 -k <base64-secret> status
 
 # Using environment variables
-export ZPAPI_RNDC_HOST=127.0.0.1
-export ZPAPI_RNDC_PORT=953
-export ZPAPI_RNDC_ALGORITHM=sha256
-export ZPAPI_RNDC_SECRET=<base64-secret>
+export RNDC_HOST=127.0.0.1
+export RNDC_PORT=953
+export RNDC_ALGORITHM=sha256
+export RNDC_SECRET=<base64-secret>
 rndc-python-cli status
 
 # Mix of both (CLI options override env vars)
@@ -41,13 +41,13 @@ rndc-python-cli --port 954 reload
 
 The client can read its settings from environment variables (or a `.env` file):
 
-- `ZPAPI_RNDC_HOST`
-- `ZPAPI_RNDC_PORT`
-- `ZPAPI_RNDC_ALGORITHM` (e.g. `hmac-sha256`)
-- `ZPAPI_RNDC_SECRET`
-- `ZPAPI_RNDC_TIMEOUT`
-- `ZPAPI_RNDC_MAX_RETRIES`
-- `ZPAPI_RNDC_RETRY_DELAY`
+- `RNDC_HOST`
+- `RNDC_PORT`
+- `RNDC_ALGORITHM` (e.g. `hmac-sha256`)
+- `RNDC_SECRET`
+- `RNDC_TIMEOUT`
+- `RNDC_MAX_RETRIES`
+- `RNDC_RETRY_DELAY`
 
 You can also configure the client directly in Python:
 

{rndc_python-0.1.1 → rndc_python-0.2.0}/pyproject.toml

@@ -1,10 +1,10 @@
 [build-system]
-requires = ["hatchling>=1.25"]
+requires = ["hatchling>=1.25", "hatch-vcs>=0.4.0"]
 build-backend = "hatchling.build"
 
 [project]
 name = "rndc-python"
-version = "0.1.1"
+dynamic = ["version"]
 description = "Python client for ISC BIND's RNDC"
 readme = "README.md"
 license = "MIT"
@@ -54,6 +54,9 @@ Homepage = "https://github.com/davidgroves/rndc-python"
 Repository = "https://github.com/davidgroves/rndc-python"
 Issues = "https://github.com/davidgroves/rndc-python/issues"
 
+[tool.hatch.version]
+source = "vcs"
+
 [tool.hatch.build.targets.wheel]
 packages = ["src/rndc_python"]
 
@@ -103,7 +106,8 @@ select = [
   "B",      # flake8-bugbear
   "C4",     # flake8-comprehensions
   "UP",     # pyupgrade
-  "SIM",    # flake8-simplify
+  "SIM",    # flake8-simple
+  "BLE001", # blind except Exception — use sparingly with noqa + comment where intentional
 ]
 ignore = [
   "E501",   # line too long (handled by formatter)

{rndc_python-0.1.1 → rndc_python-0.2.0}/src/rndc_python/__init__.py

@@ -4,7 +4,13 @@ rndc-python - A Python client library for ISC BIND's RNDC
 This library provides a Python interface to ISC BIND's Remote Name Daemon Control (RNDC).
 """
 
-__version__ = "0.1.1"
+from importlib.metadata import version
+
+try:
+    __version__ = version("rndc-python")
+except Exception:  # noqa: BLE001 — zpapi-style fallback when package metadata is unavailable
+    __version__ = "0.0.0+unknown"
+
 __author__ = "David Groves"
 __email__ = "dave@fibrecat.org"
 

{rndc_python-0.1.1 → rndc_python-0.2.0}/src/rndc_python/cli.py

@@ -5,6 +5,7 @@ Usage:
     rndc-python-cli [options] <command>
 
 Examples:
+    rndc-python-cli --version
     rndc-python-cli status
     rndc-python-cli reload
     rndc-python-cli zonestatus example.com
@@ -17,6 +18,8 @@ import sys
 
 import click
 
+from . import __version__
+from .config import ENV_ALGORITHM, ENV_HOST, ENV_PORT, ENV_SECRET, ENV_TIMEOUT
 from .enums import TSIGAlgorithm
 
 # Use lowercase enum names for CLI choices
@@ -26,37 +29,38 @@ ALGORITHM_CHOICES += [f"hmac-{alg.name.lower()}" for alg in TSIGAlgorithm]
 
 
 @click.command()
+@click.version_option(__version__, "-V", "--version", prog_name="rndc-python-cli")
 @click.option(
     "-s",
     "--host",
-    envvar="ZPAPI_RNDC_HOST",
+    envvar=ENV_HOST,
     help="RNDC server hostname or IP",
 )
 @click.option(
     "-p",
     "--port",
     type=int,
-    envvar="ZPAPI_RNDC_PORT",
+    envvar=ENV_PORT,
     help="RNDC server port",
 )
 @click.option(
     "-a",
     "--algorithm",
     type=click.Choice(ALGORITHM_CHOICES, case_sensitive=False),
-    envvar="ZPAPI_RNDC_ALGORITHM",
+    envvar=ENV_ALGORITHM,
     help="TSIG algorithm",
 )
 @click.option(
     "-k",
     "--secret",
-    envvar="ZPAPI_RNDC_SECRET",
+    envvar=ENV_SECRET,
     help="Base64-encoded RNDC secret key",
 )
 @click.option(
     "-t",
     "--timeout",
     type=int,
-    envvar="ZPAPI_RNDC_TIMEOUT",
+    envvar=ENV_TIMEOUT,
     default=10,
     help="Connection timeout in seconds",
 )
@@ -79,15 +83,13 @@ def main(
 
     # Validate required options
     if not host:
-        raise click.ClickException("Missing --host or ZPAPI_RNDC_HOST environment variable")
+        raise click.ClickException(f"Missing --host or {ENV_HOST} environment variable")
     if not port:
-        raise click.ClickException("Missing --port or ZPAPI_RNDC_PORT environment variable")
+        raise click.ClickException(f"Missing --port or {ENV_PORT} environment variable")
     if not algorithm:
-        raise click.ClickException(
-            "Missing --algorithm or ZPAPI_RNDC_ALGORITHM environment variable"
-        )
+        raise click.ClickException(f"Missing --algorithm or {ENV_ALGORITHM} environment variable")
     if not secret:
-        raise click.ClickException("Missing --secret or ZPAPI_RNDC_SECRET environment variable")
+        raise click.ClickException(f"Missing --secret or {ENV_SECRET} environment variable")
 
     # Build client kwargs
     client_kwargs: dict = {
@@ -126,7 +128,7 @@ def main(
         raise click.ClickException(f"Configuration error: {e}") from None
     except ConnectionError as e:
         raise click.ClickException(f"Connection error: {e}") from None
-    except Exception as e:
+    except Exception as e:  # noqa: BLE001 — surface unexpected errors as CLI failures after specific handlers
         raise click.ClickException(str(e)) from None
 
 

{rndc_python-0.1.1 → rndc_python-0.2.0}/src/rndc_python/config.py

@@ -9,6 +9,14 @@ import os
 
 from dotenv import load_dotenv
 
+ENV_HOST = "RNDC_HOST"
+ENV_PORT = "RNDC_PORT"
+ENV_ALGORITHM = "RNDC_ALGORITHM"
+ENV_SECRET = "RNDC_SECRET"
+ENV_TIMEOUT = "RNDC_TIMEOUT"
+ENV_MAX_RETRIES = "RNDC_MAX_RETRIES"
+ENV_RETRY_DELAY = "RNDC_RETRY_DELAY"
+
 
 def _load_env_file() -> None:
     """Load environment variables from .env file if it exists."""

rndc_python-0.2.0/src/rndc_python/models.py

@@ -0,0 +1,204 @@
+"""
+Data models for RNDC responses.
+
+This module contains typed dataclasses for parsing RNDC command responses.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from datetime import datetime
+from typing import ClassVar
+
+
+@dataclass
+class Status:
+    """Parsed RNDC status response.
+
+    Represents the status of a BIND DNS server as returned by the 'status' command.
+    """
+
+    # Version and system info
+    version: str
+    """BIND version string (e.g., 'BIND 9.20.15-2-Debian (Stable Release)')"""
+
+    running_on: str
+    """System information where BIND is running"""
+
+    boot_time: datetime
+    """When the server was started"""
+
+    last_configured: datetime
+    """When the server was last configured/reloaded"""
+
+    configuration_file: str
+    """Path to the named.conf configuration file"""
+
+    # Resource info
+    cpus_found: int
+    """Number of CPUs detected"""
+
+    worker_threads: int
+    """Number of worker threads"""
+
+    # Zone info
+    number_of_zones: int
+    """Total number of zones"""
+
+    automatic_zones: int
+    """Number of automatic zones (built-in zones like localhost)"""
+
+    # Debug and logging
+    debug_level: int
+    """Current debug level (0 = off)"""
+
+    query_logging: bool
+    """Whether query logging is enabled"""
+
+    response_logging: bool
+    """Whether response logging is enabled"""
+
+    memory_profiling_active: bool
+    """Whether memory profiling is active"""
+
+    # Transfer status
+    xfers_running: int
+    """Number of zone transfers currently running"""
+
+    xfers_deferred: int
+    """Number of zone transfers deferred"""
+
+    xfers_first_refresh: int
+    """Number of zones waiting for first refresh"""
+
+    soa_queries_in_progress: int
+    """Number of SOA queries in progress"""
+
+    # Client connections
+    recursive_clients_current: int
+    """Current number of recursive clients"""
+
+    recursive_clients_soft_limit: int
+    """Soft limit for recursive clients"""
+
+    recursive_clients_hard_limit: int
+    """Hard limit for recursive clients"""
+
+    recursive_high_water: int
+    """High water mark for recursive clients"""
+
+    tcp_clients_current: int
+    """Current number of TCP clients"""
+
+    tcp_clients_limit: int
+    """Limit for TCP clients"""
+
+    tcp_high_water: int
+    """High water mark for TCP clients"""
+
+    # Server state
+    server_is_up: bool
+    """Whether the server is up and running"""
+
+    # Raw text for any unparsed fields
+    raw_text: str
+    """The raw status text from RNDC"""
+
+    # Date format used by BIND
+    _DATE_FORMAT: ClassVar[str] = "%a, %d %b %Y %H:%M:%S %Z"
+
+    @classmethod
+    def from_text(cls, text: str) -> Status:
+        """Parse status text into a Status object.
+
+        Args:
+            text: Raw status text from RNDC status command
+
+        Returns:
+            Parsed Status object
+        """
+
+        def get_value(pattern: str, default: str = "") -> str:
+            """Extract a value using regex pattern."""
+            match = re.search(pattern, text, re.MULTILINE)
+            return match.group(1).strip() if match else default
+
+        def get_int(pattern: str, default: int = 0) -> int:
+            """Extract an integer value using regex pattern."""
+            value = get_value(pattern)
+            try:
+                return int(value) if value else default
+            except ValueError:
+                return default
+
+        def parse_datetime(pattern: str) -> datetime:
+            """Parse a datetime value using regex pattern."""
+            value = get_value(pattern)
+            if not value:
+                return datetime.min
+            try:
+                return datetime.strptime(value, cls._DATE_FORMAT)
+            except ValueError:
+                return datetime.min
+
+        def parse_bool_on_off(pattern: str) -> bool:
+            """Parse an ON/OFF boolean value."""
+            value = get_value(pattern).upper()
+            return value == "ON"
+
+        def parse_bool_active(pattern: str) -> bool:
+            """Parse an ACTIVE/INACTIVE boolean value."""
+            value = get_value(pattern).upper()
+            return value == "ACTIVE"
+
+        # Parse zones with automatic count
+        zones_match = re.search(r"number of zones:\s*(\d+)\s*(?:\((\d+)\s*automatic\))?", text)
+        number_of_zones = int(zones_match.group(1)) if zones_match else 0
+        automatic_zones = int(zones_match.group(2)) if zones_match and zones_match.group(2) else 0
+
+        # Parse recursive clients: current/soft/hard
+        recursive_match = re.search(r"recursive clients:\s*(\d+)/(\d+)/(\d+)", text)
+        if recursive_match:
+            recursive_current = int(recursive_match.group(1))
+            recursive_soft = int(recursive_match.group(2))
+            recursive_hard = int(recursive_match.group(3))
+        else:
+            recursive_current = recursive_soft = recursive_hard = 0
+
+        # Parse TCP clients: current/limit
+        tcp_match = re.search(r"tcp clients:\s*(\d+)/(\d+)", text, re.IGNORECASE)
+        if tcp_match:
+            tcp_current = int(tcp_match.group(1))
+            tcp_limit = int(tcp_match.group(2))
+        else:
+            tcp_current = tcp_limit = 0
+
+        return cls(
+            version=get_value(r"^version:\s*(.+)$"),
+            running_on=get_value(r"^running on [^:]+:\s*(.+)$"),
+            boot_time=parse_datetime(r"^boot time:\s*(.+)$"),
+            last_configured=parse_datetime(r"^last configured:\s*(.+)$"),
+            configuration_file=get_value(r"^configuration file:\s*(.+)$"),
+            cpus_found=get_int(r"^CPUs found:\s*(\d+)"),
+            worker_threads=get_int(r"^worker threads:\s*(\d+)"),
+            number_of_zones=number_of_zones,
+            automatic_zones=automatic_zones,
+            debug_level=get_int(r"^debug level:\s*(\d+)"),
+            query_logging=parse_bool_on_off(r"^query logging is\s*(\w+)"),
+            response_logging=parse_bool_on_off(r"^response logging is\s*(\w+)"),
+            memory_profiling_active=parse_bool_active(r"^memory profiling is\s*(\w+)"),
+            xfers_running=get_int(r"^xfers running:\s*(\d+)"),
+            xfers_deferred=get_int(r"^xfers deferred:\s*(\d+)"),
+            xfers_first_refresh=get_int(r"^xfers first refresh:\s*(\d+)"),
+            soa_queries_in_progress=get_int(r"^soa queries in progress:\s*(\d+)"),
+            recursive_clients_current=recursive_current,
+            recursive_clients_soft_limit=recursive_soft,
+            recursive_clients_hard_limit=recursive_hard,
+            recursive_high_water=get_int(r"^recursive high-water:\s*(\d+)"),
+            tcp_clients_current=tcp_current,
+            tcp_clients_limit=tcp_limit,
+            tcp_high_water=get_int(r"^TCP high-water:\s*(\d+)", 0),
+            server_is_up="server is up and running" in text.lower(),
+            raw_text=text,
+        )

{rndc_python-0.1.1 → rndc_python-0.2.0}/src/rndc_python/rndc_client.py

@@ -17,6 +17,7 @@ import dns
 import dns.rdataclass
 
 from . import rndc_protocol
+from .config import ENV_ALGORITHM, ENV_HOST, ENV_PORT, ENV_SECRET
 from .enums import TSIGAlgorithm
 from .exceptions import (
     RNDCAuthenticationError,
@@ -54,28 +55,28 @@ class RNDCClient:
         elif rndc_config is not None:
             self.host = rndc_config.host
         else:
-            raise ValueError("host is required (provide it or set ZPAPI_RNDC_HOST)")
+            raise ValueError(f"host is required (provide it or set {ENV_HOST})")
 
         if port is not None:
             self.port = port
         elif rndc_config is not None:
             self.port = rndc_config.port
         else:
-            raise ValueError("port is required (provide it or set ZPAPI_RNDC_PORT)")
+            raise ValueError(f"port is required (provide it or set {ENV_PORT})")
 
         if algorithm is not None:
             self.algorithm = algorithm
         elif rndc_config is not None:
             self.algorithm = rndc_config.algorithm
         else:
-            raise ValueError("algorithm is required (provide it or set ZPAPI_RNDC_ALGORITHM)")
+            raise ValueError(f"algorithm is required (provide it or set {ENV_ALGORITHM})")
 
         if secret is not None:
             self.secret = base64.b64decode(secret)
         elif rndc_config is not None:
             self.secret = base64.b64decode(rndc_config.secret)
         else:
-            raise ValueError("secret is required (provide it or set ZPAPI_RNDC_SECRET)")
+            raise ValueError(f"secret is required (provide it or set {ENV_SECRET})")
 
         if timeout is not None:
             self.timeout = timeout
@@ -198,7 +199,7 @@ class RNDCClient:
 
         try:
             remote_hash = base64.b64decode(b64_hash)
-        except Exception:
+        except Exception:  # noqa: BLE001 — malformed TSIG hash must fail verification, not raise
             return False
 
         # Verify hash

{rndc_python-0.1.1 → rndc_python-0.2.0}/src/rndc_python/rndc_config.py

@@ -8,6 +8,13 @@ Assumes .env file contains all required defaults if they aren't set in the envir
 from typing import Any
 
 from .config import (
+    ENV_ALGORITHM,
+    ENV_HOST,
+    ENV_MAX_RETRIES,
+    ENV_PORT,
+    ENV_RETRY_DELAY,
+    ENV_SECRET,
+    ENV_TIMEOUT,
     _get_required_env_var,
     _load_env_file,
     _parse_float_env_var,
@@ -48,15 +55,13 @@ class RNDCConfig:
         retry_delay: float | None = None,
     ) -> None:
         _load_env_file()
-        self.host = host or _get_required_env_var("ZPAPI_RNDC_HOST")
-        self.port = port or _parse_port(_get_required_env_var("ZPAPI_RNDC_PORT"))
-        self.algorithm = algorithm or _parse_algorithm(
-            _get_required_env_var("ZPAPI_RNDC_ALGORITHM")
-        )
-        self.secret = secret or _get_required_env_var("ZPAPI_RNDC_SECRET")
-        self.timeout = timeout or _parse_timeout(_get_required_env_var("ZPAPI_RNDC_TIMEOUT"))
-        self.max_retries = max_retries or _parse_int_env_var("ZPAPI_RNDC_MAX_RETRIES", 3)
-        self.retry_delay = retry_delay or _parse_float_env_var("ZPAPI_RNDC_RETRY_DELAY", 1.0)
+        self.host = host or _get_required_env_var(ENV_HOST)
+        self.port = port or _parse_port(_get_required_env_var(ENV_PORT))
+        self.algorithm = algorithm or _parse_algorithm(_get_required_env_var(ENV_ALGORITHM))
+        self.secret = secret or _get_required_env_var(ENV_SECRET)
+        self.timeout = timeout or _parse_timeout(_get_required_env_var(ENV_TIMEOUT))
+        self.max_retries = max_retries or _parse_int_env_var(ENV_MAX_RETRIES, 3)
+        self.retry_delay = retry_delay or _parse_float_env_var(ENV_RETRY_DELAY, 1.0)
 
     def to_dict(self) -> dict[str, Any]:
         return {