Remove redundant 'pass' from class definitions.

26 files changed, 0 insertions, 58 deletions

diff --git a/dns/dnssec.py b/dns/dnssec.py
index 52f9ba6..8510832 100644
--- a/dns/dnssec.py
+++ b/dns/dnssec.py
@@ -30,11 +30,9 @@ import dns.rdataclass
 
 class UnsupportedAlgorithm(dns.exception.DNSException):
     """The DNSSEC algorithm is not supported."""
-    pass
 
 class ValidationFailure(dns.exception.DNSException):
     """The DNSSEC signature is invalid."""
-    pass
 
 RSAMD5 = 1
 DH = 2
diff --git a/dns/exception.py b/dns/exception.py
index e07b099..60b4912 100644
--- a/dns/exception.py
+++ b/dns/exception.py
@@ -26,20 +26,15 @@ class DNSException(Exception):
 
 class FormError(DNSException):
     """DNS message is malformed."""
-    pass
 
 class SyntaxError(DNSException):
     """Text input is malformed."""
-    pass
 
 class UnexpectedEnd(SyntaxError):
     """Text input ended unexpectedly."""
-    pass
 
 class TooBig(DNSException):
     """The DNS message is too big."""
-    pass
 
 class Timeout(DNSException):
     """The DNS operation timed out."""
-    pass
diff --git a/dns/message.py b/dns/message.py
index d672a3a..c1a853c 100644
--- a/dns/message.py
+++ b/dns/message.py
@@ -38,30 +38,24 @@ import dns.wiredata
 
 class ShortHeader(dns.exception.FormError):
     """The DNS packet passed to from_wire() is too short."""
-    pass
 
 class TrailingJunk(dns.exception.FormError):
     """The DNS packet passed to from_wire() has extra junk at the end of it."""
-    pass
 
 class UnknownHeaderField(dns.exception.DNSException):
     """The header field name was not recognized when converting from text
     into a message."""
-    pass
 
 class BadEDNS(dns.exception.FormError):
     """OPT record occured somewhere other than the start of
     the additional data section."""
-    pass
 
 class BadTSIG(dns.exception.FormError):
     """A TSIG record occured somewhere other than the end of
     the additional data section."""
-    pass
 
 class UnknownTSIGKey(dns.exception.DNSException):
     """A TSIG with an unknown key was received."""
-    pass
 
 class Message(object):
     """A DNS message.
diff --git a/dns/name.py b/dns/name.py
index 8ffa674..44af098 100644
--- a/dns/name.py
+++ b/dns/name.py
@@ -39,42 +39,33 @@ NAMERELN_COMMONANCESTOR = 4
 
 class EmptyLabel(dns.exception.SyntaxError):
     """A DNS label is empty."""
-    pass
 
 class BadEscape(dns.exception.SyntaxError):
     """An escaped code in a text format of DNS name is invalid."""
-    pass
 
 class BadPointer(dns.exception.FormError):
     """A DNS compression pointer points forward instead of backward."""
-    pass
 
 class BadLabelType(dns.exception.FormError):
     """The label type in DNS name wire format is unknown."""
-    pass
 
 class NeedAbsoluteNameOrOrigin(dns.exception.DNSException):
     """An attempt was made to convert a non-absolute name to
     wire when there was also a non-absolute (or missing) origin."""
-    pass
 
 class NameTooLong(dns.exception.FormError):
     """A DNS name is > 255 octets long."""
-    pass
 
 class LabelTooLong(dns.exception.SyntaxError):
     """A DNS label is > 63 octets long."""
-    pass
 
 class AbsoluteConcatenation(dns.exception.DNSException):
     """An attempt was made to append anything other than the
     empty name to an absolute DNS name."""
-    pass
 
 class NoParent(dns.exception.DNSException):
     """An attempt was made to get the parent of the root name
     or the empty name."""
-    pass
 
 class LabelMixesUnicodeAndASCII(dns.exception.SyntaxError):
     """Raised if a label mixes Unicode characters and ASCII escapes."""
diff --git a/dns/opcode.py b/dns/opcode.py
index 52e0ce6..7874d79 100644
--- a/dns/opcode.py
+++ b/dns/opcode.py
@@ -40,7 +40,6 @@ _by_value = dict([(y, x) for x, y in _by_text.items()])
 
 class UnknownOpcode(dns.exception.DNSException):
     """An DNS opcode is unknown."""
-    pass
 
 def from_text(text):
     """Convert text into an opcode.
diff --git a/dns/query.py b/dns/query.py
index 8b0a227..c416615 100644
--- a/dns/query.py
+++ b/dns/query.py
@@ -33,11 +33,9 @@ import dns.rdatatype
 
 class UnexpectedSource(dns.exception.DNSException):
     """A DNS query response came from an unexpected address or port."""
-    pass
 
 class BadResponse(dns.exception.FormError):
     """A DNS query response does not respond to the question asked."""
-    pass
 
 def _compute_expiration(timeout):
     if timeout is None:
diff --git a/dns/rcode.py b/dns/rcode.py
index 8b9f8bd..d8b32cf 100644
--- a/dns/rcode.py
+++ b/dns/rcode.py
@@ -54,7 +54,6 @@ _by_value = dict([(y, x) for x, y in _by_text.items()])
 
 class UnknownRcode(dns.exception.DNSException):
     """A DNS rcode is unknown."""
-    pass
 
 def from_text(text):
     """Convert text into an rcode.
diff --git a/dns/rdataclass.py b/dns/rdataclass.py
index c5845a0..e197a81 100644
--- a/dns/rdataclass.py
+++ b/dns/rdataclass.py
@@ -64,7 +64,6 @@ _unknown_class_pattern = re.compile('CLASS([0-9]+)$', re.I);
 
 class UnknownRdataclass(dns.exception.DNSException):
     """A DNS class is unknown."""
-    pass
 
 def from_text(text):
     """Convert text into a DNS rdata class value.
diff --git a/dns/rdataset.py b/dns/rdataset.py
index 7a9cc37..8d112e7 100644
--- a/dns/rdataset.py
+++ b/dns/rdataset.py
@@ -31,11 +31,9 @@ SimpleSet = dns.set.Set
 class DifferingCovers(dns.exception.DNSException):
     """An attempt was made to add a DNS SIG/RRSIG whose covered type
     is not the same as that of the other rdatas in the rdataset."""
-    pass
 
 class IncompatibleTypes(dns.exception.DNSException):
     """An attempt was made to add DNS RR data of an incompatible type."""
-    pass
 
 class Rdataset(dns.set.Set):
     """A DNS rdataset.
diff --git a/dns/rdatatype.py b/dns/rdatatype.py
index f2f5e98..ae6b6ec 100644
--- a/dns/rdatatype.py
+++ b/dns/rdatatype.py
@@ -173,7 +173,6 @@ _unknown_type_pattern = re.compile('TYPE([0-9]+)$', re.I);
 
 class UnknownRdatatype(dns.exception.DNSException):
     """DNS resource record type is unknown."""
-    pass
 
 def from_text(text):
     """Convert text into a DNS rdata type value.
diff --git a/dns/rdtypes/ANY/CNAME.py b/dns/rdtypes/ANY/CNAME.py
index fb8e9be..6c6ab35 100644
--- a/dns/rdtypes/ANY/CNAME.py
+++ b/dns/rdtypes/ANY/CNAME.py
@@ -21,4 +21,3 @@ class CNAME(dns.rdtypes.nsbase.NSBase):
     Note: although CNAME is officially a singleton type, dnspython allows
     non-singleton CNAME rdatasets because such sets have been commonly
     used by BIND and other nameservers for load balancing."""
-    pass
diff --git a/dns/rdtypes/ANY/DLV.py b/dns/rdtypes/ANY/DLV.py
index 8bd7979..2a360b9 100644
--- a/dns/rdtypes/ANY/DLV.py
+++ b/dns/rdtypes/ANY/DLV.py
@@ -17,4 +17,3 @@ import dns.rdtypes.dsbase
 
 class DLV(dns.rdtypes.dsbase.DSBase):
     """DLV record"""
-    pass
diff --git a/dns/rdtypes/ANY/DS.py b/dns/rdtypes/ANY/DS.py
index 56b6332..6c669cc 100644
--- a/dns/rdtypes/ANY/DS.py
+++ b/dns/rdtypes/ANY/DS.py
@@ -17,4 +17,3 @@ import dns.rdtypes.dsbase
 
 class DS(dns.rdtypes.dsbase.DSBase):
     """DS record"""
-    pass
diff --git a/dns/rdtypes/ANY/MX.py b/dns/rdtypes/ANY/MX.py
index 92f4153..c407c11 100644
--- a/dns/rdtypes/ANY/MX.py
+++ b/dns/rdtypes/ANY/MX.py
@@ -17,4 +17,3 @@ import dns.rdtypes.mxbase
 
 class MX(dns.rdtypes.mxbase.MXBase):
     """MX record"""
-    pass
diff --git a/dns/rdtypes/ANY/NS.py b/dns/rdtypes/ANY/NS.py
index 6b45d4d..c3d0234 100644
--- a/dns/rdtypes/ANY/NS.py
+++ b/dns/rdtypes/ANY/NS.py
@@ -17,4 +17,3 @@ import dns.rdtypes.nsbase
 
 class NS(dns.rdtypes.nsbase.NSBase):
     """NS record"""
-    pass
diff --git a/dns/rdtypes/ANY/PTR.py b/dns/rdtypes/ANY/PTR.py
index 4a03753..963de63 100644
--- a/dns/rdtypes/ANY/PTR.py
+++ b/dns/rdtypes/ANY/PTR.py
@@ -17,4 +17,3 @@ import dns.rdtypes.nsbase
 
 class PTR(dns.rdtypes.nsbase.NSBase):
     """PTR record"""
-    pass
diff --git a/dns/rdtypes/ANY/RRSIG.py b/dns/rdtypes/ANY/RRSIG.py
index e9b625b..a55ef20 100644
--- a/dns/rdtypes/ANY/RRSIG.py
+++ b/dns/rdtypes/ANY/RRSIG.py
@@ -26,7 +26,6 @@ import dns.util
 
 class BadSigTime(dns.exception.DNSException):
     """Time in DNS SIG or RRSIG resource record cannot be parsed."""
-    pass
 
 def sigtime_to_posixtime(what):
     if len(what) != 14:
diff --git a/dns/rdtypes/ANY/RT.py b/dns/rdtypes/ANY/RT.py
index f9653fd..5ba9417 100644
--- a/dns/rdtypes/ANY/RT.py
+++ b/dns/rdtypes/ANY/RT.py
@@ -17,4 +17,3 @@ import dns.rdtypes.mxbase
 
 class RT(dns.rdtypes.mxbase.UncompressedDowncasingMX):
     """RT record"""
-    pass
diff --git a/dns/rdtypes/ANY/SPF.py b/dns/rdtypes/ANY/SPF.py
index 8860dd7..1df9580 100644
--- a/dns/rdtypes/ANY/SPF.py
+++ b/dns/rdtypes/ANY/SPF.py
@@ -19,4 +19,3 @@ class SPF(dns.rdtypes.txtbase.TXTBase):
     """SPF record
 
     @see: RFC 4408"""
-    pass
diff --git a/dns/rdtypes/ANY/TXT.py b/dns/rdtypes/ANY/TXT.py
index 604fd0f..f921b36 100644
--- a/dns/rdtypes/ANY/TXT.py
+++ b/dns/rdtypes/ANY/TXT.py
@@ -17,4 +17,3 @@ import dns.rdtypes.txtbase
 
 class TXT(dns.rdtypes.txtbase.TXTBase):
     """TXT record"""
-    pass
diff --git a/dns/rdtypes/IN/KX.py b/dns/rdtypes/IN/KX.py
index c7bd5bb..a01bddd 100644
--- a/dns/rdtypes/IN/KX.py
+++ b/dns/rdtypes/IN/KX.py
@@ -17,4 +17,3 @@ import dns.rdtypes.mxbase
 
 class KX(dns.rdtypes.mxbase.UncompressedMX):
     """KX record"""
-    pass
diff --git a/dns/rdtypes/IN/NSAP_PTR.py b/dns/rdtypes/IN/NSAP_PTR.py
index df5b989..122c512 100644
--- a/dns/rdtypes/IN/NSAP_PTR.py
+++ b/dns/rdtypes/IN/NSAP_PTR.py
@@ -17,4 +17,3 @@ import dns.rdtypes.nsbase
 
 class NSAP_PTR(dns.rdtypes.nsbase.UncompressedNS):
     """NSAP-PTR record"""
-    pass
diff --git a/dns/resolver.py b/dns/resolver.py
index 788b7c5..387bd50 100644
--- a/dns/resolver.py
+++ b/dns/resolver.py
@@ -48,11 +48,9 @@ if sys.platform == 'win32':
 
 class NXDOMAIN(dns.exception.DNSException):
     """The DNS query name does not exist."""
-    pass
 
 class YXDOMAIN(dns.exception.DNSException):
     """The DNS query name is too long after DNAME substitution."""
-    pass
 
 # The definition of the Timeout exception has moved from here to the
 # dns.exception module.  We keep dns.resolver.Timeout defined for
@@ -97,11 +95,9 @@ class NoNameservers(dns.exception.DNSException):
 
 class NotAbsolute(dns.exception.DNSException):
     """An absolute domain name is required but a relative name was provided."""
-    pass
 
 class NoRootSOA(dns.exception.DNSException):
     """There is no SOA RR at the DNS root name. This should never happen!"""
-    pass
 
 class NoMetaqueries(dns.exception.DNSException):
     """DNS metaqueries are not allowed."""
diff --git a/dns/tokenizer.py b/dns/tokenizer.py
index c214510..e042f67 100644
--- a/dns/tokenizer.py
+++ b/dns/tokenizer.py
@@ -35,7 +35,6 @@ DELIMITER = 6
 
 class UngetBufferFull(dns.exception.DNSException):
     """An attempt was made to unget a token when the unget buffer was full."""
-    pass
 
 class Token(object):
     """A DNS master file format token.
diff --git a/dns/tsig.py b/dns/tsig.py
index 3de11c9..478f3e4 100644
--- a/dns/tsig.py
+++ b/dns/tsig.py
@@ -27,31 +27,24 @@ import dns.name
 
 class BadTime(dns.exception.DNSException):
     """The current time is not within the TSIG's validity time."""
-    pass
 
 class BadSignature(dns.exception.DNSException):
     """The TSIG signature fails to verify."""
-    pass
 
 class PeerError(dns.exception.DNSException):
     """Base class for all TSIG errors generated by the remote peer"""
-    pass
 
 class PeerBadKey(PeerError):
     """The peer didn't know the key we used"""
-    pass
 
 class PeerBadSignature(PeerError):
     """The peer didn't like the signature we sent"""
-    pass
 
 class PeerBadTime(PeerError):
     """The peer didn't like the time we sent"""
-    pass
 
 class PeerBadTruncation(PeerError):
     """The peer didn't like amount of truncation in the TSIG we sent"""
-    pass
 
 # TSIG Algorithms
 
diff --git a/dns/zone.py b/dns/zone.py
index b127764..ce88510 100644
--- a/dns/zone.py
+++ b/dns/zone.py
@@ -35,19 +35,15 @@ import dns.grange
 
 class BadZone(dns.exception.DNSException):
     """The DNS zone is malformed."""
-    pass
 
 class NoSOA(BadZone):
     """The DNS zone has no SOA RR at its origin."""
-    pass
 
 class NoNS(BadZone):
     """The DNS zone has no NS RRset at its origin."""
-    pass
 
 class UnknownOrigin(BadZone):
     """The DNS zone's origin is unknown."""
-    pass
 
 class Zone(object):
     """A DNS zone.