Constants generation at end of file approach

.flake8

@@ -6,6 +6,8 @@ ignore =
        E129,
        # Whitespace round parameter '=' can be excessive
        E252,
+       # Multiple # in a comment is OK
+       E266,
        # Not excited by the "two blank lines" rule
        E302,
        E305,

dns/dnssec.py

@@ -64,9 +64,6 @@ def _maximum(cls):
         return 255
 
 
-globals().update(Algorithm.__members__)
-
-
 def algorithm_from_text(text):
     """Convert text into a DNSSEC algorithm value.
 
@@ -584,3 +581,25 @@ def _need_pyca(*args, **kwargs):
     validate = _validate                # type: ignore
     validate_rrsig = _validate_rrsig    # type: ignore
     _have_pyca = True
+
+### BEGIN generated Algorithm constants
+
+RSAMD5 = Algorithm.RSAMD5
+DH = Algorithm.DH
+DSA = Algorithm.DSA
+ECC = Algorithm.ECC
+RSASHA1 = Algorithm.RSASHA1
+DSANSEC3SHA1 = Algorithm.DSANSEC3SHA1
+RSASHA1NSEC3SHA1 = Algorithm.RSASHA1NSEC3SHA1
+RSASHA256 = Algorithm.RSASHA256
+RSASHA512 = Algorithm.RSASHA512
+ECCGOST = Algorithm.ECCGOST
+ECDSAP256SHA256 = Algorithm.ECDSAP256SHA256
+ECDSAP384SHA384 = Algorithm.ECDSAP384SHA384
+ED25519 = Algorithm.ED25519
+ED448 = Algorithm.ED448
+INDIRECT = Algorithm.INDIRECT
+PRIVATEDNS = Algorithm.PRIVATEDNS
+PRIVATEOID = Algorithm.PRIVATEOID
+
+### END generated Algorithm constants

dns/edns.py

@@ -50,7 +50,6 @@ class OptionType(dns.enum.IntEnum):
     def _maximum(cls):
         return 65535
 
-globals().update(OptionType.__members__)
 
 class Option:
 
@@ -352,3 +351,18 @@ def register_type(implementation, otype):
     """
 
     _type_to_class[otype] = implementation
+
+### BEGIN generated OptionType constants
+
+NSID = OptionType.NSID
+DAU = OptionType.DAU
+DHU = OptionType.DHU
+N3U = OptionType.N3U
+ECS = OptionType.ECS
+EXPIRE = OptionType.EXPIRE
+COOKIE = OptionType.COOKIE
+KEEPALIVE = OptionType.KEEPALIVE
+PADDING = OptionType.PADDING
+CHAIN = OptionType.CHAIN
+
+### END generated OptionType constants

dns/flags.py

@@ -37,8 +37,6 @@ class Flag(enum.IntFlag):
     #: Checking Disabled
     CD = 0x0010
 
-globals().update(Flag.__members__)
-
 
 # EDNS flags
 
@@ -47,9 +45,6 @@ class EDNSFlag(enum.IntFlag):
     DO = 0x8000
 
 
-globals().update(EDNSFlag.__members__)
-
-
 def _from_text(text, enum_class):
     flags = 0
     tokens = text.split()
@@ -104,3 +99,21 @@ def edns_to_text(flags):
     """
 
     return _to_text(flags, EDNSFlag)
+
+### BEGIN generated Flag constants
+
+QR = Flag.QR
+AA = Flag.AA
+TC = Flag.TC
+RD = Flag.RD
+RA = Flag.RA
+AD = Flag.AD
+CD = Flag.CD
+
+### END generated Flag constants
+
+### BEGIN generated EDNSFlag constants
+
+DO = EDNSFlag.DO
+
+### END generated EDNSFlag constants

dns/message.py

@@ -107,7 +107,6 @@ class MessageSection(dns.enum.IntEnum):
     def _maximum(cls):
         return 3
 
-globals().update(MessageSection.__members__)
 
 DEFAULT_EDNS_PAYLOAD = 1232
 MAX_CHAIN = 16
@@ -1465,3 +1464,12 @@ def make_response(query, recursion_available=False, our_payload=8192,
                           tsig_error, b'', query.keyalgorithm)
         response.request_mac = query.mac
     return response
+
+### BEGIN generated MessageSection constants
+
+QUESTION = MessageSection.QUESTION
+ANSWER = MessageSection.ANSWER
+AUTHORITY = MessageSection.AUTHORITY
+ADDITIONAL = MessageSection.ADDITIONAL
+
+### END generated MessageSection constants

dns/opcode.py

@@ -40,8 +40,6 @@ def _maximum(cls):
     def _unknown_exception_class(cls):
         return UnknownOpcode
 
-globals().update(Opcode.__members__)
-
 
 class UnknownOpcode(dns.exception.DNSException):
     """An DNS opcode is unknown."""
@@ -105,3 +103,13 @@ def is_update(flags):
     """
 
     return from_flags(flags) == Opcode.UPDATE
+
+### BEGIN generated Opcode constants
+
+QUERY = Opcode.QUERY
+IQUERY = Opcode.IQUERY
+STATUS = Opcode.STATUS
+NOTIFY = Opcode.NOTIFY
+UPDATE = Opcode.UPDATE
+
+### END generated Opcode constants

dns/rcode.py

@@ -72,7 +72,6 @@ def _maximum(cls):
     def _unknown_exception_class(cls):
         return UnknownRcode
 
-globals().update(Rcode.__members__)
 
 class UnknownRcode(dns.exception.DNSException):
     """A DNS rcode is unknown."""
@@ -137,3 +136,29 @@ def to_text(value, tsig=False):
     if tsig and value == Rcode.BADVERS:
         return 'BADSIG'
     return Rcode.to_text(value)
+
+### BEGIN generated Rcode constants
+
+NOERROR = Rcode.NOERROR
+FORMERR = Rcode.FORMERR
+SERVFAIL = Rcode.SERVFAIL
+NXDOMAIN = Rcode.NXDOMAIN
+NOTIMP = Rcode.NOTIMP
+REFUSED = Rcode.REFUSED
+YXDOMAIN = Rcode.YXDOMAIN
+YXRRSET = Rcode.YXRRSET
+NXRRSET = Rcode.NXRRSET
+NOTAUTH = Rcode.NOTAUTH
+NOTZONE = Rcode.NOTZONE
+DSOTYPENI = Rcode.DSOTYPENI
+BADVERS = Rcode.BADVERS
+BADSIG = Rcode.BADSIG
+BADKEY = Rcode.BADKEY
+BADTIME = Rcode.BADTIME
+BADMODE = Rcode.BADMODE
+BADNAME = Rcode.BADNAME
+BADALG = Rcode.BADALG
+BADTRUNC = Rcode.BADTRUNC
+BADCOOKIE = Rcode.BADCOOKIE
+
+### END generated Rcode constants

dns/rdataclass.py

@@ -48,7 +48,6 @@ def _prefix(cls):
     def _unknown_exception_class(cls):
         return UnknownRdataclass
 
-globals().update(RdataClass.__members__)
 
 _metaclasses = {RdataClass.NONE, RdataClass.ANY}
 
@@ -100,3 +99,17 @@ def is_metaclass(rdclass):
     if rdclass in _metaclasses:
         return True
     return False
+
+### BEGIN generated RdataClass constants
+
+RESERVED0 = RdataClass.RESERVED0
+IN = RdataClass.IN
+INTERNET = RdataClass.INTERNET
+CH = RdataClass.CH
+CHAOS = RdataClass.CHAOS
+HS = RdataClass.HS
+HESIOD = RdataClass.HESIOD
+NONE = RdataClass.NONE
+ANY = RdataClass.ANY
+
+### END generated RdataClass constants

dns/rdatatype.py

@@ -115,8 +115,6 @@ def _unknown_exception_class(cls):
 _registered_by_text = {}
 _registered_by_value = {}
 
-globals().update(RdataType.__members__)
-
 _metatypes = {RdataType.OPT}
 
 _singletons = {RdataType.SOA, RdataType.NXT, RdataType.DNAME,
@@ -219,3 +217,81 @@ def register_type(rdtype, rdtype_text, is_singleton=False):
     _registered_by_value[rdtype] = rdtype_text
     if is_singleton:
         _singletons.add(rdtype)
+
+### BEGIN generated RdataType constants
+
+TYPE0 = RdataType.TYPE0
+NONE = RdataType.NONE
+A = RdataType.A
+NS = RdataType.NS
+MD = RdataType.MD
+MF = RdataType.MF
+CNAME = RdataType.CNAME
+SOA = RdataType.SOA
+MB = RdataType.MB
+MG = RdataType.MG
+MR = RdataType.MR
+NULL = RdataType.NULL
+WKS = RdataType.WKS
+PTR = RdataType.PTR
+HINFO = RdataType.HINFO
+MINFO = RdataType.MINFO
+MX = RdataType.MX
+TXT = RdataType.TXT
+RP = RdataType.RP
+AFSDB = RdataType.AFSDB
+X25 = RdataType.X25
+ISDN = RdataType.ISDN
+RT = RdataType.RT
+NSAP = RdataType.NSAP
+NSAP_PTR = RdataType.NSAP_PTR
+SIG = RdataType.SIG
+KEY = RdataType.KEY
+PX = RdataType.PX
+GPOS = RdataType.GPOS
+AAAA = RdataType.AAAA
+LOC = RdataType.LOC
+NXT = RdataType.NXT
+SRV = RdataType.SRV
+NAPTR = RdataType.NAPTR
+KX = RdataType.KX
+CERT = RdataType.CERT
+A6 = RdataType.A6
+DNAME = RdataType.DNAME
+OPT = RdataType.OPT
+APL = RdataType.APL
+DS = RdataType.DS
+SSHFP = RdataType.SSHFP
+IPSECKEY = RdataType.IPSECKEY
+RRSIG = RdataType.RRSIG
+NSEC = RdataType.NSEC
+DNSKEY = RdataType.DNSKEY
+DHCID = RdataType.DHCID
+NSEC3 = RdataType.NSEC3
+NSEC3PARAM = RdataType.NSEC3PARAM
+TLSA = RdataType.TLSA
+HIP = RdataType.HIP
+NINFO = RdataType.NINFO
+CDS = RdataType.CDS
+CDNSKEY = RdataType.CDNSKEY
+OPENPGPKEY = RdataType.OPENPGPKEY
+CSYNC = RdataType.CSYNC
+SPF = RdataType.SPF
+UNSPEC = RdataType.UNSPEC
+EUI48 = RdataType.EUI48
+EUI64 = RdataType.EUI64
+TKEY = RdataType.TKEY
+TSIG = RdataType.TSIG
+IXFR = RdataType.IXFR
+AXFR = RdataType.AXFR
+MAILB = RdataType.MAILB
+MAILA = RdataType.MAILA
+ANY = RdataType.ANY
+URI = RdataType.URI
+CAA = RdataType.CAA
+AVC = RdataType.AVC
+AMTRELAY = RdataType.AMTRELAY
+TA = RdataType.TA
+DLV = RdataType.DLV
+
+### END generated RdataType constants

dns/rdtypes/dnskeybase.py

@@ -31,8 +31,6 @@ class Flag(enum.IntFlag):
     REVOKE = 0x0080
     ZONE = 0x0100
 
-globals().update(Flag.__members__)
-
 
 class DNSKEYBase(dns.rdata.Rdata):
 
@@ -72,3 +70,11 @@ def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
         key = parser.get_remaining()
         return cls(rdclass, rdtype, header[0], header[1], header[2],
                    key)
+
+### BEGIN generated Flag constants
+
+SEP = Flag.SEP
+REVOKE = Flag.REVOKE
+ZONE = Flag.ZONE
+
+### END generated Flag constants

dns/update.py

@@ -38,8 +38,6 @@ class UpdateSection(dns.enum.IntEnum):
     def _maximum(cls):
         return 3
 
-globals().update(UpdateSection.__members__)
-
 
 class UpdateMessage(dns.message.Message):
 
@@ -310,3 +308,12 @@ def _parse_rr_header(self, section, name, rdclass, rdtype):
 
 # backwards compatibility
 Update = UpdateMessage
+
+### BEGIN generated UpdateSection constants
+
+ZONE = UpdateSection.ZONE
+PREREQ = UpdateSection.PREREQ
+UPDATE = UpdateSection.UPDATE
+ADDITIONAL = UpdateSection.ADDITIONAL
+
+### END generated UpdateSection constants

tests/test_constants.py

@@ -0,0 +1,38 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
+import unittest
+
+import dns.dnssec
+import dns.rdtypes.dnskeybase
+import dns.flags
+import dns.rcode
+import dns.opcode
+import dns.message
+import dns.update
+import dns.edns
+
+import tests.util
+
+
+class ConstantsTestCase(unittest.TestCase):
+
+    def test_dnssec_constants(self):
+        tests.util.check_enum_exports(dns.dnssec, self.assertEqual,
+                                      only={dns.dnssec.Algorithm})
+        tests.util.check_enum_exports(dns.rdtypes.dnskeybase, self.assertEqual)
+
+    def test_flags_constants(self):
+        tests.util.check_enum_exports(dns.flags, self.assertEqual)
+        tests.util.check_enum_exports(dns.rcode, self.assertEqual)
+        tests.util.check_enum_exports(dns.opcode, self.assertEqual)
+
+    def test_message_constants(self):
+        tests.util.check_enum_exports(dns.message, self.assertEqual)
+        tests.util.check_enum_exports(dns.update, self.assertEqual)
+
+    def test_rdata_constants(self):
+        tests.util.check_enum_exports(dns.rdataclass, self.assertEqual)
+        tests.util.check_enum_exports(dns.rdatatype, self.assertEqual)
+
+    def test_edns_constants(self):
+        tests.util.check_enum_exports(dns.edns, self.assertEqual)