0UT1S's

opt/hc_python/lib/python3.12/site-packages/dns/

By Order of Mr.0UT1S

N/A

[DIR] __pycache__

N/A

[DIR] dnssecalgs

N/A

N/A

N/A

1.62 KB

_asyncbackend.py

2.34 KB

_asyncio_backend.py

8.84 KB

5.12 KB

2.43 KB

_immutable_ctx.py

2.40 KB

_trio_backend.py

8.27 KB

asyncbackend.py

2.73 KB

30.10 KB

asyncresolver.py

17.43 KB

40.74 KB

1.76 KB

3.88 KB

16.69 KB

4.14 KB

3.60 KB

5.81 KB

2.69 KB

2.09 KB

1.97 KB

5.64 KB

2.49 KB

6.40 KB

66.59 KB

41.78 KB

3.91 KB

9.88 KB

12.37 KB

2.67 KB

0 bytes

54.98 KB

4.06 KB

30.29 KB

2.91 KB

16.27 KB

7.27 KB

10.99 KB

72.00 KB

3.74 KB

8.96 KB

3.52 KB

9.00 KB

23.03 KB

22.06 KB

11.15 KB

2.57 KB

2.91 KB

11.96 KB

1.88 KB

11.49 KB

8.67 KB

2.76 KB

12.96 KB

50.87 KB

27.27 KB

690 bytes

# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license

from typing import Dict

import dns.exception

# pylint: disable=unused-import
from dns._asyncbackend import (  # noqa: F401  lgtm[py/unused-import]
    Backend,
    DatagramSocket,
    Socket,
    StreamSocket,
)

# pylint: enable=unused-import

_default_backend = None

_backends: Dict[str, Backend] = {}

# Allow sniffio import to be disabled for testing purposes
_no_sniffio = False

class AsyncLibraryNotFoundError(dns.exception.DNSException):
    pass

def get_backend(name: str) -> Backend:
    """Get the specified asynchronous backend.

*name*, a ``str``, the name of the backend.  Currently the "trio"
    and "asyncio" backends are available.

Raises NotImplementedError if an unknown backend name is specified.
    """
    # pylint: disable=import-outside-toplevel,redefined-outer-name
    backend = _backends.get(name)
    if backend:
        return backend
    if name == "trio":
        import dns._trio_backend

backend = dns._trio_backend.Backend()
    elif name == "asyncio":
        import dns._asyncio_backend

backend = dns._asyncio_backend.Backend()
    else:
        raise NotImplementedError(f"unimplemented async backend {name}")
    _backends[name] = backend
    return backend

def sniff() -> str:
    """Attempt to determine the in-use asynchronous I/O library by using
    the ``sniffio`` module if it is available.

Returns the name of the library, or raises AsyncLibraryNotFoundError
    if the library cannot be determined.
    """
    # pylint: disable=import-outside-toplevel
    try:
        if _no_sniffio:
            raise ImportError
        import sniffio

try:
            return sniffio.current_async_library()
        except sniffio.AsyncLibraryNotFoundError:
            raise AsyncLibraryNotFoundError("sniffio cannot determine async library")
    except ImportError:
        import asyncio

try:
            asyncio.get_running_loop()
            return "asyncio"
        except RuntimeError:
            raise AsyncLibraryNotFoundError("no async library detected")

def get_default_backend() -> Backend:
    """Get the default backend, initializing it if necessary."""
    if _default_backend:
        return _default_backend

return set_default_backend(sniff())

def set_default_backend(name: str) -> Backend:
    """Set the default backend.

It's not normally necessary to call this method, as
    ``get_default_backend()`` will initialize the backend
    appropriately in many cases.  If ``sniffio`` is not installed, or
    in testing situations, this function allows the backend to be set
    explicitly.
    """
    global _default_backend
    _default_backend = get_backend(name)
    return _default_backend