fix: keep CARP state knowledge out of the base package (4.10.1)

carp_virtual_ip() and its state table are CARP protocol knowledge; under the
agreed structure (PR #37, docs/STRUCTURE.md) the base package carries only
contracts, data shapes and I/O-free reconcilers. They move to the driver that
speaks CARP (napalm-opnsense). The contract stays: VirtualIpsDict.carp and
VirtualIpDict.holds.

Nothing used the helper yet; it was released in 4.10.0 an hour ago.

netOrk #1121.

napalm_device_types/__init__.py

@@ -134,7 +134,6 @@ from napalm_device_types.system_identity import (
 from napalm_device_types.virtual_ips import (
     VIRTUAL_IPS_COMMAND,
     VirtualIpsMixin,
-    carp_virtual_ip,
     parse_virtual_ips,
 )
 from napalm_device_types.residential_gateway import ResidentialGatewayDriver
@@ -222,7 +221,6 @@ __all__ = [
     "SshHardeningResult",
     "plan_ssh_hardening",
     "parse_virtual_ips",
-    "carp_virtual_ip",
     "add_lag_interfaces",
     "driver_supports_ping",
     "normalize_cidr",

napalm_device_types/virtual_ips.py

@@ -42,11 +42,6 @@ caller keeps what it knew. ``[]`` is a host that has none.
 script goes to the host as one ``sh -c`` argument; when the privileged call
 brings no report back, it runs again without privilege and reads what it can.
 
-**CARP.** A firewall's CARP addresses come from its own API, not from this
-command, so :func:`carp_virtual_ip` only shapes one entry: what is the same for
-every CARP firewall is the meaning of the state. CARP's MASTER holds the address
-(``holds``), which the interface list of a firewall need not show.
-
 **An exec channel, not a terminal.** With its awk program the command is about
 4 kB, past the line an interactive shell reliably takes. A driver sends it the
 way it runs any command that needs no PTY -- napalm-linux's ``run_command``.
@@ -337,53 +332,6 @@ _READERS: Dict[str, Tuple[str, Callable[[str, List[_Record]], List[VirtualIpDict
 }
 
 
-#: CARP's state of a VHID on one member -> (running, holds).
-_CARP_STATES: Dict[str, Tuple[bool, bool]] = {
-    "MASTER": (True, True),
-    "BACKUP": (True, False),
-    "INIT": (False, False),
-    "DISABLED": (False, False),
-}
-
-
-def carp_virtual_ip(
-    *,
-    address: str,
-    prefix_length: Optional[int],
-    vhid: object,
-    state: Optional[str],
-    instance: str,
-    interface: Optional[str],
-) -> Optional[VirtualIpDict]:
-    """One address bound to a CARP VHID, as a virtual IP; None for what is no address.
-
-    Who holds it comes from CARP's *state* on this member, not from its
-    interfaces: MASTER holds it, BACKUP stands by, INIT and DISABLED neither run
-    nor hold. A state this does not know says nothing (``running`` and ``holds``
-    None), and the caller falls back on the interfaces. *address* may carry its
-    prefix (``"10.0.0.1/24"``), which then wins over *prefix_length*.
-    """
-    parsed = _address(address.strip()) if address else None
-    if parsed is None:
-        return None
-    normalised, written = parsed
-    prefix = written if written is not None else prefix_length
-    if prefix is not None and not 0 <= prefix <= ipaddress.ip_address(normalised).max_prefixlen:
-        prefix = None
-    vhid_text = str(vhid).strip() if vhid is not None else ""
-    running, holds = _CARP_STATES.get((state or "").strip().upper(), (None, None))
-    return {
-        "mechanism": "carp",
-        "instance": instance or f"vhid {vhid_text}",
-        "address": normalised,
-        "prefix_length": prefix,
-        "interface": interface,
-        "group_key": f"vhid:{vhid_text}" if vhid_text.isdigit() else None,
-        "running": running,
-        "holds": holds,
-    }
-
-
 def _order(entry: VirtualIpDict) -> Tuple[int, int, str]:
     address = ipaddress.ip_address(entry["address"])
     return address.version, int(address), entry["instance"]