net.ipv6

from typing import List, Optional, Sequence

from .net_ipv4_parse_ipv4 import ipv4_value

_ALLOWED = frozenset("0123456789abcdefABCDEF:.")


def parse_ipv6(text: str) -> List[int]:
    """The eight 16-bit groups of an IPv6 address written as RFC 4291 allows.

    Hex groups of one to four digits in either case, at most one "::" standing
    for one or more zero groups, and optionally a dotted IPv4 address as the
    last 32 bits. A zone id ("%eth0") or a prefix ("/64") is not part of an
    address and is refused, as is anything around it (spaces, newlines).
    """
    groups = ipv6_groups(text)
    if groups is None:
        raise ValueError('"%s" is not an IPv6 address' % (text,))
    return groups


# Exported for is_ipv6 and for capabilities that parse IPv6 text without
# wanting an error; not part of the group's contract.


def ipv6_groups(text: object) -> Optional[List[int]]:
    """The eight groups, or None when the text is not an IPv6 address."""
    if not isinstance(text, str) or text == "":
        return None
    for ch in text:
        if ch not in _ALLOWED:
            return None
    at = text.find("::")
    if at < 0:
        groups = _pieces(text.split(":"), True)
        return groups if groups is not None and len(groups) == 8 else None
    before = text[:at]
    after = text[at + 2:]
    if "::" in after:
        return None
    head = _pieces(before.split(":") if before else [], False)
    tail = _pieces(after.split(":") if after else [], True)
    if head is None or tail is None:
        return None
    # "::" stands for at least one group, so at most seven are written.
    if len(head) + len(tail) > 7:
        return None
    return head + [0] * (8 - len(head) - len(tail)) + tail


def _pieces(parts: Sequence[str], may_end_with_ipv4: bool) -> Optional[List[int]]:
    groups: List[int] = []
    for i, part in enumerate(parts):
        if "." in part:
            if not may_end_with_ipv4 or i != len(parts) - 1:
                return None
            v4 = ipv4_value(part)
            if v4 is None:
                return None
            groups.extend([v4 // 65536, v4 % 65536])
            continue
        if len(part) < 1 or len(part) > 4:
            return None
        groups.append(int(part, 16))
    return groups

from typing import Sequence

from .net_ipv4_format_ipv4 import format_ipv4


def format_ipv6(groups: Sequence[int]) -> str:
    """RFC 5952 canonical text for eight 16-bit groups.

    Lower-case hex, no leading zeros, the longest run of two or more zero
    groups written "::" (the first on a tie, never a single group). An
    IPv4-mapped address (::ffff:0:0/96) keeps its dotted-quad tail.
    """
    if isinstance(groups, (str, bytes)) or not isinstance(groups, (list, tuple)) or len(groups) != 8:
        raise ValueError("IPv6 groups must be eight integers from 0 to 65535")
    for g in groups:
        if isinstance(g, bool) or not isinstance(g, int) or g < 0 or g > 65535:
            raise ValueError("IPv6 groups must be eight integers from 0 to 65535")
    if list(groups[:6]) == [0, 0, 0, 0, 0, 0xFFFF]:
        return "::ffff:" + format_ipv4(groups[6] * 65536 + groups[7])
    best_start, best_length = -1, 0
    i = 0
    while i < 8:
        if groups[i] != 0:
            i += 1
            continue
        j = i
        while j < 8 and groups[j] == 0:
            j += 1
        # Strictly longer, so the first of two equal runs wins.
        if j - i > best_length:
            best_start, best_length = i, j - i
        i = j
    hexes = ["%x" % g for g in groups]
    if best_length < 2:
        return ":".join(hexes)
    return ":".join(hexes[:best_start]) + "::" + ":".join(hexes[best_start + best_length:])

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

from .net_ipv6_parse_ipv6 import ipv6_groups  ← parseIpv6, another function of this group · built into the same file, even by a slim install


def is_ipv6(text: str) -> bool:
    """True exactly when parse_ipv6 would accept the text; never raises."""
    return ipv6_groups(text) is not None