Pylint: remove unused variables

This commit removes some unused variables (except those in iterations, list comprehensions and used for unpacking)

diff --git a/dns/rdtypes/ANY/LOC.py b/dns/rdtypes/ANY/LOC.py
index f2544c33b6d5a05b3e408825ac1e986f22cd3e68..b433da9487f2209de7a47713de764321e5ed8cfb 100644 (file)
--- a/dns/rdtypes/ANY/LOC.py
+++ b/dns/rdtypes/ANY/LOC.py
@@ -138,16 +138,12 @@ class LOC(dns.rdata.Rdata):
     def to_text(self, origin=None, relativize=True, **kw):
         if self.latitude[4] > 0:
             lat_hemisphere = 'N'
-            lat_degrees = self.latitude[0]
         else:
             lat_hemisphere = 'S'
-            lat_degrees = -1 * self.latitude[0]
         if self.longitude[4] > 0:
             long_hemisphere = 'E'
-            long_degrees = self.longitude[0]
         else:
             long_hemisphere = 'W'
-            long_degrees = -1 * self.longitude[0]
         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,

diff --git a/tests/test_bugs.py b/tests/test_bugs.py
index 30f1dae019d21a97abf8afb70d6130c3d6546aee..d26d85b371492065973bb337abff7ccea8a09a23 100644 (file)
--- a/tests/test_bugs.py
+++ b/tests/test_bugs.py
@@ -41,7 +41,7 @@ class BugsTestCase(unittest.TestCase):
 
     def test_TTL_bounds_check(self):
         def bad():
-            ttl = dns.ttl.from_text("2147483648")
+            dns.ttl.from_text("2147483648")
         self.failUnlessRaises(dns.ttl.BadTTL, bad)
 
     def test_empty_NSEC3_window(self):

diff --git a/tests/test_generate.py b/tests/test_generate.py
index cbd22543976bb39f85c356e271c2c4385becd2a1..1dd29cdda88251a7c16cfb097bf054ac5df105d7 100644 (file)
--- a/tests/test_generate.py
+++ b/tests/test_generate.py
@@ -142,12 +142,12 @@ class GenerateTestCase(unittest.TestCase):
 
     def testFromText(self):
         def bad():
-            z = dns.zone.from_text(example_text, 'example.', relativize=True)
+            dns.zone.from_text(example_text, 'example.', relativize=True)
         self.failUnlessRaises(dns.zone.NoSOA, bad)
 
     def testFromText1(self):
         def bad():
-            z = dns.zone.from_text(example_text1, 'example.', relativize=True)
+            dns.zone.from_text(example_text1, 'example.', relativize=True)
         self.failUnlessRaises(dns.zone.NoSOA, bad)
 
     def testIterateAllRdatas2(self):

diff --git a/tests/test_message.py b/tests/test_message.py
index 780f3e98c804b56d33eb08ffe01f6cd1a182540e..2ae6800d2be7ced8019cf054f890ed02c7985e97 100644 (file)
--- a/tests/test_message.py
+++ b/tests/test_message.py
@@ -140,7 +140,7 @@ class MessageTestCase(unittest.TestCase):
                                             dns.rdatatype.A,
                                             '10.0.0.%d' % i)
                 q.additional.append(rrset)
-            w = q.to_wire(max_size=512)
+            q.to_wire(max_size=512)
         self.failUnlessRaises(dns.exception.TooBig, bad)
 
     def test_answer1(self):
@@ -151,20 +151,20 @@ class MessageTestCase(unittest.TestCase):
     def test_TrailingJunk(self):
         def bad():
             badwire = goodwire + b'\x00'
-            m = dns.message.from_wire(badwire)
+            dns.message.from_wire(badwire)
         self.failUnlessRaises(dns.message.TrailingJunk, bad)
 
     def test_ShortHeader(self):
         def bad():
             badwire = b'\x00' * 11
-            m = dns.message.from_wire(badwire)
+            dns.message.from_wire(badwire)
         self.failUnlessRaises(dns.message.ShortHeader, bad)
 
     def test_RespondingToResponse(self):
         def bad():
             q = dns.message.make_query('foo', 'A')
             r1 = dns.message.make_response(q)
-            r2 = dns.message.make_response(r1)
+            dns.message.make_response(r1)
         self.failUnlessRaises(dns.exception.FormError, bad)
 
     def test_ExtendedRcodeSetting(self):

diff --git a/tests/test_name.py b/tests/test_name.py
index bf7b297c51ee756108a19ef68d03525f3f029325..70ec1228c75de719163c1b1ffc7b04298bc1e9e5 100644 (file)
--- a/tests/test_name.py
+++ b/tests/test_name.py
@@ -85,13 +85,13 @@ class NameTestCase(unittest.TestCase):
             ]
         for t in good:
             try:
-                n = dns.name.from_text(t)
+                dns.name.from_text(t)
             except Exception:
                 self.fail("good test '%s' raised an exception" % t)
         for t in bad:
             caught = False
             try:
-                n = dns.name.from_text(t)
+                dns.name.from_text(t)
             except Exception:
                 caught = True
             if not caught:
@@ -271,12 +271,12 @@ class NameTestCase(unittest.TestCase):
 
     def testEmptyLabel1(self):
         def bad():
-            n = dns.name.Name(['a', '', 'b'])
+            dns.name.Name(['a', '', 'b'])
         self.failUnlessRaises(dns.name.EmptyLabel, bad)
 
     def testEmptyLabel2(self):
         def bad():
-            n = dns.name.Name(['', 'b'])
+            dns.name.Name(['', 'b'])
         self.failUnlessRaises(dns.name.EmptyLabel, bad)
 
     def testEmptyLabel3(self):
@@ -289,7 +289,7 @@ class NameTestCase(unittest.TestCase):
 
     def testLabelTooLong(self):
         def bad():
-            n = dns.name.Name(['a' * 64, 'b'])
+            dns.name.Name(['a' * 64, 'b'])
         self.failUnlessRaises(dns.name.LabelTooLong, bad)
 
     def testLongName(self):
@@ -298,7 +298,7 @@ class NameTestCase(unittest.TestCase):
 
     def testNameTooLong(self):
         def bad():
-            n = dns.name.Name(['a' * 63, 'a' * 63, 'a' * 63, 'a' * 63])
+            dns.name.Name(['a' * 63, 'a' * 63, 'a' * 63, 'a' * 63])
         self.failUnlessRaises(dns.name.NameTooLong, bad)
 
     def testConcat1(self):
@@ -340,7 +340,7 @@ class NameTestCase(unittest.TestCase):
         def bad():
             n1 = dns.name.Name(['a', 'b', ''])
             n2 = dns.name.Name(['c'])
-            r = n1 + n2
+            return n1 + n2
         self.failUnlessRaises(dns.name.AbsoluteConcatenation, bad)
 
     def testBadEscape(self):
@@ -373,7 +373,7 @@ class NameTestCase(unittest.TestCase):
     def testBadDigestable(self):
         def bad():
             n = dns.name.from_text('FOO.bar', None)
-            d = n.to_digestable()
+            n.to_digestable()
         self.failUnlessRaises(dns.name.NeedAbsoluteNameOrOrigin, bad)
 
     def testToWire1(self):
@@ -463,13 +463,13 @@ class NameTestCase(unittest.TestCase):
     def testBadSplit1(self):
         def bad():
             n = dns.name.from_text('foo.bar.')
-            (prefix, suffix) = n.split(-1)
+            n.split(-1)
         self.failUnlessRaises(ValueError, bad)
 
     def testBadSplit2(self):
         def bad():
             n = dns.name.from_text('foo.bar.')
-            (prefix, suffix) = n.split(4)
+            n.split(4)
         self.failUnlessRaises(ValueError, bad)
 
     def testRelativize1(self):
@@ -588,25 +588,25 @@ class NameTestCase(unittest.TestCase):
     def testBadFromWire1(self):
         def bad():
             w = b'\x03foo\xc0\x04'
-            (n, cused) = dns.name.from_wire(w, 0)
+            dns.name.from_wire(w, 0)
         self.failUnlessRaises(dns.name.BadPointer, bad)
 
     def testBadFromWire2(self):
         def bad():
             w = b'\x03foo\xc0\x05'
-            (n, cused) = dns.name.from_wire(w, 0)
+            dns.name.from_wire(w, 0)
         self.failUnlessRaises(dns.name.BadPointer, bad)
 
     def testBadFromWire3(self):
         def bad():
             w = b'\xbffoo'
-            (n, cused) = dns.name.from_wire(w, 0)
+            dns.name.from_wire(w, 0)
         self.failUnlessRaises(dns.name.BadLabelType, bad)
 
     def testBadFromWire4(self):
         def bad():
             w = b'\x41foo'
-            (n, cused) = dns.name.from_wire(w, 0)
+            dns.name.from_wire(w, 0)
         self.failUnlessRaises(dns.name.BadLabelType, bad)
 
     def testParent1(self):
@@ -683,12 +683,12 @@ class NameTestCase(unittest.TestCase):
 
     def testBadReverseIPv4(self):
         def bad():
-            n = dns.reversename.from_address('127.0.foo.1')
+            dns.reversename.from_address('127.0.foo.1')
         self.failUnlessRaises(dns.exception.SyntaxError, bad)
 
     def testBadReverseIPv6(self):
         def bad():
-            n = dns.reversename.from_address('::1::1')
+            dns.reversename.from_address('::1::1')
         self.failUnlessRaises(dns.exception.SyntaxError, bad)
 
     def testForwardIPv4(self):

diff --git a/tests/test_namedict.py b/tests/test_namedict.py
index d17d11d9aeba688beec94c7060be9e25e3b85606..35f0b78e164bfbae30c9d810c3dcd79b39623564 100644 (file)
--- a/tests/test_namedict.py
+++ b/tests/test_namedict.py
@@ -57,18 +57,18 @@ class NameTestCase(unittest.TestCase):
     def testLookup5(self):
         def bad():
             n = dns.name.from_text('a.b.c.')
-            (k, v) = self.ndict.get_deepest_match(n)
+            self.ndict.get_deepest_match(n)
         self.failUnlessRaises(KeyError, bad)
 
     def testLookup6(self):
         def bad():
-            (k, v) = self.ndict.get_deepest_match(dns.name.empty)
+            self.ndict.get_deepest_match(dns.name.empty)
         self.failUnlessRaises(KeyError, bad)
 
     def testLookup7(self):
         self.ndict[dns.name.empty] = 100
         n = dns.name.from_text('a.b.c.')
-        (k, v) = self.ndict.get_deepest_match(n)
+        v = self.ndict.get_deepest_match(n)[1]
         self.failUnless(v == 100)
 
     def testLookup8(self):
@@ -98,7 +98,7 @@ class NameTestCase(unittest.TestCase):
     def testRelLookup7(self):
         self.rndict[dns.name.empty] = 100
         n = dns.name.from_text('a.b.c', None)
-        (k, v) = self.rndict.get_deepest_match(n)
+        v = self.rndict.get_deepest_match(n)[1]
         self.failUnless(v == 100)
 
 if __name__ == '__main__':

diff --git a/tests/test_ntoaaton.py b/tests/test_ntoaaton.py
index 2a47ceb386216c69fbe1a901c56e091954696768..d6e8bedfce9de0b62ffc9528ea4cf4e3886f51d3 100644 (file)
--- a/tests/test_ntoaaton.py
+++ b/tests/test_ntoaaton.py
@@ -60,17 +60,17 @@ class NtoAAtoNTestCase(unittest.TestCase):
 
     def test_bad_aton1(self):
         def bad():
-            a = aton6('abcd:dcba')
+            aton6('abcd:dcba')
         self.failUnlessRaises(dns.exception.SyntaxError, bad)
 
     def test_bad_aton2(self):
         def bad():
-            a = aton6('abcd::dcba::1')
+            aton6('abcd::dcba::1')
         self.failUnlessRaises(dns.exception.SyntaxError, bad)
 
     def test_bad_aton3(self):
         def bad():
-            a = aton6('1:2:3:4:5:6:7:8:9')
+            aton6('1:2:3:4:5:6:7:8:9')
         self.failUnlessRaises(dns.exception.SyntaxError, bad)
 
     def test_aton6(self):
@@ -161,12 +161,12 @@ class NtoAAtoNTestCase(unittest.TestCase):
 
     def test_bad_ntoa1(self):
         def bad():
-            a = ntoa6('')
+            ntoa6('')
         self.failUnlessRaises(ValueError, bad)
 
     def test_bad_ntoa2(self):
         def bad():
-            a = ntoa6('\x00' * 17)
+            ntoa6('\x00' * 17)
         self.failUnlessRaises(ValueError, bad)
 
     def test_good_v4_aton(self):

diff --git a/tests/test_rdtypeandclass.py b/tests/test_rdtypeandclass.py
index 733eda563b5704b93f63db641e98f688ead07a05..1a1f04083bc75318208947b6346627ae65ce29fd 100644 (file)
--- a/tests/test_rdtypeandclass.py
+++ b/tests/test_rdtypeandclass.py
@@ -44,12 +44,12 @@ class RdTypeAndClassTestCase(unittest.TestCase):
 
     def test_class_bytext_bounds2(self):
         def bad():
-            junk = dns.rdataclass.from_text('CLASS65536')
+            dns.rdataclass.from_text('CLASS65536')
         self.failUnlessRaises(ValueError, bad)
 
     def test_class_bytext_unknown(self):
         def bad():
-            junk = dns.rdataclass.from_text('XXX')
+            dns.rdataclass.from_text('XXX')
         self.failUnlessRaises(dns.rdataclass.UnknownRdataclass, bad)
 
     def test_class_totext1(self):
@@ -60,12 +60,12 @@ class RdTypeAndClassTestCase(unittest.TestCase):
 
     def test_class_totext_bounds1(self):
         def bad():
-            junk = dns.rdataclass.to_text(-1)
+            dns.rdataclass.to_text(-1)
         self.failUnlessRaises(ValueError, bad)
 
     def test_class_totext_bounds2(self):
         def bad():
-            junk = dns.rdataclass.to_text(65536)
+            dns.rdataclass.to_text(65536)
         self.failUnlessRaises(ValueError, bad)
 
     # Types
@@ -98,12 +98,12 @@ class RdTypeAndClassTestCase(unittest.TestCase):
 
     def test_type_bytext_bounds2(self):
         def bad():
-            junk = dns.rdatatype.from_text('TYPE65536')
+            dns.rdatatype.from_text('TYPE65536')
         self.failUnlessRaises(ValueError, bad)
 
     def test_type_bytext_unknown(self):
         def bad():
-            junk = dns.rdatatype.from_text('XXX')
+            dns.rdatatype.from_text('XXX')
         self.failUnlessRaises(dns.rdatatype.UnknownRdatatype, bad)
 
     def test_type_totext1(self):
@@ -114,12 +114,12 @@ class RdTypeAndClassTestCase(unittest.TestCase):
 
     def test_type_totext_bounds1(self):
         def bad():
-            junk = dns.rdatatype.to_text(-1)
+            dns.rdatatype.to_text(-1)
         self.failUnlessRaises(ValueError, bad)
 
     def test_type_totext_bounds2(self):
         def bad():
-            junk = dns.rdatatype.to_text(65536)
+            dns.rdatatype.to_text(65536)
         self.failUnlessRaises(ValueError, bad)
 
 if __name__ == '__main__':

diff --git a/tests/test_resolver.py b/tests/test_resolver.py
index bf4677545fbca18ebc3dc4d646b36ffbe888c53b..4bc9feabd866788a6d2897ff18aa4aea86d0c37d 100644 (file)
--- a/tests/test_resolver.py
+++ b/tests/test_resolver.py
@@ -158,7 +158,7 @@ class BaseResolverTests(unittest.TestCase):
     def testZoneForName4(self):
         def bad():
             name = dns.name.from_text('dnspython.org', None)
-            zname = dns.resolver.zone_for_name(name)
+            dns.resolver.zone_for_name(name)
         self.failUnlessRaises(dns.resolver.NotAbsolute, bad)
 
     def testLRUReplace(self):
@@ -363,7 +363,6 @@ class NXDOMAINExceptionTestCase(unittest.TestCase):
         self.assertTrue(e.kwargs['responses'][n4].startswith('r1.'))
 
     def test_nxdomain_canonical_name(self):
-        cname0 = "91.11.8-22.17.172.in-addr.arpa.none."
         cname1 = "91.11.8-22.17.172.in-addr.arpa."
         cname2 = "91-11-17-172.dynamic.example."
         message0 = dns.message.from_text(dangling_cname_0_message_text)

diff --git a/tests/test_tokenizer.py b/tests/test_tokenizer.py
index bdb948f271c234b9e53a3145740fc7dc26b0154f..1b09ce2366a62f8b5638da2e7036257d361ead22 100644 (file)
--- a/tests/test_tokenizer.py
+++ b/tests/test_tokenizer.py
@@ -58,19 +58,19 @@ class TokenizerTestCase(unittest.TestCase):
     def testQuotedString5(self):
         def bad():
             tok = dns.tokenizer.Tokenizer(r'"foo')
-            token = tok.get()
+            tok.get()
         self.failUnlessRaises(dns.exception.UnexpectedEnd, bad)
 
     def testQuotedString6(self):
         def bad():
             tok = dns.tokenizer.Tokenizer(r'"foo\01')
-            token = tok.get()
+            tok.get()
         self.failUnlessRaises(dns.exception.SyntaxError, bad)
 
     def testQuotedString7(self):
         def bad():
             tok = dns.tokenizer.Tokenizer('"foo\nbar"')
-            token = tok.get()
+            tok.get()
         self.failUnlessRaises(dns.exception.SyntaxError, bad)
 
     def testEmpty1(self):
@@ -134,13 +134,13 @@ class TokenizerTestCase(unittest.TestCase):
     def testMultiline3(self):
         def bad():
             tok = dns.tokenizer.Tokenizer('foo)')
-            tokens = list(iter(tok))
+            list(iter(tok))
         self.failUnlessRaises(dns.exception.SyntaxError, bad)
 
     def testMultiline4(self):
         def bad():
             tok = dns.tokenizer.Tokenizer('((foo)')
-            tokens = list(iter(tok))
+            list(iter(tok))
         self.failUnlessRaises(dns.exception.SyntaxError, bad)
 
     def testUnget1(self):

diff --git a/tests/test_zone.py b/tests/test_zone.py
index 712b5903c1b5aa665d71ed19c53ac4fabad0b3a2..1934d84af961486dcd675e03c31a988148e4316b 100644 (file)
--- a/tests/test_zone.py
+++ b/tests/test_zone.py
@@ -166,7 +166,7 @@ class ZoneTestCase(unittest.TestCase):
         f = BytesIO()
         o = dns.name.from_text('example.')
         z = dns.zone.from_file(here('example'), o)
-        for (name, node) in z.items():
+        for node in z.values():
             for rds in node:
                 for rd in rds:
                     f.seek(0)
@@ -211,7 +211,7 @@ class ZoneTestCase(unittest.TestCase):
     def testFindRdataset2(self):
         def bad():
             z = dns.zone.from_text(example_text, 'example.', relativize=True)
-            rds = z.find_rdataset('@', 'loc')
+            z.find_rdataset('@', 'loc')
         self.failUnlessRaises(KeyError, bad)
 
     def testFindRRset1(self):
@@ -223,7 +223,7 @@ class ZoneTestCase(unittest.TestCase):
     def testFindRRset2(self):
         def bad():
             z = dns.zone.from_text(example_text, 'example.', relativize=True)
-            rrs = z.find_rrset('@', 'loc')
+            z.find_rrset('@', 'loc')
         self.failUnlessRaises(KeyError, bad)
 
     def testGetRdataset1(self):
@@ -285,7 +285,7 @@ class ZoneTestCase(unittest.TestCase):
         def bad():
             z = dns.zone.from_text(example_text, 'example.', relativize=True)
             node = z['@']
-            rds = node.find_rdataset(dns.rdataclass.IN, dns.rdatatype.LOC)
+            node.find_rdataset(dns.rdataclass.IN, dns.rdatatype.LOC)
         self.failUnlessRaises(KeyError, bad)
 
     def testNodeGetRdataset1(self):
@@ -304,14 +304,14 @@ class ZoneTestCase(unittest.TestCase):
     def testNodeDeleteRdataset1(self):
         z = dns.zone.from_text(example_text, 'example.', relativize=True)
         node = z['@']
-        rds = node.delete_rdataset(dns.rdataclass.IN, dns.rdatatype.SOA)
+        node.delete_rdataset(dns.rdataclass.IN, dns.rdatatype.SOA)
         rds = node.get_rdataset(dns.rdataclass.IN, dns.rdatatype.SOA)
         self.failUnless(rds is None)
 
     def testNodeDeleteRdataset2(self):
         z = dns.zone.from_text(example_text, 'example.', relativize=True)
         node = z['@']
-        rds = node.delete_rdataset(dns.rdataclass.IN, dns.rdatatype.LOC)
+        node.delete_rdataset(dns.rdataclass.IN, dns.rdatatype.LOC)
         rds = node.get_rdataset(dns.rdataclass.IN, dns.rdatatype.LOC)
         self.failUnless(rds is None)
 
@@ -391,14 +391,12 @@ class ZoneTestCase(unittest.TestCase):
 
     def testNoSOA(self):
         def bad():
-            z = dns.zone.from_text(no_soa_text, 'example.',
-                                   relativize=True)
+            dns.zone.from_text(no_soa_text, 'example.', relativize=True)
         self.failUnlessRaises(dns.zone.NoSOA, bad)
 
     def testNoNS(self):
         def bad():
-            z = dns.zone.from_text(no_ns_text, 'example.',
-                                   relativize=True)
+            dns.zone.from_text(no_ns_text, 'example.', relativize=True)
         self.failUnlessRaises(dns.zone.NoNS, bad)
 
     def testInclude(self):
@@ -409,8 +407,7 @@ class ZoneTestCase(unittest.TestCase):
 
     def testBadDirective(self):
         def bad():
-            z = dns.zone.from_text(bad_directive_text, 'example.',
-                                   relativize=True)
+            dns.zone.from_text(bad_directive_text, 'example.', relativize=True)
         self.failUnlessRaises(dns.exception.SyntaxError, bad)
 
     def testFirstRRStartsWithWhitespace(self):
@@ -427,14 +424,14 @@ class ZoneTestCase(unittest.TestCase):
         self.failUnless(z.origin == dns.name.from_text('example.'))
         def bad1():
             o = dns.name.from_text('example', None)
-            z = dns.zone.Zone(o)
+            dns.zone.Zone(o)
         self.failUnlessRaises(ValueError, bad1)
         def bad2():
-            z = dns.zone.Zone(1.0)
+            dns.zone.Zone(1.0)
         self.failUnlessRaises(ValueError, bad2)
 
     def testZoneOriginNone(self):
-        z = dns.zone.Zone(None)
+        dns.zone.Zone(None)
 
 if __name__ == '__main__':
     unittest.main()