* Replace percent formatting with f-strings.
* Fix pyright ignores.
return self.data
def to_text(self) -> str:
- return "Generic %d" % self.otype
+ return f"Generic {self.otype}"
def to_generic(self) -> "GenericOption":
return self
if len(address) != 4:
raise dns.exception.SyntaxError
- return "%u.%u.%u.%u" % (address[0], address[1], address[2], address[3])
+ return f"{address[0]}.{address[1]}.{address[2]}.{address[3]}"
def inet_aton(text: Union[str, bytes]) -> bytes:
"""
s = io.StringIO()
- s.write("id %d\n" % self.id)
+ s.write(f"id {self.id}\n")
s.write(f"opcode {dns.opcode.to_text(self.opcode())}\n")
s.write(f"rcode {dns.rcode.to_text(self.rcode())}\n")
s.write(f"flags {dns.flags.to_text(self.flags)}\n")
s.write(f"edns {self.edns}\n")
if self.ednsflags != 0:
s.write(f"eflags {dns.flags.edns_to_text(self.ednsflags)}\n")
- s.write("payload %d\n" % self.payload)
+ s.write(f"payload {self.payload}\n")
for opt in self.options:
s.write(f"option {opt.to_text()}\n")
for name, which in self._section_enum.__members__.items():
elif c > 0x20 and c < 0x7F:
text += chr(c)
else:
- text += "\\%03d" % c
+ text += f"\\{c:03d}"
return text
# Unicode label mode. Escape only special characters and values < 0x20
if uc in _escaped_text:
text += "\\" + uc
elif uc <= "\x20":
- text += "\\%03d" % ord(uc)
+ text += f"\\{ord(uc):03d}"
else:
text += uc
return text
rrset = q.find_rrset(
q.authority, zone, dns.rdataclass.IN, dns.rdatatype.SOA, create=True
)
- soa = dns.rdata.from_text("IN", "SOA", ". . %u 0 0 0 0" % serial)
+ soa = dns.rdata.from_text("IN", "SOA", f". . {serial} 0 0 0 0")
rrset.add(soa, 0)
if keyring is not None:
q.use_tsig(keyring, keyname, algorithm=keyalgorithm)
elif c >= 0x20 and c < 0x7F:
text += chr(c)
else:
- text += "\\%03d" % c
+ text += f"\\{c:03d}"
return text
relativize: bool = True,
**kw: Dict[str, Any],
) -> str:
- return r"\# %d " % len(self.data) + _hexify(self.data, **kw) # pyright: ignore
+ return rf"\# {len(self.data)} " + _hexify(self.data, **kw) # pyright: ignore
@classmethod
def from_text(
if rd.rdcomment:
extra = f" ;{rd.rdcomment}"
s.write(
- "%s%s%d %s %s %s%s\n"
- % (
- ntext,
- pad,
- self.ttl,
- dns.rdataclass.to_text(rdclass),
- dns.rdatatype.to_text(self.rdtype),
- rd.to_text(origin=origin, relativize=relativize, **kw),
- extra,
- )
+ f"{ntext}{pad}{self.ttl} "
+ f"{dns.rdataclass.to_text(rdclass)} "
+ f"{dns.rdatatype.to_text(self.rdtype)} "
+ f"{rd.to_text(origin=origin, relativize=relativize, **kw)}"
+ f"{extra}\n"
)
#
# We strip off the final \n for the caller's convenience in printing
def to_text(self, origin=None, relativize=True, **kw):
relay = Relay(self.relay_type, self.relay).to_text(origin, relativize)
- return "%d %d %d %s" % (
- self.precedence,
- self.discovery_optional,
- self.relay_type,
- relay,
+ return (
+ f"{self.precedence} {self.discovery_optional:d} {self.relay_type} {relay}"
)
@classmethod
self.value = self._as_bytes(value)
def to_text(self, origin=None, relativize=True, **kw):
- return '%u %s "%s"' % (
- self.flags,
- dns.rdata._escapify(self.tag),
- dns.rdata._escapify(self.value),
- )
+ return f'{self.flags} {dns.rdata._escapify(self.tag)} "{dns.rdata._escapify(self.value)}"'
@classmethod
def from_text(
def to_text(self, origin=None, relativize=True, **kw):
certificate_type = _ctype_to_text(self.certificate_type)
- return "%s %d %s %s" % (
- certificate_type,
- self.key_tag,
- dns.dnssectypes.Algorithm.to_text(self.algorithm),
- dns.rdata._base64ify(self.certificate, **kw), # pyright: ignore
- )
+ algorithm = dns.dnssectypes.Algorithm.to_text(self.algorithm)
+ certificate = dns.rdata._base64ify(self.certificate, **kw) # pyright: ignore
+ return f"{certificate_type} {self.key_tag} {algorithm} {certificate}"
@classmethod
def from_text(
def to_text(self, origin=None, relativize=True, **kw):
text = Bitmap(self.windows).to_text()
- return "%d %d%s" % (self.serial, self.flags, text)
+ return f"{self.serial} {self.flags}{text}"
@classmethod
def from_text(
servers.append(server.choose_relativity(origin, relativize))
if len(servers) > 0:
text += " " + " ".join(x.to_unicode() for x in servers)
- return "%u %s %s%s" % (self.algorithm, hit, key, text)
+ return f"{self.algorithm} {hit} {key}{text}"
@classmethod
def from_text(
long_hemisphere = "E"
else:
long_hemisphere = "W"
- text = "%d %d %d.%03d %s %d %d %d.%03d %s %0.2fm" % (
- self.latitude[0],
- self.latitude[1],
- self.latitude[2],
- self.latitude[3],
- lat_hemisphere,
- self.longitude[0],
- self.longitude[1],
- self.longitude[2],
- self.longitude[3],
- long_hemisphere,
- self.altitude / 100.0,
+ text = (
+ f"{self.latitude[0]} {self.latitude[1]} "
+ f"{self.latitude[2]}.{self.latitude[3]:03d} {lat_hemisphere} "
+ f"{self.longitude[0]} {self.longitude[1]} "
+ f"{self.longitude[2]}.{self.longitude[3]:03d} {long_hemisphere} "
+ f"{(self.altitude / 100.0):0.2f}m"
)
# do not print default values
def to_text(self, origin=None, relativize=True, **kw):
fqdn = self.fqdn.choose_relativity(origin, relativize)
- return "%d %s" % (self.preference, fqdn)
+ return f"{self.preference} {fqdn}"
@classmethod
def from_text(
else:
salt = binascii.hexlify(self.salt).decode()
text = Bitmap(self.windows).to_text()
- return "%u %u %u %s %s%s" % (
- self.algorithm,
- self.flags,
- self.iterations,
- salt,
- next,
- text,
- )
+ return f"{self.algorithm} {self.flags} {self.iterations} {salt} {next}{text}"
@classmethod
def from_text(
salt = "-"
else:
salt = binascii.hexlify(self.salt).decode()
- return "%u %u %u %s" % (self.algorithm, self.flags, self.iterations, salt)
+ return f"{self.algorithm} {self.flags} {self.iterations} {salt}"
@classmethod
def from_text(
return self.type_covered
def to_text(self, origin=None, relativize=True, **kw):
- return "%s %d %d %d %s %s %d %s %s" % (
- dns.rdatatype.to_text(self.type_covered),
- self.algorithm,
- self.labels,
- self.original_ttl,
- posixtime_to_sigtime(self.expiration),
- posixtime_to_sigtime(self.inception),
- self.key_tag,
- self.signer.choose_relativity(origin, relativize),
- dns.rdata._base64ify(self.signature, **kw), # pyright: ignore
+ return (
+ f"{dns.rdatatype.to_text(self.type_covered)} "
+ f"{self.algorithm} {self.labels} {self.original_ttl} "
+ f"{posixtime_to_sigtime(self.expiration)} "
+ f"{posixtime_to_sigtime(self.inception)} "
+ f"{self.key_tag} "
+ f"{self.signer.choose_relativity(origin, relativize)} "
+ f"{dns.rdata._base64ify(self.signature, **kw)}" # pyright: ignore
)
@classmethod
def to_text(self, origin=None, relativize=True, **kw):
mname = self.mname.choose_relativity(origin, relativize)
rname = self.rname.choose_relativity(origin, relativize)
- return "%s %s %d %d %d %d %d" % (
- mname,
- rname,
- self.serial,
- self.refresh,
- self.retry,
- self.expire,
- self.minimum,
- )
+ return f"{mname} {rname} {self.serial} {self.refresh} {self.retry} {self.expire} {self.minimum}"
@classmethod
def from_text(
def to_text(self, origin=None, relativize=True, **kw):
kw = kw.copy()
chunksize = kw.pop("chunksize", 128)
- return "%d %d %s" % (
- self.algorithm,
- self.fp_type,
- dns.rdata._hexify(
- self.fingerprint, chunksize=chunksize, **kw # pyright: ignore
- ),
+ fingerprint = dns.rdata._hexify(
+ self.fingerprint, chunksize=chunksize, **kw # pyright: ignore
)
+ return f"{self.algorithm} {self.fp_type} {fingerprint}"
@classmethod
def from_text(
def to_text(self, origin=None, relativize=True, **kw):
_algorithm = self.algorithm.choose_relativity(origin, relativize)
- text = "%s %u %u %u %u %s" % (
- str(_algorithm),
- self.inception,
- self.expiration,
- self.mode,
- self.error,
- dns.rdata._base64ify(self.key, 0),
- )
+ key = dns.rdata._base64ify(self.key, 0)
+ other = ""
if len(self.other) > 0:
- text += f" {dns.rdata._base64ify(self.other, 0)}"
-
- return text
+ other = " " + dns.rdata._base64ify(self.other, 0)
+ return f"{_algorithm} {self.inception} {self.expiration} {self.mode} {self.error} {key}{other}"
@classmethod
def from_text(
raise dns.exception.SyntaxError("URI target cannot be empty")
def to_text(self, origin=None, relativize=True, **kw):
- return '%d %d "%s"' % (self.priority, self.weight, self.target.decode())
+ return f'{self.priority} {self.weight} "{self.target.decode()}"'
@classmethod
def from_text(
def to_text(self, origin=None, relativize=True, **kw):
kw = kw.copy()
chunksize = kw.pop("chunksize", 128)
- return "%d %d %d %s" % (
- self.serial,
- self.scheme,
- self.hash_algorithm,
- dns.rdata._hexify(
- self.digest, chunksize=chunksize, **kw # pyright: ignore
- ),
+ digest = dns.rdata._hexify(
+ self.digest, chunksize=chunksize, **kw # pyright: ignore
)
+ return f"{self.serial} {self.scheme} {self.hash_algorithm} {digest}"
@classmethod
def from_text(
def __str__(self):
if self.negation:
- return "!%d:%s/%s" % (self.family, self.address, self.prefix)
+ return f"!{self.family}:{self.address}/{self.prefix}"
else:
- return "%d:%s/%s" % (self.family, self.address, self.prefix)
+ return f"{self.family}:{self.address}/{self.prefix}"
def to_wire(self, file):
if self.family == 1:
def to_text(self, origin=None, relativize=True, **kw):
gateway = Gateway(self.gateway_type, self.gateway).to_text(origin, relativize)
- return "%d %d %d %s %s" % (
- self.precedence,
- self.gateway_type,
- self.algorithm,
- gateway,
- dns.rdata._base64ify(self.key, **kw), # pyright: ignore
- )
+ key = dns.rdata._base64ify(self.key, **kw) # pyright: ignore
+ return f"{self.precedence} {self.gateway_type} {self.algorithm} {gateway} {key}"
@classmethod
def from_text(
def to_text(self, origin=None, relativize=True, **kw):
replacement = self.replacement.choose_relativity(origin, relativize)
- return '%d %d "%s" "%s" "%s" %s' % (
- self.order,
- self.preference,
- dns.rdata._escapify(self.flags),
- dns.rdata._escapify(self.service),
- dns.rdata._escapify(self.regexp),
- replacement,
+ return (
+ f"{self.order} {self.preference} "
+ f'"{dns.rdata._escapify(self.flags)}" '
+ f'"{dns.rdata._escapify(self.service)}" '
+ f'"{dns.rdata._escapify(self.regexp)}" '
+ f"{replacement}"
)
@classmethod
def to_text(self, origin=None, relativize=True, **kw):
map822 = self.map822.choose_relativity(origin, relativize)
mapx400 = self.mapx400.choose_relativity(origin, relativize)
- return "%d %s %s" % (self.preference, map822, mapx400)
+ return f"{self.preference} {map822} {mapx400}"
@classmethod
def from_text(
def to_text(self, origin=None, relativize=True, **kw):
target = self.target.choose_relativity(origin, relativize)
- return "%d %d %d %s" % (self.priority, self.weight, self.port, target)
+ return f"{self.priority} {self.weight} {self.port} {target}"
@classmethod
def from_text(
if byte & (0x80 >> j):
bits.append(str(i * 8 + j))
text = " ".join(bits)
- return "%s %d %s" % (self.address, self.protocol, text)
+ return f"{self.address} {self.protocol} {text}"
@classmethod
def from_text(
self.key = self._as_bytes(key)
def to_text(self, origin=None, relativize=True, **kw):
- return "%d %d %d %s" % (
- self.flags,
- self.protocol,
- self.algorithm,
- dns.rdata._base64ify(self.key, **kw), # pyright: ignore
- )
+ key = dns.rdata._base64ify(self.key, **kw) # pyright: ignore
+ return f"{self.flags} {self.protocol} {self.algorithm} {key}"
@classmethod
def from_text(
def to_text(self, origin=None, relativize=True, **kw):
kw = kw.copy()
chunksize = kw.pop("chunksize", 128)
- return "%d %d %d %s" % (
- self.key_tag,
- self.algorithm,
- self.digest_type,
- dns.rdata._hexify(
- self.digest, chunksize=chunksize, **kw # pyright: ignore
- ),
+ digest = dns.rdata._hexify(
+ self.digest, chunksize=chunksize, **kw # pyright: ignore
)
+ return f"{self.key_tag} {self.algorithm} {self.digest_type} {digest}"
@classmethod
def from_text(
def to_text(self, origin=None, relativize=True, **kw):
exchange = self.exchange.choose_relativity(origin, relativize)
- return "%d %s" % (self.preference, exchange)
+ return f"{self.preference} {exchange}"
@classmethod
def from_text(
elif c >= 0x20 and c < 0x7F:
text += chr(c)
else:
- text += "\\%03d" % c
+ text += f"\\{c:03d}"
return text
space = " "
else:
space = ""
- return "%d %s%s%s" % (self.priority, target, space, " ".join(params))
+ return f"{self.priority} {target}{space}{' '.join(params)}"
@classmethod
def from_text(
def to_text(self, origin=None, relativize=True, **kw):
kw = kw.copy()
chunksize = kw.pop("chunksize", 128)
- return "%d %d %d %s" % (
- self.usage,
- self.selector,
- self.mtype,
- dns.rdata._hexify(self.cert, chunksize=chunksize, **kw), # pyright: ignore
+ cert = dns.rdata._hexify(
+ self.cert, chunksize=chunksize, **kw # pyright: ignore
)
+ return f"{self.usage} {self.selector} {self.mtype} {cert}"
@classmethod
def from_text(
try:
v6 = dns.ipv6.inet_aton(text)
if dns.ipv6.is_mapped(v6):
- parts = ["%d" % byte for byte in v6[12:]]
+ parts = [str(byte) for byte in v6[12:]]
origin = v4_origin
else:
parts = [x for x in str(binascii.hexlify(v6).decode())]
origin = v6_origin
except Exception:
- parts = ["%d" % byte for byte in dns.ipv4.inet_aton(text)]
+ parts = [str(byte) for byte in dns.ipv4.inet_aton(text)]
origin = v4_origin
return dns.name.from_text(".".join(reversed(parts)), origin=origin)
return self.ttype != other.ttype or self.value != other.value
def __str__(self):
- return '%d "%s"' % (self.ttype, self.value)
+ return f'{self.ttype} "{self.value}"'
def unescape(self) -> "Token":
if not self.has_escape:
value = self.get_int()
if value < 0 or value > 255:
- raise dns.exception.SyntaxError(
- "%d is not an unsigned 8-bit integer" % value
- )
+ raise dns.exception.SyntaxError(f"{value} is not an unsigned 8-bit integer")
return value
def get_uint16(self, base: int = 10) -> int:
)
else:
raise dns.exception.SyntaxError(
- "%d is not an unsigned 16-bit integer" % value
+ f"{value} is not an unsigned 16-bit integer"
)
return value
value = self.get_int(base=base)
if value < 0 or value > 4294967295:
raise dns.exception.SyntaxError(
- "%d is not an unsigned 32-bit integer" % value
+ f"{value} is not an unsigned 32-bit integer"
)
return value
value = self.get_int(base=base)
if value < 0 or value > 281474976710655:
raise dns.exception.SyntaxError(
- "%d is not an unsigned 48-bit integer" % value
+ f"{value} is not an unsigned 48-bit integer"
)
return value
token = self.get()
if not token.is_eol_or_eof():
raise dns.exception.SyntaxError(
- 'expected EOL or EOF, got %d "%s"' % (token.ttype, token.value)
+ f'expected EOL or EOF, got {token.ttype} "{token.value}"'
)
return token
elif rdata.error == dns.rcode.BADTRUNC:
raise PeerBadTruncation
else:
- raise PeerError("unknown TSIG error code %d" % rdata.error)
+ raise PeerError(f"unknown TSIG error code {rdata.error}")
if abs(rdata.time_signed - now) > rdata.fudge:
raise BadTime
if key.name != owner:
if RELEASELEVEL == 0x0F: # pragma: no cover lgtm[py/unreachable-statement]
#: version
- version = "%d.%d.%d" % (MAJOR, MINOR, MICRO) # lgtm[py/unreachable-statement]
+ version = f"{MAJOR}.{MINOR}.{MICRO}" # lgtm[py/unreachable-statement]
elif RELEASELEVEL == 0x00: # pragma: no cover lgtm[py/unreachable-statement]
- version = "%d.%d.%ddev%d" % (
- MAJOR,
- MINOR,
- MICRO,
- SERIAL,
- ) # lgtm[py/unreachable-statement]
+ version = f"{MAJOR}.{MINOR}.{MICRO}dev{SERIAL}" # lgtm[py/unreachable-statement]
elif RELEASELEVEL == 0x0C: # pragma: no cover lgtm[py/unreachable-statement]
- version = "%d.%d.%drc%d" % (
- MAJOR,
- MINOR,
- MICRO,
- SERIAL,
- ) # lgtm[py/unreachable-statement]
+ version = f"{MAJOR}.{MINOR}.{MICRO}rc{SERIAL}" # lgtm[py/unreachable-statement]
else: # pragma: no cover lgtm[py/unreachable-statement]
- version = "%d.%d.%d%x%d" % (
- MAJOR,
- MINOR,
- MICRO,
- RELEASELEVEL,
- SERIAL,
- ) # lgtm[py/unreachable-statement]
+ version = f"{MAJOR}.{MINOR}.{MICRO}{RELEASELEVEL:x}{SERIAL}" # lgtm[py/unreachable-statement]
#: hexversion
hexversion = MAJOR << 24 | MINOR << 16 | MICRO << 8 | RELEASELEVEL << 4 | SERIAL
(filename, line_number) = self.tok.where()
if detail is None:
detail = "syntax error"
- ex = dns.exception.SyntaxError(
- "%s:%d: %s" % (filename, line_number, detail)
- )
+ ex = dns.exception.SyntaxError(f"{filename}:{line_number}: {detail}")
tb = sys.exc_info()[2]
raise ex.with_traceback(tb) from None
"B904",
"B011",
"UP006",
- "UP031",
"UP035",
]
lint.exclude = ["tests/*"]
projects / thirdparty / dnspython.git / commitdiff
