black autoformatting

1 files changed, 68 insertions, 49 deletions

diff --git a/dns/node.py b/dns/node.py
index 5270b53..d870a29 100644
--- a/dns/node.py
+++ b/dns/node.py
@@ -37,26 +37,28 @@ _cname_types = {
 
 # "neutral" types can coexist with a CNAME and thus are not "other data"
 _neutral_types = {
-    dns.rdatatype.NSEC,   # RFC 4035 section 2.5
+    dns.rdatatype.NSEC,  # RFC 4035 section 2.5
     dns.rdatatype.NSEC3,  # This is not likely to happen, but not impossible!
-    dns.rdatatype.KEY,    # RFC 4035 section 2.5, RFC 3007
+    dns.rdatatype.KEY,  # RFC 4035 section 2.5, RFC 3007
 }
 
+
 def _matches_type_or_its_signature(rdtypes, rdtype, covers):
-    return rdtype in rdtypes or \
-           (rdtype == dns.rdatatype.RRSIG and covers in rdtypes)
+    return rdtype in rdtypes or (rdtype == dns.rdatatype.RRSIG and covers in rdtypes)
 
 
 @enum.unique
 class NodeKind(enum.Enum):
-    """Rdatasets in nodes
-    """
-    REGULAR = 0      # a.k.a "other data"
+    """Rdatasets in nodes"""
+
+    REGULAR = 0  # a.k.a "other data"
     NEUTRAL = 1
     CNAME = 2
 
     @classmethod
-    def classify(cls, rdtype: dns.rdatatype.RdataType, covers: dns.rdatatype.RdataType) -> 'NodeKind':
+    def classify(
+        cls, rdtype: dns.rdatatype.RdataType, covers: dns.rdatatype.RdataType
+    ) -> "NodeKind":
         if _matches_type_or_its_signature(_cname_types, rdtype, covers):
             return NodeKind.CNAME
         elif _matches_type_or_its_signature(_neutral_types, rdtype, covers):
@@ -65,7 +67,7 @@ class NodeKind(enum.Enum):
             return NodeKind.REGULAR
 
     @classmethod
-    def classify_rdataset(cls, rdataset: dns.rdataset.Rdataset) -> 'NodeKind':
+    def classify_rdataset(cls, rdataset: dns.rdataset.Rdataset) -> "NodeKind":
         return cls.classify(rdataset.rdtype, rdataset.covers)
 
 
@@ -86,7 +88,7 @@ class Node:
     deleted.
     """
 
-    __slots__ = ['rdatasets']
+    __slots__ = ["rdatasets"]
 
     def __init__(self):
         # the set of rdatasets, represented as a list.
@@ -109,11 +111,11 @@ class Node:
         for rds in self.rdatasets:
             if len(rds) > 0:
                 s.write(rds.to_text(name, **kw))  # type: ignore[arg-type]
-                s.write('\n')
+                s.write("\n")
         return s.getvalue()[:-1]
 
     def __repr__(self):
-        return '<DNS node ' + str(id(self)) + '>'
+        return "<DNS node " + str(id(self)) + ">"
 
     def __eq__(self, other):
         #
@@ -149,22 +151,28 @@ class Node:
         if len(self.rdatasets) > 0:
             kind = NodeKind.classify_rdataset(rdataset)
             if kind == NodeKind.CNAME:
-                self.rdatasets = [rds for rds in self.rdatasets if
-                                  NodeKind.classify_rdataset(rds) !=
-                                  NodeKind.REGULAR]
+                self.rdatasets = [
+                    rds
+                    for rds in self.rdatasets
+                    if NodeKind.classify_rdataset(rds) != NodeKind.REGULAR
+                ]
             elif kind == NodeKind.REGULAR:
-                self.rdatasets = [rds for rds in self.rdatasets if
-                                  NodeKind.classify_rdataset(rds) !=
-                                  NodeKind.CNAME]
+                self.rdatasets = [
+                    rds
+                    for rds in self.rdatasets
+                    if NodeKind.classify_rdataset(rds) != NodeKind.CNAME
+                ]
             # Otherwise the rdataset is NodeKind.NEUTRAL and we do not need to
             # edit self.rdatasets.
         self.rdatasets.append(rdataset)
 
-    def find_rdataset(self,
-                      rdclass: dns.rdataclass.RdataClass,
-                      rdtype: dns.rdatatype.RdataType,
-                      covers: dns.rdatatype.RdataType=dns.rdatatype.NONE,
-                      create: bool=False) -> dns.rdataset.Rdataset:
+    def find_rdataset(
+        self,
+        rdclass: dns.rdataclass.RdataClass,
+        rdtype: dns.rdatatype.RdataType,
+        covers: dns.rdatatype.RdataType = dns.rdatatype.NONE,
+        create: bool = False,
+    ) -> dns.rdataset.Rdataset:
         """Find an rdataset matching the specified properties in the
         current node.
 
@@ -199,11 +207,13 @@ class Node:
         self._append_rdataset(rds)
         return rds
 
-    def get_rdataset(self,
-                     rdclass: dns.rdataclass.RdataClass,
-                     rdtype: dns.rdatatype.RdataType,
-                     covers: dns.rdatatype.RdataType=dns.rdatatype.NONE,
-                     create: bool=False) -> Optional[dns.rdataset.Rdataset]:
+    def get_rdataset(
+        self,
+        rdclass: dns.rdataclass.RdataClass,
+        rdtype: dns.rdatatype.RdataType,
+        covers: dns.rdatatype.RdataType = dns.rdatatype.NONE,
+        create: bool = False,
+    ) -> Optional[dns.rdataset.Rdataset]:
         """Get an rdataset matching the specified properties in the
         current node.
 
@@ -234,10 +244,12 @@ class Node:
             rds = None
         return rds
 
-    def delete_rdataset(self,
-                        rdclass: dns.rdataclass.RdataClass,
-                        rdtype: dns.rdatatype.RdataType,
-                        covers: dns.rdatatype.RdataType=dns.rdatatype.NONE) -> None:
+    def delete_rdataset(
+        self,
+        rdclass: dns.rdataclass.RdataClass,
+        rdtype: dns.rdatatype.RdataType,
+        covers: dns.rdatatype.RdataType = dns.rdatatype.NONE,
+    ) -> None:
         """Delete the rdataset matching the specified properties in the
         current node.
 
@@ -270,13 +282,14 @@ class Node:
         """
 
         if not isinstance(replacement, dns.rdataset.Rdataset):
-            raise ValueError('replacement is not an rdataset')
+            raise ValueError("replacement is not an rdataset")
         if isinstance(replacement, dns.rrset.RRset):
             # RRsets are not good replacements as the match() method
             # is not compatible.
             replacement = replacement.to_rdataset()
-        self.delete_rdataset(replacement.rdclass, replacement.rdtype,
-                             replacement.covers)
+        self.delete_rdataset(
+            replacement.rdclass, replacement.rdtype, replacement.covers
+        )
         self._append_rdataset(replacement)
 
     def classify(self) -> NodeKind:
@@ -312,28 +325,34 @@ class ImmutableNode(Node):
             [dns.rdataset.ImmutableRdataset(rds) for rds in node.rdatasets]
         )
 
-    def find_rdataset(self,
-                      rdclass: dns.rdataclass.RdataClass,
-                      rdtype: dns.rdatatype.RdataType,
-                      covers: dns.rdatatype.RdataType=dns.rdatatype.NONE,
-                      create: bool=False) -> dns.rdataset.Rdataset:
+    def find_rdataset(
+        self,
+        rdclass: dns.rdataclass.RdataClass,
+        rdtype: dns.rdatatype.RdataType,
+        covers: dns.rdatatype.RdataType = dns.rdatatype.NONE,
+        create: bool = False,
+    ) -> dns.rdataset.Rdataset:
         if create:
             raise TypeError("immutable")
         return super().find_rdataset(rdclass, rdtype, covers, False)
 
-    def get_rdataset(self,
-                     rdclass: dns.rdataclass.RdataClass,
-                     rdtype: dns.rdatatype.RdataType,
-                     covers: dns.rdatatype.RdataType=dns.rdatatype.NONE,
-                     create: bool=False) -> Optional[dns.rdataset.Rdataset]:
+    def get_rdataset(
+        self,
+        rdclass: dns.rdataclass.RdataClass,
+        rdtype: dns.rdatatype.RdataType,
+        covers: dns.rdatatype.RdataType = dns.rdatatype.NONE,
+        create: bool = False,
+    ) -> Optional[dns.rdataset.Rdataset]:
         if create:
             raise TypeError("immutable")
         return super().get_rdataset(rdclass, rdtype, covers, False)
 
-    def delete_rdataset(self,
-                        rdclass: dns.rdataclass.RdataClass,
-                        rdtype: dns.rdatatype.RdataType,
-                        covers: dns.rdatatype.RdataType=dns.rdatatype.NONE) -> None:
+    def delete_rdataset(
+        self,
+        rdclass: dns.rdataclass.RdataClass,
+        rdtype: dns.rdatatype.RdataType,
+        covers: dns.rdatatype.RdataType = dns.rdatatype.NONE,
+    ) -> None:
         raise TypeError("immutable")
 
     def replace_rdataset(self, replacement: dns.rdataset.Rdataset) -> None: