Merge pull request #334 from hugovk/update-versions

Update supported versions

22 files changed, 33 insertions, 32 deletions

diff --git a/dns/dnssec.py b/dns/dnssec.py
index 1bd422e..5426373 100644
--- a/dns/dnssec.py
+++ b/dns/dnssec.py
@@ -87,7 +87,7 @@ _algorithm_by_text = {
 # cannot make any mistakes (e.g. omissions, cut-and-paste errors) that
 # would cause the mapping not to be true inverse.
 
-_algorithm_by_value = dict((y, x) for x, y in _algorithm_by_text.items())
+_algorithm_by_value = {y: x for x, y in _algorithm_by_text.items()}
 
 
 def algorithm_from_text(text):
diff --git a/dns/edns.py b/dns/edns.py
index 22104d8..487e67e 100644
--- a/dns/edns.py
+++ b/dns/edns.py
@@ -197,8 +197,8 @@ class ECSOption(Option):
             self.addrdata = self.addrdata[:-1] + last
 
     def to_text(self):
-        return "ECS %s/%s scope/%s" % (self.address, self.srclen,
-                                       self.scopelen)
+        return "ECS {}/{} scope/{}".format(self.address, self.srclen,
+                                           self.scopelen)
 
     def to_wire(self, file):
         file.write(struct.pack('!H', self.family))
diff --git a/dns/exception.py b/dns/exception.py
index 89aee9c..57f2bc1 100644
--- a/dns/exception.py
+++ b/dns/exception.py
@@ -122,5 +122,5 @@ class TooBig(DNSException):
 
 class Timeout(DNSException):
     """The DNS operation timed out."""
-    supp_kwargs = set(['timeout'])
+    supp_kwargs = {'timeout'}
     fmt = "The DNS operation timed out after {timeout} seconds"
diff --git a/dns/flags.py b/dns/flags.py
index f9a62b3..f6e30e2 100644
--- a/dns/flags.py
+++ b/dns/flags.py
@@ -56,9 +56,9 @@ _edns_by_text = {
 # cannot make any mistakes (e.g. omissions, cut-and-paste errors) that
 # would cause the mappings not to be true inverses.
 
-_by_value = dict((y, x) for x, y in _by_text.items())
+_by_value = {y: x for x, y in _by_text.items()}
 
-_edns_by_value = dict((y, x) for x, y in _edns_by_text.items())
+_edns_by_value = {y: x for x, y in _edns_by_text.items()}
 
 
 def _order_flags(table):
diff --git a/dns/ipv6.py b/dns/ipv6.py
index 49ef556..db1e9c9 100644
--- a/dns/ipv6.py
+++ b/dns/ipv6.py
@@ -117,8 +117,9 @@ def inet_aton(text):
     m = _v4_ending.match(text)
     if not m is None:
         b = bytearray(dns.ipv4.inet_aton(m.group(2)))
-        text = (u"%s:%02x%02x:%02x%02x" % (m.group(1).decode(), b[0], b[1],
-                                           b[2], b[3])).encode()
+        text = (u"{}:{:02x}{:02x}:{:02x}{:02x}".format(m.group(1).decode(),
+                                                       b[0], b[1], b[2],
+                                                       b[3])).encode()
     #
     # Try to turn '::<whatever>' into ':<whatever>'; if no match try to
     # turn '<whatever>::' into '<whatever>:'
diff --git a/dns/name.py b/dns/name.py
index 9764de5..2b159b4 100644
--- a/dns/name.py
+++ b/dns/name.py
@@ -98,7 +98,7 @@ class NoIDNA2008(dns.exception.DNSException):
 class IDNAException(dns.exception.DNSException):
     """IDNA processing raised an exception."""
 
-    supp_kwargs = set(['idna_exception'])
+    supp_kwargs = {'idna_exception'}
     fmt = "IDNA processing exception: {idna_exception}"
 
 
diff --git a/dns/opcode.py b/dns/opcode.py
index 5dcd2ab..249e359 100644
--- a/dns/opcode.py
+++ b/dns/opcode.py
@@ -40,7 +40,7 @@ _by_text = {
 # cannot make any mistakes (e.g. omissions, cut-and-paste errors) that
 # would cause the mapping not to be true inverse.
 
-_by_value = dict((y, x) for x, y in _by_text.items())
+_by_value = {y: x for x, y in _by_text.items()}
 
 
 class UnknownOpcode(dns.exception.DNSException):
diff --git a/dns/rcode.py b/dns/rcode.py
index eb4d1d6..4d564c7 100644
--- a/dns/rcode.py
+++ b/dns/rcode.py
@@ -62,7 +62,7 @@ _by_text = {
 # cannot make any mistakes (e.g. omissions, cut-and-paste errors) that
 # would cause the mapping not to be a true inverse.
 
-_by_value = dict((y, x) for x, y in _by_text.items())
+_by_value = {y: x for x, y in _by_text.items()}
 
 
 class UnknownRcode(dns.exception.DNSException):
diff --git a/dns/rdata.py b/dns/rdata.py
index 5123a24..06c4722 100644
--- a/dns/rdata.py
+++ b/dns/rdata.py
@@ -427,7 +427,7 @@ def from_wire(rdclass, rdtype, wire, current, rdlen, origin=None):
 
 class RdatatypeExists(dns.exception.DNSException):
     """DNS rdatatype already exists."""
-    supp_kwargs = set(['rdclass', 'rdtype'])
+    supp_kwargs = {'rdclass', 'rdtype'}
     fmt = "The rdata type with class {rdclass} and rdtype {rdtype} " + \
         "already exists."
 
diff --git a/dns/rdataclass.py b/dns/rdataclass.py
index 916dc61..d3d883d 100644
--- a/dns/rdataclass.py
+++ b/dns/rdataclass.py
@@ -39,7 +39,7 @@ _by_text = {
 # cannot make any mistakes (e.g. omissions, cut-and-paste errors) that
 # would cause the mapping not to be true inverse.
 
-_by_value = dict((y, x) for x, y in _by_text.items())
+_by_value = {y: x for x, y in _by_text.items()}
 
 # Now that we've built the inverse map, we can add class aliases to
 # the _by_text mapping.
diff --git a/dns/rdataset.py b/dns/rdataset.py
index bd8cfab..96f0661 100644
--- a/dns/rdataset.py
+++ b/dns/rdataset.py
@@ -204,9 +204,9 @@ class Rdataset(dns.set.Set):
             # some dynamic updates, so we don't need to print out the TTL
             # (which is meaningless anyway).
             #
-            s.write(u'%s%s%s %s\n' % (ntext, pad,
-                                      dns.rdataclass.to_text(rdclass),
-                                      dns.rdatatype.to_text(self.rdtype)))
+            s.write(u'{}{}{} {}\n'.format(ntext, pad,
+                                          dns.rdataclass.to_text(rdclass),
+                                          dns.rdatatype.to_text(self.rdtype)))
         else:
             for rd in self:
                 s.write(u'%s%s%d %s %s %s\n' %
diff --git a/dns/rdatatype.py b/dns/rdatatype.py
index c9bf599..94cbb73 100644
--- a/dns/rdatatype.py
+++ b/dns/rdatatype.py
@@ -167,7 +167,7 @@ _by_text = {
 # cannot make any mistakes (e.g. omissions, cut-and-paste errors) that
 # would cause the mapping not to be true inverse.
 
-_by_value = dict((y, x) for x, y in _by_text.items())
+_by_value = {y: x for x, y in _by_text.items()}
 
 _metatypes = {
     OPT: True
diff --git a/dns/rdtypes/ANY/GPOS.py b/dns/rdtypes/ANY/GPOS.py
index a359a77..4f22818 100644
--- a/dns/rdtypes/ANY/GPOS.py
+++ b/dns/rdtypes/ANY/GPOS.py
@@ -80,7 +80,7 @@ class GPOS(dns.rdata.Rdata):
         self.altitude = altitude
 
     def to_text(self, origin=None, relativize=True, **kw):
-        return '%s %s %s' % (self.latitude.decode(),
+        return '{} {} {}'.format(self.latitude.decode(),
                              self.longitude.decode(),
                              self.altitude.decode())
 
diff --git a/dns/rdtypes/ANY/HINFO.py b/dns/rdtypes/ANY/HINFO.py
index e5a1bea..1e0620a 100644
--- a/dns/rdtypes/ANY/HINFO.py
+++ b/dns/rdtypes/ANY/HINFO.py
@@ -45,8 +45,8 @@ class HINFO(dns.rdata.Rdata):
             self.os = os
 
     def to_text(self, origin=None, relativize=True, **kw):
-        return '"%s" "%s"' % (dns.rdata._escapify(self.cpu),
-                              dns.rdata._escapify(self.os))
+        return '"{}" "{}"'.format(dns.rdata._escapify(self.cpu),
+                                  dns.rdata._escapify(self.os))
 
     @classmethod
     def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
diff --git a/dns/rdtypes/ANY/ISDN.py b/dns/rdtypes/ANY/ISDN.py
index da2ae3a..e264814 100644
--- a/dns/rdtypes/ANY/ISDN.py
+++ b/dns/rdtypes/ANY/ISDN.py
@@ -46,7 +46,7 @@ class ISDN(dns.rdata.Rdata):
 
     def to_text(self, origin=None, relativize=True, **kw):
         if self.subaddress:
-            return '"%s" "%s"' % (dns.rdata._escapify(self.address),
+            return '"{}" "{}"'.format(dns.rdata._escapify(self.address),
                                   dns.rdata._escapify(self.subaddress))
         else:
             return '"%s"' % dns.rdata._escapify(self.address)
diff --git a/dns/rdtypes/ANY/LOC.py b/dns/rdtypes/ANY/LOC.py
index b433da9..cd5e3fb 100644
--- a/dns/rdtypes/ANY/LOC.py
+++ b/dns/rdtypes/ANY/LOC.py
@@ -156,7 +156,7 @@ class LOC(dns.rdata.Rdata):
         if self.size != _default_size or \
             self.horizontal_precision != _default_hprec or \
                 self.vertical_precision != _default_vprec:
-            text += " %0.2fm %0.2fm %0.2fm" % (
+            text += " {:0.2f}m {:0.2f}m {:0.2f}m".format(
                 self.size / 100.0, self.horizontal_precision / 100.0,
                 self.vertical_precision / 100.0
             )
diff --git a/dns/rdtypes/ANY/NSEC.py b/dns/rdtypes/ANY/NSEC.py
index dfe9685..470a49d 100644
--- a/dns/rdtypes/ANY/NSEC.py
+++ b/dns/rdtypes/ANY/NSEC.py
@@ -50,7 +50,7 @@ class NSEC(dns.rdata.Rdata):
                         bits.append(dns.rdatatype.to_text(window * 256 +
                                                           i * 8 + j))
             text += (' ' + ' '.join(bits))
-        return '%s%s' % (next, text)
+        return '{}{}'.format(next, text)
 
     @classmethod
     def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
diff --git a/dns/rdtypes/ANY/RP.py b/dns/rdtypes/ANY/RP.py
index e9071c7..5b701d9 100644
--- a/dns/rdtypes/ANY/RP.py
+++ b/dns/rdtypes/ANY/RP.py
@@ -39,7 +39,7 @@ class RP(dns.rdata.Rdata):
     def to_text(self, origin=None, relativize=True, **kw):
         mbox = self.mbox.choose_relativity(origin, relativize)
         txt = self.txt.choose_relativity(origin, relativize)
-        return "%s %s" % (str(mbox), str(txt))
+        return "{} {}".format(str(mbox), str(txt))
 
     @classmethod
     def from_text(cls, rdclass, rdtype, tok, origin=None, relativize=True):
diff --git a/dns/rdtypes/dnskeybase.py b/dns/rdtypes/dnskeybase.py
index 85c4b23..4f730ce 100644
--- a/dns/rdtypes/dnskeybase.py
+++ b/dns/rdtypes/dnskeybase.py
@@ -38,7 +38,7 @@ _flag_by_text = {
 # We construct the inverse mapping programmatically to ensure that we
 # cannot make any mistakes (e.g. omissions, cut-and-paste errors) that
 # would cause the mapping not to be true inverse.
-_flag_by_value = dict((y, x) for x, y in _flag_by_text.items())
+_flag_by_value = {y: x for x, y in _flag_by_text.items()}
 
 
 def flags_to_text_set(flags):
diff --git a/dns/rdtypes/txtbase.py b/dns/rdtypes/txtbase.py
index aa341f1..bb77609 100644
--- a/dns/rdtypes/txtbase.py
+++ b/dns/rdtypes/txtbase.py
@@ -48,7 +48,7 @@ class TXTBase(dns.rdata.Rdata):
         txt = ''
         prefix = ''
         for s in self.strings:
-            txt += '%s"%s"' % (prefix, dns.rdata._escapify(s))
+            txt += '{}"{}"'.format(prefix, dns.rdata._escapify(s))
             prefix = ' '
         return txt
 
diff --git a/dns/resolver.py b/dns/resolver.py
index b44431c..b794d31 100644
--- a/dns/resolver.py
+++ b/dns/resolver.py
@@ -47,7 +47,7 @@ if sys.platform == 'win32':
 
 class NXDOMAIN(dns.exception.DNSException):
     """The DNS query name does not exist."""
-    supp_kwargs = set(['qnames', 'responses'])
+    supp_kwargs = {'qnames', 'responses'}
     fmt = None  # we have our own __str__ implementation
 
     def _check_kwargs(self, qnames, responses=None):
@@ -71,7 +71,7 @@ class NXDOMAIN(dns.exception.DNSException):
         else:
             msg = 'The DNS query name does not exist'
         qnames = ', '.join(map(str, qnames))
-        return "%s: %s" % (msg, qnames)
+        return "{}: {}".format(msg, qnames)
 
     def canonical_name(self):
         if not 'qnames' in self.kwargs:
@@ -140,7 +140,7 @@ class NoAnswer(dns.exception.DNSException):
     """The DNS response does not contain an answer to the question."""
     fmt = 'The DNS response does not contain an answer ' + \
           'to the question: {query}'
-    supp_kwargs = set(['response'])
+    supp_kwargs = {'response'}
 
     def _fmt_kwargs(self, **kwargs):
         return super(NoAnswer, self)._fmt_kwargs(
@@ -158,12 +158,12 @@ class NoNameservers(dns.exception.DNSException):
 
     msg = "All nameservers failed to answer the query."
     fmt = "%s {query}: {errors}" % msg[:-1]
-    supp_kwargs = set(['request', 'errors'])
+    supp_kwargs = {'request', 'errors'}
 
     def _fmt_kwargs(self, **kwargs):
         srv_msgs = []
         for err in kwargs['errors']:
-            srv_msgs.append('Server %s %s port %s answered %s' % (err[0],
+            srv_msgs.append('Server {} {} port {} answered {}'.format(err[0],
                             'TCP' if err[1] else 'UDP', err[2], err[3]))
         return super(NoNameservers, self)._fmt_kwargs(
             query=kwargs['request'].question, errors='; '.join(srv_msgs))
diff --git a/dns/zone.py b/dns/zone.py
index 2c7ea69..65a1ea1 100644
--- a/dns/zone.py
+++ b/dns/zone.py
@@ -715,7 +715,7 @@ class _MasterReader(object):
             # helpful filename:line info.
             (ty, va) = sys.exc_info()[:2]
             raise dns.exception.SyntaxError(
-                "caught exception %s: %s" % (str(ty), str(va)))
+                "caught exception {}: {}".format(str(ty), str(va)))
 
         if not self.default_ttl_known and isinstance(rd, dns.rdtypes.ANY.SOA.SOA):
             # The pre-RFC2308 and pre-BIND9 behavior inherits the zone default