Remove snippet and kaitai plugin. Note their individual links.

1 files changed, 0 insertions, 992 deletions

diff --git a/python/examples/kaitai/openpgp_message.py b/python/examples/kaitai/openpgp_message.py
deleted file mode 100644
index 3b10b5bc..00000000
--- a/python/examples/kaitai/openpgp_message.py
+++ /dev/null
@@ -1,992 +0,0 @@
-# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
-
-from pkg_resources import parse_version
-from .kaitaistruct import __version__ as ks_version, KaitaiStruct, KaitaiStream, BytesIO
-from enum import Enum
-import collections
-
-
-if parse_version(ks_version) < parse_version('0.7'):
-    raise Exception("Incompatible Kaitai Struct Python API: 0.7 or later is required, but you have %s" % (ks_version))
-
-class OpenpgpMessage(KaitaiStruct):
-    """The OpenPGP Message Format is a format to store encryption and signature keys for emails.
-    
-    .. seealso::
-       Source - https://tools.ietf.org/html/rfc4880
-    """
-
-    class PublicKeyAlgorithms(Enum):
-        rsa_encrypt_or_sign_hac = 1
-        rsa_encrypt_only_hac = 2
-        rsa_sign_only_hac = 3
-        elgamal_encrypt_only_elgamal_hac = 16
-        dsa_digital_signature_algorithm_fips_hac = 17
-        reserved_for_elliptic_curve = 18
-        reserved_for_ecdsa = 19
-        reserved_formerly_elgamal_encrypt_or_sign_ = 20
-        reserved_for_diffie_hellman_x_as_defined_for_ietf_s_mime = 21
-        private_experimental_algorithm_00 = 100
-        private_experimental_algorithm_01 = 101
-        private_experimental_algorithm_02 = 102
-        private_experimental_algorithm_03 = 103
-        private_experimental_algorithm_04 = 104
-        private_experimental_algorithm_05 = 105
-        private_experimental_algorithm_06 = 106
-        private_experimental_algorithm_07 = 107
-        private_experimental_algorithm_08 = 108
-        private_experimental_algorithm_09 = 109
-        private_experimental_algorithm_10 = 110
-
-    class ServerFlags(Enum):
-        no_modify = 128
-
-    class KeyFlags(Enum):
-        this_key_may_be_used_to_certify_other_keys = 1
-        this_key_may_be_used_to_sign_data = 2
-        this_key_may_be_used_to_encrypt_communications = 4
-        this_key_may_be_used_to_encrypt_storage = 8
-        the_private_component_of_this_key_may_have_been_split_by_a_secret_sharing_mechanism = 16
-        this_key_may_be_used_for_authentication = 32
-        the_private_component_of_this_key_may_be_in_the_possession_of_more_than_one_person = 128
-
-    class CompressionAlgorithms(Enum):
-        uncompressed = 0
-        zib = 1
-        zlib = 2
-        bzip = 3
-        private_experimental_algorithm_00 = 100
-        private_experimental_algorithm_01 = 101
-        private_experimental_algorithm_02 = 102
-        private_experimental_algorithm_03 = 103
-        private_experimental_algorithm_04 = 104
-        private_experimental_algorithm_05 = 105
-        private_experimental_algorithm_06 = 106
-        private_experimental_algorithm_07 = 107
-        private_experimental_algorithm_08 = 108
-        private_experimental_algorithm_09 = 109
-        private_experimental_algorithm_10 = 110
-
-    class PacketTags(Enum):
-        reserved_a_packet_tag_must_not_have_this_value = 0
-        public_key_encrypted_session_key_packet = 1
-        signature_packet = 2
-        symmetric_key_encrypted_session_key_packet = 3
-        one_pass_signature_packet = 4
-        secret_key_packet = 5
-        public_key_packet = 6
-        secret_subkey_packet = 7
-        compressed_data_packet = 8
-        symmetrically_encrypted_data_packet = 9
-        marker_packet = 10
-        literal_data_packet = 11
-        trust_packet = 12
-        user_id_packet = 13
-        public_subkey_packet = 14
-        user_attribute_packet = 17
-        sym_encrypted_and_integrity_protected_data_packet = 18
-        modification_detection_code_packet = 19
-        private_or_experimental_values_0 = 60
-        private_or_experimental_values_1 = 61
-        private_or_experimental_values_2 = 62
-        private_or_experimental_values_3 = 63
-
-    class RevocationCodes(Enum):
-        no_reason_specified_key_revocations_or_cert_revocations = 0
-        key_is_superseded_key_revocations = 1
-        key_material_has_been_compromised_key_revocations = 2
-        key_is_retired_and_no_longer_used_key_revocations = 3
-        user_id_information_is_no_longer_valid_cert_revocations = 32
-        private_use_1 = 100
-        private_use_2 = 101
-        private_use_3 = 102
-        private_use_4 = 103
-        private_use_11 = 110
-
-    class HashAlgorithms(Enum):
-        md5 = 1
-        sha1 = 2
-        ripemd160 = 3
-        reserved_4 = 4
-        reserved_5 = 5
-        reserved_6 = 6
-        reserved_7 = 7
-        sha256 = 8
-        sha384 = 9
-        sha512 = 10
-        sha224 = 11
-        private_experimental_algorithm_00 = 100
-        private_experimental_algorithm_01 = 101
-        private_experimental_algorithm_02 = 102
-        private_experimental_algorithm_03 = 103
-        private_experimental_algorithm_04 = 104
-        private_experimental_algorithm_05 = 105
-        private_experimental_algorithm_06 = 106
-        private_experimental_algorithm_07 = 107
-        private_experimental_algorithm_08 = 108
-        private_experimental_algorithm_09 = 109
-        private_experimental_algorithm_10 = 110
-
-    class SymmetricKeyAlgorithm(Enum):
-        plain = 0
-        idea = 1
-        triple_des = 2
-        cast5 = 3
-        blowfisch = 4
-        reserved_5 = 5
-        reserved_6 = 6
-        aes_128 = 7
-        aes_192 = 8
-        aes_256 = 9
-        twofish_256 = 10
-        private_experimental_algorithm_00 = 100
-        private_experimental_algorithm_01 = 101
-        private_experimental_algorithm_02 = 102
-        private_experimental_algorithm_03 = 103
-        private_experimental_algorithm_04 = 104
-        private_experimental_algorithm_05 = 105
-        private_experimental_algorithm_06 = 106
-        private_experimental_algorithm_07 = 107
-        private_experimental_algorithm_08 = 108
-        private_experimental_algorithm_09 = 109
-        private_experimental_algorithm_10 = 110
-
-    class SubpacketTypes(Enum):
-        reserved0 = 0
-        reserved1 = 1
-        signature_creation_time = 2
-        signature_expiration_time = 3
-        exportable_certification = 4
-        trust_signature = 5
-        regular_expression = 6
-        revocable = 7
-        reserved8 = 8
-        key_expiration_time = 9
-        placeholder_for_backward_compatibility = 10
-        preferred_symmetric_algorithms = 11
-        revocation_key = 12
-        reserved13 = 13
-        reserved14 = 14
-        reserved15 = 15
-        issuer = 16
-        reserved17 = 17
-        reserved18 = 18
-        reserved19 = 19
-        notation_data = 20
-        preferred_hash_algorithms = 21
-        preferred_compression_algorithms = 22
-        key_server_preferences = 23
-        preferred_key_server = 24
-        primary_user_id = 25
-        policy_uri = 26
-        key_flags = 27
-        signers_user_id = 28
-        reason_for_revocation = 29
-        features = 30
-        signature_target = 31
-        embedded_signature = 32
-    SEQ_FIELDS = ["packets"]
-    def __init__(self, _io, _parent=None, _root=None):
-        self._io = _io
-        self._parent = _parent
-        self._root = _root if _root else self
-        self._debug = collections.defaultdict(dict)
-
-    def _read(self):
-        self._debug['packets']['start'] = self._io.pos()
-        self.packets = []
-        i = 0
-        while not self._io.is_eof():
-            if not 'arr' in self._debug['packets']:
-                self._debug['packets']['arr'] = []
-            self._debug['packets']['arr'].append({'start': self._io.pos()})
-            _t_packets = self._root.Packet(self._io, self, self._root)
-            _t_packets._read()
-            self.packets.append(_t_packets)
-            self._debug['packets']['arr'][len(self.packets) - 1]['end'] = self._io.pos()
-            i += 1
-
-        self._debug['packets']['end'] = self._io.pos()
-
-    class PreferredHashAlgorithms(KaitaiStruct):
-        SEQ_FIELDS = ["algorithm"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['algorithm']['start'] = self._io.pos()
-            self.algorithm = []
-            i = 0
-            while not self._io.is_eof():
-                if not 'arr' in self._debug['algorithm']:
-                    self._debug['algorithm']['arr'] = []
-                self._debug['algorithm']['arr'].append({'start': self._io.pos()})
-                self.algorithm.append(KaitaiStream.resolve_enum(self._root.HashAlgorithms, self._io.read_u1()))
-                self._debug['algorithm']['arr'][len(self.algorithm) - 1]['end'] = self._io.pos()
-                i += 1
-
-            self._debug['algorithm']['end'] = self._io.pos()
-
-
-    class PreferredCompressionAlgorithms(KaitaiStruct):
-        SEQ_FIELDS = ["algorithm"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['algorithm']['start'] = self._io.pos()
-            self.algorithm = []
-            i = 0
-            while not self._io.is_eof():
-                if not 'arr' in self._debug['algorithm']:
-                    self._debug['algorithm']['arr'] = []
-                self._debug['algorithm']['arr'].append({'start': self._io.pos()})
-                self.algorithm.append(KaitaiStream.resolve_enum(self._root.CompressionAlgorithms, self._io.read_u1()))
-                self._debug['algorithm']['arr'][len(self.algorithm) - 1]['end'] = self._io.pos()
-                i += 1
-
-            self._debug['algorithm']['end'] = self._io.pos()
-
-
-    class SignersUserId(KaitaiStruct):
-        SEQ_FIELDS = ["user_id"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['user_id']['start'] = self._io.pos()
-            self.user_id = (self._io.read_bytes_full()).decode(u"UTF-8")
-            self._debug['user_id']['end'] = self._io.pos()
-
-
-    class SecretKeyPacket(KaitaiStruct):
-        SEQ_FIELDS = ["public_key", "string_to_key", "symmetric_encryption_algorithm", "secret_key"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['public_key']['start'] = self._io.pos()
-            self.public_key = self._root.PublicKeyPacket(self._io, self, self._root)
-            self.public_key._read()
-            self._debug['public_key']['end'] = self._io.pos()
-            self._debug['string_to_key']['start'] = self._io.pos()
-            self.string_to_key = self._io.read_u1()
-            self._debug['string_to_key']['end'] = self._io.pos()
-            if self.string_to_key >= 254:
-                self._debug['symmetric_encryption_algorithm']['start'] = self._io.pos()
-                self.symmetric_encryption_algorithm = KaitaiStream.resolve_enum(self._root.SymmetricKeyAlgorithm, self._io.read_u1())
-                self._debug['symmetric_encryption_algorithm']['end'] = self._io.pos()
-
-            self._debug['secret_key']['start'] = self._io.pos()
-            self.secret_key = self._io.read_bytes_full()
-            self._debug['secret_key']['end'] = self._io.pos()
-
-
-    class KeyServerPreferences(KaitaiStruct):
-        SEQ_FIELDS = ["flag"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['flag']['start'] = self._io.pos()
-            self.flag = []
-            i = 0
-            while not self._io.is_eof():
-                if not 'arr' in self._debug['flag']:
-                    self._debug['flag']['arr'] = []
-                self._debug['flag']['arr'].append({'start': self._io.pos()})
-                self.flag.append(KaitaiStream.resolve_enum(self._root.ServerFlags, self._io.read_u1()))
-                self._debug['flag']['arr'][len(self.flag) - 1]['end'] = self._io.pos()
-                i += 1
-
-            self._debug['flag']['end'] = self._io.pos()
-
-
-    class RegularExpression(KaitaiStruct):
-        SEQ_FIELDS = ["regex"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['regex']['start'] = self._io.pos()
-            self.regex = (self._io.read_bytes_term(0, False, True, True)).decode(u"UTF-8")
-            self._debug['regex']['end'] = self._io.pos()
-
-
-    class Subpackets(KaitaiStruct):
-        SEQ_FIELDS = ["subpacketss"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['subpacketss']['start'] = self._io.pos()
-            self.subpacketss = []
-            i = 0
-            while not self._io.is_eof():
-                if not 'arr' in self._debug['subpacketss']:
-                    self._debug['subpacketss']['arr'] = []
-                self._debug['subpacketss']['arr'].append({'start': self._io.pos()})
-                _t_subpacketss = self._root.Subpacket(self._io, self, self._root)
-                _t_subpacketss._read()
-                self.subpacketss.append(_t_subpacketss)
-                self._debug['subpacketss']['arr'][len(self.subpacketss) - 1]['end'] = self._io.pos()
-                i += 1
-
-            self._debug['subpacketss']['end'] = self._io.pos()
-
-
-    class RevocationKey(KaitaiStruct):
-        SEQ_FIELDS = ["class_", "public_key_algorithm", "fingerprint"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['class_']['start'] = self._io.pos()
-            self.class_ = self._io.read_u1()
-            self._debug['class_']['end'] = self._io.pos()
-            self._debug['public_key_algorithm']['start'] = self._io.pos()
-            self.public_key_algorithm = KaitaiStream.resolve_enum(self._root.PublicKeyAlgorithms, self._io.read_u1())
-            self._debug['public_key_algorithm']['end'] = self._io.pos()
-            self._debug['fingerprint']['start'] = self._io.pos()
-            self.fingerprint = self._io.read_bytes(20)
-            self._debug['fingerprint']['end'] = self._io.pos()
-
-
-    class UserIdPacket(KaitaiStruct):
-        SEQ_FIELDS = ["user_id"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['user_id']['start'] = self._io.pos()
-            self.user_id = (self._io.read_bytes_full()).decode(u"UTF-8")
-            self._debug['user_id']['end'] = self._io.pos()
-
-
-    class PolicyUri(KaitaiStruct):
-        SEQ_FIELDS = ["uri"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['uri']['start'] = self._io.pos()
-            self.uri = (self._io.read_bytes_full()).decode(u"UTF-8")
-            self._debug['uri']['end'] = self._io.pos()
-
-
-    class SignatureTarget(KaitaiStruct):
-        SEQ_FIELDS = ["public_key_algorithm", "hash_algorithm", "hash"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['public_key_algorithm']['start'] = self._io.pos()
-            self.public_key_algorithm = KaitaiStream.resolve_enum(self._root.PublicKeyAlgorithms, self._io.read_u1())
-            self._debug['public_key_algorithm']['end'] = self._io.pos()
-            self._debug['hash_algorithm']['start'] = self._io.pos()
-            self.hash_algorithm = KaitaiStream.resolve_enum(self._root.HashAlgorithms, self._io.read_u1())
-            self._debug['hash_algorithm']['end'] = self._io.pos()
-            self._debug['hash']['start'] = self._io.pos()
-            self.hash = self._io.read_bytes_full()
-            self._debug['hash']['end'] = self._io.pos()
-
-
-    class KeyFlags(KaitaiStruct):
-        SEQ_FIELDS = ["flag"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['flag']['start'] = self._io.pos()
-            self.flag = []
-            i = 0
-            while not self._io.is_eof():
-                if not 'arr' in self._debug['flag']:
-                    self._debug['flag']['arr'] = []
-                self._debug['flag']['arr'].append({'start': self._io.pos()})
-                self.flag.append(KaitaiStream.resolve_enum(self._root.KeyFlags, self._io.read_u1()))
-                self._debug['flag']['arr'][len(self.flag) - 1]['end'] = self._io.pos()
-                i += 1
-
-            self._debug['flag']['end'] = self._io.pos()
-
-
-    class Features(KaitaiStruct):
-        SEQ_FIELDS = ["flags"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['flags']['start'] = self._io.pos()
-            self.flags = self._io.read_bytes_full()
-            self._debug['flags']['end'] = self._io.pos()
-
-
-    class PrimaryUserId(KaitaiStruct):
-        SEQ_FIELDS = ["user_id"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['user_id']['start'] = self._io.pos()
-            self.user_id = self._io.read_u1()
-            self._debug['user_id']['end'] = self._io.pos()
-
-
-    class Subpacket(KaitaiStruct):
-        SEQ_FIELDS = ["len", "subpacket_type", "content"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['len']['start'] = self._io.pos()
-            self.len = self._root.LenSubpacket(self._io, self, self._root)
-            self.len._read()
-            self._debug['len']['end'] = self._io.pos()
-            self._debug['subpacket_type']['start'] = self._io.pos()
-            self.subpacket_type = KaitaiStream.resolve_enum(self._root.SubpacketTypes, self._io.read_u1())
-            self._debug['subpacket_type']['end'] = self._io.pos()
-            self._debug['content']['start'] = self._io.pos()
-            _on = self.subpacket_type
-            if _on == self._root.SubpacketTypes.preferred_key_server:
-                self._raw_content = self._io.read_bytes((self.len.len - 1))
-                io = KaitaiStream(BytesIO(self._raw_content))
-                self.content = self._root.PreferredKeyServer(io, self, self._root)
-                self.content._read()
-            elif _on == self._root.SubpacketTypes.issuer:
-                self._raw_content = self._io.read_bytes((self.len.len - 1))
-                io = KaitaiStream(BytesIO(self._raw_content))
-                self.content = self._root.Issuer(io, self, self._root)
-                self.content._read()
-            elif _on == self._root.SubpacketTypes.revocable:
-                self._raw_content = self._io.read_bytes((self.len.len - 1))
-                io = KaitaiStream(BytesIO(self._raw_content))
-                self.content = self._root.Revocable(io, self, self._root)
-                self.content._read()
-            elif _on == self._root.SubpacketTypes.signature_target:
-                self._raw_content = self._io.read_bytes((self.len.len - 1))
-                io = KaitaiStream(BytesIO(self._raw_content))
-                self.content = self._root.SignatureTarget(io, self, self._root)
-                self.content._read()
-            elif _on == self._root.SubpacketTypes.regular_expression:
-                self._raw_content = self._io.read_bytes((self.len.len - 1))
-                io = KaitaiStream(BytesIO(self._raw_content))
-                self.content = self._root.RegularExpression(io, self, self._root)
-                self.content._read()
-            elif _on == self._root.SubpacketTypes.exportable_certification:
-                self._raw_content = self._io.read_bytes((self.len.len - 1))
-                io = KaitaiStream(BytesIO(self._raw_content))
-                self.content = self._root.ExportableCertification(io, self, self._root)
-                self.content._read()
-            elif _on == self._root.SubpacketTypes.reason_for_revocation:
-                self._raw_content = self._io.read_bytes((self.len.len - 1))
-                io = KaitaiStream(BytesIO(self._raw_content))
-                self.content = self._root.ReasonForRevocation(io, self, self._root)
-                self.content._read()
-            elif _on == self._root.SubpacketTypes.key_server_preferences:
-                self._raw_content = self._io.read_bytes((self.len.len - 1))
-                io = KaitaiStream(BytesIO(self._raw_content))
-                self.content = self._root.KeyServerPreferences(io, self, self._root)
-                self.content._read()
-            elif _on == self._root.SubpacketTypes.signature_creation_time:
-                self._raw_content = self._io.read_bytes((self.len.len - 1))
-                io = KaitaiStream(BytesIO(self._raw_content))
-                self.content = self._root.SignatureCreationTime(io, self, self._root)
-                self.content._read()
-            elif _on == self._root.SubpacketTypes.preferred_hash_algorithms:
-                self._raw_content = self._io.read_bytes((self.len.len - 1))
-                io = KaitaiStream(BytesIO(self._raw_content))
-                self.content = self._root.PreferredHashAlgorithms(io, self, self._root)
-                self.content._read()
-            elif _on == self._root.SubpacketTypes.trust_signature:
-                self._raw_content = self._io.read_bytes((self.len.len - 1))
-                io = KaitaiStream(BytesIO(self._raw_content))
-                self.content = self._root.TrustSignature(io, self, self._root)
-                self.content._read()
-            elif _on == self._root.SubpacketTypes.key_expiration_time:
-                self._raw_content = self._io.read_bytes((self.len.len - 1))
-                io = KaitaiStream(BytesIO(self._raw_content))
-                self.content = self._root.KeyExpirationTime(io, self, self._root)
-                self.content._read()
-            elif _on == self._root.SubpacketTypes.key_flags:
-                self._raw_content = self._io.read_bytes((self.len.len - 1))
-                io = KaitaiStream(BytesIO(self._raw_content))
-                self.content = self._root.KeyFlags(io, self, self._root)
-                self.content._read()
-            elif _on == self._root.SubpacketTypes.signature_expiration_time:
-                self._raw_content = self._io.read_bytes((self.len.len - 1))
-                io = KaitaiStream(BytesIO(self._raw_content))
-                self.content = self._root.SignatureExpirationTime(io, self, self._root)
-                self.content._read()
-            elif _on == self._root.SubpacketTypes.features:
-                self._raw_content = self._io.read_bytes((self.len.len - 1))
-                io = KaitaiStream(BytesIO(self._raw_content))
-                self.content = self._root.Features(io, self, self._root)
-                self.content._read()
-            elif _on == self._root.SubpacketTypes.signers_user_id:
-                self._raw_content = self._io.read_bytes((self.len.len - 1))
-                io = KaitaiStream(BytesIO(self._raw_content))
-                self.content = self._root.SignersUserId(io, self, self._root)
-                self.content._read()
-            elif _on == self._root.SubpacketTypes.notation_data:
-                self._raw_content = self._io.read_bytes((self.len.len - 1))
-                io = KaitaiStream(BytesIO(self._raw_content))
-                self.content = self._root.NotationData(io, self, self._root)
-                self.content._read()
-            elif _on == self._root.SubpacketTypes.revocation_key:
-                self._raw_content = self._io.read_bytes((self.len.len - 1))
-                io = KaitaiStream(BytesIO(self._raw_content))
-                self.content = self._root.RevocationKey(io, self, self._root)
-                self.content._read()
-            elif _on == self._root.SubpacketTypes.preferred_compression_algorithms:
-                self._raw_content = self._io.read_bytes((self.len.len - 1))
-                io = KaitaiStream(BytesIO(self._raw_content))
-                self.content = self._root.PreferredCompressionAlgorithms(io, self, self._root)
-                self.content._read()
-            elif _on == self._root.SubpacketTypes.policy_uri:
-                self._raw_content = self._io.read_bytes((self.len.len - 1))
-                io = KaitaiStream(BytesIO(self._raw_content))
-                self.content = self._root.PolicyUri(io, self, self._root)
-                self.content._read()
-            elif _on == self._root.SubpacketTypes.primary_user_id:
-                self._raw_content = self._io.read_bytes((self.len.len - 1))
-                io = KaitaiStream(BytesIO(self._raw_content))
-                self.content = self._root.PrimaryUserId(io, self, self._root)
-                self.content._read()
-            elif _on == self._root.SubpacketTypes.embedded_signature:
-                self._raw_content = self._io.read_bytes((self.len.len - 1))
-                io = KaitaiStream(BytesIO(self._raw_content))
-                self.content = self._root.EmbeddedSignature(io, self, self._root)
-                self.content._read()
-            else:
-                self.content = self._io.read_bytes((self.len.len - 1))
-            self._debug['content']['end'] = self._io.pos()
-
-
-    class OldPacket(KaitaiStruct):
-        SEQ_FIELDS = ["len", "body"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['len']['start'] = self._io.pos()
-            _on = self._parent.len_type
-            if _on == 0:
-                self.len = self._io.read_u1()
-            elif _on == 1:
-                self.len = self._io.read_u2be()
-            elif _on == 2:
-                self.len = self._io.read_u4be()
-            self._debug['len']['end'] = self._io.pos()
-            self._debug['body']['start'] = self._io.pos()
-            _on = self._parent.packet_type_old
-            if _on == self._root.PacketTags.public_key_packet:
-                self._raw_body = self._io.read_bytes(self.len)
-                io = KaitaiStream(BytesIO(self._raw_body))
-                self.body = self._root.PublicKeyPacket(io, self, self._root)
-                self.body._read()
-            elif _on == self._root.PacketTags.public_subkey_packet:
-                self._raw_body = self._io.read_bytes(self.len)
-                io = KaitaiStream(BytesIO(self._raw_body))
-                self.body = self._root.PublicKeyPacket(io, self, self._root)
-                self.body._read()
-            elif _on == self._root.PacketTags.user_id_packet:
-                self._raw_body = self._io.read_bytes(self.len)
-                io = KaitaiStream(BytesIO(self._raw_body))
-                self.body = self._root.UserIdPacket(io, self, self._root)
-                self.body._read()
-            elif _on == self._root.PacketTags.signature_packet:
-                self._raw_body = self._io.read_bytes(self.len)
-                io = KaitaiStream(BytesIO(self._raw_body))
-                self.body = self._root.SignaturePacket(io, self, self._root)
-                self.body._read()
-            elif _on == self._root.PacketTags.secret_subkey_packet:
-                self._raw_body = self._io.read_bytes(self.len)
-                io = KaitaiStream(BytesIO(self._raw_body))
-                self.body = self._root.PublicKeyPacket(io, self, self._root)
-                self.body._read()
-            elif _on == self._root.PacketTags.secret_key_packet:
-                self._raw_body = self._io.read_bytes(self.len)
-                io = KaitaiStream(BytesIO(self._raw_body))
-                self.body = self._root.SecretKeyPacket(io, self, self._root)
-                self.body._read()
-            else:
-                self.body = self._io.read_bytes(self.len)
-            self._debug['body']['end'] = self._io.pos()
-
-
-    class Issuer(KaitaiStruct):
-        SEQ_FIELDS = ["keyid"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['keyid']['start'] = self._io.pos()
-            self.keyid = self._io.read_u8be()
-            self._debug['keyid']['end'] = self._io.pos()
-
-
-    class ExportableCertification(KaitaiStruct):
-        SEQ_FIELDS = ["exportable"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['exportable']['start'] = self._io.pos()
-            self.exportable = self._io.read_u1()
-            self._debug['exportable']['end'] = self._io.pos()
-
-
-    class SignatureExpirationTime(KaitaiStruct):
-        SEQ_FIELDS = ["time"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['time']['start'] = self._io.pos()
-            self.time = self._io.read_u4be()
-            self._debug['time']['end'] = self._io.pos()
-
-
-    class SignatureCreationTime(KaitaiStruct):
-        SEQ_FIELDS = ["time"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['time']['start'] = self._io.pos()
-            self.time = self._io.read_u4be()
-            self._debug['time']['end'] = self._io.pos()
-
-
-    class SignaturePacket(KaitaiStruct):
-        SEQ_FIELDS = ["version", "signature_type", "public_key_algorithm", "hash_algorithm", "len_hashed_subpacket", "hashed_subpackets", "len_unhashed_subpacket", "unhashed_subpackets", "left_signed_hash", "rsa_n", "signature"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['version']['start'] = self._io.pos()
-            self.version = self._io.read_u1()
-            self._debug['version']['end'] = self._io.pos()
-            self._debug['signature_type']['start'] = self._io.pos()
-            self.signature_type = self._io.read_u1()
-            self._debug['signature_type']['end'] = self._io.pos()
-            self._debug['public_key_algorithm']['start'] = self._io.pos()
-            self.public_key_algorithm = KaitaiStream.resolve_enum(self._root.PublicKeyAlgorithms, self._io.read_u1())
-            self._debug['public_key_algorithm']['end'] = self._io.pos()
-            self._debug['hash_algorithm']['start'] = self._io.pos()
-            self.hash_algorithm = KaitaiStream.resolve_enum(self._root.HashAlgorithms, self._io.read_u1())
-            self._debug['hash_algorithm']['end'] = self._io.pos()
-            self._debug['len_hashed_subpacket']['start'] = self._io.pos()
-            self.len_hashed_subpacket = self._io.read_u2be()
-            self._debug['len_hashed_subpacket']['end'] = self._io.pos()
-            self._debug['hashed_subpackets']['start'] = self._io.pos()
-            self._raw_hashed_subpackets = self._io.read_bytes(self.len_hashed_subpacket)
-            io = KaitaiStream(BytesIO(self._raw_hashed_subpackets))
-            self.hashed_subpackets = self._root.Subpackets(io, self, self._root)
-            self.hashed_subpackets._read()
-            self._debug['hashed_subpackets']['end'] = self._io.pos()
-            self._debug['len_unhashed_subpacket']['start'] = self._io.pos()
-            self.len_unhashed_subpacket = self._io.read_u2be()
-            self._debug['len_unhashed_subpacket']['end'] = self._io.pos()
-            self._debug['unhashed_subpackets']['start'] = self._io.pos()
-            self._raw_unhashed_subpackets = self._io.read_bytes(self.len_unhashed_subpacket)
-            io = KaitaiStream(BytesIO(self._raw_unhashed_subpackets))
-            self.unhashed_subpackets = self._root.Subpackets(io, self, self._root)
-            self.unhashed_subpackets._read()
-            self._debug['unhashed_subpackets']['end'] = self._io.pos()
-            self._debug['left_signed_hash']['start'] = self._io.pos()
-            self.left_signed_hash = self._io.read_u2be()
-            self._debug['left_signed_hash']['end'] = self._io.pos()
-            self._debug['rsa_n']['start'] = self._io.pos()
-            self.rsa_n = self._io.read_u2be()
-            self._debug['rsa_n']['end'] = self._io.pos()
-            self._debug['signature']['start'] = self._io.pos()
-            self.signature = self._io.read_bytes_full()
-            self._debug['signature']['end'] = self._io.pos()
-
-
-    class Revocable(KaitaiStruct):
-        SEQ_FIELDS = ["revocable"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['revocable']['start'] = self._io.pos()
-            self.revocable = self._io.read_u1()
-            self._debug['revocable']['end'] = self._io.pos()
-
-
-    class EmbeddedSignature(KaitaiStruct):
-        SEQ_FIELDS = ["signature_packet"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['signature_packet']['start'] = self._io.pos()
-            self.signature_packet = self._root.SignaturePacket(self._io, self, self._root)
-            self.signature_packet._read()
-            self._debug['signature_packet']['end'] = self._io.pos()
-
-
-    class PreferredKeyServer(KaitaiStruct):
-        SEQ_FIELDS = ["uri"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['uri']['start'] = self._io.pos()
-            self.uri = (self._io.read_bytes_full()).decode(u"UTF-8")
-            self._debug['uri']['end'] = self._io.pos()
-
-
-    class ReasonForRevocation(KaitaiStruct):
-        SEQ_FIELDS = ["revocation_code", "reason"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['revocation_code']['start'] = self._io.pos()
-            self.revocation_code = KaitaiStream.resolve_enum(self._root.RevocationCodes, self._io.read_u1())
-            self._debug['revocation_code']['end'] = self._io.pos()
-            self._debug['reason']['start'] = self._io.pos()
-            self.reason = (self._io.read_bytes_full()).decode(u"UTF-8")
-            self._debug['reason']['end'] = self._io.pos()
-
-
-    class LenSubpacket(KaitaiStruct):
-        SEQ_FIELDS = ["first_octet", "second_octet", "scalar"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['first_octet']['start'] = self._io.pos()
-            self.first_octet = self._io.read_u1()
-            self._debug['first_octet']['end'] = self._io.pos()
-            if  ((self.first_octet >= 192) and (self.first_octet < 255)) :
-                self._debug['second_octet']['start'] = self._io.pos()
-                self.second_octet = self._io.read_u1()
-                self._debug['second_octet']['end'] = self._io.pos()
-
-            if self.first_octet == 255:
-                self._debug['scalar']['start'] = self._io.pos()
-                self.scalar = self._io.read_u4be()
-                self._debug['scalar']['end'] = self._io.pos()
-
-
-        @property
-        def len(self):
-            if hasattr(self, '_m_len'):
-                return self._m_len if hasattr(self, '_m_len') else None
-
-            self._m_len = (self.first_octet if self.first_octet < 192 else (((((self.first_octet - 192) << 8) + self.second_octet) + 192) if  ((self.first_octet >= 192) and (self.first_octet < 255))  else self.scalar))
-            return self._m_len if hasattr(self, '_m_len') else None
-
-
-    class NotationData(KaitaiStruct):
-        SEQ_FIELDS = ["flags", "len_name", "len_value", "name", "value"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['flags']['start'] = self._io.pos()
-            self.flags = self._io.read_bytes(4)
-            self._debug['flags']['end'] = self._io.pos()
-            self._debug['len_name']['start'] = self._io.pos()
-            self.len_name = self._io.read_u2be()
-            self._debug['len_name']['end'] = self._io.pos()
-            self._debug['len_value']['start'] = self._io.pos()
-            self.len_value = self._io.read_u2be()
-            self._debug['len_value']['end'] = self._io.pos()
-            self._debug['name']['start'] = self._io.pos()
-            self.name = self._io.read_bytes(self.len_name)
-            self._debug['name']['end'] = self._io.pos()
-            self._debug['value']['start'] = self._io.pos()
-            self.value = self._io.read_bytes(self.len_value)
-            self._debug['value']['end'] = self._io.pos()
-
-
-    class PublicKeyPacket(KaitaiStruct):
-        SEQ_FIELDS = ["version", "timestamp", "public_key_algorithm", "len_alg", "rsa_n", "padding", "rsa_e"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['version']['start'] = self._io.pos()
-            self.version = self._io.read_u1()
-            self._debug['version']['end'] = self._io.pos()
-            self._debug['timestamp']['start'] = self._io.pos()
-            self.timestamp = self._io.read_u4be()
-            self._debug['timestamp']['end'] = self._io.pos()
-            self._debug['public_key_algorithm']['start'] = self._io.pos()
-            self.public_key_algorithm = KaitaiStream.resolve_enum(self._root.PublicKeyAlgorithms, self._io.read_u1())
-            self._debug['public_key_algorithm']['end'] = self._io.pos()
-            self._debug['len_alg']['start'] = self._io.pos()
-            self.len_alg = self._io.read_u2be()
-            self._debug['len_alg']['end'] = self._io.pos()
-            self._debug['rsa_n']['start'] = self._io.pos()
-            self.rsa_n = self._io.read_bytes(self.len_alg // 8)
-            self._debug['rsa_n']['end'] = self._io.pos()
-            self._debug['padding']['start'] = self._io.pos()
-            self.padding = self._io.read_u2be()
-            self._debug['padding']['end'] = self._io.pos()
-            self._debug['rsa_e']['start'] = self._io.pos()
-            self.rsa_e = self._io.read_bytes(3)
-            self._debug['rsa_e']['end'] = self._io.pos()
-
-
-    class KeyExpirationTime(KaitaiStruct):
-        SEQ_FIELDS = ["time"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['time']['start'] = self._io.pos()
-            self.time = self._io.read_u4be()
-            self._debug['time']['end'] = self._io.pos()
-
-
-    class Packet(KaitaiStruct):
-        SEQ_FIELDS = ["one", "new_packet_format", "packet_type_new", "packet_type_old", "len_type", "body"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['one']['start'] = self._io.pos()
-            self.one = self._io.read_bits_int(1) != 0
-            self._debug['one']['end'] = self._io.pos()
-            self._debug['new_packet_format']['start'] = self._io.pos()
-            self.new_packet_format = self._io.read_bits_int(1) != 0
-            self._debug['new_packet_format']['end'] = self._io.pos()
-            if self.new_packet_format:
-                self._debug['packet_type_new']['start'] = self._io.pos()
-                self.packet_type_new = KaitaiStream.resolve_enum(self._root.PacketTags, self._io.read_bits_int(6))
-                self._debug['packet_type_new']['end'] = self._io.pos()
-
-            if not (self.new_packet_format):
-                self._debug['packet_type_old']['start'] = self._io.pos()
-                self.packet_type_old = KaitaiStream.resolve_enum(self._root.PacketTags, self._io.read_bits_int(4))
-                self._debug['packet_type_old']['end'] = self._io.pos()
-
-            if not (self.new_packet_format):
-                self._debug['len_type']['start'] = self._io.pos()
-                self.len_type = self._io.read_bits_int(2)
-                self._debug['len_type']['end'] = self._io.pos()
-
-            self._io.align_to_byte()
-            self._debug['body']['start'] = self._io.pos()
-            _on = self.new_packet_format
-            if _on == False:
-                self.body = self._root.OldPacket(self._io, self, self._root)
-                self.body._read()
-            self._debug['body']['end'] = self._io.pos()
-
-
-    class TrustSignature(KaitaiStruct):
-        SEQ_FIELDS = ["level", "amount"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['level']['start'] = self._io.pos()
-            self.level = self._io.read_u1()
-            self._debug['level']['end'] = self._io.pos()
-            self._debug['amount']['start'] = self._io.pos()
-            self.amount = self._io.read_u1()
-            self._debug['amount']['end'] = self._io.pos()
-
-
-