Python 3.14 compatibility

[ekrichbaum]

In common/support.py the behavior changes in more current python versions within perform_ptr_lookups.

In earlier python, asyncio.get_event_loop() seemed to create a loop if none existed. In 3.14 the current code throws an exception.

    # asyncio.get_event_loop() does not automatically create a thread in 3.10+ (3.14 for sure)
    try:
        loop = asyncio.get_event_loop()
    except RuntimeError:
        loop = asyncio.new_event_loop()

But this doesn't seem to fully address once we get down to the asyncio.gather element. Need a little more elegant way of handling this function new while maintaining the backwards compatibility.

DNSResolver, also, no longer seems to need the loop=loop passed in, but doesn't scream.

[ekrichbaum]

ended up being more involved. I did not build a PR because it requires some other fixes that are in the development branch as well with aiodns and pycares, etc.

def perform_ptr_lookups(ips, dns_servers=None):
    """
    Perform DNS reverse lookups for IP addresses to find corresponding DNS name

    Parameters
    ----------
    ips: list
        a list of IP addresses to look up
    dns_servers: list
        a list of DNS servers to use to look up list of IP addresses

    Returns
    -------
    dict: of {"ip": "hostname"} for requested ips, hostname will be None if no hostname returned
    """

    # asyncio.get_event_loop() does not automatically create a thread in 3.10+ (3.14 for sure)
    if sys.version_info.major == 3 and sys.version_info.minor >= 14:
        return asyncio.run(reverse_lookups_314(ips, dns_servers))

    loop = asyncio.get_event_loop()

    resolver = aiodns.DNSResolver(loop=loop)

    if dns_servers is not None:
        if isinstance(dns_servers, list):
            log.debug2("using provided DNS servers to perform lookup: %s" % ", ".join(dns_servers))
            resolver.nameservers = dns_servers
        else:
            log.error(f"List of provided DNS servers invalid: {dns_servers}")


    queue = asyncio.gather(*(reverse_lookup(resolver, ip) for ip in ips))
    results = loop.run_until_complete(queue)

    # return dictionary instead of a list of dictionaries
    return {k: v for x in results for k, v in x.items()}


async def reverse_lookups_314(ips, dns_servers):
    resolver = aiodns.DNSResolver() # In 3.14, loop=loop is redundant

    if dns_servers:
        resolver.nameservers = dns_servers

    # TaskGroup is faster than gather in 3.14 and provides better error safety
    async with asyncio.TaskGroup() as tg:
        tasks = [tg.create_task(reverse_lookup(resolver, ip)) for ip in ips]

    # After the 'async with' block, all tasks are guaranteed complete
    results = [task.result() for task in tasks]
    return {k: v for x in results for k, v in x.items()}

I left the original function and just branched off for a newer version. I didn't test back to 3.10 but it is possible that the newer method works from around 3.10 forward which could change that if statement slightly.