spacedatastandards.org 1.73.0__py3-none-any.whl

EPM/CryptoKey.py

@@ -0,0 +1,213 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Represents cryptographic key information
+class CryptoKey(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = CryptoKey()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsCryptoKey(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def CryptoKeyBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x45\x50\x4D", size_prefixed=size_prefixed)
+
+    # CryptoKey
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Public part of the cryptographic key, in hexidecimal format
+    # CryptoKey
+    def PUBLIC_KEY(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Extended public key https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#extended-keys
+    # CryptoKey
+    def XPUB(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Private part of the cryptographic key in hexidecimal format, should be kept secret 
+    # CryptoKey
+    def PRIVATE_KEY(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Extended private key https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#extended-keys
+    # CryptoKey
+    def XPRIV(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Address generated from the cryptographic key
+    # CryptoKey
+    def KEY_ADDRESS(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Type of the address generated from the cryptographic key
+    # CryptoKey
+    def ADDRESS_TYPE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Type of the cryptographic key (signing or encryption)
+    # CryptoKey
+    def KEY_TYPE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+        return 0
+
+def CryptoKeyStart(builder):
+    builder.StartObject(7)
+
+def Start(builder):
+    CryptoKeyStart(builder)
+
+def CryptoKeyAddPUBLIC_KEY(builder, PUBLIC_KEY):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(PUBLIC_KEY), 0)
+
+def AddPUBLIC_KEY(builder, PUBLIC_KEY):
+    CryptoKeyAddPUBLIC_KEY(builder, PUBLIC_KEY)
+
+def CryptoKeyAddXPUB(builder, XPUB):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(XPUB), 0)
+
+def AddXPUB(builder, XPUB):
+    CryptoKeyAddXPUB(builder, XPUB)
+
+def CryptoKeyAddPRIVATE_KEY(builder, PRIVATE_KEY):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(PRIVATE_KEY), 0)
+
+def AddPRIVATE_KEY(builder, PRIVATE_KEY):
+    CryptoKeyAddPRIVATE_KEY(builder, PRIVATE_KEY)
+
+def CryptoKeyAddXPRIV(builder, XPRIV):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(XPRIV), 0)
+
+def AddXPRIV(builder, XPRIV):
+    CryptoKeyAddXPRIV(builder, XPRIV)
+
+def CryptoKeyAddKEY_ADDRESS(builder, KEY_ADDRESS):
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(KEY_ADDRESS), 0)
+
+def AddKEY_ADDRESS(builder, KEY_ADDRESS):
+    CryptoKeyAddKEY_ADDRESS(builder, KEY_ADDRESS)
+
+def CryptoKeyAddADDRESS_TYPE(builder, ADDRESS_TYPE):
+    builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(ADDRESS_TYPE), 0)
+
+def AddADDRESS_TYPE(builder, ADDRESS_TYPE):
+    CryptoKeyAddADDRESS_TYPE(builder, ADDRESS_TYPE)
+
+def CryptoKeyAddKEY_TYPE(builder, KEY_TYPE):
+    builder.PrependInt8Slot(6, KEY_TYPE, 0)
+
+def AddKEY_TYPE(builder, KEY_TYPE):
+    CryptoKeyAddKEY_TYPE(builder, KEY_TYPE)
+
+def CryptoKeyEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return CryptoKeyEnd(builder)
+
+
+class CryptoKeyT(object):
+
+    # CryptoKeyT
+    def __init__(self):
+        self.PUBLIC_KEY = None  # type: str
+        self.XPUB = None  # type: str
+        self.PRIVATE_KEY = None  # type: str
+        self.XPRIV = None  # type: str
+        self.KEY_ADDRESS = None  # type: str
+        self.ADDRESS_TYPE = None  # type: str
+        self.KEY_TYPE = 0  # type: int
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        cryptoKey = CryptoKey()
+        cryptoKey.Init(buf, pos)
+        return cls.InitFromObj(cryptoKey)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, cryptoKey):
+        x = CryptoKeyT()
+        x._UnPack(cryptoKey)
+        return x
+
+    # CryptoKeyT
+    def _UnPack(self, cryptoKey):
+        if cryptoKey is None:
+            return
+        self.PUBLIC_KEY = cryptoKey.PUBLIC_KEY()
+        self.XPUB = cryptoKey.XPUB()
+        self.PRIVATE_KEY = cryptoKey.PRIVATE_KEY()
+        self.XPRIV = cryptoKey.XPRIV()
+        self.KEY_ADDRESS = cryptoKey.KEY_ADDRESS()
+        self.ADDRESS_TYPE = cryptoKey.ADDRESS_TYPE()
+        self.KEY_TYPE = cryptoKey.KEY_TYPE()
+
+    # CryptoKeyT
+    def Pack(self, builder):
+        if self.PUBLIC_KEY is not None:
+            PUBLIC_KEY = builder.CreateString(self.PUBLIC_KEY)
+        if self.XPUB is not None:
+            XPUB = builder.CreateString(self.XPUB)
+        if self.PRIVATE_KEY is not None:
+            PRIVATE_KEY = builder.CreateString(self.PRIVATE_KEY)
+        if self.XPRIV is not None:
+            XPRIV = builder.CreateString(self.XPRIV)
+        if self.KEY_ADDRESS is not None:
+            KEY_ADDRESS = builder.CreateString(self.KEY_ADDRESS)
+        if self.ADDRESS_TYPE is not None:
+            ADDRESS_TYPE = builder.CreateString(self.ADDRESS_TYPE)
+        CryptoKeyStart(builder)
+        if self.PUBLIC_KEY is not None:
+            CryptoKeyAddPUBLIC_KEY(builder, PUBLIC_KEY)
+        if self.XPUB is not None:
+            CryptoKeyAddXPUB(builder, XPUB)
+        if self.PRIVATE_KEY is not None:
+            CryptoKeyAddPRIVATE_KEY(builder, PRIVATE_KEY)
+        if self.XPRIV is not None:
+            CryptoKeyAddXPRIV(builder, XPRIV)
+        if self.KEY_ADDRESS is not None:
+            CryptoKeyAddKEY_ADDRESS(builder, KEY_ADDRESS)
+        if self.ADDRESS_TYPE is not None:
+            CryptoKeyAddADDRESS_TYPE(builder, ADDRESS_TYPE)
+        CryptoKeyAddKEY_TYPE(builder, self.KEY_TYPE)
+        cryptoKey = CryptoKeyEnd(builder)
+        return cryptoKey

EPM/EPM.py

@@ -0,0 +1,480 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Entity Profile Message
+class EPM(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = EPM()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsEPM(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def EPMBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x45\x50\x4D", size_prefixed=size_prefixed)
+
+    # EPM
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Distinguished Name of the entity
+    # EPM
+    def DN(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Common name of the entity (person or organization)
+    # EPM
+    def LEGAL_NAME(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Family name or surname of the person
+    # EPM
+    def FAMILY_NAME(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Given name or first name of the person
+    # EPM
+    def GIVEN_NAME(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Additional name or middle name of the person
+    # EPM
+    def ADDITIONAL_NAME(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Honorific prefix preceding the person's name (e.g., Mr., Dr.)
+    # EPM
+    def HONORIFIC_PREFIX(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Honorific suffix following the person's name (e.g., Jr., Sr.)
+    # EPM
+    def HONORIFIC_SUFFIX(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Job title of the person
+    # EPM
+    def JOB_TITLE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Occupation of the person
+    # EPM
+    def OCCUPATION(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Physical Address
+    # EPM
+    def ADDRESS(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from Address import Address
+            obj = Address()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Alternate names for the entity
+    # EPM
+    def ALTERNATE_NAMES(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return ""
+
+    # EPM
+    def ALTERNATE_NAMESLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # EPM
+    def ALTERNATE_NAMESIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        return o == 0
+
+    # Email address of the entity
+    # EPM
+    def EMAIL(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Telephone number of the entity
+    # EPM
+    def TELEPHONE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Cryptographic keys associated with the entity
+    # EPM
+    def KEYS(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from CryptoKey import CryptoKey
+            obj = CryptoKey()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # EPM
+    def KEYSLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # EPM
+    def KEYSIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        return o == 0
+
+    # Multiformat addresses associated with the entity
+    # EPM
+    def MULTIFORMAT_ADDRESS(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return ""
+
+    # EPM
+    def MULTIFORMAT_ADDRESSLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # EPM
+    def MULTIFORMAT_ADDRESSIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
+        return o == 0
+
+def EPMStart(builder):
+    builder.StartObject(15)
+
+def Start(builder):
+    EPMStart(builder)
+
+def EPMAddDN(builder, DN):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(DN), 0)
+
+def AddDN(builder, DN):
+    EPMAddDN(builder, DN)
+
+def EPMAddLEGAL_NAME(builder, LEGAL_NAME):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(LEGAL_NAME), 0)
+
+def AddLEGAL_NAME(builder, LEGAL_NAME):
+    EPMAddLEGAL_NAME(builder, LEGAL_NAME)
+
+def EPMAddFAMILY_NAME(builder, FAMILY_NAME):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(FAMILY_NAME), 0)
+
+def AddFAMILY_NAME(builder, FAMILY_NAME):
+    EPMAddFAMILY_NAME(builder, FAMILY_NAME)
+
+def EPMAddGIVEN_NAME(builder, GIVEN_NAME):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(GIVEN_NAME), 0)
+
+def AddGIVEN_NAME(builder, GIVEN_NAME):
+    EPMAddGIVEN_NAME(builder, GIVEN_NAME)
+
+def EPMAddADDITIONAL_NAME(builder, ADDITIONAL_NAME):
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(ADDITIONAL_NAME), 0)
+
+def AddADDITIONAL_NAME(builder, ADDITIONAL_NAME):
+    EPMAddADDITIONAL_NAME(builder, ADDITIONAL_NAME)
+
+def EPMAddHONORIFIC_PREFIX(builder, HONORIFIC_PREFIX):
+    builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(HONORIFIC_PREFIX), 0)
+
+def AddHONORIFIC_PREFIX(builder, HONORIFIC_PREFIX):
+    EPMAddHONORIFIC_PREFIX(builder, HONORIFIC_PREFIX)
+
+def EPMAddHONORIFIC_SUFFIX(builder, HONORIFIC_SUFFIX):
+    builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(HONORIFIC_SUFFIX), 0)
+
+def AddHONORIFIC_SUFFIX(builder, HONORIFIC_SUFFIX):
+    EPMAddHONORIFIC_SUFFIX(builder, HONORIFIC_SUFFIX)
+
+def EPMAddJOB_TITLE(builder, JOB_TITLE):
+    builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(JOB_TITLE), 0)
+
+def AddJOB_TITLE(builder, JOB_TITLE):
+    EPMAddJOB_TITLE(builder, JOB_TITLE)
+
+def EPMAddOCCUPATION(builder, OCCUPATION):
+    builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(OCCUPATION), 0)
+
+def AddOCCUPATION(builder, OCCUPATION):
+    EPMAddOCCUPATION(builder, OCCUPATION)
+
+def EPMAddADDRESS(builder, ADDRESS):
+    builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(ADDRESS), 0)
+
+def AddADDRESS(builder, ADDRESS):
+    EPMAddADDRESS(builder, ADDRESS)
+
+def EPMAddALTERNATE_NAMES(builder, ALTERNATE_NAMES):
+    builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(ALTERNATE_NAMES), 0)
+
+def AddALTERNATE_NAMES(builder, ALTERNATE_NAMES):
+    EPMAddALTERNATE_NAMES(builder, ALTERNATE_NAMES)
+
+def EPMStartALTERNATE_NAMESVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartALTERNATE_NAMESVector(builder, numElems):
+    return EPMStartALTERNATE_NAMESVector(builder, numElems)
+
+def EPMAddEMAIL(builder, EMAIL):
+    builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(EMAIL), 0)
+
+def AddEMAIL(builder, EMAIL):
+    EPMAddEMAIL(builder, EMAIL)
+
+def EPMAddTELEPHONE(builder, TELEPHONE):
+    builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(TELEPHONE), 0)
+
+def AddTELEPHONE(builder, TELEPHONE):
+    EPMAddTELEPHONE(builder, TELEPHONE)
+
+def EPMAddKEYS(builder, KEYS):
+    builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(KEYS), 0)
+
+def AddKEYS(builder, KEYS):
+    EPMAddKEYS(builder, KEYS)
+
+def EPMStartKEYSVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartKEYSVector(builder, numElems):
+    return EPMStartKEYSVector(builder, numElems)
+
+def EPMAddMULTIFORMAT_ADDRESS(builder, MULTIFORMAT_ADDRESS):
+    builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(MULTIFORMAT_ADDRESS), 0)
+
+def AddMULTIFORMAT_ADDRESS(builder, MULTIFORMAT_ADDRESS):
+    EPMAddMULTIFORMAT_ADDRESS(builder, MULTIFORMAT_ADDRESS)
+
+def EPMStartMULTIFORMAT_ADDRESSVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartMULTIFORMAT_ADDRESSVector(builder, numElems):
+    return EPMStartMULTIFORMAT_ADDRESSVector(builder, numElems)
+
+def EPMEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return EPMEnd(builder)
+
+import Address
+import CryptoKey
+try:
+    from typing import List, Optional
+except:
+    pass
+
+class EPMT(object):
+
+    # EPMT
+    def __init__(self):
+        self.DN = None  # type: str
+        self.LEGAL_NAME = None  # type: str
+        self.FAMILY_NAME = None  # type: str
+        self.GIVEN_NAME = None  # type: str
+        self.ADDITIONAL_NAME = None  # type: str
+        self.HONORIFIC_PREFIX = None  # type: str
+        self.HONORIFIC_SUFFIX = None  # type: str
+        self.JOB_TITLE = None  # type: str
+        self.OCCUPATION = None  # type: str
+        self.ADDRESS = None  # type: Optional[Address.AddressT]
+        self.ALTERNATE_NAMES = None  # type: List[str]
+        self.EMAIL = None  # type: str
+        self.TELEPHONE = None  # type: str
+        self.KEYS = None  # type: List[CryptoKey.CryptoKeyT]
+        self.MULTIFORMAT_ADDRESS = None  # type: List[str]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        EPM = EPM()
+        EPM.Init(buf, pos)
+        return cls.InitFromObj(EPM)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, EPM):
+        x = EPMT()
+        x._UnPack(EPM)
+        return x
+
+    # EPMT
+    def _UnPack(self, EPM):
+        if EPM is None:
+            return
+        self.DN = EPM.DN()
+        self.LEGAL_NAME = EPM.LEGAL_NAME()
+        self.FAMILY_NAME = EPM.FAMILY_NAME()
+        self.GIVEN_NAME = EPM.GIVEN_NAME()
+        self.ADDITIONAL_NAME = EPM.ADDITIONAL_NAME()
+        self.HONORIFIC_PREFIX = EPM.HONORIFIC_PREFIX()
+        self.HONORIFIC_SUFFIX = EPM.HONORIFIC_SUFFIX()
+        self.JOB_TITLE = EPM.JOB_TITLE()
+        self.OCCUPATION = EPM.OCCUPATION()
+        if EPM.ADDRESS() is not None:
+            self.ADDRESS = Address.AddressT.InitFromObj(EPM.ADDRESS())
+        if not EPM.ALTERNATE_NAMESIsNone():
+            self.ALTERNATE_NAMES = []
+            for i in range(EPM.ALTERNATE_NAMESLength()):
+                self.ALTERNATE_NAMES.append(EPM.ALTERNATE_NAMES(i))
+        self.EMAIL = EPM.EMAIL()
+        self.TELEPHONE = EPM.TELEPHONE()
+        if not EPM.KEYSIsNone():
+            self.KEYS = []
+            for i in range(EPM.KEYSLength()):
+                if EPM.KEYS(i) is None:
+                    self.KEYS.append(None)
+                else:
+                    cryptoKey_ = CryptoKey.CryptoKeyT.InitFromObj(EPM.KEYS(i))
+                    self.KEYS.append(cryptoKey_)
+        if not EPM.MULTIFORMAT_ADDRESSIsNone():
+            self.MULTIFORMAT_ADDRESS = []
+            for i in range(EPM.MULTIFORMAT_ADDRESSLength()):
+                self.MULTIFORMAT_ADDRESS.append(EPM.MULTIFORMAT_ADDRESS(i))
+
+    # EPMT
+    def Pack(self, builder):
+        if self.DN is not None:
+            DN = builder.CreateString(self.DN)
+        if self.LEGAL_NAME is not None:
+            LEGAL_NAME = builder.CreateString(self.LEGAL_NAME)
+        if self.FAMILY_NAME is not None:
+            FAMILY_NAME = builder.CreateString(self.FAMILY_NAME)
+        if self.GIVEN_NAME is not None:
+            GIVEN_NAME = builder.CreateString(self.GIVEN_NAME)
+        if self.ADDITIONAL_NAME is not None:
+            ADDITIONAL_NAME = builder.CreateString(self.ADDITIONAL_NAME)
+        if self.HONORIFIC_PREFIX is not None:
+            HONORIFIC_PREFIX = builder.CreateString(self.HONORIFIC_PREFIX)
+        if self.HONORIFIC_SUFFIX is not None:
+            HONORIFIC_SUFFIX = builder.CreateString(self.HONORIFIC_SUFFIX)
+        if self.JOB_TITLE is not None:
+            JOB_TITLE = builder.CreateString(self.JOB_TITLE)
+        if self.OCCUPATION is not None:
+            OCCUPATION = builder.CreateString(self.OCCUPATION)
+        if self.ADDRESS is not None:
+            ADDRESS = self.ADDRESS.Pack(builder)
+        if self.ALTERNATE_NAMES is not None:
+            ALTERNATE_NAMESlist = []
+            for i in range(len(self.ALTERNATE_NAMES)):
+                ALTERNATE_NAMESlist.append(builder.CreateString(self.ALTERNATE_NAMES[i]))
+            EPMStartALTERNATE_NAMESVector(builder, len(self.ALTERNATE_NAMES))
+            for i in reversed(range(len(self.ALTERNATE_NAMES))):
+                builder.PrependUOffsetTRelative(ALTERNATE_NAMESlist[i])
+            ALTERNATE_NAMES = builder.EndVector()
+        if self.EMAIL is not None:
+            EMAIL = builder.CreateString(self.EMAIL)
+        if self.TELEPHONE is not None:
+            TELEPHONE = builder.CreateString(self.TELEPHONE)
+        if self.KEYS is not None:
+            KEYSlist = []
+            for i in range(len(self.KEYS)):
+                KEYSlist.append(self.KEYS[i].Pack(builder))
+            EPMStartKEYSVector(builder, len(self.KEYS))
+            for i in reversed(range(len(self.KEYS))):
+                builder.PrependUOffsetTRelative(KEYSlist[i])
+            KEYS = builder.EndVector()
+        if self.MULTIFORMAT_ADDRESS is not None:
+            MULTIFORMAT_ADDRESSlist = []
+            for i in range(len(self.MULTIFORMAT_ADDRESS)):
+                MULTIFORMAT_ADDRESSlist.append(builder.CreateString(self.MULTIFORMAT_ADDRESS[i]))
+            EPMStartMULTIFORMAT_ADDRESSVector(builder, len(self.MULTIFORMAT_ADDRESS))
+            for i in reversed(range(len(self.MULTIFORMAT_ADDRESS))):
+                builder.PrependUOffsetTRelative(MULTIFORMAT_ADDRESSlist[i])
+            MULTIFORMAT_ADDRESS = builder.EndVector()
+        EPMStart(builder)
+        if self.DN is not None:
+            EPMAddDN(builder, DN)
+        if self.LEGAL_NAME is not None:
+            EPMAddLEGAL_NAME(builder, LEGAL_NAME)
+        if self.FAMILY_NAME is not None:
+            EPMAddFAMILY_NAME(builder, FAMILY_NAME)
+        if self.GIVEN_NAME is not None:
+            EPMAddGIVEN_NAME(builder, GIVEN_NAME)
+        if self.ADDITIONAL_NAME is not None:
+            EPMAddADDITIONAL_NAME(builder, ADDITIONAL_NAME)
+        if self.HONORIFIC_PREFIX is not None:
+            EPMAddHONORIFIC_PREFIX(builder, HONORIFIC_PREFIX)
+        if self.HONORIFIC_SUFFIX is not None:
+            EPMAddHONORIFIC_SUFFIX(builder, HONORIFIC_SUFFIX)
+        if self.JOB_TITLE is not None:
+            EPMAddJOB_TITLE(builder, JOB_TITLE)
+        if self.OCCUPATION is not None:
+            EPMAddOCCUPATION(builder, OCCUPATION)
+        if self.ADDRESS is not None:
+            EPMAddADDRESS(builder, ADDRESS)
+        if self.ALTERNATE_NAMES is not None:
+            EPMAddALTERNATE_NAMES(builder, ALTERNATE_NAMES)
+        if self.EMAIL is not None:
+            EPMAddEMAIL(builder, EMAIL)
+        if self.TELEPHONE is not None:
+            EPMAddTELEPHONE(builder, TELEPHONE)
+        if self.KEYS is not None:
+            EPMAddKEYS(builder, KEYS)
+        if self.MULTIFORMAT_ADDRESS is not None:
+            EPMAddMULTIFORMAT_ADDRESS(builder, MULTIFORMAT_ADDRESS)
+        EPM = EPMEnd(builder)
+        return EPM

EPM/KeyType.py

@@ -0,0 +1,7 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+class KeyType(object):
+    Signing = 0
+    Encryption = 1