net.cidr

Imports name this capability’s declared dependencies, which fune builds next to it in your project; each one links to its page.

from .net_cidr_is_cidr import cidr_block  ← isCidr, another function of this group · built into the same file, even by a slim install
from .net_cidr_types import CidrInfo
from .net_ipv4_format_ipv4 import format_ipv4


def cidr_info(cidr: str) -> CidrInfo:
    """Everything a subnet calculator shows for one IPv4 block.

    Host bits in the input are dropped (192.168.1.77/24 describes
    192.168.1.0/24). A /31 is a point-to-point link with two usable addresses
    and no broadcast (RFC 3021); a /32 is one host.
    """
    block = cidr_block(cidr)
    if block is None:
        raise ValueError('"%s" is not a CIDR block' % (cidr,))
    if block.version != 4:
        raise ValueError('cidrInfo handles IPv4 blocks only, received "%s"' % (cidr,))
    prefix = block.prefix
    size = 2 ** (32 - prefix)
    network = block.bits[0] - block.bits[0] % size
    last = network + size - 1
    point_to_point = prefix >= 31
    return CidrInfo(
        cidr="%s/%d" % (format_ipv4(network), prefix),
        network=format_ipv4(network),
        prefix=prefix,
        netmask=format_ipv4(4294967296 - size),
        wildcard=format_ipv4(size - 1),
        broadcast=None if point_to_point else format_ipv4(last),
        first_host=format_ipv4(network if point_to_point else network + 1),
        last_host=format_ipv4(last if point_to_point else last - 1),
        host_count=size if point_to_point else size - 2,
        address_count=size,
    )

Imports name this capability’s declared dependencies, which fune builds next to it in your project; each one links to its page.

from .net_cidr_is_cidr import cidr_block  ← isCidr, another function of this group · built into the same file, even by a slim install
from .net_ipv4_parse_ipv4 import ipv4_value
from .net_ipv6_parse_ipv6 import ipv6_groups


def cidr_contains(cidr: str, address: str) -> bool:
    """Whether an address lies inside a block, IPv4 or IPv6.

    An address of the other family is never inside (an IPv4-mapped IPv6
    address is not treated as its IPv4 address).
    """
    block = cidr_block(cidr)
    if block is None:
        raise ValueError('"%s" is not a CIDR block' % (cidr,))
    v4 = ipv4_value(address)
    v6 = ipv6_groups(address) if v4 is None else None
    if v4 is None and v6 is None:
        raise ValueError('"%s" is not an IP address' % (address,))
    if block.version == 4:
        if v4 is None:
            return False
        size = 2 ** (32 - block.prefix)
        return v4 // size == block.bits[0] // size
    if v6 is None:
        return False
    for i in range(8):
        bits = max(0, min(16, block.prefix - 16 * i))
        size = 2 ** (16 - bits)
        if v6[i] // size != block.bits[i] // size:
            return False
    return True

from typing import List, NamedTuple, Optional

from .net_ipv4_parse_ipv4 import ipv4_value
from .net_ipv6_parse_ipv6 import ipv6_groups


def is_cidr(text: str) -> bool:
    """True for a well-formed IPv4 (prefix 0-32) or IPv6 (prefix 0-128) block; never raises."""
    return cidr_block(text) is not None


# Exported for the other functions of this group; not part of its contract.


class CidrBlock(NamedTuple):
    version: int
    bits: List[int]
    prefix: int


def cidr_block(text: object) -> Optional[CidrBlock]:
    """The block, or None when the text is not address/prefix with a strict decimal prefix."""
    if not isinstance(text, str) or text.count("/") != 1:
        return None
    address, digits = text.split("/")
    if len(digits) < 1 or len(digits) > 3:
        return None
    for ch in digits:
        if not ("0" <= ch <= "9"):
            return None
    if len(digits) > 1 and digits[0] == "0":
        return None
    prefix = int(digits)
    v4 = ipv4_value(address)
    if v4 is not None:
        return CidrBlock(4, [v4], prefix) if prefix <= 32 else None
    v6 = ipv6_groups(address)
    if v6 is not None:
        return CidrBlock(6, v6, prefix) if prefix <= 128 else None
    return None

from .net_ipv4_format_ipv4 import format_ipv4


def prefix_to_netmask(prefix: int) -> str:
    """The dotted-quad mask for a prefix length: 24 is 255.255.255.0."""
    if isinstance(prefix, bool) or not isinstance(prefix, int) or prefix < 0 or prefix > 32:
        raise ValueError("prefix must be an integer from 0 to 32, received %r" % (prefix,))
    return format_ipv4(4294967296 - 2 ** (32 - prefix))

from .net_ipv4_parse_ipv4 import parse_ipv4


def netmask_to_prefix(netmask: str) -> int:
    """The prefix length of a dotted-quad mask; a mask with a gap in its one bits is refused."""
    value = parse_ipv4(netmask)
    host_part = 4294967295 - value + 1
    for prefix in range(33):
        if 2 ** (32 - prefix) == host_part:
            return prefix
    raise ValueError('"%s" is not a contiguous netmask' % (netmask,))