pyfect-dev 0.1.0__py3-none-any.whl

pyfect/net/dns/_service.py

@@ -0,0 +1,287 @@
+"""The DNS service (Effect's ``Dns``): built from a lookup, and optionally a
+record resolver and reverse lookup, by ``make``; or from a fixed zone by
+``make_static``."""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Callable, Iterable, Mapping, Sequence
+from dataclasses import dataclass
+from ipaddress import IPv4Address, IPv6Address
+from typing import Literal, overload
+
+from pyfect._core import Effect
+from pyfect.context import Tag
+from pyfect.effect import fail, from_result, succeed, sync
+from pyfect.layer import Layer
+from pyfect.layer import effect as layer_effect
+from pyfect.net._errors import NetAddressError
+from pyfect.net.dns._error import DnsError, DnsMethod
+from pyfect.net.dns._records import (
+    A,
+    Aaaa,
+    DnsRecord,
+    Ptr,
+    RecordType,
+    record_classes,
+    reverse_name,
+)
+from pyfect.net.host import DomainName, DomainNameInput, domain_name_from_input, to_relative
+from pyfect.net.net_address._inet import (
+    InetAddress,
+    InetAddressInput,
+    InetAddressV4,
+    InetAddressV6,
+    inet_address_from_input,
+    inet_address_unsafe,
+)
+from pyfect.net.net_address._inet import inet_address_from_string as parse_inet
+from pyfect.net.net_address._ip import (
+    IpAddress,
+    IpAddressInput,
+    IpFamily,
+    family_of,
+    format_ip,
+    ip_from_input,
+)
+from pyfect.result import Err, Ok, Result
+
+type Lookup = Callable[[DomainName, IpFamily | None], Effect[Sequence[IpAddress], DnsError]]
+type Resolve = Callable[[DomainName, RecordType], Effect[Sequence[DnsRecord], DnsError]]
+type Reverse = Callable[[IpAddress], Effect[Sequence[str], DnsError]]
+
+_ASCII_NAME = re.compile(r"[\w.-]+", re.ASCII)
+_HOST_PORT = re.compile(r"[^:]*:[0-9]+")
+
+
+def _dedupe[A](values: Iterable[A]) -> tuple[A, ...]:
+    return tuple(dict.fromkeys(values))
+
+
+def _not_found(method: DnsMethod, hostname: str, record_type: RecordType | None = None) -> DnsError:
+    return DnsError("NotFound", method, hostname, record_type)
+
+
+@dataclass(frozen=True, slots=True)
+class DnsService:
+    """Host lookups, record queries and reverse lookups. Every result is
+    non-empty and without duplicates; an empty answer fails with
+    ``NotFound``, a name that does not parse with ``BadName``."""
+
+    _lookup: Lookup
+    _resolve: Resolve
+    _reverse: Reverse
+
+    @overload
+    def lookup(
+        self, host: DomainNameInput, *, family: Literal["IPv4"]
+    ) -> Effect[tuple[IPv4Address, ...], DnsError]: ...
+    @overload
+    def lookup(
+        self, host: DomainNameInput, *, family: Literal["IPv6"]
+    ) -> Effect[tuple[IPv6Address, ...], DnsError]: ...
+    @overload
+    def lookup(
+        self, host: DomainNameInput, *, family: IpFamily | None = None
+    ) -> Effect[tuple[IpAddress, ...], DnsError]: ...
+    def lookup(
+        self, host: DomainNameInput, *, family: IpFamily | None = None
+    ) -> Effect[tuple[IpAddress, ...], DnsError]:
+        """The addresses of ``host``, of ``family`` when given."""
+        match domain_name_from_input(host):
+            case Err(error):
+                return fail(DnsError("BadName", "lookup", host, cause=error))
+            case Ok(name):
+                pass
+
+        def found(addresses: Sequence[IpAddress]) -> Effect[tuple[IpAddress, ...], DnsError]:
+            kept = _dedupe(a for a in addresses if family is None or family_of(a) == family)
+            return succeed(kept) if kept else fail(_not_found("lookup", name))
+
+        return self._lookup(name, family).flat_map(found)
+
+    def resolve[R: DnsRecord](
+        self, name: DomainNameInput, record_type: type[R]
+    ) -> Effect[tuple[R, ...], DnsError]:
+        """The records of ``record_type`` (a record class: ``dns.Mx``) at
+        ``name``."""
+        tag = record_type.tag
+        match domain_name_from_input(name):
+            case Err(error):
+                return fail(DnsError("BadName", "resolve", name, tag, error))
+            case Ok(domain):
+                pass
+
+        def found(records: Sequence[DnsRecord]) -> Effect[tuple[R, ...], DnsError]:
+            kept = _dedupe(r for r in records if isinstance(r, record_type))
+            return succeed(kept) if kept else fail(_not_found("resolve", domain, tag))
+
+        return self._resolve(domain, tag).flat_map(found)
+
+    def reverse(self, address: IpAddressInput) -> Effect[tuple[DomainName, ...], DnsError]:
+        """The names of ``address``; only ASCII names are kept (a UTF-8 name
+        would become a different ``xn--`` name)."""
+        match ip_from_input(address):
+            case Err(error):
+                return fail(DnsError("BadName", "reverse", str(address), cause=error))
+            case Ok(ip):
+                pass
+        hostname = format_ip(ip)
+
+        def found(names: Sequence[str]) -> Effect[tuple[DomainName, ...], DnsError]:
+            hosts = _dedupe(
+                parsed.value
+                for name in names
+                if _ASCII_NAME.fullmatch(name)
+                for parsed in (domain_name_from_input(name),)
+                if isinstance(parsed, Ok)
+            )
+            if hosts:
+                return succeed(hosts)
+            if names:
+                return fail(DnsError("InvalidResponse", "reverse", hostname))
+            return fail(_not_found("reverse", hostname))
+
+        return self._reverse(ip).flat_map(found)
+
+
+class Dns(Tag[DnsService], key="effect/net/Dns"):
+    """The DNS service."""
+
+
+def make(
+    lookup: Lookup, resolve: Resolve | None = None, reverse: Reverse | None = None
+) -> DnsService:
+    """A DNS service from its primitives. Without ``resolve``, record
+    queries fail with ``Unsupported``; without ``reverse``, reverse lookups
+    query PTR records."""
+
+    def unsupported(
+        name: DomainName, record_type: RecordType
+    ) -> Effect[Sequence[DnsRecord], DnsError]:
+        return fail(DnsError("Unsupported", "resolve", name, record_type))
+
+    resolve_records = resolve or unsupported
+
+    def reverse_by_ptr(address: IpAddress) -> Effect[Sequence[str], DnsError]:
+        def rename(error: DnsError) -> DnsError:
+            return DnsError(error.reason, "reverse", format_ip(address), cause=error.cause)
+
+        return (
+            resolve_records(reverse_name(address), "PTR")
+            .map(lambda records: [r.host for r in records if isinstance(r, Ptr)])
+            .map_error(rename)
+        )
+
+    return DnsService(lookup, resolve_records, reverse or reverse_by_ptr)
+
+
+def _zone_key(name: str) -> str:
+    return to_relative(DomainName(name))
+
+
+@dataclass(slots=True)
+class _Entry:
+    addresses: list[IpAddress]
+    records: list[DnsRecord]
+
+
+def make_static(
+    hosts: Mapping[str, Sequence[IpAddressInput]] | None = None,
+    records: Mapping[str, Sequence[DnsRecord]] | None = None,
+) -> Result[DnsService, NetAddressError]:
+    """A DNS service answering from a fixed zone: addresses by host name,
+    records by name."""
+    entries: dict[str, _Entry] = {}
+
+    def entry(name: str) -> Result[_Entry, NetAddressError]:
+        return domain_name_from_input(name).map(
+            lambda domain: entries.setdefault(_zone_key(domain), _Entry([], []))
+        )
+
+    for name, inputs in (hosts or {}).items():
+        match entry(name):
+            case Err() as error:
+                return error
+            case Ok(current):
+                for value in inputs:
+                    match ip_from_input(value):
+                        case Err() as error:
+                            return error
+                        case Ok(address):
+                            current.addresses.append(address)
+    for name, values in (records or {}).items():
+        match entry(name):
+            case Err() as error:
+                return error
+            case Ok(current):
+                for record in values:
+                    if not isinstance(record, record_classes):
+                        return Err(NetAddressError("expected a DNS record", record))
+                    current.records.append(record)
+
+    def records_at(name: str) -> list[DnsRecord]:
+        found = entries.get(_zone_key(name))
+        return [] if found is None else found.records
+
+    def lookup(host: DomainName, _family: IpFamily | None) -> Effect[Sequence[IpAddress], DnsError]:
+        def answer() -> Sequence[IpAddress]:
+            found = entries.get(_zone_key(host))
+            direct = [] if found is None else found.addresses
+            return [*direct, *(r.address for r in records_at(host) if isinstance(r, A | Aaaa))]
+
+        return sync(answer)
+
+    def resolve(name: DomainName, _type: RecordType) -> Effect[Sequence[DnsRecord], DnsError]:
+        return sync(lambda: records_at(name))
+
+    def reverse(address: IpAddress) -> Effect[Sequence[str], DnsError]:
+        def answer() -> Sequence[str]:
+            named = [name for name, current in entries.items() if address in current.addresses]
+            pointed = [r.host for r in records_at(reverse_name(address)) if isinstance(r, Ptr)]
+            return [*named, *pointed]
+
+        return sync(answer)
+
+    return Ok(make(lookup, resolve, reverse))
+
+
+def layer_static(
+    hosts: Mapping[str, Sequence[IpAddressInput]] | None = None,
+    records: Mapping[str, Sequence[DnsRecord]] | None = None,
+) -> Layer[Dns, NetAddressError]:
+    """A ``Dns`` layer answering from a fixed zone."""
+    return layer_effect(Dns, from_result(make_static(hosts, records)))
+
+
+def name_server_from_string(text: str) -> Result[InetAddress, NetAddressError]:
+    """A name server address; port 53 unless given."""
+    if text.startswith("[") or _HOST_PORT.fullmatch(text):
+        return parse_inet(text)
+    return parse_inet(f"[{text}]:53" if ":" in text else f"{text}:53")
+
+
+def name_server_from_input(
+    value: IpAddressInput | InetAddressInput,
+) -> Result[InetAddress, NetAddressError]:
+    """A name server address from text, parts with a port, or an IP address
+    (port 53)."""
+    if isinstance(value, str):
+        return name_server_from_string(value)
+    if isinstance(value, Mapping | InetAddressV4 | InetAddressV6):
+        return inet_address_from_input(value)
+    return ip_from_input(value).map(lambda address: inet_address_unsafe(address, 53))
+
+
+__all__ = [
+    "Dns",
+    "DnsService",
+    "Lookup",
+    "Resolve",
+    "Reverse",
+    "layer_static",
+    "make",
+    "make_static",
+    "name_server_from_input",
+    "name_server_from_string",
+]

pyfect/net/dns/_system.py

@@ -0,0 +1,89 @@
+"""The operating system's resolver as the ``Dns`` service (Effect's
+``NodeDns``, minus record queries).
+
+Lookups go through ``getaddrinfo`` (the hosts file and the system's DNS
+configuration, as Node's ``dns.lookup``); reverse lookups through
+``gethostbyaddr``. Python's standard library has no DNS record queries, so
+``resolve`` fails with ``Unsupported``. Each call runs on a thread of its
+own and resumes the fiber through its scheduler; an interrupted call's
+answer is dropped.
+"""
+
+from __future__ import annotations
+
+import socket
+import threading
+from collections.abc import Callable, Sequence
+from ipaddress import ip_address
+
+from pyfect._core import Effect
+from pyfect._os_wait import Resume, os_wait
+from pyfect.effect import fail, succeed
+from pyfect.layer import Layer
+from pyfect.layer import succeed as layer_succeed
+from pyfect.net.dns._error import DnsError, DnsErrorReason, DnsMethod
+from pyfect.net.dns._service import Dns, DnsService, make
+from pyfect.net.host import DomainName
+from pyfect.net.net_address._ip import IpAddress, IpFamily, format_ip
+
+_REASON_NAMES: list[tuple[str, DnsErrorReason]] = [
+    ("EAI_NONAME", "NotFound"),
+    ("EAI_NODATA", "NotFound"),
+    ("EAI_AGAIN", "Temporary"),
+    ("EAI_FAIL", "Refused"),
+    ("EAI_FAMILY", "BadName"),
+]
+_REASONS: dict[int, DnsErrorReason] = {
+    code: reason
+    for name, reason in _REASON_NAMES
+    if isinstance(code := getattr(socket, name, None), int)
+}
+
+_FAMILIES = {None: socket.AF_UNSPEC, "IPv4": socket.AF_INET, "IPv6": socket.AF_INET6}
+
+
+def dns_error_from_cause(cause: OSError, method: DnsMethod, hostname: str) -> DnsError:
+    """The ``DnsError`` of a resolver failure, by its error code."""
+    if isinstance(cause, socket.herror):
+        return DnsError("NotFound", method, hostname, cause=cause)
+    reason = _REASONS.get(cause.errno, "Unknown") if cause.errno is not None else "Unknown"
+    return DnsError(reason, method, hostname, cause=cause)
+
+
+def _on_thread[A](method: DnsMethod, hostname: str, call: Callable[[], A]) -> Effect[A, DnsError]:
+    def register(resume: Resume[A, DnsError]) -> None:
+        def run() -> None:
+            try:
+                resume(succeed(call()))
+            except OSError as cause:
+                resume(fail(dns_error_from_cause(cause, method, hostname)))
+
+        threading.Thread(target=run, name=f"pyfect-dns-{method}", daemon=True).start()
+
+    return os_wait(register, waits_for="work")
+
+
+def _lookup(host: DomainName, family: IpFamily | None) -> Effect[Sequence[IpAddress], DnsError]:
+    def call() -> list[IpAddress]:
+        entries = socket.getaddrinfo(host, None, _FAMILIES[family], socket.SOCK_STREAM)
+        return [ip_address(str(entry[4][0]).partition("%")[0]) for entry in entries]
+
+    return _on_thread("lookup", host, call)
+
+
+def _reverse(address: IpAddress) -> Effect[Sequence[str], DnsError]:
+    def call() -> list[str]:
+        name, aliases, _ = socket.gethostbyaddr(format_ip(address))
+        return [name, *aliases]
+
+    return _on_thread("reverse", format_ip(address), call)
+
+
+def make_system() -> DnsService:
+    """The system resolver as a ``DnsService``."""
+    return make(_lookup, reverse=_reverse)
+
+
+def layer_system() -> Layer[Dns]:
+    """``Dns`` answered by the operating system's resolver."""
+    return layer_succeed(Dns, make_system())

pyfect/net/host.py

@@ -0,0 +1,311 @@
+"""Host names and endpoints (Effect's ``Host``).
+
+A host is an IP address, a scoped IPv6 literal (``fe80::1%eth0``) or a
+``DomainName``: lowercase ASCII, internationalized labels converted to
+their ``xn--`` form, an optional trailing dot. ``HostPort`` pairs a host
+with a port::
+
+    host.host_port_from_string("DB.internal:5432")   # Ok(HostPort("db.internal", 5432))
+    host.format_host_port(endpoint)                   # "db.internal:5432"
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Mapping
+from dataclasses import dataclass
+from ipaddress import IPv4Address, IPv6Address
+from typing import NewType, TypedDict
+
+from pyfect._digits import parse_digits
+from pyfect.net._errors import NetAddressError, address_error
+from pyfect.net.net_address._ip import (
+    IpAddress,
+    IpAddressInput,
+    ScopedIpv6Literal,
+    format_ip,
+    ip_from_input,
+    ip_from_string,
+    is_scoped_ipv6_literal,
+    scoped_ipv6_literal_from_string,
+)
+from pyfect.result import Ok, Result
+
+DomainName = NewType("DomainName", str)
+"""A validated, lowercase ASCII domain name; a trailing dot makes it fully
+qualified, ``"."`` is the root."""
+
+type DomainNameInput = DomainName | str
+type Host = IpAddress | ScopedIpv6Literal | DomainName
+type HostInput = Host | IpAddressInput
+
+
+class HostPortParts(TypedDict):
+    host: HostInput
+    port: int
+
+
+_ASCII_NAME_CHARACTER = re.compile(r"[a-z0-9_.-]", re.IGNORECASE)
+_LABEL = re.compile(r"[a-z0-9_](?:[a-z0-9_-]{0,61}[a-z0-9_])?")
+_NUMERIC_LABEL = re.compile(r"[0-9]+|0x[0-9a-f]*")
+_DOMAIN_TEXT = re.compile(r"[a-z0-9_.-]+")
+_NUMERIC_HOST = re.compile(r"[0-9.]+")
+
+
+def _validate(name: str) -> str | None:  # noqa: PLR0911
+    """Why ``name`` (lowercase ASCII) is not a domain name, or ``None``."""
+    if name == ".":
+        return None
+    relative = name.removesuffix(".")
+    if not relative:
+        return "domain name must not be empty"
+    if len(relative) > 253:
+        return "domain name must be at most 253 characters"
+    labels = relative.split(".")
+    for label in labels:
+        if not label:
+            return "domain name labels must not be empty"
+        if len(label) > 63:
+            return "domain name labels must be at most 63 characters"
+        if not _LABEL.fullmatch(label):
+            return (
+                "domain name labels must contain only letters, digits, hyphens, or "
+                "underscores and must not start or end with a hyphen"
+            )
+    if _NUMERIC_LABEL.fullmatch(labels[-1]):
+        return "the last domain name label must not be numeric"
+    return None
+
+
+def _to_ascii(text: str) -> str | None:
+    """The name lowercased, or its WHATWG URL host form when it holds
+    non-ASCII characters; ``None`` for characters a name cannot hold."""
+    if all(_ASCII_NAME_CHARACTER.fullmatch(ch) for ch in text if ch.isascii()):
+        if text.isascii():
+            return text.lower()
+        from pyfect.http import url
+
+        try:
+            return url.parse(f"http://{text}").hostname
+        except ValueError:
+            return None
+    return None
+
+
+def is_domain_name(value: object) -> bool:
+    """Whether ``value`` is already a normalized domain name."""
+    return (
+        isinstance(value, str) and bool(_DOMAIN_TEXT.fullmatch(value)) and _validate(value) is None
+    )
+
+
+def is_host(value: object) -> bool:
+    return (
+        isinstance(value, IPv4Address | IPv6Address)
+        or is_scoped_ipv6_literal(value)
+        or is_domain_name(value)
+    )
+
+
+def domain_name_from_string(text: str) -> Result[DomainName, NetAddressError]:
+    name = _to_ascii(text)
+    if name is None:
+        return address_error(text, "invalid domain name")
+    error = _validate(name)
+    return Ok(DomainName(name)) if error is None else address_error(text, error)
+
+
+def domain_name_from_string_unsafe(text: str) -> DomainName:
+    return domain_name_from_string(text).get_or_raise()
+
+
+def domain_name_from_input(value: DomainNameInput) -> Result[DomainName, NetAddressError]:
+    return domain_name_from_string(value)
+
+
+def domain_name_from_input_unsafe(value: DomainNameInput) -> DomainName:
+    return domain_name_from_input(value).get_or_raise()
+
+
+def host_from_string(text: str) -> Result[Host, NetAddressError]:
+    """A scoped IPv6 literal, an IP address or a domain name, by its text."""
+    if "%" in text:
+        scoped: Result[Host, NetAddressError] = scoped_ipv6_literal_from_string(text)
+        return scoped
+    if ":" in text:
+        return ip_from_string(text)
+    if _NUMERIC_HOST.fullmatch(text):
+        address = ip_from_string(text)
+        if isinstance(address, Ok):
+            return address
+    return domain_name_from_string(text)
+
+
+def host_from_string_unsafe(text: str) -> Host:
+    return host_from_string(text).get_or_raise()
+
+
+def host_from_input(value: HostInput) -> Result[Host, NetAddressError]:
+    if isinstance(value, str):
+        return host_from_string(value)
+    return ip_from_input(value)
+
+
+def host_from_input_unsafe(value: HostInput) -> Host:
+    return host_from_input(value).get_or_raise()
+
+
+def format_host(host: Host) -> str:
+    return host if isinstance(host, str) else format_ip(host)
+
+
+def is_fully_qualified(name: DomainName) -> bool:
+    return name.endswith(".")
+
+
+def to_fully_qualified(name: DomainName) -> DomainName:
+    return name if is_fully_qualified(name) else DomainName(f"{name}.")
+
+
+def to_relative(name: DomainName) -> DomainName:
+    return DomainName(name[:-1]) if len(name) > 1 and is_fully_qualified(name) else name
+
+
+@dataclass(frozen=True, slots=True)
+class HostPort:
+    """A host and port; ``str`` gives ``host:port`` (``[ipv6]:port``)."""
+
+    host: Host
+    port: int
+
+    def __post_init__(self) -> None:
+        if not is_host(self.host):
+            raise NetAddressError("expected a host", self.host)
+        if not _is_port(self.port):
+            raise NetAddressError("port must be an integer from 0 through 65535", self.port)
+
+    def __str__(self) -> str:
+        return format_host_port(self)
+
+
+type HostPortInput = HostPort | str | HostPortParts
+
+
+def _is_port(port: object) -> bool:
+    return isinstance(port, int) and not isinstance(port, bool) and 0 <= port <= 0xFFFF
+
+
+def host_port(host: Host, port: int) -> Result[HostPort, NetAddressError]:
+    if not is_host(host):
+        return address_error(host, "expected a host")
+    if not _is_port(port):
+        return address_error(port, "port must be an integer from 0 through 65535")
+    return Ok(HostPort(host, port))
+
+
+def host_port_unsafe(host: Host, port: int) -> HostPort:
+    return host_port(host, port).get_or_raise()
+
+
+def host_port_from_string(text: str) -> Result[HostPort, NetAddressError]:  # noqa: PLR0911
+    if text.startswith("["):
+        end = text.find("]")
+        if end == -1 or text[end + 1 : end + 2] != ":":
+            return address_error(text, "expected [IPv6]:port")
+        host_text, port_text = text[1:end], text[end + 2 :]
+        if ":" not in host_text:
+            return address_error(text, "only IPv6 addresses use brackets")
+    else:
+        separator = text.rfind(":")
+        if separator == -1:
+            return address_error(text, "expected host:port")
+        if text.find(":") != separator:
+            return address_error(text, "IPv6 addresses must be bracketed")
+        host_text, port_text = text[:separator], text[separator + 1 :]
+    port = parse_digits(port_text, unpadded=True)
+    if port is None:
+        return address_error(text, "port must be an unpadded decimal integer")
+    if not _is_port(port):
+        return address_error(text, "port must be an integer from 0 through 65535")
+    return host_from_string(host_text).map(lambda host: HostPort(host, port))
+
+
+def host_port_from_string_unsafe(text: str) -> HostPort:
+    return host_port_from_string(text).get_or_raise()
+
+
+def host_port_from_input(value: HostPortInput) -> Result[HostPort, NetAddressError]:
+    """An endpoint, its text, or ``{"host": ..., "port": ...}``."""
+    if isinstance(value, HostPort):
+        return Ok(value)
+    if isinstance(value, str):
+        return host_port_from_string(value)
+    port = value["port"]
+    return host_from_input(value["host"]).flat_map(lambda host: host_port(host, port))
+
+
+def host_port_from_input_unsafe(value: HostPortInput) -> HostPort:
+    return host_port_from_input(value).get_or_raise()
+
+
+def format_host_port(endpoint: HostPort) -> str:
+    host = format_host(endpoint.host)
+    return f"[{host}]:{endpoint.port}" if ":" in host else f"{host}:{endpoint.port}"
+
+
+type HostsTable = Mapping[DomainName, tuple[IpAddress, ...]]
+
+
+def parse_hosts_file(text: str) -> HostsTable:
+    """A hosts file's addresses by relative name, in file order; lines and
+    names that do not parse are skipped."""
+    hosts: dict[DomainName, list[IpAddress]] = {}
+    for line in re.split(r"\r?\n", text):
+        fields = line.partition("#")[0].split()
+        if not fields:
+            continue
+        address = ip_from_string(fields[0])
+        if not isinstance(address, Ok):
+            continue
+        for name in fields[1:]:
+            domain = domain_name_from_string(name)
+            if not isinstance(domain, Ok):
+                continue
+            addresses = hosts.setdefault(to_relative(domain.value), [])
+            if address.value not in addresses:
+                addresses.append(address.value)
+    return {name: tuple(addresses) for name, addresses in hosts.items()}
+
+
+__all__ = [
+    "DomainName",
+    "DomainNameInput",
+    "Host",
+    "HostInput",
+    "HostPort",
+    "HostPortInput",
+    "HostPortParts",
+    "HostsTable",
+    "domain_name_from_input",
+    "domain_name_from_input_unsafe",
+    "domain_name_from_string",
+    "domain_name_from_string_unsafe",
+    "format_host",
+    "format_host_port",
+    "host_from_input",
+    "host_from_input_unsafe",
+    "host_from_string",
+    "host_from_string_unsafe",
+    "host_port",
+    "host_port_from_input",
+    "host_port_from_input_unsafe",
+    "host_port_from_string",
+    "host_port_from_string_unsafe",
+    "host_port_unsafe",
+    "is_domain_name",
+    "is_fully_qualified",
+    "is_host",
+    "parse_hosts_file",
+    "to_fully_qualified",
+    "to_relative",
+]