pycares 4.5.0__cp313-cp313-win32.whl → 4.6.1__cp313-cp313-win32.whl

pycares/__init__.py

@@ -9,79 +9,68 @@ from . import errno
 from .utils import ascii_bytes, maybe_str, parse_name
 from ._version import __version__
 
-import collections.abc
 import socket
 import math
 import functools
 import sys
-
-
-exported_pycares_symbols = [
-    # Flag values
-    'ARES_FLAG_USEVC',
-    'ARES_FLAG_PRIMARY',
-    'ARES_FLAG_IGNTC',
-    'ARES_FLAG_NORECURSE',
-    'ARES_FLAG_STAYOPEN',
-    'ARES_FLAG_NOSEARCH',
-    'ARES_FLAG_NOALIASES',
-    'ARES_FLAG_NOCHECKRESP',
-
-    # Nameinfo flag values
-    'ARES_NI_NOFQDN',
-    'ARES_NI_NUMERICHOST',
-    'ARES_NI_NAMEREQD',
-    'ARES_NI_NUMERICSERV',
-    'ARES_NI_DGRAM',
-    'ARES_NI_TCP',
-    'ARES_NI_UDP',
-    'ARES_NI_SCTP',
-    'ARES_NI_DCCP',
-    'ARES_NI_NUMERICSCOPE',
-    'ARES_NI_LOOKUPHOST',
-    'ARES_NI_LOOKUPSERVICE',
-    'ARES_NI_IDN',
-    'ARES_NI_IDN_ALLOW_UNASSIGNED',
-    'ARES_NI_IDN_USE_STD3_ASCII_RULES',
-
-    # Bad socket
-    'ARES_SOCKET_BAD',
-]
-
-for symbol in exported_pycares_symbols:
-    globals()[symbol] = getattr(_lib, symbol)
-
-
-exported_pycares_symbols_map = {
-    # Query types
-    "QUERY_TYPE_A"     : "T_A",
-    "QUERY_TYPE_AAAA"  : "T_AAAA",
-    "QUERY_TYPE_ANY"   : "T_ANY",
-    "QUERY_TYPE_CAA"   : "T_CAA",
-    "QUERY_TYPE_CNAME" : "T_CNAME",
-    "QUERY_TYPE_MX"    : "T_MX",
-    "QUERY_TYPE_NAPTR" : "T_NAPTR",
-    "QUERY_TYPE_NS"    : "T_NS",
-    "QUERY_TYPE_PTR"   : "T_PTR",
-    "QUERY_TYPE_SOA"   : "T_SOA",
-    "QUERY_TYPE_SRV"   : "T_SRV",
-    "QUERY_TYPE_TXT"   : "T_TXT",
-
-    # Query classes
-    "QUERY_CLASS_IN"   : "C_IN",
-    "QUERY_CLASS_CHAOS": "C_CHAOS",
-    "QUERY_CLASS_HS"   : "C_HS",
-    "QUERY_CLASS_NONE" :"C_NONE",
-    "QUERY_CLASS_ANY"  : "C_ANY",
-}
-
-for k, v in exported_pycares_symbols_map.items():
-    globals()[k] = getattr(_lib, v)
-
-
-globals()['ARES_VERSION'] = maybe_str(_ffi.string(_lib.ares_version(_ffi.NULL)))
-
-
+from collections.abc import Callable, Iterable
+from typing import Any, Optional, Union
+
+IP4 = tuple[str, int]
+IP6 = tuple[str, int, int, int]
+
+# Flag values
+ARES_FLAG_USEVC = _lib.ARES_FLAG_USEVC
+ARES_FLAG_PRIMARY = _lib.ARES_FLAG_PRIMARY
+ARES_FLAG_IGNTC = _lib.ARES_FLAG_IGNTC
+ARES_FLAG_NORECURSE = _lib.ARES_FLAG_NORECURSE
+ARES_FLAG_STAYOPEN = _lib.ARES_FLAG_STAYOPEN
+ARES_FLAG_NOSEARCH = _lib.ARES_FLAG_NOSEARCH
+ARES_FLAG_NOALIASES = _lib.ARES_FLAG_NOALIASES
+ARES_FLAG_NOCHECKRESP = _lib.ARES_FLAG_NOCHECKRESP
+
+# Nameinfo flag values
+ARES_NI_NOFQDN = _lib.ARES_NI_NOFQDN
+ARES_NI_NUMERICHOST = _lib.ARES_NI_NUMERICHOST
+ARES_NI_NAMEREQD = _lib.ARES_NI_NAMEREQD
+ARES_NI_NUMERICSERV = _lib.ARES_NI_NUMERICSERV
+ARES_NI_DGRAM = _lib.ARES_NI_DGRAM
+ARES_NI_TCP = _lib.ARES_NI_TCP
+ARES_NI_UDP = _lib.ARES_NI_UDP
+ARES_NI_SCTP = _lib.ARES_NI_SCTP
+ARES_NI_DCCP = _lib.ARES_NI_DCCP
+ARES_NI_NUMERICSCOPE = _lib.ARES_NI_NUMERICSCOPE
+ARES_NI_LOOKUPHOST = _lib.ARES_NI_LOOKUPHOST
+ARES_NI_LOOKUPSERVICE = _lib.ARES_NI_LOOKUPSERVICE
+ARES_NI_IDN = _lib.ARES_NI_IDN
+ARES_NI_IDN_ALLOW_UNASSIGNED = _lib.ARES_NI_IDN_ALLOW_UNASSIGNED
+ARES_NI_IDN_USE_STD3_ASCII_RULES = _lib.ARES_NI_IDN_USE_STD3_ASCII_RULES
+
+# Bad socket
+ARES_SOCKET_BAD = _lib.ARES_SOCKET_BAD
+
+# Query types
+QUERY_TYPE_A = _lib.T_A
+QUERY_TYPE_AAAA = _lib.T_AAAA
+QUERY_TYPE_ANY = _lib.T_ANY
+QUERY_TYPE_CAA = _lib.T_CAA
+QUERY_TYPE_CNAME = _lib.T_CNAME
+QUERY_TYPE_MX = _lib.T_MX
+QUERY_TYPE_NAPTR = _lib.T_NAPTR
+QUERY_TYPE_NS = _lib.T_NS
+QUERY_TYPE_PTR = _lib.T_PTR
+QUERY_TYPE_SOA = _lib.T_SOA
+QUERY_TYPE_SRV = _lib.T_SRV
+QUERY_TYPE_TXT = _lib.T_TXT
+
+# Query classes
+QUERY_CLASS_IN = _lib.C_IN
+QUERY_CLASS_CHAOS = _lib.C_CHAOS
+QUERY_CLASS_HS = _lib.C_HS
+QUERY_CLASS_NONE = _lib.C_NONE
+QUERY_CLASS_ANY = _lib.C_ANY
+
+ARES_VERSION = maybe_str(_ffi.string(_lib.ares_version(_ffi.NULL)))
 PYCARES_ADDRTTL_SIZE = 256
 
 
@@ -138,7 +127,7 @@ def _query_cb(arg, status, timeouts, abuf, alen):
                     result = None
                     break
                 if r is not None:
-                    if isinstance(r, collections.abc.Iterable):
+                    if isinstance(r, Iterable):
                         result.extend(r)
                     else:
                         result.append(r)
@@ -328,22 +317,22 @@ class Channel:
     __qclasses__ = (_lib.C_IN, _lib.C_CHAOS, _lib.C_HS, _lib.C_NONE, _lib.C_ANY)
 
     def __init__(self,
-                 flags = None,
-                 timeout = None,
-                 tries = None,
-                 ndots = None,
-                 tcp_port = None,
-                 udp_port = None,
-                 servers = None,
-                 domains = None,
-                 lookups = None,
-                 sock_state_cb = None,
-                 socket_send_buffer_size = None,
-                 socket_receive_buffer_size = None,
-                 rotate = False,
-                 local_ip = None,
-                 local_dev = None,
-                 resolvconf_path = None):
+                 flags: Optional[int] = None,
+                 timeout: Optional[float] = None,
+                 tries: Optional[int] = None,
+                 ndots: Optional[int] = None,
+                 tcp_port: Optional[int] = None,
+                 udp_port: Optional[int] = None,
+                 servers: Optional[Iterable[Union[str, bytes]]] = None,
+                 domains: Optional[Iterable[Union[str, bytes]]] = None,
+                 lookups: Union[str, bytes, None] = None,
+                 sock_state_cb: Optional[Callable[[int, bool, bool], None]] = None,
+                 socket_send_buffer_size: Optional[int] = None,
+                 socket_receive_buffer_size: Optional[int] = None,
+                 rotate: bool = False,
+                 local_ip: Union[str, bytes, None] = None,
+                 local_dev: Optional[str] = None,
+                 resolvconf_path: Union[str, bytes, None] = None):
 
         channel = _ffi.new("ares_channel *")
         options = _ffi.new("struct ares_options *")
@@ -430,11 +419,11 @@ class Channel:
         if local_dev:
             self.set_local_dev(local_dev)
 
-    def cancel(self):
+    def cancel(self) -> None:
         _lib.ares_cancel(self._channel[0])
 
     @property
-    def servers(self):
+    def servers(self) -> list[str]:
         servers = _ffi.new("struct ares_addr_node **")
 
         r = _lib.ares_get_servers(self._channel[0], servers)
@@ -457,7 +446,7 @@ class Channel:
         return server_list
 
     @servers.setter
-    def servers(self, servers):
+    def servers(self, servers: Iterable[Union[str, bytes]]) -> None:
         c = _ffi.new("struct ares_addr_node[%d]" % len(servers))
         for i, server in enumerate(servers):
             if _lib.ares_inet_pton(socket.AF_INET, ascii_bytes(server), _ffi.addressof(c[i].addr.addr4)) == 1:
@@ -487,7 +476,7 @@ class Channel:
 
         return rfds, wfds
 
-    def process_fd(self, read_fd, write_fd):
+    def process_fd(self, read_fd: int, write_fd: int) -> None:
         _lib.ares_process_fd(self._channel[0], _ffi.cast("ares_socket_t", read_fd), _ffi.cast("ares_socket_t", write_fd))
 
     def timeout(self, t = None):
@@ -509,7 +498,7 @@ class Channel:
 
         return (tv.tv_sec + tv.tv_usec / 1000000.0)
 
-    def gethostbyaddr(self, addr, callback):
+    def gethostbyaddr(self, addr: str, callback: Callable[[Any, int], None]) -> None:
         if not callable(callback):
             raise TypeError("a callable is required")
 
@@ -528,7 +517,7 @@ class Channel:
         _global_set.add(userdata)
         _lib.ares_gethostbyaddr(self._channel[0], address, _ffi.sizeof(address[0]), family, _lib._host_cb, userdata)
 
-    def gethostbyname(self, name, family, callback):
+    def gethostbyname(self, name: str, family: socket.AddressFamily, callback: Callable[[Any, int], None]) -> None:
         if not callable(callback):
             raise TypeError("a callable is required")
 
@@ -536,7 +525,16 @@ class Channel:
         _global_set.add(userdata)
         _lib.ares_gethostbyname(self._channel[0], parse_name(name), family, _lib._host_cb, userdata)
 
-    def getaddrinfo(self, host, port, callback, family=0, type=0, proto=0, flags=0):
+    def getaddrinfo(
+        self,
+        host: str,
+        port: Optional[int],
+        callback: Callable[[Any, int], None],
+        family: socket.AddressFamily = 0,
+        type: int = 0,
+        proto: int = 0,
+        flags: int = 0
+    ) -> None:
         if not callable(callback):
             raise TypeError("a callable is required")
 
@@ -557,7 +555,7 @@ class Channel:
         hints.ai_protocol = proto
         _lib.ares_getaddrinfo(self._channel[0], parse_name(host), service, hints, _lib._addrinfo_cb, userdata)
 
-    def query(self, name, query_type, callback, query_class=None):
+    def query(self, name: str, query_type: str, callback: Callable[[Any, int], None], query_class: Optional[str] = None) -> None:
         self._do_query(_lib.ares_query, name, query_type, callback, query_class=query_class)
 
     def search(self, name, query_type, callback, query_class=None):
@@ -590,7 +588,7 @@ class Channel:
         else:
             raise ValueError("invalid IP address")
 
-    def getnameinfo(self, address, flags, callback):
+    def getnameinfo(self, address: Union[IP4, IP6], flags: int, callback: Callable[[Any, int], None]) -> None:
         if not callable(callback):
             raise TypeError("a callable is required")
 
@@ -849,7 +847,62 @@ class ares_addrinfo_result(AresResult):
         _lib.ares_freeaddrinfo(ares_addrinfo)
 
 
+__all__ = (
+    "ARES_FLAG_USEVC",
+    "ARES_FLAG_PRIMARY",
+    "ARES_FLAG_IGNTC",
+    "ARES_FLAG_NORECURSE",
+    "ARES_FLAG_STAYOPEN",
+    "ARES_FLAG_NOSEARCH",
+    "ARES_FLAG_NOALIASES",
+    "ARES_FLAG_NOCHECKRESP",
+
+    # Nameinfo flag values
+    "ARES_NI_NOFQDN",
+    "ARES_NI_NUMERICHOST",
+    "ARES_NI_NAMEREQD",
+    "ARES_NI_NUMERICSERV",
+    "ARES_NI_DGRAM",
+    "ARES_NI_TCP",
+    "ARES_NI_UDP",
+    "ARES_NI_SCTP",
+    "ARES_NI_DCCP",
+    "ARES_NI_NUMERICSCOPE",
+    "ARES_NI_LOOKUPHOST",
+    "ARES_NI_LOOKUPSERVICE",
+    "ARES_NI_IDN",
+    "ARES_NI_IDN_ALLOW_UNASSIGNED",
+    "ARES_NI_IDN_USE_STD3_ASCII_RULES",
+
+    # Bad socket
+    "ARES_SOCKET_BAD",
 
-__all__ = exported_pycares_symbols + list(exported_pycares_symbols_map.keys()) + ['AresError', 'Channel', 'errno', '__version__']
 
-del exported_pycares_symbols, exported_pycares_symbols_map
+    # Query types
+    "QUERY_TYPE_A",
+    "QUERY_TYPE_AAAA",
+    "QUERY_TYPE_ANY",
+    "QUERY_TYPE_CAA",
+    "QUERY_TYPE_CNAME",
+    "QUERY_TYPE_MX",
+    "QUERY_TYPE_NAPTR",
+    "QUERY_TYPE_NS",
+    "QUERY_TYPE_PTR",
+    "QUERY_TYPE_SOA",
+    "QUERY_TYPE_SRV",
+    "QUERY_TYPE_TXT",
+
+    # Query classes
+    "QUERY_CLASS_IN",
+    "QUERY_CLASS_CHAOS",
+    "QUERY_CLASS_HS",
+    "QUERY_CLASS_NONE",
+    "QUERY_CLASS_ANY",
+
+
+    "ARES_VERSION",
+    "AresError",
+    "Channel",
+    "errno",
+    "__version__"
+)

pycares/_version.py

@@ -1,2 +1,2 @@
 
-__version__ = '4.5.0'
+__version__ = '4.6.1'

pycares/errno.py

@@ -1,50 +1,69 @@
+from typing import Union
 
 from ._cares import ffi as _ffi, lib as _lib
 from .utils import maybe_str
 
+ARES_SUCCESS = _lib.ARES_SUCCESS
+# error codes
+ARES_ENODATA = _lib.ARES_ENODATA
+ARES_EFORMERR = _lib.ARES_EFORMERR
+ARES_ESERVFAIL = _lib.ARES_ESERVFAIL
+ARES_ENOTFOUND = _lib.ARES_ENOTFOUND
+ARES_ENOTIMP = _lib.ARES_ENOTIMP
+ARES_EREFUSED = _lib.ARES_EREFUSED
+ARES_EBADQUERY = _lib.ARES_EBADQUERY
+ARES_EBADNAME = _lib.ARES_EBADNAME
+ARES_EBADFAMILY = _lib.ARES_EBADFAMILY
+ARES_EBADRESP = _lib.ARES_EBADRESP
+ARES_ECONNREFUSED = _lib.ARES_ECONNREFUSED
+ARES_ETIMEOUT = _lib.ARES_ETIMEOUT
+ARES_EOF = _lib.ARES_EOF
+ARES_EFILE = _lib.ARES_EFILE
+ARES_ENOMEM = _lib.ARES_ENOMEM
+ARES_EDESTRUCTION = _lib.ARES_EDESTRUCTION
+ARES_EBADSTR = _lib.ARES_EBADSTR
+ARES_EBADFLAGS = _lib.ARES_EBADFLAGS
+ARES_ENONAME = _lib.ARES_ENONAME
+ARES_EBADHINTS = _lib.ARES_EBADHINTS
+ARES_ENOTINITIALIZED = _lib.ARES_ENOTINITIALIZED
+ARES_ELOADIPHLPAPI = _lib.ARES_ELOADIPHLPAPI
+ARES_EADDRGETNETWORKPARAMS = _lib.ARES_EADDRGETNETWORKPARAMS
+ARES_ECANCELLED = _lib.ARES_ECANCELLED
+ARES_ESERVICE = _lib.ARES_ESERVICE
 
-exported_pycares_symbols = [
-    'ARES_SUCCESS',
+errorcode = {
+    ARES_SUCCESS: "ARES_SUCCESS",
     # error codes
-    'ARES_ENODATA',
-    'ARES_EFORMERR',
-    'ARES_ESERVFAIL',
-    'ARES_ENOTFOUND',
-    'ARES_ENOTIMP',
-    'ARES_EREFUSED',
-    'ARES_EBADQUERY',
-    'ARES_EBADNAME',
-    'ARES_EBADFAMILY',
-    'ARES_EBADRESP',
-    'ARES_ECONNREFUSED',
-    'ARES_ETIMEOUT',
-    'ARES_EOF',
-    'ARES_EFILE',
-    'ARES_ENOMEM',
-    'ARES_EDESTRUCTION',
-    'ARES_EBADSTR',
-    'ARES_EBADFLAGS',
-    'ARES_ENONAME',
-    'ARES_EBADHINTS',
-    'ARES_ENOTINITIALIZED',
-    'ARES_ELOADIPHLPAPI',
-    'ARES_EADDRGETNETWORKPARAMS',
-    'ARES_ECANCELLED',
-    'ARES_ESERVICE'
-]
+    ARES_ENODATA: "ARES_ENODATA",
+    ARES_EFORMERR: "ARES_EFORMERR",
+    ARES_ESERVFAIL: "ARES_ESERVFAIL",
+    ARES_ENOTFOUND: "ARES_ENOTFOUND",
+    ARES_ENOTIMP: "ARES_ENOTIMP",
+    ARES_EREFUSED: "ARES_EREFUSED",
+    ARES_EBADQUERY: "ARES_EBADQUERY",
+    ARES_EBADNAME: "ARES_EBADNAME",
+    ARES_EBADFAMILY: "ARES_EBADFAMILY",
+    ARES_EBADRESP: "ARES_EBADRESP",
+    ARES_ECONNREFUSED: "ARES_ECONNREFUSED",
+    ARES_ETIMEOUT: "ARES_ETIMEOUT",
+    ARES_EOF: "ARES_EOF",
+    ARES_EFILE: "ARES_EFILE",
+    ARES_ENOMEM: "ARES_ENOMEM",
+    ARES_EDESTRUCTION: "ARES_EDESTRUCTION",
+    ARES_EBADSTR: "ARES_EBADSTR",
+    ARES_EBADFLAGS: "ARES_EBADFLAGS",
+    ARES_ENONAME: "ARES_ENONAME",
+    ARES_EBADHINTS: "ARES_EBADHINTS",
+    ARES_ENOTINITIALIZED: "ARES_ENOTINITIALIZED",
+    ARES_ELOADIPHLPAPI: "ARES_ELOADIPHLPAPI",
+    ARES_EADDRGETNETWORKPARAMS: "ARES_EADDRGETNETWORKPARAMS",
+    ARES_ECANCELLED: "ARES_ECANCELLED",
+    ARES_ESERVICE: "ARES_ESERVICE",
+}
 
-errorcode = {}
 
-for symbol in exported_pycares_symbols:
-    value = getattr(_lib, symbol)
-    globals()[symbol] = value
-    globals()["errorcode"][value] = symbol
-
-
-def strerror(code):
+def strerror(code: int) -> Union[str, bytes]:
     return maybe_str(_ffi.string(_lib.ares_strerror(code)))
 
 
-__all__ = exported_pycares_symbols + ['errorcode', 'strerror']
-
-del exported_pycares_symbols
+__all__ = ("errorcode", "strerror", *errorcode.values())

pycares/utils.py

@@ -1,4 +1,6 @@
 
+from typing import Union
+
 try:
     import idna as idna2008
 except ImportError:
@@ -24,25 +26,20 @@ def maybe_str(data):
     raise TypeError('only str (ascii encoding) and bytes are supported')
 
 
-def is_all_ascii(text):
-    for c in text:
-        if ord(c) > 0x7f:
-            return False
-    return True
-
-def parse_name_idna2008(name):
+def parse_name_idna2008(name: str) -> str:
     parts = name.split('.')
     r = []
     for part in parts:
-        if is_all_ascii(part):
+        if part.isascii():
             r.append(part.encode('ascii'))
         else:
             r.append(idna2008.encode(part))
     return b'.'.join(r)
 
-def parse_name(name):
+
+def parse_name(name: Union[str, bytes]) -> bytes:
     if isinstance(name, str):
-        if is_all_ascii(name):
+        if name.isascii():
             return name.encode('ascii')
         if idna2008 is not None:
             return parse_name_idna2008(name)

{pycares-4.5.0.dist-info → pycares-4.6.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: pycares
-Version: 4.5.0
+Version: 4.6.1
 Summary: Python interface for c-ares
 Home-page: http://github.com/saghul/pycares
 Author: Saúl Ibarra Corretgé
@@ -28,6 +28,19 @@ License-File: LICENSE
 Requires-Dist: cffi>=1.5.0
 Provides-Extra: idna
 Requires-Dist: idna>=2.1; extra == "idna"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: platform
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 Looking for new maintainers
 ===========================

pycares-4.6.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+pycares/__init__.py,sha256=FUE_1XczxLUO4f9jWARbumO4oAWM4eF1UBS9Cs0EiQw,32626
+pycares/__main__.py,sha256=-WwwGX4NQ8hpOqrNuCy59quCQJt7IAwQXdQjga5s4WA,2880
+pycares/_cares.pyd,sha256=d8IuKCHHw7L5msgzbEDbSeZkLSTE9JtARFNeolfbVys,107008
+pycares/_version.py,sha256=nMxGyGYNJ1000wnb1Janrs5k6aKCiMEh6a7VTHwXuaI,25
+pycares/errno.py,sha256=32f2SnSjYACq7peW9Iqb7cvDvwup6LDpNMWGHWhLnWI,2340
+pycares/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pycares/utils.py,sha256=ZzjEdkygbU3_B1g4SVwlDS949PhttJG2gK735_6G5Ps,1344
+pycares-4.6.1.dist-info/licenses/LICENSE,sha256=ZzIVbIpf5QFzaiLCDSjxhvH5EViAWLVO-W4ZgBzWvb8,1090
+pycares-4.6.1.dist-info/METADATA,sha256=RA-2SXrzVC5VSMorEwbeyn1F8QTt2tpHQxwVsh1plp8,4622
+pycares-4.6.1.dist-info/WHEEL,sha256=h1yBWRp7d7E3iSx_-CIQ9ghyrJ6lbw3eXQNv0LtpqIM,97
+pycares-4.6.1.dist-info/top_level.txt,sha256=nIeo7L2XUVBQZO2YE6pH7tlKaBWTfmmRcXbqe_NWYCw,15
+pycares-4.6.1.dist-info/RECORD,,

{pycares-4.5.0.dist-info → pycares-4.6.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.6.0)
+Generator: setuptools (78.1.1)
 Root-Is-Purelib: false
 Tag: cp313-cp313-win32
 

pycares-4.5.0.dist-info/RECORD

@@ -1,11 +0,0 @@
-pycares/__init__.py,sha256=EIkDaFs0MmRAYi6Ce2VzcA3H14-25zPyiD_6TfSBCSQ,30609
-pycares/__main__.py,sha256=-WwwGX4NQ8hpOqrNuCy59quCQJt7IAwQXdQjga5s4WA,2880
-pycares/_cares.pyd,sha256=lda5UE9DOhQQlJpPbieXRsLYk7OYHybPy97BnquuXzQ,107008
-pycares/_version.py,sha256=LndxDVTCo2jR91ipCX7gSKfdLq7B21t2ofpRE-CSa_E,25
-pycares/errno.py,sha256=cForwpErZsnPUQYttEgUjWZgi37cyrOGCWxUcO76HUE,1089
-pycares/utils.py,sha256=lKohvVcx0fjDcbkK0hGgvgY5WWnshj1Snxy-gGRbDNo,1399
-pycares-4.5.0.dist-info/LICENSE,sha256=ZzIVbIpf5QFzaiLCDSjxhvH5EViAWLVO-W4ZgBzWvb8,1090
-pycares-4.5.0.dist-info/METADATA,sha256=2zq6M_4O0AU22YCieCf9t1DXPLZzHvlce5fYCA1JFYs,4331
-pycares-4.5.0.dist-info/WHEEL,sha256=pUXSsnGWJ09R6rv65E7mPoM8rWovBqrkySmEuK3ly_A,97
-pycares-4.5.0.dist-info/top_level.txt,sha256=nIeo7L2XUVBQZO2YE6pH7tlKaBWTfmmRcXbqe_NWYCw,15
-pycares-4.5.0.dist-info/RECORD,,