multiaddr 0.1.1__tar.gz → 0.2.0__tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (49) hide show
  1. {multiaddr-0.1.1 → multiaddr-0.2.0}/HISTORY.rst +26 -0
  2. {multiaddr-0.1.1 → multiaddr-0.2.0}/PKG-INFO +2 -2
  3. {multiaddr-0.1.1 → multiaddr-0.2.0}/multiaddr/__init__.py +1 -1
  4. {multiaddr-0.1.1 → multiaddr-0.2.0}/multiaddr/codecs/certhash.py +11 -1
  5. {multiaddr-0.1.1 → multiaddr-0.2.0}/multiaddr/codecs/domain.py +0 -13
  6. multiaddr-0.2.0/multiaddr/resolvers/__init__.py +17 -0
  7. {multiaddr-0.1.1 → multiaddr-0.2.0}/multiaddr/resolvers/dns.py +6 -3
  8. multiaddr-0.2.0/multiaddr/resolvers/util.py +173 -0
  9. {multiaddr-0.1.1 → multiaddr-0.2.0}/multiaddr.egg-info/PKG-INFO +2 -2
  10. {multiaddr-0.1.1 → multiaddr-0.2.0}/multiaddr.egg-info/SOURCES.txt +1 -0
  11. {multiaddr-0.1.1 → multiaddr-0.2.0}/pyproject.toml +3 -3
  12. {multiaddr-0.1.1 → multiaddr-0.2.0}/tests/test_multiaddr.py +3 -2
  13. {multiaddr-0.1.1 → multiaddr-0.2.0}/tests/test_resolvers.py +404 -1
  14. multiaddr-0.1.1/multiaddr/resolvers/__init__.py +0 -6
  15. {multiaddr-0.1.1 → multiaddr-0.2.0}/AUTHORS +0 -0
  16. {multiaddr-0.1.1 → multiaddr-0.2.0}/CONTRIBUTING.rst +0 -0
  17. {multiaddr-0.1.1 → multiaddr-0.2.0}/LICENSE-APACHE2 +0 -0
  18. {multiaddr-0.1.1 → multiaddr-0.2.0}/LICENSE-MIT +0 -0
  19. {multiaddr-0.1.1 → multiaddr-0.2.0}/MANIFEST.in +0 -0
  20. {multiaddr-0.1.1 → multiaddr-0.2.0}/README.rst +0 -0
  21. {multiaddr-0.1.1 → multiaddr-0.2.0}/multiaddr/codecs/__init__.py +0 -0
  22. {multiaddr-0.1.1 → multiaddr-0.2.0}/multiaddr/codecs/cid.py +0 -0
  23. {multiaddr-0.1.1 → multiaddr-0.2.0}/multiaddr/codecs/fspath.py +0 -0
  24. {multiaddr-0.1.1 → multiaddr-0.2.0}/multiaddr/codecs/garlic32.py +0 -0
  25. {multiaddr-0.1.1 → multiaddr-0.2.0}/multiaddr/codecs/garlic64.py +0 -0
  26. {multiaddr-0.1.1 → multiaddr-0.2.0}/multiaddr/codecs/http_path.py +0 -0
  27. {multiaddr-0.1.1 → multiaddr-0.2.0}/multiaddr/codecs/ip4.py +0 -0
  28. {multiaddr-0.1.1 → multiaddr-0.2.0}/multiaddr/codecs/ip6.py +0 -0
  29. {multiaddr-0.1.1 → multiaddr-0.2.0}/multiaddr/codecs/ipcidr.py +0 -0
  30. {multiaddr-0.1.1 → multiaddr-0.2.0}/multiaddr/codecs/memory.py +0 -0
  31. {multiaddr-0.1.1 → multiaddr-0.2.0}/multiaddr/codecs/onion.py +0 -0
  32. {multiaddr-0.1.1 → multiaddr-0.2.0}/multiaddr/codecs/onion3.py +0 -0
  33. {multiaddr-0.1.1 → multiaddr-0.2.0}/multiaddr/codecs/uint16be.py +0 -0
  34. {multiaddr-0.1.1 → multiaddr-0.2.0}/multiaddr/codecs/utf8.py +0 -0
  35. {multiaddr-0.1.1 → multiaddr-0.2.0}/multiaddr/exceptions.py +0 -0
  36. {multiaddr-0.1.1 → multiaddr-0.2.0}/multiaddr/multiaddr.py +0 -0
  37. {multiaddr-0.1.1 → multiaddr-0.2.0}/multiaddr/protocols.py +0 -0
  38. {multiaddr-0.1.1 → multiaddr-0.2.0}/multiaddr/resolvers/base.py +0 -0
  39. {multiaddr-0.1.1 → multiaddr-0.2.0}/multiaddr/transforms.py +0 -0
  40. {multiaddr-0.1.1 → multiaddr-0.2.0}/multiaddr/utils.py +0 -0
  41. {multiaddr-0.1.1 → multiaddr-0.2.0}/multiaddr.egg-info/dependency_links.txt +0 -0
  42. {multiaddr-0.1.1 → multiaddr-0.2.0}/multiaddr.egg-info/not-zip-safe +0 -0
  43. {multiaddr-0.1.1 → multiaddr-0.2.0}/multiaddr.egg-info/requires.txt +0 -0
  44. {multiaddr-0.1.1 → multiaddr-0.2.0}/multiaddr.egg-info/top_level.txt +0 -0
  45. {multiaddr-0.1.1 → multiaddr-0.2.0}/setup.cfg +0 -0
  46. {multiaddr-0.1.1 → multiaddr-0.2.0}/tests/__init__.py +0 -0
  47. {multiaddr-0.1.1 → multiaddr-0.2.0}/tests/test_protocols.py +0 -0
  48. {multiaddr-0.1.1 → multiaddr-0.2.0}/tests/test_thin_waist_addresses.py +0 -0
  49. {multiaddr-0.1.1 → multiaddr-0.2.0}/tests/test_transforms.py +0 -0
@@ -3,6 +3,32 @@ History
3
3
 
4
4
  .. towncrier release notes start
5
5
 
6
+ py-multiaddr v0.2.0 (2026-03-17)
7
+ --------------------------------
8
+
9
+ Features
10
+ ~~~~~~~~
11
+
12
+ - Add resolver utility functions ported from go-multiaddr-dns: ``matches()``, ``resolve_all()``, ``is_fqdn()``, ``fqdn()``, ``addr_len()``, and ``offset_addr()``. These utilities support DNS-based multiaddr resolution workflows including iterative resolution and FQDN handling. (`#101 <https://github.com/multiformats/py-multiaddr/issues/101>`__)
13
+
14
+
15
+ Internal Changes - for py-multiaddr Contributors
16
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
17
+
18
+ - Updated the tox GitHub Actions workflow so lint runs only once on Linux with
19
+ Python 3.10, while core tests continue to run across all configured Python
20
+ versions. (`#104 <https://github.com/multiformats/py-multiaddr/issues/104>`__)
21
+ - Aligned local tox defaults with CI by running lint only in ``py310-lint``,
22
+ while keeping core test environments for all configured Python versions. (`#106 <https://github.com/multiformats/py-multiaddr/issues/106>`__)
23
+
24
+
25
+ Removals
26
+ ~~~~~~~~
27
+
28
+ - Removed the module-level ``to_bytes`` and ``to_string`` helpers from ``multiaddr.codecs.domain``.
29
+ Domain codec behavior remains available through ``multiaddr.codecs.domain.Codec``. (`#100 <https://github.com/multiformats/py-multiaddr/issues/100>`__)
30
+
31
+
6
32
  py-multiaddr v0.1.1 (2025-12-07)
7
33
  --------------------------------
8
34
 
@@ -1,13 +1,13 @@
1
1
  Metadata-Version: 2.4
2
2
  Name: multiaddr
3
- Version: 0.1.1
3
+ Version: 0.2.0
4
4
  Summary: Python implementation of jbenet's multiaddr
5
5
  Author-email: Steven Buss <steven.buss@gmail.com>
6
6
  Maintainer: acul71
7
7
  Maintainer-email: pacrob <pacrob@protonmail.com>, Manu Sheel Gupta <manu@seeta.in>
8
8
  License: MIT License
9
9
  Project-URL: Homepage, https://github.com/multiformats/py-multiaddr
10
- Project-URL: Download, https://github.com/multiformats/py-multiaddr/tarball/0.1.1
10
+ Project-URL: Download, https://github.com/multiformats/py-multiaddr/tarball/0.2.0
11
11
  Keywords: multiaddr
12
12
  Classifier: Development Status :: 2 - Pre-Alpha
13
13
  Classifier: Intended Audience :: Developers
@@ -2,4 +2,4 @@ from .multiaddr import Multiaddr # NOQA
2
2
 
3
3
  __author__ = "Steven Buss"
4
4
  __email__ = "steven.buss@gmail.com"
5
- __version__ = "0.1.1"
5
+ __version__ = "0.2.0"
@@ -52,12 +52,22 @@ class Codec(CodecBase):
52
52
  Raises:
53
53
  ValueError: If the string is not valid multibase or not a multihash.
54
54
  """
55
+ if not string.startswith("u"):
56
+ raise ValueError("certhash must use base64url multibase prefix 'u'")
57
+
55
58
  try:
56
59
  # Decode the multibase string to get the raw multihash bytes.
57
- decoded_bytes = multibase.decode(string)
60
+ decoded = multibase.decode(string)
58
61
  except Exception as e:
59
62
  raise ValueError(f"Failed to decode multibase string: {string}") from e
60
63
 
64
+ # Some multibase implementations expose decode metadata as a tuple.
65
+ # Normalize to raw bytes for consistent validation and return type.
66
+ decoded_bytes = decoded[1] if isinstance(decoded, tuple) else decoded
67
+ if not isinstance(decoded_bytes, (bytes, bytearray)):
68
+ raise ValueError("Failed to decode multibase string to bytes")
69
+ decoded_bytes = bytes(decoded_bytes)
70
+
61
71
  # Validate that the decoded bytes are a valid multihash.
62
72
  self.validate(decoded_bytes)
63
73
  return decoded_bytes
@@ -37,16 +37,3 @@ class Codec(CodecBase):
37
37
  return value
38
38
  except (UnicodeDecodeError, idna.IDNAError) as e:
39
39
  raise BinaryParseError(f"Invalid domain name encoding: {e!s}", buf, proto.name, e)
40
-
41
-
42
- def to_bytes(proto: Any, string: str) -> bytes:
43
- # Validate using IDNA, but store as UTF-8
44
- idna.encode(string, uts46=True)
45
- return string.encode("utf-8")
46
-
47
-
48
- def to_string(proto: Any, buf: bytes) -> str:
49
- string = buf.decode("utf-8")
50
- # Validate using IDNA
51
- idna.encode(string, uts46=True)
52
- return string
@@ -0,0 +1,17 @@
1
+ """DNS resolution support for multiaddr."""
2
+
3
+ from .base import Resolver
4
+ from .dns import DNSADDR_TXT_PREFIX, DNSResolver
5
+ from .util import addr_len, fqdn, is_fqdn, matches, offset_addr, resolve_all
6
+
7
+ __all__ = [
8
+ "DNSADDR_TXT_PREFIX",
9
+ "DNSResolver",
10
+ "Resolver",
11
+ "addr_len",
12
+ "fqdn",
13
+ "is_fqdn",
14
+ "matches",
15
+ "offset_addr",
16
+ "resolve_all",
17
+ ]
@@ -36,6 +36,9 @@ from ..multiaddr import Multiaddr
36
36
  from ..protocols import P_DNS, P_DNS4, P_DNS6, P_DNSADDR, Protocol
37
37
  from .base import Resolver
38
38
 
39
+ DNSADDR_TXT_PREFIX = "dnsaddr="
40
+ """Prefix for dnsaddr TXT records (e.g. ``dnsaddr=/ip4/...``)."""
41
+
39
42
 
40
43
  class DNSResolver(Resolver):
41
44
  """
@@ -226,8 +229,8 @@ class DNSResolver(Resolver):
226
229
  else:
227
230
  txt_data = str(txt_data_raw)
228
231
  logging.debug(f"{indent} TXT: {txt_data}")
229
- if txt_data.startswith("dnsaddr="):
230
- multiaddr_str = txt_data[8:]
232
+ if txt_data.startswith(DNSADDR_TXT_PREFIX):
233
+ multiaddr_str = txt_data[len(DNSADDR_TXT_PREFIX) :]
231
234
  multiaddr_str = self._clean_quotes(multiaddr_str).strip()
232
235
  logging.debug(f"{indent} Parsed multiaddr: {multiaddr_str}")
233
236
  if not multiaddr_str:
@@ -405,4 +408,4 @@ class DNSResolver(Resolver):
405
408
  return results
406
409
 
407
410
 
408
- __all__ = ["DNSResolver"]
411
+ __all__ = ["DNSADDR_TXT_PREFIX", "DNSResolver"]
@@ -0,0 +1,173 @@
1
+ """Utility functions for multiaddr resolution."""
2
+
3
+ from __future__ import annotations
4
+
5
+ from typing import TYPE_CHECKING
6
+
7
+ from ..exceptions import RecursionLimitError
8
+ from ..multiaddr import Multiaddr
9
+ from ..protocols import P_DNS, P_DNS4, P_DNS6, P_DNSADDR
10
+
11
+ if TYPE_CHECKING:
12
+ from .base import Resolver
13
+
14
+ __all__ = ["addr_len", "fqdn", "is_fqdn", "matches", "offset_addr", "resolve_all"]
15
+
16
+ _DNS_PROTOCOLS = frozenset({P_DNS, P_DNS4, P_DNS6, P_DNSADDR})
17
+
18
+
19
+ def is_fqdn(s: str) -> bool:
20
+ """Check if string is a fully qualified domain name (ends with unescaped dot).
21
+
22
+ Args:
23
+ s: The domain name string to check.
24
+
25
+ Returns:
26
+ ``True`` if *s* ends with an unescaped ``'.'``, ``False`` otherwise.
27
+ """
28
+ if not s:
29
+ return False
30
+ # Count trailing backslashes before the final character
31
+ if s[-1] != ".":
32
+ return False
33
+ # Check if the trailing dot is escaped
34
+ num_backslashes = 0
35
+ for i in range(len(s) - 2, -1, -1):
36
+ if s[i] == "\\":
37
+ num_backslashes += 1
38
+ else:
39
+ break
40
+ # Odd number of backslashes means the dot is escaped
41
+ return num_backslashes % 2 == 0
42
+
43
+
44
+ def fqdn(s: str) -> str:
45
+ """Append a trailing dot to *s* if it is not already a FQDN.
46
+
47
+ Args:
48
+ s: The domain name string.
49
+
50
+ Returns:
51
+ The domain name with a trailing ``'.'`` appended if needed.
52
+
53
+ Example::
54
+
55
+ >>> fqdn("example.com")
56
+ 'example.com.'
57
+ >>> fqdn("example.com.")
58
+ 'example.com.'
59
+ """
60
+ if is_fqdn(s):
61
+ return s
62
+ return s + "."
63
+
64
+
65
+ def addr_len(maddr: Multiaddr) -> int:
66
+ """Count the number of protocol components in a multiaddr.
67
+
68
+ Args:
69
+ maddr: The multiaddr to measure.
70
+
71
+ Returns:
72
+ The number of protocol components.
73
+ """
74
+ return len(list(maddr.protocols()))
75
+
76
+
77
+ def offset_addr(maddr: Multiaddr, n: int) -> Multiaddr:
78
+ """Return a new multiaddr with the first *n* protocol components removed.
79
+
80
+ Args:
81
+ maddr: The source multiaddr.
82
+ n: Number of leading components to skip. Must be >= 0.
83
+
84
+ Returns:
85
+ A new :class:`~multiaddr.Multiaddr` without the first *n* components,
86
+ or ``Multiaddr("/")`` if *n* >= the total number of components.
87
+
88
+ Raises:
89
+ ValueError: If *n* is negative.
90
+ """
91
+ if n < 0:
92
+ raise ValueError(f"offset must be non-negative, got {n}")
93
+ parts = maddr.split(n)
94
+ if len(parts) <= n:
95
+ return Multiaddr("/")
96
+ return parts[n]
97
+
98
+
99
+ def matches(maddr: Multiaddr) -> bool:
100
+ """Check if a multiaddr contains any DNS protocol component.
101
+
102
+ Args:
103
+ maddr: The multiaddr to inspect.
104
+
105
+ Returns:
106
+ ``True`` if *maddr* contains a ``dns``, ``dns4``, ``dns6``, or
107
+ ``dnsaddr`` component.
108
+
109
+ Example::
110
+
111
+ >>> matches(Multiaddr("/dns4/example.com/tcp/80"))
112
+ True
113
+ >>> matches(Multiaddr("/ip4/127.0.0.1/tcp/80"))
114
+ False
115
+ """
116
+ return any(p.code in _DNS_PROTOCOLS for p in maddr.protocols())
117
+
118
+
119
+ async def resolve_all(
120
+ resolver: Resolver,
121
+ maddr: Multiaddr,
122
+ *,
123
+ max_iterations: int = 32,
124
+ ) -> list[Multiaddr]:
125
+ """Resolve all DNS components in a multiaddr iteratively.
126
+
127
+ Calls ``resolver.resolve()`` in a loop until every returned address is
128
+ free of DNS components.
129
+
130
+ Args:
131
+ resolver: A resolver instance implementing an async ``resolve()`` method.
132
+ maddr: The multiaddr to resolve.
133
+ max_iterations: Safety limit on resolution rounds to prevent infinite
134
+ loops (default ``32``).
135
+
136
+ Returns:
137
+ A list of fully-resolved :class:`~multiaddr.Multiaddr` instances.
138
+
139
+ Raises:
140
+ RecursionLimitError: If DNS components remain after *max_iterations*
141
+ rounds.
142
+
143
+ Example::
144
+
145
+ >>> import trio
146
+ >>> result = trio.run(resolve_all, my_resolver, Multiaddr("/dns4/example.com/tcp/80"))
147
+ """
148
+ queue = [maddr]
149
+ resolved: list[Multiaddr] = []
150
+
151
+ for _ in range(max_iterations):
152
+ if not queue:
153
+ break
154
+ next_queue: list[Multiaddr] = []
155
+ for addr in queue:
156
+ if not matches(addr):
157
+ resolved.append(addr)
158
+ continue
159
+ results = await resolver.resolve(addr)
160
+ for r in results:
161
+ if matches(r):
162
+ next_queue.append(r)
163
+ else:
164
+ resolved.append(r)
165
+ queue = next_queue
166
+
167
+ if queue:
168
+ raise RecursionLimitError(
169
+ f"resolve_all exceeded {max_iterations} iterations; "
170
+ f"{len(queue)} addresses still contain DNS components"
171
+ )
172
+
173
+ return resolved
@@ -1,13 +1,13 @@
1
1
  Metadata-Version: 2.4
2
2
  Name: multiaddr
3
- Version: 0.1.1
3
+ Version: 0.2.0
4
4
  Summary: Python implementation of jbenet's multiaddr
5
5
  Author-email: Steven Buss <steven.buss@gmail.com>
6
6
  Maintainer: acul71
7
7
  Maintainer-email: pacrob <pacrob@protonmail.com>, Manu Sheel Gupta <manu@seeta.in>
8
8
  License: MIT License
9
9
  Project-URL: Homepage, https://github.com/multiformats/py-multiaddr
10
- Project-URL: Download, https://github.com/multiformats/py-multiaddr/tarball/0.1.1
10
+ Project-URL: Download, https://github.com/multiformats/py-multiaddr/tarball/0.2.0
11
11
  Keywords: multiaddr
12
12
  Classifier: Development Status :: 2 - Pre-Alpha
13
13
  Classifier: Intended Audience :: Developers
@@ -37,6 +37,7 @@ multiaddr/codecs/utf8.py
37
37
  multiaddr/resolvers/__init__.py
38
38
  multiaddr/resolvers/base.py
39
39
  multiaddr/resolvers/dns.py
40
+ multiaddr/resolvers/util.py
40
41
  tests/__init__.py
41
42
  tests/test_multiaddr.py
42
43
  tests/test_protocols.py
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
4
4
 
5
5
  [project]
6
6
  name = "multiaddr"
7
- version = "0.1.1"
7
+ version = "0.2.0"
8
8
  description = "Python implementation of jbenet's multiaddr"
9
9
  readme = "README.rst"
10
10
  authors = [{ name = "Steven Buss", email = "steven.buss@gmail.com" }]
@@ -44,7 +44,7 @@ dependencies = [
44
44
 
45
45
  [project.urls]
46
46
  Homepage = "https://github.com/multiformats/py-multiaddr"
47
- Download = "https://github.com/multiformats/py-multiaddr/tarball/0.1.1"
47
+ Download = "https://github.com/multiformats/py-multiaddr/tarball/0.2.0"
48
48
 
49
49
  [project.optional-dependencies]
50
50
  dev = [
@@ -137,7 +137,7 @@ name = "Removals"
137
137
  showcontent = true
138
138
 
139
139
  [tool.bumpversion]
140
- current_version = "0.1.1"
140
+ current_version = "0.2.0"
141
141
  parse = """
142
142
  (?P<major>\\d+)
143
143
  \\.(?P<minor>\\d+)
@@ -67,8 +67,7 @@ from multiaddr.protocols import (
67
67
  "/garlic32/566niximlxdzpanmn4qouucvua3k7neniwss47li5r6ugoertzu:80",
68
68
  "/garlic32/566niximlxdzpanmn4qouucvua3k7neniwss47li5r6ugoertzuq:-1",
69
69
  "/garlic32/566niximlxdzpanmn4qouucvua3k7neniwss47li5r6ugoertzu@",
70
- "/ip4/127.0.0.1/udp/1234/quic-v1/webtransport/certhash/b2uaraocy6yrdblb4sfptaddgimjmmpy",
71
- "/ip4/127.0.0.1/udp/1234/quic-v1/webtransport/certhash/b2uaraocy6yrdblb4sfptaddgimjmmpy/certhash/zQmbWTwYGcmdyK9CYfNBcfs9nhZs17a6FQ4Y8oea278xx41",
70
+ "/ip4/127.0.0.1/udp/1234/quic-v1/webtransport/certhash/b2uaraocy6yrdblb4sfptaddgimjmmp",
72
71
  "/udp/1234/sctp",
73
72
  "/udp/1234/udt/1234",
74
73
  "/udp/1234/utp/1234",
@@ -142,6 +141,8 @@ def test_invalid(addr_str):
142
141
  "/ip4/127.0.0.1/tcp/127/webrtc",
143
142
  "/certhash/uEiDDq4_xNyDorZBH3TlGazyJdOWSwvo4PUo5YHFMrvDE8g"
144
143
  "/ip4/127.0.0.1/udp/9090/webrtc-direct/certhash/uEiDDq4_xNyDorZBH3TlGazyJdOWSwvo4PUo5YHFMrvDE8g",
144
+ "/ip4/127.0.0.1/udp/1234/quic-v1/webtransport/certhash/u1QEQOFj2IjCsPJFfMAxmQxLGPw",
145
+ "/ip4/127.0.0.1/udp/1234/quic-v1/webtransport/certhash/u1QEQOFj2IjCsPJFfMAxmQxLGPw/certhash/uEiDDq4_xNyDorZBH3TlGazyJdOWSwvo4PUo5YHFMrvDE8g",
145
146
  ],
146
147
  ) # nopep8
147
148
  def test_valid(addr_str):
@@ -9,7 +9,15 @@ import trio
9
9
 
10
10
  from multiaddr import Multiaddr
11
11
  from multiaddr.exceptions import RecursionLimitError
12
- from multiaddr.resolvers import DNSResolver
12
+ from multiaddr.resolvers import (
13
+ DNSResolver,
14
+ addr_len,
15
+ fqdn,
16
+ is_fqdn,
17
+ matches,
18
+ offset_addr,
19
+ resolve_all,
20
+ )
13
21
 
14
22
  if sys.version_info >= (3, 11):
15
23
  from builtins import BaseExceptionGroup
@@ -408,3 +416,398 @@ async def test_resolve_dnsaddr_quic_ipv6_zones(dns_resolver):
408
416
  in the Python implementation.
409
417
  """
410
418
  pytest.skip("IPv6 zones have binary encoding issues in Python implementation")
419
+
420
+
421
+ # ---------------------------------------------------------------------------
422
+ # Go test equivalents: DNSResolver.resolve()
423
+ # (from go-multiaddr-dns/resolve_test.go)
424
+ # ---------------------------------------------------------------------------
425
+
426
+
427
+ @pytest.fixture
428
+ def _go_style_dns_mocks():
429
+ """Create mock DNS answers matching the Go test setup.
430
+
431
+ Go test constants:
432
+ ip4a = 192.0.2.1, ip4b = 192.0.2.2
433
+ ip6a = 2001:db8::a3, ip6b = 2001:db8::a4
434
+ example.com → A: [ip4a, ip4b], AAAA: [ip6a, ip6b]
435
+ _dnsaddr.example.com → TXT: [dnsaddr=/ip4/192.0.2.1, dnsaddr=/ip6/2001:db8::a3]
436
+ """
437
+ mock_answer_a = AsyncMock()
438
+ rdata_a1 = AsyncMock()
439
+ rdata_a1.address = "192.0.2.1"
440
+ rdata_a2 = AsyncMock()
441
+ rdata_a2.address = "192.0.2.2"
442
+ mock_answer_a.__iter__.return_value = [rdata_a1, rdata_a2]
443
+
444
+ mock_answer_aaaa = AsyncMock()
445
+ rdata_aaaa1 = AsyncMock()
446
+ rdata_aaaa1.address = "2001:db8::a3"
447
+ rdata_aaaa2 = AsyncMock()
448
+ rdata_aaaa2.address = "2001:db8::a4"
449
+ mock_answer_aaaa.__iter__.return_value = [rdata_aaaa1, rdata_aaaa2]
450
+
451
+ mock_answer_txt = AsyncMock()
452
+ rdata_txt1 = AsyncMock()
453
+ rdata_txt1.strings = ["dnsaddr=/ip4/192.0.2.1"]
454
+ rdata_txt2 = AsyncMock()
455
+ rdata_txt2.strings = ["dnsaddr=/ip6/2001:db8::a3"]
456
+ mock_answer_txt.__iter__.return_value = [rdata_txt1, rdata_txt2]
457
+
458
+ async def side_effect(hostname, record_type):
459
+ if record_type == "A" and hostname in ("example.com", "example.com."):
460
+ return mock_answer_a
461
+ if record_type == "AAAA" and hostname in ("example.com", "example.com."):
462
+ return mock_answer_aaaa
463
+ if record_type == "TXT" and hostname in ("_dnsaddr.example.com", "_dnsaddr.example.com."):
464
+ return mock_answer_txt
465
+ raise dns.resolver.NXDOMAIN()
466
+
467
+ return side_effect
468
+
469
+
470
+ @pytest.mark.trio
471
+ async def test_simple_ip_resolve_dns4(dns_resolver, _go_style_dns_mocks):
472
+ """Go: TestSimpleIPResolve — dns4 resolves to IPv4 addresses only."""
473
+ with patch.object(dns_resolver._resolver, "resolve") as mock:
474
+ mock.side_effect = _go_style_dns_mocks
475
+ result = await dns_resolver.resolve(Multiaddr("/dns4/example.com"))
476
+ assert len(result) == 2
477
+ assert result[0] == Multiaddr("/ip4/192.0.2.1")
478
+ assert result[1] == Multiaddr("/ip4/192.0.2.2")
479
+
480
+
481
+ @pytest.mark.trio
482
+ async def test_simple_ip_resolve_dns6(dns_resolver, _go_style_dns_mocks):
483
+ """Go: TestSimpleIPResolve — dns6 resolves to IPv6 addresses only."""
484
+ with patch.object(dns_resolver._resolver, "resolve") as mock:
485
+ mock.side_effect = _go_style_dns_mocks
486
+ result = await dns_resolver.resolve(Multiaddr("/dns6/example.com"))
487
+ assert len(result) == 2
488
+ assert result[0] == Multiaddr("/ip6/2001:db8::a3")
489
+ assert result[1] == Multiaddr("/ip6/2001:db8::a4")
490
+
491
+
492
+ @pytest.mark.trio
493
+ async def test_simple_ip_resolve_dns_both(dns_resolver, _go_style_dns_mocks):
494
+ """Go: TestSimpleIPResolve — dns resolves to both IPv4 and IPv6."""
495
+ with patch.object(dns_resolver._resolver, "resolve") as mock:
496
+ mock.side_effect = _go_style_dns_mocks
497
+ result = await dns_resolver.resolve(Multiaddr("/dns/example.com"))
498
+ assert len(result) == 4
499
+ assert result[0] == Multiaddr("/ip4/192.0.2.1")
500
+ assert result[1] == Multiaddr("/ip4/192.0.2.2")
501
+ assert result[2] == Multiaddr("/ip6/2001:db8::a3")
502
+ assert result[3] == Multiaddr("/ip6/2001:db8::a4")
503
+
504
+
505
+ @pytest.mark.trio
506
+ async def test_resolve_only_once(dns_resolver, _go_style_dns_mocks):
507
+ """Go: TestResolveOnlyOnce — only the first DNS component is resolved."""
508
+ with patch.object(dns_resolver._resolver, "resolve") as mock:
509
+ mock.side_effect = _go_style_dns_mocks
510
+ result = await dns_resolver.resolve(Multiaddr("/dns4/example.com/quic/dns6/example.com"))
511
+ # dns4 resolved to 2 IPs, dns6 stays unresolved in each
512
+ assert len(result) == 2
513
+ assert result[0] == Multiaddr("/ip4/192.0.2.1/quic/dns6/example.com")
514
+ assert result[1] == Multiaddr("/ip4/192.0.2.2/quic/dns6/example.com")
515
+
516
+
517
+ @pytest.mark.trio
518
+ async def test_simple_txt_resolve(dns_resolver, _go_style_dns_mocks):
519
+ """Go: TestSimpleTXTResolve — dnsaddr resolves via TXT records."""
520
+ with patch.object(dns_resolver._resolver, "resolve") as mock:
521
+ mock.side_effect = _go_style_dns_mocks
522
+ result = await dns_resolver.resolve(Multiaddr("/dnsaddr/example.com"))
523
+ assert len(result) == 2
524
+ assert result[0] == Multiaddr("/ip4/192.0.2.1")
525
+ assert result[1] == Multiaddr("/ip6/2001:db8::a3")
526
+
527
+
528
+ @pytest.mark.trio
529
+ async def test_resolve_empty_result(dns_resolver):
530
+ """Go: TestEmptyResult — dnsaddr for unknown domain returns empty list."""
531
+ with patch.object(dns_resolver._resolver, "resolve", side_effect=dns.resolver.NXDOMAIN):
532
+ result = await dns_resolver.resolve(Multiaddr("/dnsaddr/none.com"))
533
+ assert result == []
534
+
535
+
536
+ @pytest.mark.trio
537
+ async def test_resolve_dns4_with_suffix(dns_resolver, _go_style_dns_mocks):
538
+ """Go: TestSimpleIPResolve variant — dns4 with /tcp suffix preserved."""
539
+ with patch.object(dns_resolver._resolver, "resolve") as mock:
540
+ mock.side_effect = _go_style_dns_mocks
541
+ result = await dns_resolver.resolve(Multiaddr("/dns4/example.com/tcp/80"))
542
+ assert len(result) == 2
543
+ assert result[0] == Multiaddr("/ip4/192.0.2.1/tcp/80")
544
+ assert result[1] == Multiaddr("/ip4/192.0.2.2/tcp/80")
545
+
546
+
547
+ # ---------------------------------------------------------------------------
548
+ # Utility function tests
549
+ # ---------------------------------------------------------------------------
550
+
551
+
552
+ class TestIsFqdn:
553
+ """Tests for is_fqdn."""
554
+
555
+ def test_empty(self):
556
+ assert is_fqdn("") is False
557
+
558
+ def test_dot(self):
559
+ assert is_fqdn(".") is True
560
+
561
+ def test_no_trailing_dot(self):
562
+ assert is_fqdn("example.com") is False
563
+
564
+ def test_trailing_dot(self):
565
+ assert is_fqdn("example.com.") is True
566
+
567
+ def test_escaped_dot_in_middle(self):
568
+ # escaped dot in middle, real dot at end
569
+ assert is_fqdn("example\\.com.") is True
570
+
571
+ def test_trailing_escaped_dot(self):
572
+ # trailing dot is escaped → not FQDN
573
+ assert is_fqdn("example.com\\.") is False
574
+
575
+ def test_escaped_backslash_before_dot(self):
576
+ # escaped backslash before real dot
577
+ assert is_fqdn("example.com\\\\.") is True
578
+
579
+ def test_escaped_backslash_and_escaped_dot(self):
580
+ # escaped backslash + escaped dot
581
+ assert is_fqdn("example.com\\\\\\.") is False
582
+
583
+
584
+ class TestFqdn:
585
+ """Tests for fqdn."""
586
+
587
+ def test_empty(self):
588
+ assert fqdn("") == "."
589
+
590
+ def test_dot(self):
591
+ assert fqdn(".") == "."
592
+
593
+ def test_no_trailing_dot(self):
594
+ assert fqdn("example.com") == "example.com."
595
+
596
+ def test_already_fqdn(self):
597
+ assert fqdn("example.com.") == "example.com."
598
+
599
+ def test_escaped_trailing_dot(self):
600
+ # trailing dot is escaped → append a real dot
601
+ assert fqdn("example.com\\.") == "example.com\\.."
602
+
603
+ def test_escaped_backslash_already_fqdn(self):
604
+ # escaped backslash before real dot → already FQDN
605
+ assert fqdn("example.com\\\\.") == "example.com\\\\."
606
+
607
+
608
+ class TestAddrLen:
609
+ def test_single_protocol(self):
610
+ assert addr_len(Multiaddr("/ip4/127.0.0.1")) == 1
611
+
612
+ def test_two_protocols(self):
613
+ assert addr_len(Multiaddr("/ip4/127.0.0.1/tcp/80")) == 2
614
+
615
+ def test_three_protocols(self):
616
+ assert addr_len(Multiaddr("/ip4/127.0.0.1/tcp/80/http")) == 3
617
+
618
+
619
+ class TestOffsetAddr:
620
+ def test_offset_zero(self):
621
+ ma = Multiaddr("/ip4/127.0.0.1/tcp/80")
622
+ assert offset_addr(ma, 0) == ma
623
+
624
+ def test_offset_one(self):
625
+ ma = Multiaddr("/ip4/127.0.0.1/tcp/80")
626
+ assert offset_addr(ma, 1) == Multiaddr("/tcp/80")
627
+
628
+ def test_offset_all(self):
629
+ ma = Multiaddr("/ip4/127.0.0.1/tcp/80")
630
+ assert offset_addr(ma, 2) == Multiaddr("/")
631
+
632
+ def test_negative_offset(self):
633
+ ma = Multiaddr("/ip4/127.0.0.1/tcp/80")
634
+ with pytest.raises(ValueError, match="non-negative"):
635
+ offset_addr(ma, -1)
636
+
637
+
638
+ class TestMatches:
639
+ def test_dns4(self):
640
+ assert matches(Multiaddr("/dns4/example.com/tcp/80")) is True
641
+
642
+ def test_dns6(self):
643
+ assert matches(Multiaddr("/dns6/example.com/tcp/80")) is True
644
+
645
+ def test_dnsaddr(self):
646
+ assert matches(Multiaddr("/dnsaddr/example.com")) is True
647
+
648
+ def test_dns(self):
649
+ assert matches(Multiaddr("/dns/example.com/tcp/80")) is True
650
+
651
+ def test_ip4(self):
652
+ assert matches(Multiaddr("/ip4/127.0.0.1/tcp/80")) is False
653
+
654
+ def test_ip6(self):
655
+ assert matches(Multiaddr("/ip6/::1/tcp/80")) is False
656
+
657
+ def test_dns_not_first_position(self):
658
+ """Go: TestMatches — DNS at non-first position still matches."""
659
+ assert matches(Multiaddr("/tcp/1234/dns6/example.com")) is True
660
+
661
+
662
+ # ---------------------------------------------------------------------------
663
+ # resolve_all tests
664
+ # ---------------------------------------------------------------------------
665
+
666
+
667
+ class MockResolver:
668
+ """A mock resolver for testing resolve_all."""
669
+
670
+ def __init__(self, mapping: dict[str, list[str]]):
671
+ self._mapping = mapping
672
+
673
+ async def resolve(self, maddr: Multiaddr) -> list[Multiaddr]:
674
+ key = str(maddr)
675
+ if key in self._mapping:
676
+ return [Multiaddr(v) for v in self._mapping[key]]
677
+ return [maddr]
678
+
679
+
680
+ @pytest.mark.trio
681
+ async def test_resolve_all_no_dns():
682
+ """Non-DNS multiaddr is returned unchanged."""
683
+ resolver = MockResolver({})
684
+ ma = Multiaddr("/ip4/127.0.0.1/tcp/80")
685
+ result = await resolve_all(resolver, ma)
686
+ assert result == [ma]
687
+
688
+
689
+ @pytest.mark.trio
690
+ async def test_resolve_all_single_dns():
691
+ """Single DNS component is resolved."""
692
+ resolver = MockResolver(
693
+ {
694
+ "/dns4/example.com/tcp/80": ["/ip4/1.2.3.4/tcp/80"],
695
+ }
696
+ )
697
+ result = await resolve_all(resolver, Multiaddr("/dns4/example.com/tcp/80"))
698
+ assert result == [Multiaddr("/ip4/1.2.3.4/tcp/80")]
699
+
700
+
701
+ @pytest.mark.trio
702
+ async def test_resolve_all_multiple_dns_components():
703
+ """Multiple DNS components in one multiaddr are all resolved."""
704
+ resolver = MockResolver(
705
+ {
706
+ "/dns4/a.example.com/quic/dns6/b.example.com": ["/ip4/1.2.3.4/quic/dns6/b.example.com"],
707
+ "/ip4/1.2.3.4/quic/dns6/b.example.com": ["/ip4/1.2.3.4/quic/ip6/::1"],
708
+ }
709
+ )
710
+ result = await resolve_all(resolver, Multiaddr("/dns4/a.example.com/quic/dns6/b.example.com"))
711
+ assert result == [Multiaddr("/ip4/1.2.3.4/quic/ip6/::1")]
712
+
713
+
714
+ @pytest.mark.trio
715
+ async def test_resolve_all_chained():
716
+ """Chained resolution: DNS resolves to another DNS address."""
717
+ resolver = MockResolver(
718
+ {
719
+ "/dns4/a.com": ["/dns4/b.com/tcp/80"],
720
+ "/dns4/b.com/tcp/80": ["/ip4/1.2.3.4/tcp/80"],
721
+ }
722
+ )
723
+ result = await resolve_all(resolver, Multiaddr("/dns4/a.com"))
724
+ assert result == [Multiaddr("/ip4/1.2.3.4/tcp/80")]
725
+
726
+
727
+ @pytest.mark.trio
728
+ async def test_resolve_all_max_iterations_exceeded():
729
+ """Raises RecursionLimitError when DNS never fully resolves."""
730
+ resolver = MockResolver(
731
+ {
732
+ "/dns4/loop.com": ["/dns4/loop.com"],
733
+ }
734
+ )
735
+ with pytest.raises(RecursionLimitError, match="resolve_all exceeded"):
736
+ await resolve_all(resolver, Multiaddr("/dns4/loop.com"), max_iterations=3)
737
+
738
+
739
+ @pytest.mark.trio
740
+ async def test_resolve_all_empty_result():
741
+ """Empty resolve result drops the address without looping."""
742
+
743
+ class EmptyResolver:
744
+ async def resolve(self, maddr: Multiaddr) -> list[Multiaddr]:
745
+ return []
746
+
747
+ result = await resolve_all(EmptyResolver(), Multiaddr("/dns4/gone.com/tcp/80"))
748
+ assert result == []
749
+
750
+
751
+ @pytest.mark.trio
752
+ async def test_resolve_all_cartesian_product():
753
+ """Go: TestResolveMultiple — dns4 x dns6 produces cartesian product.
754
+
755
+ /dns4/example.com/quic/dns6/example.com with dns4→[ip4a, ip4b]
756
+ and dns6→[ip6a, ip6b] produces 4 results.
757
+ """
758
+ resolver = MockResolver(
759
+ {
760
+ "/dns4/example.com/quic/dns6/example.com": [
761
+ "/ip4/192.0.2.1/quic/dns6/example.com",
762
+ "/ip4/192.0.2.2/quic/dns6/example.com",
763
+ ],
764
+ "/ip4/192.0.2.1/quic/dns6/example.com": [
765
+ "/ip4/192.0.2.1/quic/ip6/2001:db8::a3",
766
+ "/ip4/192.0.2.1/quic/ip6/2001:db8::a4",
767
+ ],
768
+ "/ip4/192.0.2.2/quic/dns6/example.com": [
769
+ "/ip4/192.0.2.2/quic/ip6/2001:db8::a3",
770
+ "/ip4/192.0.2.2/quic/ip6/2001:db8::a4",
771
+ ],
772
+ }
773
+ )
774
+ result = await resolve_all(resolver, Multiaddr("/dns4/example.com/quic/dns6/example.com"))
775
+ expected = [
776
+ Multiaddr("/ip4/192.0.2.1/quic/ip6/2001:db8::a3"),
777
+ Multiaddr("/ip4/192.0.2.1/quic/ip6/2001:db8::a4"),
778
+ Multiaddr("/ip4/192.0.2.2/quic/ip6/2001:db8::a3"),
779
+ Multiaddr("/ip4/192.0.2.2/quic/ip6/2001:db8::a4"),
780
+ ]
781
+ assert result == expected
782
+
783
+
784
+ @pytest.mark.trio
785
+ async def test_resolve_all_sandwich():
786
+ """Go: TestResolveMultipleSandwitch — DNS sandwiched between non-DNS protocols.
787
+
788
+ /quic/dns4/example.com/dns6/example.com/http resolves both DNS components.
789
+ """
790
+ resolver = MockResolver(
791
+ {
792
+ "/quic/dns4/example.com/dns6/example.com/http": [
793
+ "/quic/ip4/192.0.2.1/dns6/example.com/http",
794
+ "/quic/ip4/192.0.2.2/dns6/example.com/http",
795
+ ],
796
+ "/quic/ip4/192.0.2.1/dns6/example.com/http": [
797
+ "/quic/ip4/192.0.2.1/ip6/2001:db8::a3/http",
798
+ "/quic/ip4/192.0.2.1/ip6/2001:db8::a4/http",
799
+ ],
800
+ "/quic/ip4/192.0.2.2/dns6/example.com/http": [
801
+ "/quic/ip4/192.0.2.2/ip6/2001:db8::a3/http",
802
+ "/quic/ip4/192.0.2.2/ip6/2001:db8::a4/http",
803
+ ],
804
+ }
805
+ )
806
+ result = await resolve_all(resolver, Multiaddr("/quic/dns4/example.com/dns6/example.com/http"))
807
+ expected = [
808
+ Multiaddr("/quic/ip4/192.0.2.1/ip6/2001:db8::a3/http"),
809
+ Multiaddr("/quic/ip4/192.0.2.1/ip6/2001:db8::a4/http"),
810
+ Multiaddr("/quic/ip4/192.0.2.2/ip6/2001:db8::a3/http"),
811
+ Multiaddr("/quic/ip4/192.0.2.2/ip6/2001:db8::a4/http"),
812
+ ]
813
+ assert result == expected
@@ -1,6 +0,0 @@
1
- """DNS resolution support for multiaddr."""
2
-
3
- from .base import Resolver
4
- from .dns import DNSResolver
5
-
6
- __all__ = ["DNSResolver", "Resolver"]
File without changes
File without changes
File without changes
File without changes
File without changes
File without changes
File without changes
File without changes
File without changes