diff --git a/README.md b/README.md
index fd294d9..1ef0489 100644
--- a/README.md
+++ b/README.md
@@ -6,7 +6,7 @@ A library to create and issue biometrically-binding QR code identity cards.
 
 ![Alt text](idpasslite_qr.png?raw=true "api")
 
-## Getting started
+## Getting Started
 
 This library can be used in C and C++ projects. Download `libidpasslite.so` from the [Releases](https://github.com/idpass/idpass-lite/releases) page or [build it from source](https://github.com/idpass/idpass-lite/wiki/Building-from-source), then add it to the project that will use it.
 
diff --git a/build.sh b/build.sh
index 092cdb1..741491e 100755
--- a/build.sh
+++ b/build.sh
@@ -186,8 +186,8 @@ build_desktop_idpasslite() {
     assert_exists cmake
     assert_exists make
     # for #include <jni.h>
-    assert_exists java 
-    assert_exists javac 
+    # assert_exists java
+    # assert_exists javac
 
     build_release
 }
diff --git a/lib/src/idpass.cpp b/lib/src/idpass.cpp
index 38ee6b4..b3fa3c0 100755
--- a/lib/src/idpass.cpp
+++ b/lib/src/idpass.cpp
@@ -2107,6 +2107,22 @@ unsigned char* idpass_lite_merge_CardDetails(unsigned char* d1buf,
     return buf;
 }
 
+MODULE_API
+char* idpass_lite_qrcodesvg(void* self,
+                            const unsigned char* data,
+                            int data_len)
+{
+    if (self == nullptr || data == nullptr
+        || data_len <= 0) 
+    {
+        return nullptr; 
+    }
+    Context* context = (Context*)self;
+    std::lock_guard<std::mutex> guard(context->mtx); // protect the static output buf
+
+    return qrcode_svg(data, data_len, context->qrcode_ecc);
+}
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/lib/src/idpass.h b/lib/src/idpass.h
index fd51f34..23a40cc 100755
--- a/lib/src/idpass.h
+++ b/lib/src/idpass.h
@@ -577,6 +577,12 @@ unsigned char* idpass_lite_merge_CardDetails(unsigned char* d1buf,
                                              int d2buf_len,
                                              int* outlen);
 
+
+MODULE_API
+char* idpass_lite_qrcodesvg(void* self,
+                            const unsigned char* data,
+                            int data_len);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/lib/src/qrcode.cpp b/lib/src/qrcode.cpp
index 6fb607b..e50a237 100755
--- a/lib/src/qrcode.cpp
+++ b/lib/src/qrcode.cpp
@@ -146,6 +146,18 @@ static const uint16_t NUM_RAW_DATA_MODULES = 567;
 
 #endif
 
+const char* str1 = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
+const char* str2 = "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">";
+const char* str4 = "\t<rect width=\"100%\" height=\"100%\" fill=\"#FFFFFF\"/>";
+const char* str5 = "\t<path d=\"";
+const char* str7 = "\" fill=\"#000000\"/>";
+const char* str8 = "</svg>";
+
+static void StringBuilder_append(char *dest, const char *stuff)
+{
+    strcat(dest, stuff);
+}
+
 static int max(int a, int b)
 {
     if (a > b) {
@@ -1225,3 +1237,64 @@ void qrcode_getHex(QRCode *qrcode, char *result) {
 
 }
 */
+
+char *qrcode_svg(const unsigned char *data,
+                 int data_len,
+                 int ecc)
+{
+    // Create the QR code
+    QRCode qrcode;
+    int version = 1; // start with version 1
+
+    int status = qrcode_initText(&qrcode,
+                                 nullptr,
+                                 version,
+                                 ecc,
+                                 reinterpret_cast<const char *>(data),
+                                 data_len);
+
+    if (status != 0)
+        return NULL;
+
+    char str3[100];
+    static char output[524288];
+    char str6[100];
+
+    output[0] = '\0';
+
+    auto SetBit = [](unsigned char A[], int k) {
+        // Set the bit at the k-th position in A[i]
+        A[k / 8] |= 1 << (k % 8);
+    };
+
+    int n = qrcode.size;
+    int border = 3;
+
+    sprintf(str3, "<svg xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\" viewBox=\"0 0 %d %d\" stroke=\"none\">", n + border * 2, n + border * 2);
+
+    StringBuilder_append(output, str1);
+    StringBuilder_append(output, str2);
+    StringBuilder_append(output, str3);
+    StringBuilder_append(output, str4);
+    StringBuilder_append(output, str5);
+
+    for (uint8_t y = 0; y < n; y++) {
+        // Each horizontal module
+        for (uint8_t x = 0; x < n; x++) {
+            int p = (y * n + x);
+            if (qrcode_getModule(&qrcode, x, y)) {
+                // SetBit(pixels, p);
+                if (x != 0 || y != 0) {
+                    StringBuilder_append(output, " ");
+                }
+                sprintf(str6, "M%d,%dh1v1h-1z", y + border, x + border);
+                StringBuilder_append(output, str6);
+            }
+        }
+    }
+
+    StringBuilder_append(output, str7);
+    StringBuilder_append(output, str8);
+    // printf("%s\n", output);
+    return output;
+}
diff --git a/lib/src/qrcode.h b/lib/src/qrcode.h
index 1d42ebd..87f85a3 100755
--- a/lib/src/qrcode.h
+++ b/lib/src/qrcode.h
@@ -97,6 +97,10 @@ uint8_t *qrcode_getpixel(const unsigned char *data,
                          int *,
                          int ecc);
 
+char *qrcode_svg(const unsigned char *data,
+                 int data_len,
+                 int ecc);
+
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */
diff --git a/python-wrap/IDPassLite.py b/python-wrap/IDPassLite.py
new file mode 100644
index 0000000..10da422
--- /dev/null
+++ b/python-wrap/IDPassLite.py
@@ -0,0 +1,222 @@
+from ctypes import *
+import sys
+from IDPassNative import IDPassNative
+import idpasslite_pb2
+import api_pb2
+
+class Helper(object):
+    def generate_encryption_key():
+        key = (c_ubyte * 32)()
+        IDPassNative.lib.idpass_lite_generate_encryption_key(key, len(key))
+        return key
+
+    def generate_secret_signature_keypair():
+        ver = (c_ubyte * 32)()
+        sig = (c_ubyte * 64)()
+        IDPassNative.lib.idpass_lite_generate_secret_signature_keypair(ver, len(ver), sig, len(sig))
+        return (ver, sig)
+
+    def getPublicKey(privatekey):
+        #print(type(privatekey))
+        pubkey = (c_ubyte * 32)(*privatekey[32:64])
+        return pubkey
+
+class Reader(object):
+    ctx = 0
+    m_keySet = None
+
+    def __init__(self, keySet):
+        self.m_keySet = keySet
+        keysetba = bytearray(self.m_keySet.SerializeToString())
+        self.ctx = IDPassNative.lib.idpass_lite_init((c_ubyte * len(keysetba))(*keysetba), len(keysetba), None , 0)
+        if self.ctx is None:
+            raise ValueError('fail to initialize with specified keys')
+        self.ioctl(IDPassNative.IOCTL_SET_ACL, IDPassNative.DETAIL_SURNAME | IDPassNative.DETAIL_GIVENNAME)
+
+    def ioctl(self, cmd, param):
+        #IOCTL_SET_FDIM = 0x02 # full mode
+        ioctlcmd = [ cmd, param ] 
+        IDPassNative.lib.idpass_lite_ioctl( self.ctx, None, (c_ubyte * len(ioctlcmd))(*ioctlcmd), len(ioctlcmd) )
+
+    # ioctl cannot influence the setting and there is no more setting
+    # since the template are already generated. There is no context 
+    # this is a static method
+    def compare_face_template(self, input1, input2):
+        fdiff = c_float(10.0)
+        status = IDPassNative.lib.idpass_lite_compare_face_template(
+            (c_ubyte *len(input1))(*input1), 
+            len(input1), 
+            (c_ubyte *len(input2))(*input2), 
+            len(input2), 
+            byref(fdiff))
+        if status != 0:
+            raise ValueError('fail to compute face template error code [%d]' % status)
+        return fdiff.value
+
+    def computeFullTemplate(self, inputfile):
+        photo = open(inputfile, "rb").read()
+        # 128 floats with 4 bytes per float (128*4 = 512)
+        # Do not (c_ubyte * 128*4)() as that creates two-dimensional
+        # array where len(fdim) = 4 and len(fdim[0]) = 128
+        fdim = (c_ubyte *512)()
+        facecount = IDPassNative.lib.idpass_lite_face128dbuf( 
+                        self.ctx,
+                        (c_ubyte * len(photo))(*photo), 
+                        len(photo), 
+                        fdim
+                        )
+
+        if facecount != 1:
+            raise ValueError('Dlib found %d face(s) error' % facecount)
+        return bytearray(fdim)
+
+    def computeHalfTemplate(self, inputfile):
+        photo = open(inputfile, "rb").read()
+        # 64 floats with 2 bytes per float (64*2 = 128)
+        # Do not (c_ubyte * 64*2)() as that creates two-dimensional
+        # array where len(fdim) = 2 and len(fdim[0]) = 64
+        hdim = (c_ubyte *128)()
+        facecount = IDPassNative.lib.idpass_lite_face64dbuf(
+                        self.ctx,
+                        (c_ubyte * len(photo))(*photo), 
+                        len(photo), 
+                        hdim
+                        )
+
+        if facecount != 1:
+            raise ValueError('Dlib found %d face(s) error' % facecount)
+        return bytearray(hdim)
+
+    def computeFullTemplateAsFloats(self, inputfile):
+        photo = open(inputfile, "rb").read()
+        fdim = (c_float *128)()
+        facecount = IDPassNative.lib.idpass_lite_face128d(
+                        self.ctx,
+                        (c_ubyte * len(photo))(*photo), 
+                        len(photo), 
+                        fdim)
+        
+        if facecount != 1:
+            raise ValueError('Dlib found %d face(s) error' % facecount)
+        return fdim    
+
+    # The ioctl setting can switch to full or half and this influences
+    # the facial biometry representation either in full 512 bytes or in
+    # half 128 bytes, and from these representation the Euclidean 
+    # difference is calculated. There is context as first param
+    def compare_face_photo(self, inputfile1, inputfile2):
+        photo1 = open(inputfile1, "rb").read()
+        photo2 = open(inputfile2, "rb").read()
+
+        fdiff = c_float(10.0)
+        status = IDPassNative.lib.idpass_lite_compare_face_photo(
+            self.ctx,
+            (c_ubyte * len(photo1))(*photo1),
+            len(photo1),
+            (c_ubyte * len(photo2))(*photo2),
+            len(photo2),
+            byref(fdiff))
+        if status != 0:
+            raise ValueError('fail to compute face template error code [%d]' % status)
+        return fdiff.value
+
+    def computeHalfTemplateAsFloats(self, inputfile):
+        photo = open(inputfile, "rb").read()
+        hdim = (c_float *64)()
+        facecount = IDPassNative.lib.idpass_lite_face64d(
+                        self.ctx,
+                        (c_ubyte * len(photo))(*photo), 
+                        len(photo), 
+                        hdim)
+
+        if facecount != 1:
+            raise ValueError('Dlib found %d face(s) error' % facecount)
+        return hdim
+
+    def create_card_with_face(self, ident):
+        identba = bytearray(ident.SerializeToString())
+        cardbalen = c_int(0)
+
+        cardba = IDPassNative.lib.idpass_lite_create_card_with_face(
+            self.ctx, 
+            byref(cardbalen),
+            (c_ubyte * len(identba))(*identba), 
+            len(identba)
+            )
+
+        if cardba is None:
+            raise ValueError('create card with face error')
+        cards = idpasslite_pb2.IDPassCards()
+        cards.ParseFromString(string_at(cardba, cardbalen.value))
+        card = Card(self.ctx, cardba, cardbalen.value)
+        return card
+
+    def _create_card_with_face(self, ident):
+        identba = bytearray(ident.SerializeToString())
+        cardbalen = c_int(0)
+
+        cardba = IDPassNative.lib.idpass_lite_create_card_with_face(
+            self.ctx, 
+            byref(cardbalen),
+            (c_ubyte * len(identba))(*identba), 
+            len(identba)
+            )
+
+        if cardba is None:
+            raise ValueError('create card with face error')
+        cards = idpasslite_pb2.IDPassCards()
+        cards.ParseFromString(string_at(cardba, cardbalen.value))
+        return (cards, cardba, cardbalen.value) # TODO: Improve API
+
+    # TODO: Do something like in Java below, or probably better this is done inside
+    # libidpasslite.so in C++ as the string type format is portable
+    # https://github.com/idpass/idpass-lite-java/blob/develop/src/main/java/org/idpass/lite/IDPassReader.java#L515-L547
+    def asQRCode(self, data, datalen):
+        #inputdata = (c_ubyte * len(data)).from_buffer_copy(data)
+        buf = IDPassNative.lib.idpass_lite_qrcodesvg(self.ctx, data, datalen)
+        _strip1 = str(cast(buf,c_char_p).value)[2:]
+        content = _strip1[:-1]
+        return content
+
+    def authenticateWithPin(self, cardba, cardbalen, pincode):
+        details = idpasslite_pb2.CardDetails()
+        buflen = c_int(0)
+        buf = IDPassNative.lib.idpass_lite_verify_card_with_pin(
+            self.ctx, 
+            byref(buflen), 
+            cardba, 
+            cardbalen, 
+            pincode.encode('utf-8'))
+        if buflen.value == 0:
+            return None
+        details.ParseFromString(string_at(buf, buflen))
+        return details
+
+    def freemem(self, addr):
+        IDPassNative.lib.idpass_lite_freemem(self.ctx, addr)
+
+class Card(object):
+    def __init__(self, ctx, buf, buflen):
+        self.ctx = ctx
+        self.buf = buf
+        self.buflen = buflen
+
+    def asQRCodeSVG(self):
+        buf = IDPassNative.lib.idpass_lite_qrcodesvg(self.ctx, self.buf, self.buflen)
+        _strip1 = str(cast(buf,c_char_p).value)[2:]
+        content = _strip1[:-1]
+        return content
+
+    def authenticateWithPin(self, pincode):
+        details = idpasslite_pb2.CardDetails()
+        buflen = c_int(0)
+        buf = IDPassNative.lib.idpass_lite_verify_card_with_pin(
+            self.ctx, 
+            byref(buflen), 
+            self.buf, 
+            self.buflen, 
+            pincode.encode('utf-8'))
+        if buflen.value == 0:
+            return None
+        details.ParseFromString(string_at(buf, buflen))
+        return details
diff --git a/python-wrap/IDPassNative.py b/python-wrap/IDPassNative.py
new file mode 100644
index 0000000..ca1763b
--- /dev/null
+++ b/python-wrap/IDPassNative.py
@@ -0,0 +1,107 @@
+# https://github.com/newlogic42/lab_idpass_lite/blob/master/lib/src/idpass.h
+
+import ctypes
+import ctypes.util
+import sys,os,signal
+
+def signal_handler(sig, frame):
+    print('You pressed Ctrl+C!')
+    sys.exit(0)
+
+class IDPassNative(object):
+    IOCTL_SET_FACEDIFF = 0x00
+    IOCTL_GET_FACEDIFF = 0x01
+    IOCTL_SET_FDIM = 0x02
+    IOCTL_GET_FDIM = 0x03
+    IOCTL_SET_ECC = 0x04
+    IOCTL_SET_ACL = 0x05
+    
+    DETAIL_SURNAME = 1
+    DETAIL_GIVENNAME = 2
+    DETAIL_DATEOFBIRTH = 4
+    DETAIL_PLACEOFBIRTH = 8
+    DETAIL_CREATEDAT = 16
+    DETAIL_UIN = 32
+    DETAIL_FULLNAME = 64
+    DETAIL_GENDER = 128
+    DETAIL_POSTALADDRESS = 256
+
+    try:
+        # lib = CDLL("lib/libidpasslite.so")
+        # Linux   -> export LD_LIBRARY_PATH=/path/to/lib/:$LB_LIBRARY_PATH
+        # Windows -> set PATH=c:/path/to/lib;%PATH%
+        idpasslite = ctypes.util.find_library('idpasslite') or ctypes.util.find_library('libidpasslite')
+
+        if idpasslite is None:
+            raise ValueError('Unable to find idpasslite library')
+
+        lib = ctypes.cdll.LoadLibrary(idpasslite)
+        if not lib._name:
+            raise ValueError('Unable to correctly load idpasslite library')
+
+        signal.signal(signal.SIGINT, signal_handler)
+
+        # These argtypes/restype signatures declarations here are optional but helps in a certain way
+        lib.idpass_lite_ioctl.argtypes = [ ctypes.c_void_p, ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_ubyte), ctypes.c_int ]
+        lib.idpass_lite_ioctl.restype = ctypes.POINTER(ctypes.c_ubyte)
+
+        lib.idpass_lite_compare_face_photo.argtypes = [ ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_int, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_int, ctypes.POINTER(ctypes.c_float) ]
+        lib.idpass_lite_compare_face_photo.restype = ctypes.c_int
+
+        # doesn't need ctx and can be invoke as a class method just like the generate key methods
+        lib.idpass_lite_compare_face_template.argtypes = [ ctypes.POINTER(ctypes.c_ubyte), ctypes.c_int, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_int, ctypes.POINTER(ctypes.c_float) ]
+        lib.idpass_lite_compare_face_template.restype = ctypes.c_int
+
+        lib.idpass_lite_face128d.argtypes = [ ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_int, ctypes.POINTER(ctypes.c_float) ]
+        lib.idpass_lite_face128d.restype = ctypes.c_int
+
+        lib.idpass_lite_face64d.argtypes = [ ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_int, ctypes.POINTER(ctypes.c_float) ]
+        lib.idpass_lite_face64d.restype = ctypes.c_int
+
+        # since output size already known, then caller must pre-allocate the last param as 128*4 bytes and then pass into function
+        lib.idpass_lite_face128dbuf.argtypes = [ ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_int, ctypes.POINTER(ctypes.c_ubyte) ]
+        lib.idpass_lite_face128dbuf.restype = ctypes.c_int
+
+        # since output size already known, then caller must pre-allocate the last param as 64*2 bytes and then pass into function
+        lib.idpass_lite_face64dbuf.argtypes = [ ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_int, ctypes.POINTER(ctypes.c_ubyte) ]
+        lib.idpass_lite_face64dbuf.restype = ctypes.c_int
+
+        lib.idpass_lite_generate_encryption_key.argtypes = [ ctypes.POINTER(ctypes.c_ubyte), ctypes.c_int ]
+        lib.idpass_lite_generate_encryption_key.restype = ctypes.c_int
+
+        lib.idpass_lite_generate_secret_signature_keypair.argtypes = [ ctypes.POINTER(ctypes.c_ubyte), ctypes.c_int, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_int]
+        lib.idpass_lite_generate_secret_signature_keypair.restype = ctypes.c_int
+
+        lib.idpass_lite_init.argtypes = [ ctypes.POINTER(ctypes.c_ubyte), ctypes.c_int, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_int]
+        lib.idpass_lite_init.restype = ctypes.c_void_p
+
+        lib.idpass_lite_create_card_with_face.argtypes = [ 
+            ctypes.c_void_p, 
+            ctypes.POINTER(ctypes.c_int), 
+            ctypes.POINTER(ctypes.c_ubyte), 
+            ctypes.c_int
+            ]
+
+        lib.idpass_lite_create_card_with_face.restype = ctypes.POINTER(ctypes.c_ubyte)
+
+        lib.idpass_lite_verify_card_with_pin.argtypes = [ 
+            ctypes.c_void_p, 
+            ctypes.POINTER(ctypes.c_int), 
+            ctypes.POINTER(ctypes.c_ubyte), 
+            ctypes.c_int, 
+            ctypes.POINTER(ctypes.c_char) 
+            ]
+        lib.idpass_lite_verify_card_with_pin.restype = ctypes.POINTER(ctypes.c_ubyte)
+
+        lib.idpass_lite_qrpixel2.argtypes = [ ctypes.c_void_p, ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_ubyte), ctypes.c_int, ctypes.POINTER(ctypes.c_int) ]
+        lib.idpass_lite_qrpixel2.restype = ctypes.POINTER(ctypes.c_ubyte)
+
+        lib.idpass_lite_freemem.argtypes = [ ctypes.c_void_p, ctypes.c_void_p ]
+        lib.idpass_lite_freemem.restype = None
+
+        lib.idpass_lite_qrcodesvg.argtypes = [ ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_int ]
+        lib.idpass_lite_qrcodesvg.restype = ctypes.POINTER(ctypes.c_char_p)
+
+    except Exception as e:
+        print(str(e))
+        sys.exit(1)
diff --git a/python-wrap/README.md b/python-wrap/README.md
new file mode 100644
index 0000000..6644746
--- /dev/null
+++ b/python-wrap/README.md
@@ -0,0 +1,70 @@
+### Test run in a backend deploy
+
+All that is needed is inside the `python-wrap/` folder. So doing a `cp -a python-wrap/* /some/other/path/` followed by:
+
+```
+cd /home/other/path/
+./run.sh
+```
+
+So, basically in `run.sh` we have:
+
+```
+test ID details -> main.py -> qrcode1.svg, qrcode2.svg
+```
+
+will generate an `qrcode1.svg` output file using a test identity detail in `ident1.json`, `ident2.json`
+
+
+### Usage within another application
+
+General description:
+
+- Initialize `Reader` with a key set. Generated QR codes using the `demokeys.bin` key set shall be readable from the "Android Smartscanner mobile app".
+- Given an identity details in `json` format, convert this `json` into it's corresponding protobuf message equivalent (Ident)
+- Call `reader.create_card_with_face(identobj)` will return a `Card` object
+- Calling `card.asQRCodeSVG()` will return a QR code representation of the card.
+- Open this QR code SVG format from a browser, and scan it using the "ID PASS Smartscanner Android mobile app" 
+
+```
+keySet = KEYSET_fromFile("demokeys.bin")    # Load matching keyset 
+reader = IDPassLite.Reader(keySet)          # create reader object associated with a key set
+ident = getIdentFromJson("ident1.json")     # create ident object from an identity json
+card  = reader.create_card_with_face(ident) # generate card from an ident object
+svg = card.asQRCodeSVG()                    # generate SVG QR code from a card
+open("qrcode.svg","w").write(svg)           # write SVG file to disc
+```
+
+### Step debug in VSCode IDE:
+
+To develop further the python wrapping API using VSCode IDE:
+
+```
+cd python-wrap
+./code.sh
+```
+
+Some notes of where some files are coming from. The below `.py` files are auto-generated from the [library's proto files](https://github.com/idpass/idpass-lite/tree/python-wrap/lib/src/proto):
+
+- api_pb2.py
+- idpasslite_pb2.py
+
+via command 
+
+```
+dependencies/build/desktop/bin/protoc --proto_path=lib/src/proto --python_out=myoutdir lib/src/proto/api.proto lib/src/proto/idpasslite.proto
+```
+
+It's recommended to use the library's provided `protoc` compiler to ensure compatibility. The `libidpasslite.so` library is the output of:
+
+```
+./build.sh desktop
+``` 
+
+The `demokeys.bin` is a demo key. QR codes that are generated from this key set is readable in "ID PASS Android Smartscanner Mobile App".
+
+The `IDPassNative.py` loads `idpasslite.so` library. The library's methods defined in [idpass.h](https://github.com/idpass/idpass-lite/blob/python-wrap/lib/src/idpass.h) are mapped in `IDPassNative.py`. 
+
+# Miscellaneous Notes
+
+- The function `idpass_lite_qrcodesvg` in idpass.h is not multithreaded and is protected by a mutex. Currently, an `output` array of 5MB is made static in order for the `output` heap memory to survive upon return at the python space. 
diff --git a/python-wrap/api_pb2.py b/python-wrap/api_pb2.py
new file mode 100644
index 0000000..a803b43
--- /dev/null
+++ b/python-wrap/api_pb2.py
@@ -0,0 +1,435 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: api.proto
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+import idpasslite_pb2 as idpasslite__pb2
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='api.proto',
+  package='api',
+  syntax='proto3',
+  serialized_options=b'\n\rorg.api.protoP\001',
+  create_key=_descriptor._internal_create_key,
+  serialized_pb=b'\n\tapi.proto\x12\x03\x61pi\x1a\x10idpasslite.proto\"\x9f\x01\n\tbyteArray\x12\x1f\n\x03typ\x18\x01 \x01(\x0e\x32\x12.api.byteArray.Typ\x12\x0b\n\x03val\x18\x02 \x01(\x0c\"d\n\x03Typ\x12\x08\n\x04\x42LOB\x10\x00\x12\x0b\n\x07\x41\x45\x41\x44KEY\x10\x01\x12\x11\n\rED25519PUBKEY\x10\x02\x12\x12\n\x0e\x45\x44\x32\x35\x35\x31\x39PRIVKEY\x10\x03\x12\x14\n\x10\x45\x44\x32\x35\x35\x31\x39SIGNATURE\x10\x04\x12\t\n\x05PHOTO\x10\x05\"*\n\nbyteArrays\x12\x1c\n\x04vals\x18\x01 \x03(\x0b\x32\x0e.api.byteArray\"_\n\x06KeySet\x12\x15\n\rencryptionKey\x18\x01 \x01(\x0c\x12\x14\n\x0csignatureKey\x18\x02 \x01(\x0c\x12(\n\x10verificationKeys\x18\x03 \x03(\x0b\x32\x0e.api.byteArray\"1\n\x0c\x43\x65rtificates\x12!\n\x04\x63\x65rt\x18\x01 \x03(\x0b\x32\x13.idpass.Certificate\"\xbf\x02\n\x05Ident\x12\x0f\n\x07surName\x18\x01 \x01(\t\x12\x11\n\tgivenName\x18\x02 \x01(\t\x12\x14\n\x0cplaceOfBirth\x18\x03 \x01(\t\x12\x0b\n\x03pin\x18\x04 \x01(\t\x12!\n\x0b\x64\x61teOfBirth\x18\x05 \x01(\x0b\x32\x0c.idpass.Date\x12\x1f\n\x06photos\x18\x06 \x01(\x0b\x32\x0f.api.byteArrays\x12\r\n\x05photo\x18\x07 \x01(\x0c\x12\x1f\n\tprivExtra\x18\x08 \x03(\x0b\x32\x0c.idpass.Pair\x12\x1e\n\x08pubExtra\x18\t \x03(\x0b\x32\x0c.idpass.Pair\x12\x0b\n\x03UIN\x18\n \x01(\t\x12\x10\n\x08\x66ullName\x18\x0b \x01(\t\x12\x0e\n\x06gender\x18\x0c \x01(\x05\x12,\n\rpostalAddress\x18\r \x01(\x0b\x32\x15.idpass.PostalAddress\"#\n\x06Idents\x12\x19\n\x05ident\x18\x01 \x03(\x0b\x32\n.api.IdentB\x11\n\rorg.api.protoP\x01\x62\x06proto3'
+  ,
+  dependencies=[idpasslite__pb2.DESCRIPTOR,])
+
+
+
+_BYTEARRAY_TYP = _descriptor.EnumDescriptor(
+  name='Typ',
+  full_name='api.byteArray.Typ',
+  filename=None,
+  file=DESCRIPTOR,
+  create_key=_descriptor._internal_create_key,
+  values=[
+    _descriptor.EnumValueDescriptor(
+      name='BLOB', index=0, number=0,
+      serialized_options=None,
+      type=None,
+      create_key=_descriptor._internal_create_key),
+    _descriptor.EnumValueDescriptor(
+      name='AEADKEY', index=1, number=1,
+      serialized_options=None,
+      type=None,
+      create_key=_descriptor._internal_create_key),
+    _descriptor.EnumValueDescriptor(
+      name='ED25519PUBKEY', index=2, number=2,
+      serialized_options=None,
+      type=None,
+      create_key=_descriptor._internal_create_key),
+    _descriptor.EnumValueDescriptor(
+      name='ED25519PRIVKEY', index=3, number=3,
+      serialized_options=None,
+      type=None,
+      create_key=_descriptor._internal_create_key),
+    _descriptor.EnumValueDescriptor(
+      name='ED25519SIGNATURE', index=4, number=4,
+      serialized_options=None,
+      type=None,
+      create_key=_descriptor._internal_create_key),
+    _descriptor.EnumValueDescriptor(
+      name='PHOTO', index=5, number=5,
+      serialized_options=None,
+      type=None,
+      create_key=_descriptor._internal_create_key),
+  ],
+  containing_type=None,
+  serialized_options=None,
+  serialized_start=96,
+  serialized_end=196,
+)
+_sym_db.RegisterEnumDescriptor(_BYTEARRAY_TYP)
+
+
+_BYTEARRAY = _descriptor.Descriptor(
+  name='byteArray',
+  full_name='api.byteArray',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  create_key=_descriptor._internal_create_key,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='typ', full_name='api.byteArray.typ', index=0,
+      number=1, type=14, cpp_type=8, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='val', full_name='api.byteArray.val', index=1,
+      number=2, type=12, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+    _BYTEARRAY_TYP,
+  ],
+  serialized_options=None,
+  is_extendable=False,
+  syntax='proto3',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=37,
+  serialized_end=196,
+)
+
+
+_BYTEARRAYS = _descriptor.Descriptor(
+  name='byteArrays',
+  full_name='api.byteArrays',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  create_key=_descriptor._internal_create_key,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='vals', full_name='api.byteArrays.vals', index=0,
+      number=1, type=11, cpp_type=10, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  serialized_options=None,
+  is_extendable=False,
+  syntax='proto3',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=198,
+  serialized_end=240,
+)
+
+
+_KEYSET = _descriptor.Descriptor(
+  name='KeySet',
+  full_name='api.KeySet',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  create_key=_descriptor._internal_create_key,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='encryptionKey', full_name='api.KeySet.encryptionKey', index=0,
+      number=1, type=12, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='signatureKey', full_name='api.KeySet.signatureKey', index=1,
+      number=2, type=12, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='verificationKeys', full_name='api.KeySet.verificationKeys', index=2,
+      number=3, type=11, cpp_type=10, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  serialized_options=None,
+  is_extendable=False,
+  syntax='proto3',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=242,
+  serialized_end=337,
+)
+
+
+_CERTIFICATES = _descriptor.Descriptor(
+  name='Certificates',
+  full_name='api.Certificates',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  create_key=_descriptor._internal_create_key,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='cert', full_name='api.Certificates.cert', index=0,
+      number=1, type=11, cpp_type=10, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  serialized_options=None,
+  is_extendable=False,
+  syntax='proto3',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=339,
+  serialized_end=388,
+)
+
+
+_IDENT = _descriptor.Descriptor(
+  name='Ident',
+  full_name='api.Ident',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  create_key=_descriptor._internal_create_key,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='surName', full_name='api.Ident.surName', index=0,
+      number=1, type=9, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"".decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='givenName', full_name='api.Ident.givenName', index=1,
+      number=2, type=9, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"".decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='placeOfBirth', full_name='api.Ident.placeOfBirth', index=2,
+      number=3, type=9, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"".decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='pin', full_name='api.Ident.pin', index=3,
+      number=4, type=9, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"".decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='dateOfBirth', full_name='api.Ident.dateOfBirth', index=4,
+      number=5, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='photos', full_name='api.Ident.photos', index=5,
+      number=6, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='photo', full_name='api.Ident.photo', index=6,
+      number=7, type=12, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='privExtra', full_name='api.Ident.privExtra', index=7,
+      number=8, type=11, cpp_type=10, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='pubExtra', full_name='api.Ident.pubExtra', index=8,
+      number=9, type=11, cpp_type=10, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='UIN', full_name='api.Ident.UIN', index=9,
+      number=10, type=9, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"".decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='fullName', full_name='api.Ident.fullName', index=10,
+      number=11, type=9, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"".decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='gender', full_name='api.Ident.gender', index=11,
+      number=12, type=5, cpp_type=1, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='postalAddress', full_name='api.Ident.postalAddress', index=12,
+      number=13, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  serialized_options=None,
+  is_extendable=False,
+  syntax='proto3',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=391,
+  serialized_end=710,
+)
+
+
+_IDENTS = _descriptor.Descriptor(
+  name='Idents',
+  full_name='api.Idents',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  create_key=_descriptor._internal_create_key,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='ident', full_name='api.Idents.ident', index=0,
+      number=1, type=11, cpp_type=10, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  serialized_options=None,
+  is_extendable=False,
+  syntax='proto3',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=712,
+  serialized_end=747,
+)
+
+_BYTEARRAY.fields_by_name['typ'].enum_type = _BYTEARRAY_TYP
+_BYTEARRAY_TYP.containing_type = _BYTEARRAY
+_BYTEARRAYS.fields_by_name['vals'].message_type = _BYTEARRAY
+_KEYSET.fields_by_name['verificationKeys'].message_type = _BYTEARRAY
+_CERTIFICATES.fields_by_name['cert'].message_type = idpasslite__pb2._CERTIFICATE
+_IDENT.fields_by_name['dateOfBirth'].message_type = idpasslite__pb2._DATE
+_IDENT.fields_by_name['photos'].message_type = _BYTEARRAYS
+_IDENT.fields_by_name['privExtra'].message_type = idpasslite__pb2._PAIR
+_IDENT.fields_by_name['pubExtra'].message_type = idpasslite__pb2._PAIR
+_IDENT.fields_by_name['postalAddress'].message_type = idpasslite__pb2._POSTALADDRESS
+_IDENTS.fields_by_name['ident'].message_type = _IDENT
+DESCRIPTOR.message_types_by_name['byteArray'] = _BYTEARRAY
+DESCRIPTOR.message_types_by_name['byteArrays'] = _BYTEARRAYS
+DESCRIPTOR.message_types_by_name['KeySet'] = _KEYSET
+DESCRIPTOR.message_types_by_name['Certificates'] = _CERTIFICATES
+DESCRIPTOR.message_types_by_name['Ident'] = _IDENT
+DESCRIPTOR.message_types_by_name['Idents'] = _IDENTS
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+byteArray = _reflection.GeneratedProtocolMessageType('byteArray', (_message.Message,), {
+  'DESCRIPTOR' : _BYTEARRAY,
+  '__module__' : 'api_pb2'
+  # @@protoc_insertion_point(class_scope:api.byteArray)
+  })
+_sym_db.RegisterMessage(byteArray)
+
+byteArrays = _reflection.GeneratedProtocolMessageType('byteArrays', (_message.Message,), {
+  'DESCRIPTOR' : _BYTEARRAYS,
+  '__module__' : 'api_pb2'
+  # @@protoc_insertion_point(class_scope:api.byteArrays)
+  })
+_sym_db.RegisterMessage(byteArrays)
+
+KeySet = _reflection.GeneratedProtocolMessageType('KeySet', (_message.Message,), {
+  'DESCRIPTOR' : _KEYSET,
+  '__module__' : 'api_pb2'
+  # @@protoc_insertion_point(class_scope:api.KeySet)
+  })
+_sym_db.RegisterMessage(KeySet)
+
+Certificates = _reflection.GeneratedProtocolMessageType('Certificates', (_message.Message,), {
+  'DESCRIPTOR' : _CERTIFICATES,
+  '__module__' : 'api_pb2'
+  # @@protoc_insertion_point(class_scope:api.Certificates)
+  })
+_sym_db.RegisterMessage(Certificates)
+
+Ident = _reflection.GeneratedProtocolMessageType('Ident', (_message.Message,), {
+  'DESCRIPTOR' : _IDENT,
+  '__module__' : 'api_pb2'
+  # @@protoc_insertion_point(class_scope:api.Ident)
+  })
+_sym_db.RegisterMessage(Ident)
+
+Idents = _reflection.GeneratedProtocolMessageType('Idents', (_message.Message,), {
+  'DESCRIPTOR' : _IDENTS,
+  '__module__' : 'api_pb2'
+  # @@protoc_insertion_point(class_scope:api.Idents)
+  })
+_sym_db.RegisterMessage(Idents)
+
+
+DESCRIPTOR._options = None
+# @@protoc_insertion_point(module_scope)
diff --git a/python-wrap/code.sh b/python-wrap/code.sh
new file mode 100755
index 0000000..a2fe5e3
--- /dev/null
+++ b/python-wrap/code.sh
@@ -0,0 +1,5 @@
+#!/bin/sh
+#
+
+export LD_LIBRARY_PATH=`pwd`/lib:$LD_LIBRARY_PATH
+code .
diff --git a/python-wrap/demokeys.bin b/python-wrap/demokeys.bin
new file mode 100644
index 0000000..b686af6
Binary files /dev/null and b/python-wrap/demokeys.bin differ
diff --git a/python-wrap/florence_ID_Photo.jpg b/python-wrap/florence_ID_Photo.jpg
new file mode 100755
index 0000000..f151dc9
Binary files /dev/null and b/python-wrap/florence_ID_Photo.jpg differ
diff --git a/python-wrap/ident1.json b/python-wrap/ident1.json
new file mode 100644
index 0000000..6570347
--- /dev/null
+++ b/python-wrap/ident1.json
@@ -0,0 +1,44 @@
+{
+  "surName": "DUPONT",
+  "givenName": "MARION FLORENCE",
+  "placeOfBirth": "FRANCE",
+  "pin": "12345",
+  "dateOfBirth": {
+    "year": 1985,
+    "month": 1,
+    "day": 1
+  },
+  "photo": "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",
+  "privExtra": [
+    {
+      "key": "SS Number",
+      "value": "2 85 01 75 116 001 42"
+    },
+    {
+      "key": "contract",
+      "value": "0x28BFC23c29D6859E3f43d2d1714d019a7c44ba0E"
+    }
+  ],
+  "pubExtra": [
+    {
+      "key": "Sex",
+      "value": "F"
+    },
+    {
+      "key": "Nationality",
+      "value": "French"
+    },
+    {
+      "key": "Date Of Issue",
+      "value": "02 JAN 2025"
+    },
+    {
+      "key": "Date Of Expiry",
+      "value": "01 JAN 2035"
+    },
+    {
+      "key": "ID",
+      "value": "SA437277"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/python-wrap/ident2.json b/python-wrap/ident2.json
new file mode 100644
index 0000000..668c3f3
--- /dev/null
+++ b/python-wrap/ident2.json
@@ -0,0 +1,39 @@
+{
+  "surName": "Gast",
+  "givenName": "Friedrich",
+  "placeOfBirth": "Rocken, Lutzen, Germany",
+  "pin": "54321",
+  "dateOfBirth": {
+    "year": 1844,
+    "month": 10,
+    "day": 15
+  },
+  "privExtra": [
+    {
+      "key": "Friend",
+      "value": "Wagner"
+    }
+  ],
+  "pubExtra": [
+    {
+      "key": "Sex",
+      "value": "M"
+    },
+    {
+      "key": "Nationality",
+      "value": "German"
+    },
+    {
+      "key": "Date Of Issue",
+      "value": "02 JAN 2025"
+    },
+    {
+      "key": "Date Of Expiry",
+      "value": "01 JAN 2035"
+    },
+    {
+      "key": "ID",
+      "value": "XZ3312F"
+    }
+  ]
+}
diff --git a/python-wrap/idpasslite_pb2.py b/python-wrap/idpasslite_pb2.py
new file mode 100644
index 0000000..7b1d7fd
--- /dev/null
+++ b/python-wrap/idpasslite_pb2.py
@@ -0,0 +1,822 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: idpasslite.proto
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='idpasslite.proto',
+  package='idpass',
+  syntax='proto3',
+  serialized_options=b'\n\025org.idpass.lite.protoP\001',
+  create_key=_descriptor._internal_create_key,
+  serialized_pb=b'\n\x10idpasslite.proto\x12\x06idpass\"0\n\x04\x44\x61te\x12\x0c\n\x04year\x18\x01 \x01(\x05\x12\r\n\x05month\x18\x02 \x01(\x05\x12\x0b\n\x03\x64\x61y\x18\x03 \x01(\x05\"\"\n\x04Pair\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t\")\n\nDictionary\x12\x1b\n\x05pairs\x18\x01 \x03(\x0b\x32\x0c.idpass.Pair\"\x99\x02\n\nCardAccess\x12-\n\x06\x66inger\x18\x01 \x01(\x0e\x32\x1d.idpass.CardAccess.FingerType\x12\x13\n\x0b\x66ingerprint\x18\x02 \x01(\x0c\x12\'\n\x03\x65ye\x18\x03 \x01(\x0e\x32\x1a.idpass.CardAccess.EyeType\x12\x0c\n\x04iris\x18\x04 \x01(\x0c\x12\x0c\n\x04\x66\x61\x63\x65\x18\x05 \x01(\x0c\x12\x0b\n\x03pin\x18\x06 \x01(\t\"\\\n\nFingerType\x12\x06\n\x02R1\x10\x00\x12\x06\n\x02R2\x10\x01\x12\x06\n\x02R3\x10\x02\x12\x06\n\x02R4\x10\x03\x12\x06\n\x02R5\x10\x04\x12\x06\n\x02L1\x10\x05\x12\x06\n\x02L2\x10\x06\x12\x06\n\x02L3\x10\x07\x12\x06\n\x02L4\x10\x08\x12\x06\n\x02L5\x10\t\"\x17\n\x07\x45yeType\x12\x05\n\x01R\x10\x00\x12\x05\n\x01L\x10\x01\"\xfd\x01\n\rPostalAddress\x12\x10\n\x08revision\x18\x01 \x01(\x05\x12\x13\n\x0bregion_code\x18\x02 \x01(\t\x12\x15\n\rlanguage_code\x18\x03 \x01(\t\x12\x13\n\x0bpostal_code\x18\x04 \x01(\t\x12\x14\n\x0csorting_code\x18\x05 \x01(\t\x12\x1b\n\x13\x61\x64ministrative_area\x18\x06 \x01(\t\x12\x10\n\x08locality\x18\x07 \x01(\t\x12\x13\n\x0bsublocality\x18\x08 \x01(\t\x12\x15\n\raddress_lines\x18\t \x03(\t\x12\x12\n\nrecipients\x18\n \x03(\t\x12\x14\n\x0corganization\x18\x0b \x01(\t\"\xf7\x01\n\x0b\x43\x61rdDetails\x12\x0b\n\x03UIN\x18\t \x01(\t\x12\x10\n\x08\x66ullName\x18\x08 \x01(\t\x12\x0f\n\x07surName\x18\x01 \x01(\t\x12\x11\n\tgivenName\x18\x02 \x01(\t\x12\x14\n\x0cplaceOfBirth\x18\x03 \x01(\t\x12!\n\x0b\x64\x61teOfBirth\x18\x04 \x01(\x0b\x32\x0c.idpass.Date\x12\x0e\n\x06gender\x18\x07 \x01(\x05\x12,\n\rpostalAddress\x18\n \x01(\x0b\x32\x15.idpass.PostalAddress\x12\x1b\n\x05\x65xtra\x18\x05 \x03(\x0b\x32\x0c.idpass.Pair\x12\x11\n\tcreatedAt\x18\x06 \x01(\x03\"m\n\nIDPassCard\x12\"\n\x06\x61\x63\x63\x65ss\x18\x01 \x01(\x0b\x32\x12.idpass.CardAccess\x12$\n\x07\x64\x65tails\x18\x02 \x01(\x0b\x32\x13.idpass.CardDetails\x12\x15\n\rencryptionKey\x18\x03 \x01(\x0c\"4\n\x10SignedIDPassCard\x12 \n\x04\x63\x61rd\x18\x01 \x01(\x0b\x32\x12.idpass.IDPassCard\">\n\x16PublicSignedIDPassCard\x12$\n\x07\x64\x65tails\x18\x01 \x01(\x0b\x32\x13.idpass.CardDetails\"C\n\x0b\x43\x65rtificate\x12\x0e\n\x06pubkey\x18\x01 \x01(\x0c\x12\x11\n\tissuerkey\x18\x02 \x01(\x0c\x12\x11\n\tsignature\x18\x03 \x01(\x0c\"\xaf\x01\n\x0bIDPassCards\x12\x32\n\npublicCard\x18\x01 \x01(\x0b\x32\x1e.idpass.PublicSignedIDPassCard\x12\x15\n\rencryptedCard\x18\x02 \x01(\x0c\x12\x11\n\tsignature\x18\x03 \x01(\x0c\x12\x17\n\x0fsignerPublicKey\x18\x04 \x01(\x0c\x12)\n\x0c\x63\x65rtificates\x18\x05 \x03(\x0b\x32\x13.idpass.CertificateB\x19\n\x15org.idpass.lite.protoP\x01\x62\x06proto3'
+)
+
+
+
+_CARDACCESS_FINGERTYPE = _descriptor.EnumDescriptor(
+  name='FingerType',
+  full_name='idpass.CardAccess.FingerType',
+  filename=None,
+  file=DESCRIPTOR,
+  create_key=_descriptor._internal_create_key,
+  values=[
+    _descriptor.EnumValueDescriptor(
+      name='R1', index=0, number=0,
+      serialized_options=None,
+      type=None,
+      create_key=_descriptor._internal_create_key),
+    _descriptor.EnumValueDescriptor(
+      name='R2', index=1, number=1,
+      serialized_options=None,
+      type=None,
+      create_key=_descriptor._internal_create_key),
+    _descriptor.EnumValueDescriptor(
+      name='R3', index=2, number=2,
+      serialized_options=None,
+      type=None,
+      create_key=_descriptor._internal_create_key),
+    _descriptor.EnumValueDescriptor(
+      name='R4', index=3, number=3,
+      serialized_options=None,
+      type=None,
+      create_key=_descriptor._internal_create_key),
+    _descriptor.EnumValueDescriptor(
+      name='R5', index=4, number=4,
+      serialized_options=None,
+      type=None,
+      create_key=_descriptor._internal_create_key),
+    _descriptor.EnumValueDescriptor(
+      name='L1', index=5, number=5,
+      serialized_options=None,
+      type=None,
+      create_key=_descriptor._internal_create_key),
+    _descriptor.EnumValueDescriptor(
+      name='L2', index=6, number=6,
+      serialized_options=None,
+      type=None,
+      create_key=_descriptor._internal_create_key),
+    _descriptor.EnumValueDescriptor(
+      name='L3', index=7, number=7,
+      serialized_options=None,
+      type=None,
+      create_key=_descriptor._internal_create_key),
+    _descriptor.EnumValueDescriptor(
+      name='L4', index=8, number=8,
+      serialized_options=None,
+      type=None,
+      create_key=_descriptor._internal_create_key),
+    _descriptor.EnumValueDescriptor(
+      name='L5', index=9, number=9,
+      serialized_options=None,
+      type=None,
+      create_key=_descriptor._internal_create_key),
+  ],
+  containing_type=None,
+  serialized_options=None,
+  serialized_start=322,
+  serialized_end=414,
+)
+_sym_db.RegisterEnumDescriptor(_CARDACCESS_FINGERTYPE)
+
+_CARDACCESS_EYETYPE = _descriptor.EnumDescriptor(
+  name='EyeType',
+  full_name='idpass.CardAccess.EyeType',
+  filename=None,
+  file=DESCRIPTOR,
+  create_key=_descriptor._internal_create_key,
+  values=[
+    _descriptor.EnumValueDescriptor(
+      name='R', index=0, number=0,
+      serialized_options=None,
+      type=None,
+      create_key=_descriptor._internal_create_key),
+    _descriptor.EnumValueDescriptor(
+      name='L', index=1, number=1,
+      serialized_options=None,
+      type=None,
+      create_key=_descriptor._internal_create_key),
+  ],
+  containing_type=None,
+  serialized_options=None,
+  serialized_start=416,
+  serialized_end=439,
+)
+_sym_db.RegisterEnumDescriptor(_CARDACCESS_EYETYPE)
+
+
+_DATE = _descriptor.Descriptor(
+  name='Date',
+  full_name='idpass.Date',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  create_key=_descriptor._internal_create_key,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='year', full_name='idpass.Date.year', index=0,
+      number=1, type=5, cpp_type=1, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='month', full_name='idpass.Date.month', index=1,
+      number=2, type=5, cpp_type=1, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='day', full_name='idpass.Date.day', index=2,
+      number=3, type=5, cpp_type=1, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  serialized_options=None,
+  is_extendable=False,
+  syntax='proto3',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=28,
+  serialized_end=76,
+)
+
+
+_PAIR = _descriptor.Descriptor(
+  name='Pair',
+  full_name='idpass.Pair',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  create_key=_descriptor._internal_create_key,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='key', full_name='idpass.Pair.key', index=0,
+      number=1, type=9, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"".decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='value', full_name='idpass.Pair.value', index=1,
+      number=2, type=9, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"".decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  serialized_options=None,
+  is_extendable=False,
+  syntax='proto3',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=78,
+  serialized_end=112,
+)
+
+
+_DICTIONARY = _descriptor.Descriptor(
+  name='Dictionary',
+  full_name='idpass.Dictionary',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  create_key=_descriptor._internal_create_key,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='pairs', full_name='idpass.Dictionary.pairs', index=0,
+      number=1, type=11, cpp_type=10, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  serialized_options=None,
+  is_extendable=False,
+  syntax='proto3',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=114,
+  serialized_end=155,
+)
+
+
+_CARDACCESS = _descriptor.Descriptor(
+  name='CardAccess',
+  full_name='idpass.CardAccess',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  create_key=_descriptor._internal_create_key,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='finger', full_name='idpass.CardAccess.finger', index=0,
+      number=1, type=14, cpp_type=8, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='fingerprint', full_name='idpass.CardAccess.fingerprint', index=1,
+      number=2, type=12, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='eye', full_name='idpass.CardAccess.eye', index=2,
+      number=3, type=14, cpp_type=8, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='iris', full_name='idpass.CardAccess.iris', index=3,
+      number=4, type=12, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='face', full_name='idpass.CardAccess.face', index=4,
+      number=5, type=12, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='pin', full_name='idpass.CardAccess.pin', index=5,
+      number=6, type=9, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"".decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+    _CARDACCESS_FINGERTYPE,
+    _CARDACCESS_EYETYPE,
+  ],
+  serialized_options=None,
+  is_extendable=False,
+  syntax='proto3',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=158,
+  serialized_end=439,
+)
+
+
+_POSTALADDRESS = _descriptor.Descriptor(
+  name='PostalAddress',
+  full_name='idpass.PostalAddress',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  create_key=_descriptor._internal_create_key,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='revision', full_name='idpass.PostalAddress.revision', index=0,
+      number=1, type=5, cpp_type=1, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='region_code', full_name='idpass.PostalAddress.region_code', index=1,
+      number=2, type=9, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"".decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='language_code', full_name='idpass.PostalAddress.language_code', index=2,
+      number=3, type=9, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"".decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='postal_code', full_name='idpass.PostalAddress.postal_code', index=3,
+      number=4, type=9, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"".decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='sorting_code', full_name='idpass.PostalAddress.sorting_code', index=4,
+      number=5, type=9, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"".decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='administrative_area', full_name='idpass.PostalAddress.administrative_area', index=5,
+      number=6, type=9, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"".decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='locality', full_name='idpass.PostalAddress.locality', index=6,
+      number=7, type=9, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"".decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='sublocality', full_name='idpass.PostalAddress.sublocality', index=7,
+      number=8, type=9, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"".decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='address_lines', full_name='idpass.PostalAddress.address_lines', index=8,
+      number=9, type=9, cpp_type=9, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='recipients', full_name='idpass.PostalAddress.recipients', index=9,
+      number=10, type=9, cpp_type=9, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='organization', full_name='idpass.PostalAddress.organization', index=10,
+      number=11, type=9, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"".decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  serialized_options=None,
+  is_extendable=False,
+  syntax='proto3',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=442,
+  serialized_end=695,
+)
+
+
+_CARDDETAILS = _descriptor.Descriptor(
+  name='CardDetails',
+  full_name='idpass.CardDetails',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  create_key=_descriptor._internal_create_key,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='UIN', full_name='idpass.CardDetails.UIN', index=0,
+      number=9, type=9, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"".decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='fullName', full_name='idpass.CardDetails.fullName', index=1,
+      number=8, type=9, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"".decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='surName', full_name='idpass.CardDetails.surName', index=2,
+      number=1, type=9, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"".decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='givenName', full_name='idpass.CardDetails.givenName', index=3,
+      number=2, type=9, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"".decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='placeOfBirth', full_name='idpass.CardDetails.placeOfBirth', index=4,
+      number=3, type=9, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"".decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='dateOfBirth', full_name='idpass.CardDetails.dateOfBirth', index=5,
+      number=4, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='gender', full_name='idpass.CardDetails.gender', index=6,
+      number=7, type=5, cpp_type=1, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='postalAddress', full_name='idpass.CardDetails.postalAddress', index=7,
+      number=10, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='extra', full_name='idpass.CardDetails.extra', index=8,
+      number=5, type=11, cpp_type=10, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='createdAt', full_name='idpass.CardDetails.createdAt', index=9,
+      number=6, type=3, cpp_type=2, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  serialized_options=None,
+  is_extendable=False,
+  syntax='proto3',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=698,
+  serialized_end=945,
+)
+
+
+_IDPASSCARD = _descriptor.Descriptor(
+  name='IDPassCard',
+  full_name='idpass.IDPassCard',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  create_key=_descriptor._internal_create_key,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='access', full_name='idpass.IDPassCard.access', index=0,
+      number=1, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='details', full_name='idpass.IDPassCard.details', index=1,
+      number=2, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='encryptionKey', full_name='idpass.IDPassCard.encryptionKey', index=2,
+      number=3, type=12, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  serialized_options=None,
+  is_extendable=False,
+  syntax='proto3',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=947,
+  serialized_end=1056,
+)
+
+
+_SIGNEDIDPASSCARD = _descriptor.Descriptor(
+  name='SignedIDPassCard',
+  full_name='idpass.SignedIDPassCard',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  create_key=_descriptor._internal_create_key,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='card', full_name='idpass.SignedIDPassCard.card', index=0,
+      number=1, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  serialized_options=None,
+  is_extendable=False,
+  syntax='proto3',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=1058,
+  serialized_end=1110,
+)
+
+
+_PUBLICSIGNEDIDPASSCARD = _descriptor.Descriptor(
+  name='PublicSignedIDPassCard',
+  full_name='idpass.PublicSignedIDPassCard',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  create_key=_descriptor._internal_create_key,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='details', full_name='idpass.PublicSignedIDPassCard.details', index=0,
+      number=1, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  serialized_options=None,
+  is_extendable=False,
+  syntax='proto3',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=1112,
+  serialized_end=1174,
+)
+
+
+_CERTIFICATE = _descriptor.Descriptor(
+  name='Certificate',
+  full_name='idpass.Certificate',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  create_key=_descriptor._internal_create_key,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='pubkey', full_name='idpass.Certificate.pubkey', index=0,
+      number=1, type=12, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='issuerkey', full_name='idpass.Certificate.issuerkey', index=1,
+      number=2, type=12, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='signature', full_name='idpass.Certificate.signature', index=2,
+      number=3, type=12, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  serialized_options=None,
+  is_extendable=False,
+  syntax='proto3',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=1176,
+  serialized_end=1243,
+)
+
+
+_IDPASSCARDS = _descriptor.Descriptor(
+  name='IDPassCards',
+  full_name='idpass.IDPassCards',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  create_key=_descriptor._internal_create_key,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='publicCard', full_name='idpass.IDPassCards.publicCard', index=0,
+      number=1, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='encryptedCard', full_name='idpass.IDPassCards.encryptedCard', index=1,
+      number=2, type=12, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='signature', full_name='idpass.IDPassCards.signature', index=2,
+      number=3, type=12, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='signerPublicKey', full_name='idpass.IDPassCards.signerPublicKey', index=3,
+      number=4, type=12, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='certificates', full_name='idpass.IDPassCards.certificates', index=4,
+      number=5, type=11, cpp_type=10, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  serialized_options=None,
+  is_extendable=False,
+  syntax='proto3',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=1246,
+  serialized_end=1421,
+)
+
+_DICTIONARY.fields_by_name['pairs'].message_type = _PAIR
+_CARDACCESS.fields_by_name['finger'].enum_type = _CARDACCESS_FINGERTYPE
+_CARDACCESS.fields_by_name['eye'].enum_type = _CARDACCESS_EYETYPE
+_CARDACCESS_FINGERTYPE.containing_type = _CARDACCESS
+_CARDACCESS_EYETYPE.containing_type = _CARDACCESS
+_CARDDETAILS.fields_by_name['dateOfBirth'].message_type = _DATE
+_CARDDETAILS.fields_by_name['postalAddress'].message_type = _POSTALADDRESS
+_CARDDETAILS.fields_by_name['extra'].message_type = _PAIR
+_IDPASSCARD.fields_by_name['access'].message_type = _CARDACCESS
+_IDPASSCARD.fields_by_name['details'].message_type = _CARDDETAILS
+_SIGNEDIDPASSCARD.fields_by_name['card'].message_type = _IDPASSCARD
+_PUBLICSIGNEDIDPASSCARD.fields_by_name['details'].message_type = _CARDDETAILS
+_IDPASSCARDS.fields_by_name['publicCard'].message_type = _PUBLICSIGNEDIDPASSCARD
+_IDPASSCARDS.fields_by_name['certificates'].message_type = _CERTIFICATE
+DESCRIPTOR.message_types_by_name['Date'] = _DATE
+DESCRIPTOR.message_types_by_name['Pair'] = _PAIR
+DESCRIPTOR.message_types_by_name['Dictionary'] = _DICTIONARY
+DESCRIPTOR.message_types_by_name['CardAccess'] = _CARDACCESS
+DESCRIPTOR.message_types_by_name['PostalAddress'] = _POSTALADDRESS
+DESCRIPTOR.message_types_by_name['CardDetails'] = _CARDDETAILS
+DESCRIPTOR.message_types_by_name['IDPassCard'] = _IDPASSCARD
+DESCRIPTOR.message_types_by_name['SignedIDPassCard'] = _SIGNEDIDPASSCARD
+DESCRIPTOR.message_types_by_name['PublicSignedIDPassCard'] = _PUBLICSIGNEDIDPASSCARD
+DESCRIPTOR.message_types_by_name['Certificate'] = _CERTIFICATE
+DESCRIPTOR.message_types_by_name['IDPassCards'] = _IDPASSCARDS
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+Date = _reflection.GeneratedProtocolMessageType('Date', (_message.Message,), {
+  'DESCRIPTOR' : _DATE,
+  '__module__' : 'idpasslite_pb2'
+  # @@protoc_insertion_point(class_scope:idpass.Date)
+  })
+_sym_db.RegisterMessage(Date)
+
+Pair = _reflection.GeneratedProtocolMessageType('Pair', (_message.Message,), {
+  'DESCRIPTOR' : _PAIR,
+  '__module__' : 'idpasslite_pb2'
+  # @@protoc_insertion_point(class_scope:idpass.Pair)
+  })
+_sym_db.RegisterMessage(Pair)
+
+Dictionary = _reflection.GeneratedProtocolMessageType('Dictionary', (_message.Message,), {
+  'DESCRIPTOR' : _DICTIONARY,
+  '__module__' : 'idpasslite_pb2'
+  # @@protoc_insertion_point(class_scope:idpass.Dictionary)
+  })
+_sym_db.RegisterMessage(Dictionary)
+
+CardAccess = _reflection.GeneratedProtocolMessageType('CardAccess', (_message.Message,), {
+  'DESCRIPTOR' : _CARDACCESS,
+  '__module__' : 'idpasslite_pb2'
+  # @@protoc_insertion_point(class_scope:idpass.CardAccess)
+  })
+_sym_db.RegisterMessage(CardAccess)
+
+PostalAddress = _reflection.GeneratedProtocolMessageType('PostalAddress', (_message.Message,), {
+  'DESCRIPTOR' : _POSTALADDRESS,
+  '__module__' : 'idpasslite_pb2'
+  # @@protoc_insertion_point(class_scope:idpass.PostalAddress)
+  })
+_sym_db.RegisterMessage(PostalAddress)
+
+CardDetails = _reflection.GeneratedProtocolMessageType('CardDetails', (_message.Message,), {
+  'DESCRIPTOR' : _CARDDETAILS,
+  '__module__' : 'idpasslite_pb2'
+  # @@protoc_insertion_point(class_scope:idpass.CardDetails)
+  })
+_sym_db.RegisterMessage(CardDetails)
+
+IDPassCard = _reflection.GeneratedProtocolMessageType('IDPassCard', (_message.Message,), {
+  'DESCRIPTOR' : _IDPASSCARD,
+  '__module__' : 'idpasslite_pb2'
+  # @@protoc_insertion_point(class_scope:idpass.IDPassCard)
+  })
+_sym_db.RegisterMessage(IDPassCard)
+
+SignedIDPassCard = _reflection.GeneratedProtocolMessageType('SignedIDPassCard', (_message.Message,), {
+  'DESCRIPTOR' : _SIGNEDIDPASSCARD,
+  '__module__' : 'idpasslite_pb2'
+  # @@protoc_insertion_point(class_scope:idpass.SignedIDPassCard)
+  })
+_sym_db.RegisterMessage(SignedIDPassCard)
+
+PublicSignedIDPassCard = _reflection.GeneratedProtocolMessageType('PublicSignedIDPassCard', (_message.Message,), {
+  'DESCRIPTOR' : _PUBLICSIGNEDIDPASSCARD,
+  '__module__' : 'idpasslite_pb2'
+  # @@protoc_insertion_point(class_scope:idpass.PublicSignedIDPassCard)
+  })
+_sym_db.RegisterMessage(PublicSignedIDPassCard)
+
+Certificate = _reflection.GeneratedProtocolMessageType('Certificate', (_message.Message,), {
+  'DESCRIPTOR' : _CERTIFICATE,
+  '__module__' : 'idpasslite_pb2'
+  # @@protoc_insertion_point(class_scope:idpass.Certificate)
+  })
+_sym_db.RegisterMessage(Certificate)
+
+IDPassCards = _reflection.GeneratedProtocolMessageType('IDPassCards', (_message.Message,), {
+  'DESCRIPTOR' : _IDPASSCARDS,
+  '__module__' : 'idpasslite_pb2'
+  # @@protoc_insertion_point(class_scope:idpass.IDPassCards)
+  })
+_sym_db.RegisterMessage(IDPassCards)
+
+
+DESCRIPTOR._options = None
+# @@protoc_insertion_point(module_scope)
diff --git a/python-wrap/lib/libidpasslite.so b/python-wrap/lib/libidpasslite.so
new file mode 100755
index 0000000..bc0b6e9
Binary files /dev/null and b/python-wrap/lib/libidpasslite.so differ
diff --git a/python-wrap/main.py b/python-wrap/main.py
new file mode 100644
index 0000000..5f5b065
--- /dev/null
+++ b/python-wrap/main.py
@@ -0,0 +1,99 @@
+from google.protobuf.json_format import Parse
+import api_pb2
+import idpasslite_pb2
+import IDPassLite
+from ctypes import *
+
+def KEYSET_fromFile(filename):
+    keySet = api_pb2.KeySet()
+    with open(filename, "rb") as binaryfile :
+       ba = binaryfile.read()
+    keySet.ParseFromString(ba) 
+    return keySet
+
+def KEYSET_fromRandom():
+    keySet = api_pb2.KeySet()
+    encryptionKey = IDPassLite.Helper.generate_encryption_key()
+    (verificationKey, signatureKey) = IDPassLite.Helper.generate_secret_signature_keypair()
+    ba = api_pb2.byteArray()
+    ba.val = bytes(verificationKey)
+    ba.typ = api_pb2.byteArray.Typ.ED25519PUBKEY
+    keySet.encryptionKey = bytes(encryptionKey) 
+    keySet.signatureKey = bytes(signatureKey)
+    keySet.verificationKeys.append(ba) 
+    return keySet
+
+def getIdent1():
+    ident = api_pb2.Ident()
+    photo = open("florence_ID_Photo.jpg", "rb").read()
+    surName = "DUPONT".encode('utf-8')
+    givenName = "MARION FLORENCE".encode('utf-8')
+    placeOfBirth = "FRANCE".encode('utf-8')
+    pin = "12345".encode('utf-8')
+    ident.surName = surName
+    ident.givenName = givenName
+    ident.dateOfBirth.year = 1985
+    ident.dateOfBirth.month = 1
+    ident.dateOfBirth.day = 1
+    ident.placeOfBirth = placeOfBirth
+    ident.pin = pin
+    ident.photo = photo
+    extra = idpasslite_pb2.Pair()
+    extra.key = "Sex"
+    extra.value = "F"
+    ident.pubExtra.append(extra)
+    extra.key = "Nationality"
+    extra.value = "French"
+    ident.pubExtra.append(extra)
+    extra.key = "Date Of Issue"
+    extra.value = "02 JAN 2025"
+    ident.pubExtra.append(extra)
+    extra.key = "Date Of Expiry"
+    extra.value = "01 JAN 2035"
+    ident.pubExtra.append(extra)
+    extra.key = "ID"
+    extra.value = "SA437277"
+    ident.pubExtra.append(extra)
+    # SS Number field only visible after authentication
+    extra.key = "SS Number"
+    extra.value = "2 85 01 75 116 001 42"
+    ident.privExtra.append(extra) 
+    extra.key = "contract"
+    extra.value = "0x28BFC23c29D6859E3f43d2d1714d019a7c44ba0E"
+    ident.privExtra.append(extra) 
+    return ident
+
+def getIdentFromJson(file):
+    with open(file, "r") as inf:
+        txt = inf.read()
+    ident = Parse(txt, api_pb2.Ident())
+    return ident
+    
+if __name__ == "__main__":
+    keySet = KEYSET_fromFile("demokeys.bin") # Load matching keyset from Android reader app
+    reader = IDPassLite.Reader(keySet)
+    # ident1 = getIdent1() # Use this identity details as an example
+    ident1 = getIdentFromJson("ident1.json")
+    ident2 = getIdentFromJson("ident2.json")
+    card1  = reader.create_card_with_face(ident1)
+    svg1 = card1.asQRCodeSVG()
+    open("qrcode1.svg","w").write(svg1)
+
+    card2  = reader.create_card_with_face(ident2)
+    svg2 = card2.asQRCodeSVG()
+    open("qrcode2.svg","w").write(svg2)
+
+    # card2 = card.authenticateWithPin("12345")
+    
+    # publicCard = cards.publicCard
+    # print(publicCard.details.surName)
+    # print(publicCard.details.givenName)
+    # print(publicCard.details.placeOfBirth) # Prior to authentication, placeOfBirth is not visible
+    # qrcodesvg = reader.asQRCode(buf, buflen)
+    # open("qrcode.svg","w").write(qrcodesvg)
+
+    # c = reader.authenticateWithPin(buf, buflen, "12345")
+    # if c is not None:
+    #     print(c.placeOfBirth) # After authentication, placeOfBirth is now visible
+    # else:
+    #     print("wrong pin code")
diff --git a/python-wrap/run.sh b/python-wrap/run.sh
new file mode 100755
index 0000000..e8f4e60
--- /dev/null
+++ b/python-wrap/run.sh
@@ -0,0 +1,7 @@
+#!/bin/sh
+#
+
+export LD_LIBRARY_PATH=`pwd`/lib:$LD_LIBRARY_PATH
+python3 main.py
+
+ls -l qrcode1.svg qrcode1.svg