diff --git a/setup.py b/setup.py
index 34ca5d7..d838485 100644
--- a/setup.py
+++ b/setup.py
@@ -27,10 +27,10 @@ def pEpLog(*msg):
         msgstr += str(m)
         msgstr += separator
     func = inspect.currentframe().f_back.f_code
-    print(func.co_filename + " : " + func.co_name + " : "  + msgstr)
+    print(func.co_filename + " : " + func.co_name + " : " + msgstr)
 
-class BuildExtCommand(build_ext):
 
+class BuildExtCommand(build_ext):
     user_options = build_ext.user_options + [
         ('local', None, 'Use local pEp install in HOME/USERPROFILE for libs/includes'),
         ('prefix=', None, 'Use local pEp install in prefix for libs/includes'),
@@ -155,15 +155,15 @@ class BuildExtCommand(build_ext):
         # Append home-dir
         if self.local:
             pEpLog("local mode")
-            home_include=[ join(home, 'include') ]
-            home_libdirs=[ join(home, 'lib') ]
+            home_include = [join(home, 'include')]
+            home_libdirs = [join(home, 'lib')]
             includes += home_include
             libdirs += home_libdirs
 
         # Append prefix-dir
         if self.prefix:
-            prefix_include=[ join(self.prefix, 'include') ]
-            prefix_libdirs=[ join(self.prefix, 'lib') ]
+            prefix_include = [join(self.prefix, 'include')]
+            prefix_libdirs = [join(self.prefix, 'lib')]
             includes += prefix_include
             libdirs += prefix_libdirs
 
@@ -194,7 +194,7 @@ class BuildExtCommand(build_ext):
 
 
 if sys.platform == 'winnt':
-    if  sys.version_info[0] >= 3:
+    if sys.version_info[0] >= 3:
         import winreg
     else:
         import _winreg as winreg
@@ -202,18 +202,17 @@ if sys.platform == 'winnt':
 if sys.version_info[0] < 3:
     FileNotFoundError = EnvironmentError
 
-
 module_pEp = Extension(
     'native_pEp',
-    sources =   [
-                'src/pEp/native_pEp/pEpmodule.cc',
-                'src/pEp/native_pEp/basic_api.cc',
-                'src/pEp/native_pEp/identity.cc',
-                'src/pEp/native_pEp/message.cc',
-                'src/pEp/native_pEp/message_api.cc',
-                'src/pEp/native_pEp/str_attr.cc',
-                # 'src/pEp/native_pEp/user_interface.cc',
-                ],
+    sources=[
+        'src/pEp/native_pEp/pEpmodule.cc',
+        'src/pEp/native_pEp/basic_api.cc',
+        'src/pEp/native_pEp/identity.cc',
+        'src/pEp/native_pEp/message.cc',
+        'src/pEp/native_pEp/message_api.cc',
+        'src/pEp/native_pEp/str_attr.cc',
+        # 'src/pEp/native_pEp/user_interface.cc',
+    ],
 )
 
 # "MAIN" Function
@@ -225,7 +224,7 @@ setup(
     author_email="vb@pep-project.org",
     maintainer="Heck",
     maintainer_email="heck@pep.foundation",
-    package_dir={'':'src'},
+    package_dir={'': 'src'},
     packages=['pEp'],
     ext_modules=[module_pEp],
     cmdclass={
diff --git a/src/pEp/__init__.py b/src/pEp/__init__.py
index 8a32e83..0bc2c9e 100644
--- a/src/pEp/__init__.py
+++ b/src/pEp/__init__.py
@@ -11,6 +11,7 @@ from native_pEp import *
 # import the module
 import native_pEp
 
+
 # Executed on module import
 def init():
     print(init, "called")
@@ -45,8 +46,9 @@ def notify_handshake(me, partner, signal):
 def main():
     print("I am being run as a script")
 
+
 # MAIN
 if __name__ == "__main__":
     main()
 else:
-    init()
\ No newline at end of file
+    init()
diff --git a/src/pEp/native_pEp/basic_api.cc b/src/pEp/native_pEp/basic_api.cc
index c3e1097..50cc802 100644
--- a/src/pEp/native_pEp/basic_api.cc
+++ b/src/pEp/native_pEp/basic_api.cc
@@ -13,160 +13,149 @@
 #include "basic_api.hh"
 
 namespace pEp {
-namespace PythonAdapter {
-using namespace std;
-
-void update_identity(Identity& ident)
-{
-    if (ident.address() == "")
-        throw invalid_argument("address needed");
-    if (ident.user_id() == PEP_OWN_USERID)
-        throw runtime_error("update_identity: '" PEP_OWN_USERID
-                "' may only be used for own identities");
-
-    PEP_STATUS status = update_identity(Adapter::session(), ident);
-    _throw_status(status);
-}
-
-void myself(Identity& ident)
-{
-    if (ident.address() == "")
-        throw invalid_argument("address needed");
-    if (ident.username() == "")
-        throw invalid_argument("username needed");
-
-    if (ident.user_id() == "")
-        ident.user_id(ident.address());
-
-    PEP_STATUS status = myself(Adapter::session(), ident);
-    _throw_status(status);
-}
-
-string _trustwords(Identity me, Identity partner, string lang, bool full)
-{
-    if (me.fpr() == "" || partner.fpr() == "")
-        throw invalid_argument("fingerprint needed in Identities");
-
-    if (lang == "" && me.lang() == partner.lang())
-        lang = me.lang();
-
-    char *words = NULL;
-    size_t size = 0;
-    PEP_STATUS status =  get_trustwords(Adapter::session(), me, partner,
-                                lang.c_str(),&words, &size, full);
-    _throw_status(status);
-    return words;
-}
-
-void trust_personal_key(Identity ident)
-{
-    if (ident.fpr() == "")
-        throw invalid_argument("fingerprint needed in Identities");
-    if (ident.user_id() == "")
-        throw invalid_argument("user_id must be provided");
-
-    PEP_STATUS status = trust_personal_key(Adapter::session(), ident);
-    _throw_status(status);
-}
-
-void set_identity_flags(Identity ident, identity_flags_t flags)
-{
-    if (ident.address() == "")
-        throw invalid_argument("address needed");
-    if (ident.user_id() == "")
-        throw invalid_argument("user_id needed");
-
-    PEP_STATUS status = set_identity_flags(Adapter::session(), ident, flags);
-    _throw_status(status);
-}
-
-void unset_identity_flags(Identity ident, identity_flags_t flags)
-{
-    if (ident.address() == "")
-        throw invalid_argument("address needed");
-    if (ident.user_id() == "")
-        throw invalid_argument("user_id needed");
-
-    PEP_STATUS status = unset_identity_flags(Adapter::session(), ident, flags);
-    _throw_status(status);
-}
-
-void key_reset_trust(Identity ident)
-{
-    if (ident.fpr() == "")
-        throw invalid_argument("fpr needed");
-    if (ident.address() == "")
-        throw invalid_argument("address needed");
-    if (ident.user_id() == "")
-        throw invalid_argument("user_id needed");
-
-    PEP_STATUS status = key_reset_trust(Adapter::session(), ident);
-    _throw_status(status);
-}
-
-
-
-boost::python::list import_key(string key_data)
-{
-    ::identity_list *private_keys = NULL;
-    PEP_STATUS status = ::import_key(Adapter::session(), key_data.c_str(), key_data.size(), &private_keys);
-    if (status && status != PEP_KEY_IMPORTED)
-        _throw_status(status);
-
-    auto result = boost::python::list();
-    for (::identity_list *il = private_keys; il && il->ident; il=il->next) {
-        ::pEp_identity *ident = ::identity_dup(il->ident);
-        if (!ident) {
+    namespace PythonAdapter {
+        using namespace std;
+
+        void update_identity(Identity &ident) {
+            if (ident.address() == "")
+                throw invalid_argument("address needed");
+            if (ident.user_id() == PEP_OWN_USERID)
+                throw runtime_error("update_identity: '"
+            PEP_OWN_USERID
+            "' may only be used for own identities");
+
+            PEP_STATUS status = update_identity(Adapter::session(), ident);
+            _throw_status(status);
+        }
+
+        void myself(Identity &ident) {
+            if (ident.address() == "")
+                throw invalid_argument("address needed");
+            if (ident.username() == "")
+                throw invalid_argument("username needed");
+
+            if (ident.user_id() == "")
+                ident.user_id(ident.address());
+
+            PEP_STATUS status = myself(Adapter::session(), ident);
+            _throw_status(status);
+        }
+
+        string _trustwords(Identity me, Identity partner, string lang, bool full) {
+            if (me.fpr() == "" || partner.fpr() == "")
+                throw invalid_argument("fingerprint needed in Identities");
+
+            if (lang == "" && me.lang() == partner.lang())
+                lang = me.lang();
+
+            char *words = NULL;
+            size_t size = 0;
+            PEP_STATUS status = get_trustwords(Adapter::session(), me, partner,
+                                               lang.c_str(), &words, &size, full);
+            _throw_status(status);
+            return words;
+        }
+
+        void trust_personal_key(Identity ident) {
+            if (ident.fpr() == "")
+                throw invalid_argument("fingerprint needed in Identities");
+            if (ident.user_id() == "")
+                throw invalid_argument("user_id must be provided");
+
+            PEP_STATUS status = trust_personal_key(Adapter::session(), ident);
+            _throw_status(status);
+        }
+
+        void set_identity_flags(Identity ident, identity_flags_t flags) {
+            if (ident.address() == "")
+                throw invalid_argument("address needed");
+            if (ident.user_id() == "")
+                throw invalid_argument("user_id needed");
+
+            PEP_STATUS status = set_identity_flags(Adapter::session(), ident, flags);
+            _throw_status(status);
+        }
+
+        void unset_identity_flags(Identity ident, identity_flags_t flags) {
+            if (ident.address() == "")
+                throw invalid_argument("address needed");
+            if (ident.user_id() == "")
+                throw invalid_argument("user_id needed");
+
+            PEP_STATUS status = unset_identity_flags(Adapter::session(), ident, flags);
+            _throw_status(status);
+        }
+
+        void key_reset_trust(Identity ident) {
+            if (ident.fpr() == "")
+                throw invalid_argument("fpr needed");
+            if (ident.address() == "")
+                throw invalid_argument("address needed");
+            if (ident.user_id() == "")
+                throw invalid_argument("user_id needed");
+
+            PEP_STATUS status = key_reset_trust(Adapter::session(), ident);
+            _throw_status(status);
+        }
+
+
+        boost::python::list import_key(string key_data) {
+            ::identity_list *private_keys = NULL;
+            PEP_STATUS status = ::import_key(Adapter::session(), key_data.c_str(), key_data.size(), &private_keys);
+            if (status && status != PEP_KEY_IMPORTED)
+                _throw_status(status);
+
+            auto result = boost::python::list();
+            for (::identity_list *il = private_keys; il && il->ident; il = il->next) {
+                ::pEp_identity *ident = ::identity_dup(il->ident);
+                if (!ident) {
+                    free_identity_list(private_keys);
+                    throw bad_alloc();
+                }
+                result.append(Identity(ident));
+            }
+
             free_identity_list(private_keys);
-            throw bad_alloc();
+            return result;
+        }
+
+        string export_key(Identity ident) {
+            PEP_STATUS status = PEP_STATUS_OK;
+            char *key_data = NULL;
+            size_t size;
+            status = ::export_key(Adapter::session(), ident.fpr().c_str(), &key_data, &size);
+
+            _throw_status(status);
+            return key_data;
         }
-        result.append(Identity(ident));
-    }
-
-    free_identity_list(private_keys);
-    return result;
-}
-
-string export_key(Identity ident)
-{
-    PEP_STATUS status = PEP_STATUS_OK;
-    char* key_data = NULL;
-    size_t size;
-    status = ::export_key(Adapter::session(), ident.fpr().c_str(), &key_data, &size);
-
-    _throw_status(status);
-    return key_data;
-}
-
-string export_secret_key(Identity ident)
-{
-    PEP_STATUS status = PEP_STATUS_OK;
-    char* key_data = NULL;
-    size_t size;
-    status = ::export_secret_key(Adapter::session(), ident.fpr().c_str(), &key_data, &size);
-
-    _throw_status(status);
-    return key_data;
-}
-
-void set_own_key(Identity& ident, string fpr)
-{
-    if (ident.address() == "")
-        throw invalid_argument("address needed");
-    if (ident.username() == "")
-        throw invalid_argument("username needed");
-    if (ident.user_id() == "")
-        throw invalid_argument("user_id needed");
-    if (fpr == "")
-        throw invalid_argument("fpr needed");
-
-
-    const char* fpr_c = fpr.c_str();
-    PEP_STATUS status = set_own_key(Adapter::session(), ident, fpr_c);
-    _throw_status(status);
-}
-
-} // namespace PythonAdapter
-} // namespace pEp {
+
+        string export_secret_key(Identity ident) {
+            PEP_STATUS status = PEP_STATUS_OK;
+            char *key_data = NULL;
+            size_t size;
+            status = ::export_secret_key(Adapter::session(), ident.fpr().c_str(), &key_data, &size);
+
+            _throw_status(status);
+            return key_data;
+        }
+
+        void set_own_key(Identity &ident, string fpr) {
+            if (ident.address() == "")
+                throw invalid_argument("address needed");
+            if (ident.username() == "")
+                throw invalid_argument("username needed");
+            if (ident.user_id() == "")
+                throw invalid_argument("user_id needed");
+            if (fpr == "")
+                throw invalid_argument("fpr needed");
+
+
+            const char *fpr_c = fpr.c_str();
+            PEP_STATUS status = set_own_key(Adapter::session(), ident, fpr_c);
+            _throw_status(status);
+        }
+
+    } // namespace PythonAdapter
+} // namespace pEp
 
 
diff --git a/src/pEp/native_pEp/basic_api.hh b/src/pEp/native_pEp/basic_api.hh
index f4714a8..e4b99f2 100644
--- a/src/pEp/native_pEp/basic_api.hh
+++ b/src/pEp/native_pEp/basic_api.hh
@@ -7,24 +7,31 @@
 #include "pEpmodule.hh"
 
 namespace pEp {
-namespace PythonAdapter {
+    namespace PythonAdapter {
 
-void update_identity(Identity& ident);
-void myself(Identity& ident);
-string _trustwords(Identity me, Identity partner, string lang, bool full);
-void trust_personal_key(Identity ident);
+        void update_identity(Identity &ident);
 
-void set_identity_flags(Identity ident, identity_flags_t flags);
-void unset_identity_flags(Identity ident, identity_flags_t flags);
+        void myself(Identity &ident);
 
-void key_reset_trust(Identity ident);
+        string _trustwords(Identity me, Identity partner, string lang, bool full);
 
-boost::python::list import_key(string key_data);
-string export_key(Identity ident);
-string export_secret_key(Identity ident);
-void set_own_key(Identity& ident, string fpr);
+        void trust_personal_key(Identity ident);
 
-} /* namespace PythonAdapter */
+        void set_identity_flags(Identity ident, identity_flags_t flags);
+
+        void unset_identity_flags(Identity ident, identity_flags_t flags);
+
+        void key_reset_trust(Identity ident);
+
+        boost::python::list import_key(string key_data);
+
+        string export_key(Identity ident);
+
+        string export_secret_key(Identity ident);
+
+        void set_own_key(Identity &ident, string fpr);
+
+    } /* namespace PythonAdapter */
 } /* namespace pEp */
 
 #endif /* BASIC_API_HH */
\ No newline at end of file
diff --git a/src/pEp/native_pEp/identity.cc b/src/pEp/native_pEp/identity.cc
index 6849741..63fbb35 100644
--- a/src/pEp/native_pEp/identity.cc
+++ b/src/pEp/native_pEp/identity.cc
@@ -17,269 +17,241 @@
 #include "message_api.hh"
 
 namespace pEp {
-namespace PythonAdapter {
-using namespace std;
-using namespace boost::python;
-
-Identity::Identity(string address, string username, string user_id,
-        string fpr, int comm_type, string lang, identity_flags_t flags)
-    : _ident(new_identity(address.c_str(), fpr.c_str(), user_id.c_str(),
-                username.c_str()), &::free_identity)
-{
-    if (!_ident)
-        throw bad_alloc();
-    _ident->comm_type = (PEP_comm_type) comm_type;
-    _ident->flags = (identity_flags_t) flags;
-    this->lang(lang);
-}
-
-Identity::Identity(const Identity& second)
-    : _ident(second._ident)
-{
-
-}
-
-Identity::Identity(pEp_identity *ident)
-    : _ident(ident, &::free_identity)
-{
-
-}
-
-Identity::~Identity()
-{
-
-}
-
-Identity::operator pEp_identity *()
-{
-    return _ident.get();
-}
-
-Identity::operator const pEp_identity *() const
-{
-    return _ident.get();
-}
-
-string Identity::_repr()
-{
-    stringstream build;
-    build << "Identity(";
-    string address;
-    if (_ident->address)
-        address = string(_ident->address);
-    build << repr(address) << ", ";
-    string username;
-    if (_ident->username)
-        username = string(_ident->username);
-    build << repr(username) << ", ";
-    string user_id;
-    if (_ident->user_id)
-        user_id = string(_ident->user_id);
-    build << repr(user_id) << ", ";
-    string fpr;
-    if (_ident->fpr)
-        fpr = string(_ident->fpr);
-    build << repr(fpr) << ", ";
-    build << (int) _ident->comm_type << ", ";
-    string lang = _ident->lang;
-    build << repr(lang) << ")";
-    return build.str();
-}
-
-string Identity::_str()
-{
-    if (!(_ident->address && _ident->address[0]))
-        return "";
-    if (!(_ident->username && _ident->username[0]))
-        return _ident->address;
-    return string(_ident->username) + " <" + _ident->address + ">";
-}
-
-void Identity::username(string value)
-{
-    if (value.length() && value.length() < 5)
-        throw length_error("username must be at least 5 characters");
-
-    str_attr(_ident->username, value);
-}
-
-void Identity::lang(string value)
-{
-    if (value == "")
-        memset(_ident->lang, 0, 3);
-    else if (value.length() != 2)
-        throw length_error("length of lang must be 2");
-    else
-        memcpy(_ident->lang, value.c_str(), 3);
-}
-
-string Identity::lang()
-{
-    return _ident->lang;
-}
-
-int Identity::rating()
-{
-    if (!(_ident->address))
-        throw invalid_argument("address must be given");
-
-    PEP_rating rating = PEP_rating_undefined;
-    PEP_STATUS status = ::identity_rating(Adapter::session(), _ident.get(), &rating);
-    _throw_status(status);
-
-    return (int) rating;
-}
-
-PEP_color Identity::color()
-{
-    return _color(rating());
-}
-
-Identity Identity::copy()
-{
-    pEp_identity *dup = ::identity_dup(*this);
-    if (!dup)
-        throw bad_alloc();
-
-    return Identity(dup);
-}
-
-Identity Identity::deepcopy(dict&)
-{
-    return copy();
-}
-
-void Identity::update()
-{
-    update_identity(*this);
-}
-
-void Identity::key_reset(string fpr)
-{
-    PEP_STATUS status = ::key_reset_identity(Adapter::session(), *this,
-            fpr != "" ? fpr.c_str() : nullptr);
-    _throw_status(status);
-}
-
-void Identity::key_mistrusted()
-{
-    PEP_STATUS status = ::key_mistrusted(Adapter::session(), *this);
-    _throw_status(status);
-}
-
-bool Identity::is_pEp_user()
-{
-    bool result;
-    PEP_STATUS status = ::is_pEp_user(Adapter::session(), *this, &result);
-    _throw_status(status);
-    return result;
-}
-
-void Identity::enable_for_sync()
-{
-    PEP_STATUS status = ::enable_identity_for_sync(Adapter::session(), *this);
-    _throw_status(status);
-}
-
-void Identity::disable_for_sync()
-{
-    PEP_STATUS status = ::disable_identity_for_sync(Adapter::session(), *this);
-    _throw_status(status);
-}
-
-Myself::Myself(string address, string username, string user_id, string lang)
-    : Identity(address, username, user_id, "", 0, lang)
-
-{
-    if (!(address.length() && username.length()))
-        throw invalid_argument("address and username must be set");
-    if (lang.length() && lang.length() != 2)
-        throw length_error("lang must be an ISO 639-1 language code or empty");
-
-    // FIXME: should set .me
-    // _ident->me = true;
-    if (user_id.length())
-        throw runtime_error("user_id feature not yet implemented for Myself");
-}
-
-void Myself::update()
-{
-    pEp::PythonAdapter::myself(*this);
-}
-
-Identity identity_attr(pEp_identity *&ident)
-{
-    if (!ident)
-        throw out_of_range("no identity assigned");
-
-    pEp_identity *_dup = identity_dup(ident);
-    if (!_dup)
-        throw bad_alloc();
-
-    Identity _ident(_dup);
-    return _ident;
-}
-
-void identity_attr(pEp_identity *&ident, object value)
-{
-    Identity& _ident = extract< Identity& >(value);
-    pEp_identity *_dup = ::identity_dup(_ident);
-    if (!_dup)
-        throw bad_alloc();
-    PEP_STATUS status = update_identity(Adapter::session(), _dup);
-    _throw_status(status);
-    free_identity(ident);
-    ident = _dup;
-}
-
-boost::python::list identitylist_attr(identity_list *&il)
-{
-    boost::python::list result;
-
-    for (identity_list *_il = il; _il && _il->ident; _il = _il->next) {
-        pEp_identity *ident = ::identity_dup(_il->ident);
-        if (!ident)
-            throw bad_alloc();
-        result.append(object(Identity(ident)));
-    }
-
-    return result;
-}
-
-void identitylist_attr(identity_list *&il, boost::python::list value)
-{
-    identity_list *_il = new_identity_list(NULL);
-    if (!_il)
-        throw bad_alloc();
-
-    identity_list *_i = _il;
-    for (int i=0; i<len(value); i++) {
-        extract< Identity& > extract_identity(value[i]);
-        if (!extract_identity.check()) {
-            free_identity_list(_il);
+    namespace PythonAdapter {
+        using namespace std;
+        using namespace boost::python;
+
+        Identity::Identity(string address, string username, string user_id,
+                           string fpr, int comm_type, string lang, identity_flags_t flags)
+                : _ident(new_identity(address.c_str(), fpr.c_str(), user_id.c_str(),
+                                      username.c_str()), &::free_identity) {
+            if (!_ident)
+                throw bad_alloc();
+            _ident->comm_type = (PEP_comm_type) comm_type;
+            _ident->flags = (identity_flags_t) flags;
+            this->lang(lang);
         }
-        pEp_identity *_ident = extract_identity();
-        pEp_identity *_dup = ::identity_dup(_ident);
-        if (!_dup) {
-            free_identity_list(_il);
-            throw bad_alloc();
+
+        Identity::Identity(const Identity &second)
+                : _ident(second._ident) {
+
+        }
+
+        Identity::Identity(pEp_identity *ident)
+                : _ident(ident, &::free_identity) {
+
         }
-        PEP_STATUS status = update_identity(Adapter::session(), _dup);
-        if (status != PEP_STATUS_OK) {
-            free_identity_list(_il);
+
+        Identity::~Identity() {
+
+        }
+
+        Identity::operator pEp_identity *() {
+            return _ident.get();
+        }
+
+        Identity::operator const pEp_identity *() const {
+            return _ident.get();
+        }
+
+        string Identity::_repr() {
+            stringstream build;
+            build << "Identity(";
+            string address;
+            if (_ident->address)
+                address = string(_ident->address);
+            build << repr(address) << ", ";
+            string username;
+            if (_ident->username)
+                username = string(_ident->username);
+            build << repr(username) << ", ";
+            string user_id;
+            if (_ident->user_id)
+                user_id = string(_ident->user_id);
+            build << repr(user_id) << ", ";
+            string fpr;
+            if (_ident->fpr)
+                fpr = string(_ident->fpr);
+            build << repr(fpr) << ", ";
+            build << (int) _ident->comm_type << ", ";
+            string lang = _ident->lang;
+            build << repr(lang) << ")";
+            return build.str();
+        }
+
+        string Identity::_str() {
+            if (!(_ident->address && _ident->address[0]))
+                return "";
+            if (!(_ident->username && _ident->username[0]))
+                return _ident->address;
+            return string(_ident->username) + " <" + _ident->address + ">";
+        }
+
+        void Identity::username(string value) {
+            if (value.length() && value.length() < 5)
+                throw length_error("username must be at least 5 characters");
+
+            str_attr(_ident->username, value);
+        }
+
+        void Identity::lang(string value) {
+            if (value == "")
+                memset(_ident->lang, 0, 3);
+            else if (value.length() != 2)
+                throw length_error("length of lang must be 2");
+            else
+                memcpy(_ident->lang, value.c_str(), 3);
+        }
+
+        string Identity::lang() {
+            return _ident->lang;
+        }
+
+        int Identity::rating() {
+            if (!(_ident->address))
+                throw invalid_argument("address must be given");
+
+            PEP_rating rating = PEP_rating_undefined;
+            PEP_STATUS status = ::identity_rating(Adapter::session(), _ident.get(), &rating);
             _throw_status(status);
+
+            return (int) rating;
+        }
+
+        PEP_color Identity::color() {
+            return _color(rating());
+        }
+
+        Identity Identity::copy() {
+            pEp_identity *dup = ::identity_dup(*this);
+            if (!dup)
+                throw bad_alloc();
+
+            return Identity(dup);
         }
-        _i = identity_list_add(_i, _dup);
-        if (!_i) {
-            free_identity_list(_il);
-            throw bad_alloc();
+
+        Identity Identity::deepcopy(dict &) {
+            return copy();
         }
-    }
 
-    free_identity_list(il);
-    il = _il;
-}
+        void Identity::update() {
+            update_identity(*this);
+        }
+
+        void Identity::key_reset(string fpr) {
+            PEP_STATUS status = ::key_reset_identity(Adapter::session(), *this,
+                                                     fpr != "" ? fpr.c_str() : nullptr);
+            _throw_status(status);
+        }
+
+        void Identity::key_mistrusted() {
+            PEP_STATUS status = ::key_mistrusted(Adapter::session(), *this);
+            _throw_status(status);
+        }
+
+        bool Identity::is_pEp_user() {
+            bool result;
+            PEP_STATUS status = ::is_pEp_user(Adapter::session(), *this, &result);
+            _throw_status(status);
+            return result;
+        }
+
+        void Identity::enable_for_sync() {
+            PEP_STATUS status = ::enable_identity_for_sync(Adapter::session(), *this);
+            _throw_status(status);
+        }
+
+        void Identity::disable_for_sync() {
+            PEP_STATUS status = ::disable_identity_for_sync(Adapter::session(), *this);
+            _throw_status(status);
+        }
+
+        Myself::Myself(string address, string username, string user_id, string lang)
+                : Identity(address, username, user_id, "", 0, lang) {
+            if (!(address.length() && username.length()))
+                throw invalid_argument("address and username must be set");
+            if (lang.length() && lang.length() != 2)
+                throw length_error("lang must be an ISO 639-1 language code or empty");
+
+            // FIXME: should set .me
+            // _ident->me = true;
+            if (user_id.length())
+                throw runtime_error("user_id feature not yet implemented for Myself");
+        }
+
+        void Myself::update() {
+            pEp::PythonAdapter::myself(*this);
+        }
+
+        Identity identity_attr(pEp_identity *&ident) {
+            if (!ident)
+                throw out_of_range("no identity assigned");
+
+            pEp_identity *_dup = identity_dup(ident);
+            if (!_dup)
+                throw bad_alloc();
+
+            Identity _ident(_dup);
+            return _ident;
+        }
+
+        void identity_attr(pEp_identity *&ident, object value) {
+            Identity &_ident = extract<Identity &>(value);
+            pEp_identity *_dup = ::identity_dup(_ident);
+            if (!_dup)
+                throw bad_alloc();
+            PEP_STATUS status = update_identity(Adapter::session(), _dup);
+            _throw_status(status);
+            free_identity(ident);
+            ident = _dup;
+        }
+
+        boost::python::list identitylist_attr(identity_list *&il) {
+            boost::python::list result;
+
+            for (identity_list *_il = il; _il && _il->ident; _il = _il->next) {
+                pEp_identity *ident = ::identity_dup(_il->ident);
+                if (!ident)
+                    throw bad_alloc();
+                result.append(object(Identity(ident)));
+            }
+
+            return result;
+        }
+
+        void identitylist_attr(identity_list *&il, boost::python::list value) {
+            identity_list *_il = new_identity_list(NULL);
+            if (!_il)
+                throw bad_alloc();
+
+            identity_list *_i = _il;
+            for (int i = 0; i < len(value); i++) {
+                extract < Identity & > extract_identity(value[i]);
+                if (!extract_identity.check()) {
+                    free_identity_list(_il);
+                }
+                pEp_identity *_ident = extract_identity();
+                pEp_identity *_dup = ::identity_dup(_ident);
+                if (!_dup) {
+                    free_identity_list(_il);
+                    throw bad_alloc();
+                }
+                PEP_STATUS status = update_identity(Adapter::session(), _dup);
+                if (status != PEP_STATUS_OK) {
+                    free_identity_list(_il);
+                    _throw_status(status);
+                }
+                _i = identity_list_add(_i, _dup);
+                if (!_i) {
+                    free_identity_list(_il);
+                    throw bad_alloc();
+                }
+            }
+
+            free_identity_list(il);
+            il = _il;
+        }
 
-} // namespace PythonAdapter
-} // namespace pEp {
+    } // namespace PythonAdapter
+} // namespace pEp
 
diff --git a/src/pEp/native_pEp/identity.hh b/src/pEp/native_pEp/identity.hh
index d70133f..071ac4a 100644
--- a/src/pEp/native_pEp/identity.hh
+++ b/src/pEp/native_pEp/identity.hh
@@ -21,82 +21,101 @@
 #include "str_attr.hh"
 
 namespace pEp {
-namespace PythonAdapter {
+    namespace PythonAdapter {
 
-using std::string;
-using std::shared_ptr;
+        using std::string;
+        using std::shared_ptr;
 
 // Identity is owning a pEp_identity
 
-class Identity {
-protected:
-    shared_ptr< pEp_identity > _ident;
+        class Identity {
+        protected:
+            shared_ptr <pEp_identity> _ident;
 
-public:
-    Identity(string address = "", string username = "",
-            string user_id = "", string fpr = "", int comm_type = 0,
-            string lang = "", identity_flags_t flags = 0);
+        public:
+            Identity(string address = "", string username = "",
+                     string user_id = "", string fpr = "", int comm_type = 0,
+                     string lang = "", identity_flags_t flags = 0);
 
-    Identity(const Identity& second);
-    Identity(pEp_identity *ident);
-    virtual ~Identity();
-    operator pEp_identity *();
-    operator const pEp_identity *() const;
+            Identity(const Identity &second);
 
-    string _repr();
-    string _str();
+            Identity(pEp_identity *ident);
 
-    string address() { return str_attr(_ident->address); }
-    void address(string value) { str_attr(_ident->address, value); }
+            virtual ~Identity();
 
-    string fpr() { return str_attr(_ident->fpr); }
-    void fpr(string value) { str_attr(_ident->fpr, value); }
+            operator pEp_identity *();
 
-    string user_id() { return str_attr(_ident->user_id); }
-    void user_id(string value) { str_attr(_ident->user_id, value); }
+            operator const pEp_identity *() const;
 
-    string username() { return str_attr(_ident->username); }
-    void username(string value);
+            string _repr();
 
-    PEP_comm_type comm_type() { return _ident->comm_type; }
-    void comm_type(PEP_comm_type value) { _ident->comm_type = value; };
+            string _str();
 
-    std::string lang();
-    void lang(std::string value);
+            string address() { return str_attr(_ident->address); }
 
-    identity_flags_t flags() { return _ident->flags; }
-    void flags(identity_flags_t flags) { _ident->flags = flags; }
+            void address(string value) { str_attr(_ident->address, value); }
 
-    int rating();
-    PEP_color color();
+            string fpr() { return str_attr(_ident->fpr); }
 
-    Identity copy();
-    Identity deepcopy(dict& memo);
+            void fpr(string value) { str_attr(_ident->fpr, value); }
 
-    virtual void update();
+            string user_id() { return str_attr(_ident->user_id); }
 
-    void key_reset(string fpr="");
-    void key_mistrusted();
+            void user_id(string value) { str_attr(_ident->user_id, value); }
 
-    bool is_pEp_user();
+            string username() { return str_attr(_ident->username); }
 
-    void enable_for_sync();
-    void disable_for_sync();
-};
+            void username(string value);
 
-class Myself : public Identity {
-public:
-    Myself(string address, string username, string user_id="", string lang="");
-    virtual void update();
-};
+            PEP_comm_type comm_type() { return _ident->comm_type; }
 
-Identity identity_attr(pEp_identity *&ident);
-void identity_attr(pEp_identity *&ident, object value);
+            void comm_type(PEP_comm_type value) { _ident->comm_type = value; };
 
-boost::python::list identitylist_attr(identity_list *&il);
-void identitylist_attr(identity_list *&il, boost::python::list value);
+            std::string lang();
 
-} /* namespace PythonAdapter */
-} /* namespace pEp */
+            void lang(std::string value);
+
+            identity_flags_t flags() { return _ident->flags; }
+
+            void flags(identity_flags_t flags) { _ident->flags = flags; }
+
+            int rating();
+
+            PEP_color color();
+
+            Identity copy();
+
+            Identity deepcopy(dict &memo);
+
+            virtual void update();
+
+            void key_reset(string fpr = "");
+
+            void key_mistrusted();
+
+            bool is_pEp_user();
+
+            void enable_for_sync();
+
+            void disable_for_sync();
+        };
+
+        class Myself : public Identity {
+        public:
+            Myself(string address, string username, string user_id = "", string lang = "");
+
+            virtual void update();
+        };
+
+        Identity identity_attr(pEp_identity *&ident);
+
+        void identity_attr(pEp_identity *&ident, object value);
+
+        boost::python::list identitylist_attr(identity_list *&il);
+
+        void identitylist_attr(identity_list *&il, boost::python::list value);
+
+    } // namespace PythonAdapter
+} // namespace pEp
 
 #endif /* IDENTITY_HH */
\ No newline at end of file
diff --git a/src/pEp/native_pEp/message.cc b/src/pEp/native_pEp/message.cc
index 3d0a279..ffdcca7 100644
--- a/src/pEp/native_pEp/message.cc
+++ b/src/pEp/native_pEp/message.cc
@@ -19,395 +19,367 @@
 #include "message_api.hh"
 
 namespace pEp {
-namespace PythonAdapter {
-using namespace std;
-using namespace boost::python;
-
-Message::Blob::Blob(bloblist_t *bl, bool chained) :
-    _bl(bl), part_of_chain(chained)
-{
-    if (!_bl)
-        throw bad_alloc();
-}
-
-Message::Blob::Blob(object data, string mime_type, string filename) :
-    _bl(new_bloblist(NULL, 0, NULL, NULL)), part_of_chain(false)
-{
-    if (!_bl)
-        throw bad_alloc();
-
-    Py_buffer src;
-    int result = PyObject_GetBuffer(data.ptr(), &src, PyBUF_CONTIG_RO);
-    if (result)
-        throw invalid_argument("need a contiguous buffer to read");
-
-    char *mem = (char *)malloc(src.len);
-    if (!mem) {
-        PyBuffer_Release(&src);
-        throw bad_alloc();
-    }
-
-    memcpy(mem, src.buf, src.len);
-    free(_bl->value);
-    _bl->size = src.len;
-    _bl->value = mem;
-
-    PyBuffer_Release(&src);
-
-    this->mime_type(mime_type);
-    this->filename(filename);
-}
-
-Message::Blob::Blob(const Message::Blob& second) :
-    _bl(second._bl), part_of_chain(true)
-{
-
-}
-
-Message::Blob::~Blob()
-{
-    if (!part_of_chain) {
-        free(_bl->value);
-        free(_bl);
-    }
-}
-
-string Message::Blob::_repr()
-{
-    stringstream build;
-    build << "Blob(";
-    if (!_bl) {
-        build << "b'', '', ''";
-    }
-    else {
-        build << "bytes(" << _bl->size << "), ";
-        string mime_type;
-        if (_bl->mime_type)
-            mime_type = string(_bl->mime_type);
-        string filename;
-        if (_bl->filename)
-            filename = string(_bl->filename);
-        build << repr(mime_type) << ", ";
-        build << repr(filename);
-    }
-    build << ")";
-    return build.str();
-}
-
-int Message::Blob::getbuffer(PyObject *self, Py_buffer *view, int flags) {
-    bloblist_t *bl = NULL;
-
-    try {
-        Message::Blob& blob = extract< Message::Blob& >(self);
-        bl = blob._bl;
-    }
-    catch (exception& e) {
-        PyErr_SetString(PyExc_RuntimeError, "extract not possible");
-        view->obj = NULL;
-        return -1;
-    }
-
-    if (!(bl && bl->value)) {
-        PyErr_SetString(PyExc_RuntimeError, "no data available");
-        view->obj = NULL;
-        return -1;
-    }
-
-    return PyBuffer_FillInfo(view, self, bl->value, bl->size, 0, flags);
-}
-
-string Message::Blob::decode(string encoding)
-{
-    if (encoding == "") {
-        string _mime_type = _bl->mime_type ? _bl->mime_type : "";
-        encoding = "ascii";
-
-        if (_mime_type == "application/pEp.sync")
-            encoding = "pep.sync";
-
-        if (_mime_type == "application/pEp.keyreset")
-            encoding = "pep.distribution";
-
-    }
-    object codecs = import("codecs");
-    object _decode = codecs.attr("decode");
-    return call< string >(_decode.ptr(), this, encoding);
-}
-
-PyBufferProcs Message::Blob::bp = { getbuffer, NULL };
-
-Message::Message(int dir, Identity *from)
-    : _msg(new_message((PEP_msg_direction) dir), &free_message)
-{
-    if (!_msg)
-        throw bad_alloc();
-
-    if (from) {
-        _msg->from = ::identity_dup(*from);
-        if (!_msg->from)
-            throw bad_alloc();
-        _msg->dir = (PEP_msg_direction) dir;
-    }
-}
-
-Message::Message(string mimetext)
-    : _msg(NULL, &free_message)
-{
-    message *_cpy;
-    PEP_STATUS status = mime_decode_message(mimetext.c_str(),
-            mimetext.size(), &_cpy, NULL);
-    switch (status) {
-        case PEP_STATUS_OK:
-            if (_cpy)
-                _cpy->dir = PEP_dir_outgoing;
-            else
-                _cpy = new_message(PEP_dir_outgoing);
-
-            if (!_cpy)
+    namespace PythonAdapter {
+        using namespace std;
+        using namespace boost::python;
+
+        Message::Blob::Blob(bloblist_t *bl, bool chained) :
+                _bl(bl), part_of_chain(chained) {
+            if (!_bl)
                 throw bad_alloc();
+        }
 
-            _msg = shared_ptr< message >(_cpy);
-            break;
+        Message::Blob::Blob(object data, string mime_type, string filename) :
+                _bl(new_bloblist(NULL, 0, NULL, NULL)), part_of_chain(false) {
+            if (!_bl)
+                throw bad_alloc();
 
-        case PEP_BUFFER_TOO_SMALL:
-            throw runtime_error("mime_decode_message: buffer too small");
+            Py_buffer src;
+            int result = PyObject_GetBuffer(data.ptr(), &src, PyBUF_CONTIG_RO);
+            if (result)
+                throw invalid_argument("need a contiguous buffer to read");
 
-        case PEP_CANNOT_CREATE_TEMP_FILE:
-            throw runtime_error("mime_decode_message: cannot create temp file");
+            char *mem = (char *) malloc(src.len);
+            if (!mem) {
+                PyBuffer_Release(&src);
+                throw bad_alloc();
+            }
+
+            memcpy(mem, src.buf, src.len);
+            free(_bl->value);
+            _bl->size = src.len;
+            _bl->value = mem;
 
-        case PEP_OUT_OF_MEMORY:
-            throw bad_alloc();
+            PyBuffer_Release(&src);
 
-        default:
+            this->mime_type(mime_type);
+            this->filename(filename);
+        }
+
+        Message::Blob::Blob(const Message::Blob &second) :
+                _bl(second._bl), part_of_chain(true) {
+
+        }
+
+        Message::Blob::~Blob() {
+            if (!part_of_chain) {
+                free(_bl->value);
+                free(_bl);
+            }
+        }
+
+        string Message::Blob::_repr() {
             stringstream build;
-            build << "mime_decode_message: unknown error (" << (int) status << ")";
-            throw runtime_error(build.str());
-    }
-}
+            build << "Blob(";
+            if (!_bl) {
+                build << "b'', '', ''";
+            } else {
+                build << "bytes(" << _bl->size << "), ";
+                string mime_type;
+                if (_bl->mime_type)
+                    mime_type = string(_bl->mime_type);
+                string filename;
+                if (_bl->filename)
+                    filename = string(_bl->filename);
+                build << repr(mime_type) << ", ";
+                build << repr(filename);
+            }
+            build << ")";
+            return build.str();
+        }
+
+        int Message::Blob::getbuffer(PyObject *self, Py_buffer *view, int flags) {
+            bloblist_t *bl = NULL;
+
+            try {
+                Message::Blob &blob = extract<Message::Blob &>(self);
+                bl = blob._bl;
+            }
+            catch (exception &e) {
+                PyErr_SetString(PyExc_RuntimeError, "extract not possible");
+                view->obj = NULL;
+                return -1;
+            }
+
+            if (!(bl && bl->value)) {
+                PyErr_SetString(PyExc_RuntimeError, "no data available");
+                view->obj = NULL;
+                return -1;
+            }
+
+            return PyBuffer_FillInfo(view, self, bl->value, bl->size, 0, flags);
+        }
+
+        string Message::Blob::decode(string encoding) {
+            if (encoding == "") {
+                string _mime_type = _bl->mime_type ? _bl->mime_type : "";
+                encoding = "ascii";
 
-Message::Message(const Message& second)
-    : _msg(second._msg)
-{
-    if (!_msg.get())
-        throw bad_alloc();
-}
+                if (_mime_type == "application/pEp.sync")
+                    encoding = "pep.sync";
 
-Message::Message(message *msg)
-    : _msg(::message_dup(msg), &free_message)
-{
+                if (_mime_type == "application/pEp.keyreset")
+                    encoding = "pep.distribution";
 
-}
+            }
+            object codecs = import("codecs");
+            object _decode = codecs.attr("decode");
+            return call<string>(_decode.ptr(), this, encoding);
+        }
 
-Message::~Message()
-{
+        PyBufferProcs Message::Blob::bp = {getbuffer, NULL};
 
-}
+        Message::Message(int dir, Identity *from)
+                : _msg(new_message((PEP_msg_direction) dir), &free_message) {
+            if (!_msg)
+                throw bad_alloc();
 
-Message::operator message *()
-{
-    return _msg.get();
-}
+            if (from) {
+                _msg->from = ::identity_dup(*from);
+                if (!_msg->from)
+                    throw bad_alloc();
+                _msg->dir = (PEP_msg_direction) dir;
+            }
+        }
 
-Message::operator const message *() const
-{
-    return _msg.get();
-}
+        Message::Message(string mimetext)
+                : _msg(NULL, &free_message) {
+            message *_cpy;
+            PEP_STATUS status = mime_decode_message(mimetext.c_str(),
+                                                    mimetext.size(), &_cpy, NULL);
+            switch (status) {
+                case PEP_STATUS_OK:
+                    if (_cpy)
+                        _cpy->dir = PEP_dir_outgoing;
+                    else
+                        _cpy = new_message(PEP_dir_outgoing);
+
+                    if (!_cpy)
+                        throw bad_alloc();
+
+                    _msg = shared_ptr<message>(_cpy);
+                    break;
+
+                case PEP_BUFFER_TOO_SMALL:
+                    throw runtime_error("mime_decode_message: buffer too small");
+
+                case PEP_CANNOT_CREATE_TEMP_FILE:
+                    throw runtime_error("mime_decode_message: cannot create temp file");
+
+                case PEP_OUT_OF_MEMORY:
+                    throw bad_alloc();
+
+                default:
+                    stringstream build;
+                    build << "mime_decode_message: unknown error (" << (int) status << ")";
+                    throw runtime_error(build.str());
+            }
+        }
 
-string Message::_str()
-{
-    if (!(_msg->from && _msg->from->address && _msg->from->address[0]))
-        throw out_of_range(".from_.address missing");
+        Message::Message(const Message &second)
+                : _msg(second._msg) {
+            if (!_msg.get())
+                throw bad_alloc();
+        }
 
-    char *mimetext;
-    string result;
+        Message::Message(message *msg)
+                : _msg(::message_dup(msg), &free_message) {
 
-    PEP_STATUS status = mime_encode_message(*this, false, &mimetext, false);
-    switch (status) {
-        case PEP_STATUS_OK:
-            result = mimetext;
-            free(mimetext);
-            break;
+        }
 
-        case PEP_BUFFER_TOO_SMALL:
-            throw runtime_error("mime_encode_message: buffer too small");
+        Message::~Message() {
 
-        case PEP_CANNOT_CREATE_TEMP_FILE:
-            throw runtime_error("mime_encode_message: cannot create temp file");
+        }
 
-        case PEP_OUT_OF_MEMORY:
-            throw bad_alloc();
+        Message::operator message *() {
+            return _msg.get();
+        }
 
-        default:
+        Message::operator const message *() const {
+            return _msg.get();
+        }
+
+        string Message::_str() {
+            if (!(_msg->from && _msg->from->address && _msg->from->address[0]))
+                throw out_of_range(".from_.address missing");
+
+            char *mimetext;
+            string result;
+
+            PEP_STATUS status = mime_encode_message(*this, false, &mimetext, false);
+            switch (status) {
+                case PEP_STATUS_OK:
+                    result = mimetext;
+                    free(mimetext);
+                    break;
+
+                case PEP_BUFFER_TOO_SMALL:
+                    throw runtime_error("mime_encode_message: buffer too small");
+
+                case PEP_CANNOT_CREATE_TEMP_FILE:
+                    throw runtime_error("mime_encode_message: cannot create temp file");
+
+                case PEP_OUT_OF_MEMORY:
+                    throw bad_alloc();
+
+                default:
+                    stringstream build;
+                    build << "mime_encode_message: unknown error (" << (int) status << ")";
+                    throw runtime_error(build.str());
+            }
+
+            return result;
+        }
+
+        string Message::_repr() {
             stringstream build;
-            build << "mime_encode_message: unknown error (" << (int) status << ")";
-            throw runtime_error(build.str());
-    }
-
-    return result;
-}
-
-string Message::_repr()
-{
-    stringstream build;
-    build << "Message(" << repr(_str()) << ")";
-    return build.str();
-}
-
-boost::python::tuple Message::attachments()
-{
-    boost::python::list l;
-
-    for (bloblist_t *bl = _msg->attachments; bl && bl->value; bl =
-            bl->next) {
-        l.append(Blob(bl, true));
-    }
-
-    return boost::python::tuple(l);
-}
-
-void Message::attachments(boost::python::list value)
-{
-    bloblist_t *bl = new_bloblist(NULL, 0, NULL, NULL);
-    if (!bl)
-        throw bad_alloc();
-
-    bloblist_t *_l = bl;
-    for (int i=0; i<len(value); i++) {
-        Message::Blob& blob = extract< Message::Blob& >(value[i]);
-        _l = bloblist_add(_l, blob._bl->value, blob._bl->size,
-                blob._bl->mime_type, blob._bl->filename);
-        if (!_l) {
-            for (_l = bl; _l && _l->value; ) {
-                free(_l->mime_type);
-                free(_l->filename);
-                bloblist_t *_ll = _l;
-                _l = _l->next;
-                free(_ll);
+            build << "Message(" << repr(_str()) << ")";
+            return build.str();
+        }
+
+        boost::python::tuple Message::attachments() {
+            boost::python::list l;
+
+            for (bloblist_t *bl = _msg->attachments; bl && bl->value; bl =
+                                                                              bl->next) {
+                l.append(Blob(bl, true));
             }
-            throw bad_alloc();
+
+            return boost::python::tuple(l);
+        }
+
+        void Message::attachments(boost::python::list value) {
+            bloblist_t *bl = new_bloblist(NULL, 0, NULL, NULL);
+            if (!bl)
+                throw bad_alloc();
+
+            bloblist_t *_l = bl;
+            for (int i = 0; i < len(value); i++) {
+                Message::Blob &blob = extract<Message::Blob &>(value[i]);
+                _l = bloblist_add(_l, blob._bl->value, blob._bl->size,
+                                  blob._bl->mime_type, blob._bl->filename);
+                if (!_l) {
+                    for (_l = bl; _l && _l->value;) {
+                        free(_l->mime_type);
+                        free(_l->filename);
+                        bloblist_t *_ll = _l;
+                        _l = _l->next;
+                        free(_ll);
+                    }
+                    throw bad_alloc();
+                }
+            }
+
+            for (int i = 0; i < len(value); i++) {
+                Message::Blob &blob = extract<Message::Blob &>(value[i]);
+                blob._bl->value = NULL;
+                blob._bl->size = 0;
+                free(blob._bl->mime_type);
+                blob._bl->mime_type = NULL;
+                free(blob._bl->filename);
+                blob._bl->filename = NULL;
+            }
+
+            free_bloblist(_msg->attachments);
+            _msg->attachments = bl;
+        }
+
+        Message Message::encrypt() {
+            boost::python::list extra;
+            return encrypt_message(*this, extra, PEP_enc_PGP_MIME, 0);
         }
-    }
-
-    for (int i=0; i<len(value); i++) {
-        Message::Blob& blob = extract< Message::Blob& >(value[i]);
-        blob._bl->value = NULL;
-        blob._bl->size = 0;
-        free(blob._bl->mime_type);
-        blob._bl->mime_type = NULL;
-        free(blob._bl->filename);
-        blob._bl->filename = NULL;
-    }
-
-    free_bloblist(_msg->attachments);
-    _msg->attachments = bl;
-}
-
-Message Message::encrypt()
-{
-    boost::python::list extra;
-    return encrypt_message(*this, extra, PEP_enc_PGP_MIME, 0);
-}
-
-Message Message::_encrypt(boost::python::list extra, int enc_format, int flags)
-{
-    if (!enc_format)
-        enc_format = PEP_enc_PGP_MIME;
-    return encrypt_message(*this, extra, enc_format, flags);
-}
-
-boost::python::tuple Message::decrypt(int flags) {
-    return pEp::PythonAdapter::decrypt_message(*this, flags);
-}
-
-PEP_rating Message::outgoing_rating()
-{
-    if (_msg->dir != PEP_dir_outgoing)
-        throw invalid_argument("Message.dir must be outgoing");
-
-    if (from().address() == "")
-        throw invalid_argument("from.address needed");
-    if (from().username() == "")
-        throw invalid_argument("from.username needed");
-
-    if (len(to()) + len(cc()) == 0)
-        throw invalid_argument("either to or cc needed");
-
-    PEP_STATUS status = myself(Adapter::session(), _msg->from);
-    _throw_status(status);
-
-    PEP_rating rating = PEP_rating_undefined;
-    status = outgoing_message_rating(Adapter::session(), *this, &rating);
-    _throw_status(status);
-
-    return rating;
-}
-
-PEP_color Message::outgoing_color()
-{
-    return _color(outgoing_rating());
-}
-
-Message Message::copy()
-{
-    message *dup = message_dup(*this);
-    if (!dup)
-        throw bad_alloc();
-    return Message(dup);
-}
-
-Message Message::deepcopy(dict&)
-{
-    return copy();
-}
-
-Message outgoing_message(Identity me)
-{
-    if (me.address().empty() || me.user_id().empty())
-        throw runtime_error("at least address and user_id of own user needed");
-
-    ::myself(Adapter::session(), me);
-    auto m = Message(PEP_dir_outgoing, &me);
-    return m;
-}
-
-static object update(Identity ident)
-{
-    if (ident.address().empty())
-        throw runtime_error("at least address needed");
-    update_identity(Adapter::session(), ident);
-    return object(ident);
-}
-
-static boost::python::list update(boost::python::list il)
-{
-    for (int i=0; i<len(il); i++) {
-        update(extract< Identity >(il[i]));
-    }
-
-    return il;
-}
-
-Message incoming_message(string mime_text)
-{
-    auto m = Message(mime_text);
-    m.dir(PEP_dir_incoming);
-
-    try {
-        m.from(update(m.from()));
-    }
-    catch (out_of_range&) { }
-
-    try {
-        m.recv_by(update(m.recv_by()));
-    }
-    catch (out_of_range&) { }
-
-    m.to(update(m.to()));
-    m.cc(update(m.cc()));
-    m.reply_to(update(m.reply_to()));
-
-    return m;
-}
-
-} // namespace PythonAdapter
-} // namespace pEp {
+
+        Message Message::_encrypt(boost::python::list extra, int enc_format, int flags) {
+            if (!enc_format)
+                enc_format = PEP_enc_PGP_MIME;
+            return encrypt_message(*this, extra, enc_format, flags);
+        }
+
+        boost::python::tuple Message::decrypt(int flags) {
+            return pEp::PythonAdapter::decrypt_message(*this, flags);
+        }
+
+        PEP_rating Message::outgoing_rating() {
+            if (_msg->dir != PEP_dir_outgoing)
+                throw invalid_argument("Message.dir must be outgoing");
+
+            if (from().address() == "")
+                throw invalid_argument("from.address needed");
+            if (from().username() == "")
+                throw invalid_argument("from.username needed");
+
+            if (len(to()) + len(cc()) == 0)
+                throw invalid_argument("either to or cc needed");
+
+            PEP_STATUS status = myself(Adapter::session(), _msg->from);
+            _throw_status(status);
+
+            PEP_rating rating = PEP_rating_undefined;
+            status = outgoing_message_rating(Adapter::session(), *this, &rating);
+            _throw_status(status);
+
+            return rating;
+        }
+
+        PEP_color Message::outgoing_color() {
+            return _color(outgoing_rating());
+        }
+
+        Message Message::copy() {
+            message *dup = message_dup(*this);
+            if (!dup)
+                throw bad_alloc();
+            return Message(dup);
+        }
+
+        Message Message::deepcopy(dict &) {
+            return copy();
+        }
+
+        Message outgoing_message(Identity me) {
+            if (me.address().empty() || me.user_id().empty())
+                throw runtime_error("at least address and user_id of own user needed");
+
+            ::myself(Adapter::session(), me);
+            auto m = Message(PEP_dir_outgoing, &me);
+            return m;
+        }
+
+        static object update(Identity ident) {
+            if (ident.address().empty())
+                throw runtime_error("at least address needed");
+            update_identity(Adapter::session(), ident);
+            return object(ident);
+        }
+
+        static boost::python::list update(boost::python::list il) {
+            for (int i = 0; i < len(il); i++) {
+                update(extract<Identity>(il[i]));
+            }
+
+            return il;
+        }
+
+        Message incoming_message(string mime_text) {
+            auto m = Message(mime_text);
+            m.dir(PEP_dir_incoming);
+
+            try {
+                m.from(update(m.from()));
+            }
+            catch (out_of_range &) {}
+
+            try {
+                m.recv_by(update(m.recv_by()));
+            }
+            catch (out_of_range &) {}
+
+            m.to(update(m.to()));
+            m.cc(update(m.cc()));
+            m.reply_to(update(m.reply_to()));
+
+            return m;
+        }
+
+    } // namespace PythonAdapter
+} // namespace pEp
diff --git a/src/pEp/native_pEp/message.hh b/src/pEp/native_pEp/message.hh
index dac9a73..5eba845 100644
--- a/src/pEp/native_pEp/message.hh
+++ b/src/pEp/native_pEp/message.hh
@@ -18,137 +18,177 @@
 #include "identity.hh"
 
 namespace pEp {
-namespace PythonAdapter {
-using std::string;
-using std::runtime_error;
-using std::invalid_argument;
-using boost::lexical_cast;
+    namespace PythonAdapter {
+        using std::string;
+        using std::runtime_error;
+        using std::invalid_argument;
+        using boost::lexical_cast;
 
 // Message is owning a message struct
 
-class Message {
-    shared_ptr< ::message > _msg;
+        class Message {
+            shared_ptr<::message> _msg;
 
-public:
-    // Blob is owning a bloblist_t struct - or not and just managing
-    // one depending on part_of_chain
+        public:
+            // Blob is owning a bloblist_t struct - or not and just managing
+            // one depending on part_of_chain
 
-    class Blob {
-        bloblist_t *_bl;
-        bool part_of_chain;
+            class Blob {
+                bloblist_t *_bl;
+                bool part_of_chain;
 
-    public:
-        Blob(bloblist_t *bl = new_bloblist(NULL, 0, NULL, NULL),
-                bool chained = false);
-        Blob(object data, string mime_type = "", string filename = "");
-        Blob(const Blob& second);
-        ~Blob();
+            public:
+                Blob(bloblist_t *bl = new_bloblist(NULL, 0, NULL, NULL),
+                     bool chained = false);
 
-        string _repr();
+                Blob(object data, string mime_type = "", string filename = "");
 
-        string mime_type() { return _bl ? str_attr(_bl->mime_type) : ""; }
-        void mime_type(string value) { str_attr(_bl->mime_type, value); }
+                Blob(const Blob &second);
 
-        string filename() { return str_attr(_bl->filename); }
-        void filename(string value) { str_attr(_bl->filename, value); }
+                ~Blob();
 
-        size_t size() { return _bl->size; }
-        string decode(string encoding);
-        string decode() { return decode(""); }
+                string _repr();
 
-        static PyBufferProcs bp;
+                string mime_type() { return _bl ? str_attr(_bl->mime_type) : ""; }
 
-        friend class Message;
+                void mime_type(string value) { str_attr(_bl->mime_type, value); }
 
-    protected:
-        static int getbuffer(PyObject *self, Py_buffer *view, int flags);
-    };
+                string filename() { return str_attr(_bl->filename); }
 
-    Message(int dir = PEP_dir_outgoing, Identity *from = NULL);
-    Message(string mimetext);
-    Message(const Message& second);
-    Message(message *msg);
-    ~Message();
-    operator message *();
-    operator const message *() const;
+                void filename(string value) { str_attr(_bl->filename, value); }
 
-    string _str();
-    string _repr();
+                size_t size() { return _bl->size; }
 
-    PEP_msg_direction dir() { return _msg->dir; }
-    void dir(PEP_msg_direction value) { _msg->dir = value; }
+                string decode(string encoding);
 
-    string id() { return str_attr(_msg->id); }
-    void id(string value) { str_attr(_msg->id, value); }
+                string decode() { return decode(""); }
 
-    string shortmsg() { return str_attr(_msg->shortmsg); }
-    void shortmsg(string value) { str_attr(_msg->shortmsg, value); }
+                static PyBufferProcs bp;
 
-    string longmsg() { return str_attr(_msg->longmsg); }
-    void longmsg(string value) { str_attr(_msg->longmsg, value); }
+                friend class Message;
 
-    string longmsg_formatted() { return str_attr(_msg->longmsg_formatted); }
-    void longmsg_formatted(string value) { str_attr(_msg->longmsg_formatted, value); }
+            protected:
+                static int getbuffer(PyObject *self, Py_buffer *view, int flags);
+            };
 
-    boost::python::tuple attachments();
-    void attachments(boost::python::list value);
+            Message(int dir = PEP_dir_outgoing, Identity *from = NULL);
 
-    time_t sent() { return timestamp_attr(_msg->sent); }
-    void sent(time_t value) { timestamp_attr(_msg->sent, value); }
+            Message(string mimetext);
 
-    time_t recv() { return timestamp_attr(_msg->recv); }
-    void recv(time_t value) { timestamp_attr(_msg->recv, value); }
+            Message(const Message &second);
 
-    Identity from() { return identity_attr(_msg->from); }
-    void from(object value) { identity_attr(_msg->from, value); }
+            Message(message *msg);
 
-    boost::python::list to() { return identitylist_attr(_msg->to); }
-    void to(boost::python::list value) { identitylist_attr(_msg->to, value); }
+            ~Message();
 
-    Identity recv_by() { return identity_attr(_msg->recv_by); }
-    void recv_by(object value) { identity_attr(_msg->recv_by, value); }
+            operator message *();
 
-    boost::python::list cc() { return identitylist_attr(_msg->cc); }
-    void cc(boost::python::list value) { identitylist_attr(_msg->cc, value); }
+            operator const message *() const;
 
-    boost::python::list bcc() { return identitylist_attr(_msg->bcc); }
-    void bcc(boost::python::list value) { identitylist_attr(_msg->bcc, value); }
+            string _str();
 
-    boost::python::list reply_to() { return identitylist_attr(_msg->reply_to); }
-    void reply_to(boost::python::list value) { identitylist_attr(_msg->reply_to, value); }
+            string _repr();
 
-    boost::python::list in_reply_to() { return strlist_attr(_msg->in_reply_to); }
-    void in_reply_to(boost::python::list value) { strlist_attr(_msg->in_reply_to, value); }
+            PEP_msg_direction dir() { return _msg->dir; }
 
-    boost::python::list references() { return strlist_attr(_msg->references); }
-    void references(boost::python::list value) { strlist_attr(_msg->references, value); }
+            void dir(PEP_msg_direction value) { _msg->dir = value; }
 
-    boost::python::list keywords() { return strlist_attr(_msg->keywords); }
-    void keywords(boost::python::list value) { strlist_attr(_msg->keywords, value); }
+            string id() { return str_attr(_msg->id); }
 
-    string comments() { return str_attr(_msg->comments); }
-    void comments(string value) { str_attr(_msg->comments, value); }
+            void id(string value) { str_attr(_msg->id, value); }
 
-    dict opt_fields() { return strdict_attr(_msg->opt_fields); }
-    void opt_fields(dict value) { return strdict_attr(_msg->opt_fields, value); }
+            string shortmsg() { return str_attr(_msg->shortmsg); }
 
-    PEP_enc_format enc_format() { return _msg->enc_format; }
-    void enc_format(PEP_enc_format value) { _msg->enc_format = value; }
+            void shortmsg(string value) { str_attr(_msg->shortmsg, value); }
 
-    Message encrypt();
-    Message _encrypt(boost::python::list extra, int enc_format=4, int flags=0);
+            string longmsg() { return str_attr(_msg->longmsg); }
 
-    boost::python::tuple decrypt(int flags=0);
-    PEP_rating outgoing_rating();
-    PEP_color outgoing_color();
-    Message deepcopy(dict& memo);
-    Message copy();
-};
+            void longmsg(string value) { str_attr(_msg->longmsg, value); }
 
-Message outgoing_message(Identity me);
-Message incoming_message(string mime_text);
+            string longmsg_formatted() { return str_attr(_msg->longmsg_formatted); }
 
-} /* namespace PythonAdapter */
+            void longmsg_formatted(string value) { str_attr(_msg->longmsg_formatted, value); }
+
+            boost::python::tuple attachments();
+
+            void attachments(boost::python::list value);
+
+            time_t sent() { return timestamp_attr(_msg->sent); }
+
+            void sent(time_t value) { timestamp_attr(_msg->sent, value); }
+
+            time_t recv() { return timestamp_attr(_msg->recv); }
+
+            void recv(time_t value) { timestamp_attr(_msg->recv, value); }
+
+            Identity from() { return identity_attr(_msg->from); }
+
+            void from(object value) { identity_attr(_msg->from, value); }
+
+            boost::python::list to() { return identitylist_attr(_msg->to); }
+
+            void to(boost::python::list value) { identitylist_attr(_msg->to, value); }
+
+            Identity recv_by() { return identity_attr(_msg->recv_by); }
+
+            void recv_by(object value) { identity_attr(_msg->recv_by, value); }
+
+            boost::python::list cc() { return identitylist_attr(_msg->cc); }
+
+            void cc(boost::python::list value) { identitylist_attr(_msg->cc, value); }
+
+            boost::python::list bcc() { return identitylist_attr(_msg->bcc); }
+
+            void bcc(boost::python::list value) { identitylist_attr(_msg->bcc, value); }
+
+            boost::python::list reply_to() { return identitylist_attr(_msg->reply_to); }
+
+            void reply_to(boost::python::list value) { identitylist_attr(_msg->reply_to, value); }
+
+            boost::python::list in_reply_to() { return strlist_attr(_msg->in_reply_to); }
+
+            void in_reply_to(boost::python::list value) { strlist_attr(_msg->in_reply_to, value); }
+
+            boost::python::list references() { return strlist_attr(_msg->references); }
+
+            void references(boost::python::list value) { strlist_attr(_msg->references, value); }
+
+            boost::python::list keywords() { return strlist_attr(_msg->keywords); }
+
+            void keywords(boost::python::list value) { strlist_attr(_msg->keywords, value); }
+
+            string comments() { return str_attr(_msg->comments); }
+
+            void comments(string value) { str_attr(_msg->comments, value); }
+
+            dict opt_fields() { return strdict_attr(_msg->opt_fields); }
+
+            void opt_fields(dict value) { return strdict_attr(_msg->opt_fields, value); }
+
+            PEP_enc_format enc_format() { return _msg->enc_format; }
+
+            void enc_format(PEP_enc_format value) { _msg->enc_format = value; }
+
+            Message encrypt();
+
+            Message _encrypt(boost::python::list extra, int enc_format = 4, int flags = 0);
+
+            boost::python::tuple decrypt(int flags = 0);
+
+            PEP_rating outgoing_rating();
+
+            PEP_color outgoing_color();
+
+            Message deepcopy(dict &memo);
+
+            Message copy();
+        };
+
+        Message outgoing_message(Identity me);
+
+        Message incoming_message(string mime_text);
+
+    } /* namespace PythonAdapter */
 } /* namespace pEp */
 
 #endif /* MESSAGE_HH */
\ No newline at end of file
diff --git a/src/pEp/native_pEp/message_api.cc b/src/pEp/native_pEp/message_api.cc
index 6a4b76d..1c2e3c7 100644
--- a/src/pEp/native_pEp/message_api.cc
+++ b/src/pEp/native_pEp/message_api.cc
@@ -13,160 +13,149 @@
 #include "basic_api.hh"
 
 namespace pEp {
-namespace PythonAdapter {
-using namespace std;
-using namespace boost::python;
-
-Message encrypt_message(Message src, boost::python::list extra, int enc_format, int flags)
-{
-    Identity _from = src.from();
-    if (_from.address() == "")
-        throw invalid_argument("encrypt_message: src.from_.address empty");
-    if (_from.username() == "")
-        throw invalid_argument("encrypt_message: src.from_.username empty");
-
-    if (_from.user_id() == "")
-        src.from().user_id(_from.address());
-
-    stringlist_t *_extra = to_stringlist(extra);
-    PEP_enc_format _enc_format = (PEP_enc_format) enc_format;
-    PEP_encrypt_flags_t _flags = (PEP_encrypt_flags_t) flags;
-    message *_dst = NULL;
-
-    message *_src = src;
-    PEP_STATUS status = encrypt_message(Adapter::session(), _src, _extra, &_dst,
-            _enc_format, _flags);
-    free_stringlist(_extra);
-    _throw_status(status);
-
-    if (!_dst || _dst == _src)
-        return Message(_src);
-
-    return Message(_dst);
-}
-
-boost::python::tuple decrypt_message(Message src, int flags)
-{
-    message *_dst = NULL;
-    stringlist_t *_keylist = NULL;
-    PEP_rating _rating = PEP_rating_undefined;
-    PEP_decrypt_flags_t _flags = (PEP_decrypt_flags_t) flags;
-    message *_src = src;
-
-    PEP_STATUS status = ::decrypt_message(Adapter::session(), _src, &_dst, &_keylist,
-            &_rating, &_flags);
-    _throw_status(status);
-
-    boost::python::list keylist;
-    if (_keylist) {
-        keylist = from_stringlist(_keylist);
-        free_stringlist(_keylist);
-    }
-
-    Message dst = _dst ? Message(_dst) : Message(src);
-    return boost::python::make_tuple(dst, keylist, _rating, _flags);
-}
-
-PEP_color _color(int rating)
-{
-    return ::color_from_rating((PEP_rating) rating);
-}
-
-boost::python::tuple sync_decode(object buffer)
-{
-    Py_buffer src;
-    int result = PyObject_GetBuffer(buffer.ptr(), &src, PyBUF_CONTIG_RO);
-    if (result)
-        throw invalid_argument("need a contiguous buffer to read");
-
-    char *dst = NULL;
-    PEP_STATUS status = PER_to_XER_Sync_msg((char *) src.buf, src.len, &dst);
-    PyBuffer_Release(&src);
-    _throw_status(status);
-
-    string _dst(dst);
-    free(dst);
-    return boost::python::make_tuple(_dst, 0);
-}
-
-static boost::python::tuple sync_encode(string text)
-{
-    char *data = NULL;
-    size_t size = 0;
-    PEP_STATUS status = XER_to_PER_Sync_msg(text.c_str(), &data, &size);
-    _throw_status(status);
-
-    PyObject *ba = PyBytes_FromStringAndSize(data, size);
-    free(data);
-    if (!ba)
-        throw bad_alloc();
-
-    return boost::python::make_tuple(object(handle<>(ba)), 0);
-}
-
-boost::python::tuple Distribution_decode(object buffer)
-{
-    Py_buffer src;
-    int result = PyObject_GetBuffer(buffer.ptr(), &src, PyBUF_CONTIG_RO);
-    if (result)
-        throw invalid_argument("need a contiguous buffer to read");
-
-    char *dst = NULL;
-    PEP_STATUS status = PER_to_XER_Distribution_msg((char *) src.buf, src.len, &dst);
-    PyBuffer_Release(&src);
-    _throw_status(status);
-
-    string _dst(dst);
-    free(dst);
-    return boost::python::make_tuple(_dst, 0);
-}
-
-static boost::python::tuple Distribution_encode(string text)
-{
-    char *data = NULL;
-    size_t size = 0;
-    PEP_STATUS status = XER_to_PER_Distribution_msg(text.c_str(), &data, &size);
-    _throw_status(status);
-
-    PyObject *ba = PyBytes_FromStringAndSize(data, size);
-    free(data);
-    if (!ba)
-        throw bad_alloc();
-
-    return boost::python::make_tuple(object(handle<>(ba)), 0);
-}
-
-object sync_search(string name)
-{
-    if (name != "pep.sync") {
-        return object();
-    }
-    else {
-        object codecs = import("codecs");
-        object CodecInfo = codecs.attr("CodecInfo");
-
-        object _sync_decode = make_function(sync_decode);
-        object _sync_encode = make_function(sync_encode);
-
-        return call< object >(CodecInfo.ptr(), _sync_encode, _sync_decode);
-    }
-}
-
-object distribution_search(string name)
-{
-    if (name != "pep.distribution") {
-        return object();
-    }
-    else {
-        object codecs = import("codecs");
-        object CodecInfo = codecs.attr("CodecInfo");
-
-        object _distribution_decode = make_function(Distribution_decode);
-        object _distribution_encode = make_function(Distribution_encode);
-
-        return call< object >(CodecInfo.ptr(), _distribution_encode, _distribution_decode);
-    }
-}
-
-} // namespace PythonAdapter
+    namespace PythonAdapter {
+        using namespace std;
+        using namespace boost::python;
+
+        Message encrypt_message(Message src, boost::python::list extra, int enc_format, int flags) {
+            Identity _from = src.from();
+            if (_from.address() == "")
+                throw invalid_argument("encrypt_message: src.from_.address empty");
+            if (_from.username() == "")
+                throw invalid_argument("encrypt_message: src.from_.username empty");
+
+            if (_from.user_id() == "")
+                src.from().user_id(_from.address());
+
+            stringlist_t *_extra = to_stringlist(extra);
+            PEP_enc_format _enc_format = (PEP_enc_format) enc_format;
+            PEP_encrypt_flags_t _flags = (PEP_encrypt_flags_t) flags;
+            message *_dst = NULL;
+
+            message *_src = src;
+            PEP_STATUS status = encrypt_message(Adapter::session(), _src, _extra, &_dst,
+                                                _enc_format, _flags);
+            free_stringlist(_extra);
+            _throw_status(status);
+
+            if (!_dst || _dst == _src)
+                return Message(_src);
+
+            return Message(_dst);
+        }
+
+        boost::python::tuple decrypt_message(Message src, int flags) {
+            message *_dst = NULL;
+            stringlist_t *_keylist = NULL;
+            PEP_rating _rating = PEP_rating_undefined;
+            PEP_decrypt_flags_t _flags = (PEP_decrypt_flags_t) flags;
+            message *_src = src;
+
+            PEP_STATUS status = ::decrypt_message(Adapter::session(), _src, &_dst, &_keylist,
+                                                  &_rating, &_flags);
+            _throw_status(status);
+
+            boost::python::list keylist;
+            if (_keylist) {
+                keylist = from_stringlist(_keylist);
+                free_stringlist(_keylist);
+            }
+
+            Message dst = _dst ? Message(_dst) : Message(src);
+            return boost::python::make_tuple(dst, keylist, _rating, _flags);
+        }
+
+        PEP_color _color(int rating) {
+            return ::color_from_rating((PEP_rating) rating);
+        }
+
+        boost::python::tuple sync_decode(object buffer) {
+            Py_buffer src;
+            int result = PyObject_GetBuffer(buffer.ptr(), &src, PyBUF_CONTIG_RO);
+            if (result)
+                throw invalid_argument("need a contiguous buffer to read");
+
+            char *dst = NULL;
+            PEP_STATUS status = PER_to_XER_Sync_msg((char *) src.buf, src.len, &dst);
+            PyBuffer_Release(&src);
+            _throw_status(status);
+
+            string _dst(dst);
+            free(dst);
+            return boost::python::make_tuple(_dst, 0);
+        }
+
+        static boost::python::tuple sync_encode(string text) {
+            char *data = NULL;
+            size_t size = 0;
+            PEP_STATUS status = XER_to_PER_Sync_msg(text.c_str(), &data, &size);
+            _throw_status(status);
+
+            PyObject *ba = PyBytes_FromStringAndSize(data, size);
+            free(data);
+            if (!ba)
+                throw bad_alloc();
+
+            return boost::python::make_tuple(object(handle<>(ba)), 0);
+        }
+
+        boost::python::tuple Distribution_decode(object buffer) {
+            Py_buffer src;
+            int result = PyObject_GetBuffer(buffer.ptr(), &src, PyBUF_CONTIG_RO);
+            if (result)
+                throw invalid_argument("need a contiguous buffer to read");
+
+            char *dst = NULL;
+            PEP_STATUS status = PER_to_XER_Distribution_msg((char *) src.buf, src.len, &dst);
+            PyBuffer_Release(&src);
+            _throw_status(status);
+
+            string _dst(dst);
+            free(dst);
+            return boost::python::make_tuple(_dst, 0);
+        }
+
+        static boost::python::tuple Distribution_encode(string text) {
+            char *data = NULL;
+            size_t size = 0;
+            PEP_STATUS status = XER_to_PER_Distribution_msg(text.c_str(), &data, &size);
+            _throw_status(status);
+
+            PyObject *ba = PyBytes_FromStringAndSize(data, size);
+            free(data);
+            if (!ba)
+                throw bad_alloc();
+
+            return boost::python::make_tuple(object(handle<>(ba)), 0);
+        }
+
+        object sync_search(string name) {
+            if (name != "pep.sync") {
+                return object();
+            } else {
+                object codecs = import("codecs");
+                object CodecInfo = codecs.attr("CodecInfo");
+
+                object _sync_decode = make_function(sync_decode);
+                object _sync_encode = make_function(sync_encode);
+
+                return call<object>(CodecInfo.ptr(), _sync_encode, _sync_decode);
+            }
+        }
+
+        object distribution_search(string name) {
+            if (name != "pep.distribution") {
+                return object();
+            } else {
+                object codecs = import("codecs");
+                object CodecInfo = codecs.attr("CodecInfo");
+
+                object _distribution_decode = make_function(Distribution_decode);
+                object _distribution_encode = make_function(Distribution_encode);
+
+                return call<object>(CodecInfo.ptr(), _distribution_encode, _distribution_decode);
+            }
+        }
+
+    } // namespace PythonAdapter
 } // namespace pEp {
diff --git a/src/pEp/native_pEp/message_api.hh b/src/pEp/native_pEp/message_api.hh
index a793d32..2d153b6 100644
--- a/src/pEp/native_pEp/message_api.hh
+++ b/src/pEp/native_pEp/message_api.hh
@@ -7,21 +7,24 @@
 #include "pEpmodule.hh"
 
 namespace pEp {
-namespace PythonAdapter {
+    namespace PythonAdapter {
 
-Message encrypt_message(
-    Message src,
-    boost::python::list extra = boost::python::list(),
-    int enc_format = 4,
-    int flags = 0
-);
+        Message encrypt_message(
+                Message src,
+                boost::python::list extra = boost::python::list(),
+                int enc_format = 4,
+                int flags = 0
+        );
 
-boost::python::tuple decrypt_message(Message src, int flags=0);
-PEP_color _color(int rating);
-object sync_search(string name);
-object distribution_search(string name);
+        boost::python::tuple decrypt_message(Message src, int flags = 0);
 
-} /* namespace PythonAdapter */
+        PEP_color _color(int rating);
+
+        object sync_search(string name);
+
+        object distribution_search(string name);
+
+    } /* namespace PythonAdapter */
 } /* namespace pEp */
 
 #endif /* MESSAGE_API_HH */
\ No newline at end of file
diff --git a/src/pEp/native_pEp/pEpmodule.cc b/src/pEp/native_pEp/pEpmodule.cc
index 6148c95..3d2bff1 100644
--- a/src/pEp/native_pEp/pEpmodule.cc
+++ b/src/pEp/native_pEp/pEpmodule.cc
@@ -27,579 +27,562 @@
 //#include "user_interface.hh"
 
 namespace pEp {
-namespace PythonAdapter {
-using namespace std;
-using namespace boost::python;
+    namespace PythonAdapter {
+        using namespace std;
+        using namespace boost::python;
 
-static const char *version_string = "p≡p Python adapter version 0.3";
+        static const char *version_string = "p≡p Python adapter version 0.3";
 
-void init_before_main_module() {
-    pEpLog("called");
-}
+        void init_before_main_module() {
+            pEpLog("called");
+        }
 
 // hidden init function, wrapped by hello_world.init()
-void _init_after_main_module() {
-    pEpLog("called");
-    callback_dispatcher.add(_messageToSend, notifyHandshake, nullptr, nullptr);
-    Adapter::_messageToSend = CallbackDispatcher::messageToSend;
-}
-
-
-void config_passive_mode(bool enable)
-{
-    ::config_passive_mode(Adapter::session(), enable);
-}
-
-void config_unencrypted_subject(bool enable)
-{
-    ::config_unencrypted_subject(Adapter::session(), enable);
-}
-
-void key_reset_user(string user_id, string fpr)
-{
-    if (user_id == "")
-        throw invalid_argument("user_id required");
-
-    PEP_STATUS status = ::key_reset_user(Adapter::session(),
-            user_id.c_str(), fpr != "" ?  fpr.c_str() : nullptr);
-    _throw_status(status);
-}
-
-void key_reset_user2(string user_id)
-{
-    key_reset_user(user_id, "");
-}
-
-void key_reset_all_own_keys()
-{
-    PEP_STATUS status = ::key_reset_all_own_keys(Adapter::session());
-    _throw_status(status);
-}
-
-static string about()
-{
-    string version = string(version_string) + "\np≡p version "
-        + PEP_VERSION + "\n";
-    return version;
-}
-
-void _throw_status(PEP_STATUS status)
-{
-    if (status == PEP_STATUS_OK)
-        return;
-    if (status >= 0x400 && status <= 0x4ff)
-        return;
-    if (status == PEP_OUT_OF_MEMORY)
-        throw bad_alloc();
-    if (status == PEP_ILLEGAL_VALUE)
-        throw invalid_argument("illegal value");
-
-    if (string(pEp_status_to_string(status)) == "unknown status code") {
-        stringstream build;
-        build << setfill('0') << "p≡p 0x" << setw(4) << hex << status;
-        throw runtime_error(build.str());
-    }
-    else {
-        throw runtime_error(pEp_status_to_string(status));
-    }
-}
-
-PEP_STATUS _messageToSend(::message *msg)
-{
-    pEpLog("called");
-    try {
-        PyGILState_STATE gil = PyGILState_Ensure();
-        pEpLog("GIL Aquired");
-        object modref = import("pEp");
-        object funcref = modref.attr("message_to_send");
-        call<void>(funcref.ptr(), Message());
-        PyGILState_Release(gil);
-        pEpLog("GIL released");
-    } catch (exception& e) { }
-
-    return PEP_STATUS_OK;
-}
-
-PEP_STATUS notifyHandshake(pEp_identity *me, pEp_identity *partner, sync_handshake_signal signal)
-{
-    pEpLog("called");
-    try {
-        PyGILState_STATE gil = PyGILState_Ensure();
-        pEpLog("GIL Aquired");
-        object modref = import("pEp");
-        object funcref = modref.attr("notify_handshake");
-        call<void>(funcref.ptr(), me, partner, signal);
-        PyGILState_Release(gil);
-        pEpLog("GIL released");
-    } catch (exception& e) { }
-
-    return PEP_STATUS_OK;
-}
-
-
-void start_sync()
-{
-    CallbackDispatcher::start_sync();
-}
-
-void shutdown_sync()
-{
-    CallbackDispatcher::stop_sync();
-}
-
-void debug_color(int ansi_color)
-{
-    ::set_debug_color(Adapter::session(), ansi_color);
-}
-
-void leave_device_group()
-{
-    ::leave_device_group(Adapter::session());
-}
-
-bool is_sync_active()
-{
-    return Adapter::is_sync_running();
-}
-
-void testfunc() {
-    _messageToSend(NULL);
-}
-
-void deliverHandshakeResult(int result, object identities)
-{
-    identity_list *shared_identities = nullptr;
-    if (identities != boost::python::api::object() && boost::python::len(identities)) {
-        shared_identities = new_identity_list(nullptr);
-        if (!shared_identities)
-            throw bad_alloc();
-
-        try {
-            identity_list *si = shared_identities;
-            for (int i=0; i < boost::python::len(identities); ++i) {
-                Identity ident = extract< Identity >(identities[i]);
-                si = identity_list_add(si, ident);
-                if (!si)
-                    throw bad_alloc();
+        void _init_after_main_module() {
+            pEpLog("called");
+            callback_dispatcher.add(_messageToSend, notifyHandshake, nullptr, nullptr);
+            Adapter::_messageToSend = CallbackDispatcher::messageToSend;
+        }
+
+
+        void config_passive_mode(bool enable) {
+            ::config_passive_mode(Adapter::session(), enable);
+        }
+
+        void config_unencrypted_subject(bool enable) {
+            ::config_unencrypted_subject(Adapter::session(), enable);
+        }
+
+        void key_reset_user(string user_id, string fpr) {
+            if (user_id == "")
+                throw invalid_argument("user_id required");
+
+            PEP_STATUS status = ::key_reset_user(Adapter::session(),
+                                                 user_id.c_str(), fpr != "" ? fpr.c_str() : nullptr);
+            _throw_status(status);
+        }
+
+        void key_reset_user2(string user_id) {
+            key_reset_user(user_id, "");
+        }
+
+        void key_reset_all_own_keys() {
+            PEP_STATUS status = ::key_reset_all_own_keys(Adapter::session());
+            _throw_status(status);
+        }
+
+        static string about() {
+            string version = string(version_string) + "\np≡p version "
+                             + PEP_VERSION + "\n";
+            return version;
+        }
+
+        void _throw_status(PEP_STATUS status) {
+            if (status == PEP_STATUS_OK)
+                return;
+            if (status >= 0x400 && status <= 0x4ff)
+                return;
+            if (status == PEP_OUT_OF_MEMORY)
+                throw bad_alloc();
+            if (status == PEP_ILLEGAL_VALUE)
+                throw invalid_argument("illegal value");
+
+            if (string(pEp_status_to_string(status)) == "unknown status code") {
+                stringstream build;
+                build << setfill('0') << "p≡p 0x" << setw(4) << hex << status;
+                throw runtime_error(build.str());
+            } else {
+                throw runtime_error(pEp_status_to_string(status));
             }
         }
-        catch (exception& ex) {
-            free_identity_list(shared_identities);
-            throw ex;
+
+        PEP_STATUS _messageToSend(::message *msg) {
+            pEpLog("called");
+            try {
+                PyGILState_STATE gil = PyGILState_Ensure();
+                pEpLog("GIL Aquired");
+                object modref = import("pEp");
+                object funcref = modref.attr("message_to_send");
+                call<void>(funcref.ptr(), Message());
+                PyGILState_Release(gil);
+                pEpLog("GIL released");
+            } catch (exception &e) {}
+
+            return PEP_STATUS_OK;
+        }
+
+        PEP_STATUS notifyHandshake(pEp_identity *me, pEp_identity *partner, sync_handshake_signal signal) {
+            pEpLog("called");
+            try {
+                PyGILState_STATE gil = PyGILState_Ensure();
+                pEpLog("GIL Aquired");
+                object modref = import("pEp");
+                object funcref = modref.attr("notify_handshake");
+                call<void>(funcref.ptr(), me, partner, signal);
+                PyGILState_Release(gil);
+                pEpLog("GIL released");
+            } catch (exception &e) {}
+
+            return PEP_STATUS_OK;
         }
-    }
 
-    PEP_STATUS status = ::deliverHandshakeResult(Adapter::session(), (sync_handshake_result) result, shared_identities);
-    free_identity_list(shared_identities);
-    _throw_status(status);
-}
 
-BOOST_PYTHON_MODULE(native_pEp)
-{
-    init_before_main_module();
+        void start_sync() {
+            CallbackDispatcher::start_sync();
+        }
+
+        void shutdown_sync() {
+            CallbackDispatcher::stop_sync();
+        }
+
+        void debug_color(int ansi_color) {
+            ::set_debug_color(Adapter::session(), ansi_color);
+        }
+
+        void leave_device_group() {
+            ::leave_device_group(Adapter::session());
+        }
+
+        bool is_sync_active() {
+            return Adapter::is_sync_running();
+        }
+
+        void testfunc() {
+            _messageToSend(NULL);
+        }
 
-    // Module init function called by pEp.init()
-    def("_init_after_main_module", _init_after_main_module);
-    def("testfunc", &testfunc);
+        void deliverHandshakeResult(int result, object identities) {
+            identity_list *shared_identities = nullptr;
+            if (identities != boost::python::api::object() && boost::python::len(identities)) {
+                shared_identities = new_identity_list(nullptr);
+                if (!shared_identities)
+                    throw bad_alloc();
+
+                try {
+                    identity_list *si = shared_identities;
+                    for (int i = 0; i < boost::python::len(identities); ++i) {
+                        Identity ident = extract<Identity>(identities[i]);
+                        si = identity_list_add(si, ident);
+                        if (!si)
+                            throw bad_alloc();
+                    }
+                }
+                catch (exception &ex) {
+                    free_identity_list(shared_identities);
+                    throw ex;
+                }
+            }
+
+            PEP_STATUS status = ::deliverHandshakeResult(Adapter::session(), (sync_handshake_result) result, shared_identities);
+            free_identity_list(shared_identities);
+            _throw_status(status);
+        }
 
-    docstring_options doc_options(true, false, false);
-    boost::locale::generator gen;
-    std::locale::global(gen(""));
+        BOOST_PYTHON_MODULE(native_pEp) {
+                init_before_main_module();
+
+                // Module init function called by pEp.init()
+                def("_init_after_main_module", _init_after_main_module);
+                def("testfunc", &testfunc);
+
+                docstring_options doc_options(true, false, false);
+                boost::locale::generator gen;
+                std::locale::global(gen(""));
 
 //    _scope = new scope();
-    scope().attr("about") = about();
-    scope().attr("per_user_directory") = per_user_directory();
-    scope().attr("per_machine_directory") = per_machine_directory();
-    scope().attr("engine_version") = get_engine_version();
-    scope().attr("protocol_version") = get_protocol_version();
-
-    def("passive_mode", config_passive_mode,
-            "do not attach pub keys to all messages");
-
-    def("unencrypted_subject", config_unencrypted_subject,
-            "do not encrypt the subject of messages");
-
-    def("key_reset", key_reset_user,
-            "reset the default database status for the user / keypair provided\n"
-            "This will effectively perform key_reset on each identity\n"
-            "associated with the key and user_id, if a key is provided, and for\n"
-            "each key (and all of their identities) if an fpr is not.");
-
-    def("key_reset", key_reset_user2,
-            "reset the default database status for the user / keypair provided\n"
-            "This will effectively perform key_reset on each identity\n"
-            "associated with the key and user_id, if a key is provided, and for\n"
-            "each key (and all of their identities) if an fpr is not.");
-
-    def("key_reset_all_own_keys", key_reset_all_own_keys,
-            "revoke and mistrust all own keys, generate new keys for all\n"
-            "own identities, and opportunistically communicate key reset\n"
-            "information to people we have recently contacted.");
-
-    auto identity_class = class_<Identity>("Identity",
-    "Identity(address, username, user_id='', fpr='', comm_type=0, lang='en')\n"
-    "\n"
-    "represents a p≡p identity\n"
-    "\n"
-    "an identity is a network address, under which a user is represented in\n"
-    "the network\n"
-    "\n"
-    "   address     network address, either an SMTP address or a URI\n"
-    "   username    real name or nickname for user\n"
-    "   user_id     ID this user is handled by the application\n"
-    "   fpr         full fingerprint of the key being used as key ID,\n"
-    "               hex encoded\n"
-    "   comm_type   first rating level of this communication channel\n"
-    "   lang        ISO 639-1 language code for language being preferred\n"
-    "               on this communication channel\n"
-        )
-        .def(boost::python::init<string>())
-        .def(boost::python::init<string, string>())
-        .def(boost::python::init<string, string, string>())
-        .def(boost::python::init<string, string, string, string>())
-        .def(boost::python::init<string, string, string, string, int>())
-        .def(boost::python::init<string, string, string, string, int, string>())
-        .def("__repr__", &Identity::_repr)
-        .def("__str__", &Identity::_str,
-            "string representation of this identity\n"
-            "following the pattern 'username < address >'\n"
+                scope().attr("about") = about();
+                scope().attr("per_user_directory") = per_user_directory();
+                scope().attr("per_machine_directory") = per_machine_directory();
+                scope().attr("engine_version") = get_engine_version();
+                scope().attr("protocol_version") = get_protocol_version();
+
+                def("passive_mode", config_passive_mode,
+                "do not attach pub keys to all messages");
+
+                def("unencrypted_subject", config_unencrypted_subject,
+                "do not encrypt the subject of messages");
+
+                def("key_reset", key_reset_user,
+                "reset the default database status for the user / keypair provided\n"
+                "This will effectively perform key_reset on each identity\n"
+                "associated with the key and user_id, if a key is provided, and for\n"
+                "each key (and all of their identities) if an fpr is not.");
+
+                def("key_reset", key_reset_user2,
+                "reset the default database status for the user / keypair provided\n"
+                "This will effectively perform key_reset on each identity\n"
+                "associated with the key and user_id, if a key is provided, and for\n"
+                "each key (and all of their identities) if an fpr is not.");
+
+                def("key_reset_all_own_keys", key_reset_all_own_keys,
+                "revoke and mistrust all own keys, generate new keys for all\n"
+                "own identities, and opportunistically communicate key reset\n"
+                "information to people we have recently contacted.");
+
+                auto identity_class = class_<Identity>("Identity",
+                "Identity(address, username, user_id='', fpr='', comm_type=0, lang='en')\n"
+                "\n"
+                "represents a p≡p identity\n"
+                "\n"
+                "an identity is a network address, under which a user is represented in\n"
+                "the network\n"
+                "\n"
+                "   address     network address, either an SMTP address or a URI\n"
+                "   username    real name or nickname for user\n"
+                "   user_id     ID this user is handled by the application\n"
+                "   fpr         full fingerprint of the key being used as key ID,\n"
+                "               hex encoded\n"
+                "   comm_type   first rating level of this communication channel\n"
+                "   lang        ISO 639-1 language code for language being preferred\n"
+                "               on this communication channel\n"
+                )
+                .def(boost::python::init<string>())
+                .def(boost::python::init<string, string>())
+                .def(boost::python::init<string, string, string>())
+                .def(boost::python::init<string, string, string, string>())
+                .def(boost::python::init<string, string, string, string, int>())
+                .def(boost::python::init<string, string, string, string, int, string>())
+                .def("__repr__", &Identity::_repr)
+                .def("__str__", &Identity::_str,
+                "string representation of this identity\n"
+                "following the pattern 'username < address >'\n"
                 )
-        .def("key_reset", &Identity::key_reset,
+                .def("key_reset", &Identity::key_reset,
                 boost::python::arg("fpr")=object(""),
-            "reset the default database status for the identity / keypair provided. If this\n"
-            "corresponds to the own user and a private key, also revoke the key, generate a\n"
-            "new one, and communicate the reset to recently contacted pEp partners for this\n"
-            "identity. If it does not, remove the key from the keyring; the key's status is\n"
-            "completely fresh on next contact from the partner.")
+                "reset the default database status for the identity / keypair provided. If this\n"
+                "corresponds to the own user and a private key, also revoke the key, generate a\n"
+                "new one, and communicate the reset to recently contacted pEp partners for this\n"
+                "identity. If it does not, remove the key from the keyring; the key's status is\n"
+                "completely fresh on next contact from the partner.")
 
-        .def("key_mistrusted", &Identity::key_mistrusted,
+                .def("key_mistrusted", &Identity::key_mistrusted,
                 boost::python::arg("fpr")=object(""),
-            "If you want updated trust on the identity, you ll have"
-            "to call update_identity or myself respectively after this."
-            "N.B. If you are calling this on a key that is the identity or user default,"
-            "it will be removed as the default key for ANY identity and user for which"
-            "it is the default. Please keep in mind that the undo in undo_last_mistrust"
-            "will only undo the current identity's / it's user's default, not any"
-            "other identities which may be impacted (this will not affect most use cases)")
-
-        .def("enable_for_sync", &Identity::enable_for_sync,
+                "If you want updated trust on the identity, you ll have"
+                "to call update_identity or myself respectively after this."
+                "N.B. If you are calling this on a key that is the identity or user default,"
+                "it will be removed as the default key for ANY identity and user for which"
+                "it is the default. Please keep in mind that the undo in undo_last_mistrust"
+                "will only undo the current identity's / it's user's default, not any"
+                "other identities which may be impacted (this will not affect most use cases)")
+
+                .def("enable_for_sync", &Identity::enable_for_sync,
                 "Enable own identity for p≡p sync.\n\n"
                 "Only use this on own identities, which are used as accounts.\n")
-        .def("disable_for_sync", &Identity::disable_for_sync,
+                .def("disable_for_sync", &Identity::disable_for_sync,
                 "Disable own identity for p≡p sync.\n\n"
                 "Only use this on own identities, which are used as accounts.\n")
 
-        .add_property("address", (string(Identity::*)()) &Identity::address,
+                .add_property("address", (string(Identity::*)()) &Identity::address,
                 (void(Identity::*)(string)) &Identity::address,
                 "email address or URI")
-        .add_property("fpr", (string(Identity::*)()) &Identity::fpr,
+                .add_property("fpr", (string(Identity::*)()) &Identity::fpr,
                 (void(Identity::*)(string)) &Identity::fpr,
                 "key ID (full fingerprint, hex encoded)")
-        .add_property("user_id", (string(Identity::*)()) &Identity::user_id,
+                .add_property("user_id", (string(Identity::*)()) &Identity::user_id,
                 (void(Identity::*)(string)) &Identity::user_id,
                 "ID of person associated or 'pEp_own_userId' if own identity")
-        .add_property("username", (string(Identity::*)()) &Identity::username,
+                .add_property("username", (string(Identity::*)()) &Identity::username,
                 (void(Identity::*)(string)) &Identity::username,
                 "name in full of person associated")
-        .add_property("comm_type", (int(Identity::*)())
+                .add_property("comm_type", (int(Identity::*)())
                 (PEP_comm_type(Identity::*)()) &Identity::comm_type,
                 (void(Identity::*)(int))
                 (void(Identity::*)(PEP_comm_type)) &Identity::comm_type,
-                 "communication type, first rating level (p≡p internal)")
-        .add_property("lang", (string(Identity::*)()) &Identity::lang,
+                "communication type, first rating level (p≡p internal)")
+                .add_property("lang", (string(Identity::*)()) &Identity::lang,
                 (void(Identity::*)(string)) &Identity::lang,
                 "ISO 639-1 language code")
-        .add_property("flags", (identity_flags_t(Identity::*)()) &Identity::flags,
+                .add_property("flags", (identity_flags_t(Identity::*)()) &Identity::flags,
                 (void(Identity::*)(identity_flags_t)) &Identity::flags,
                 "flags (p≡p internal)")
-        .add_property("rating", &Identity::rating, "rating of Identity")
-        .add_property("color", &Identity::color, "color of Identity as PEP_color")
-        .add_property("is_pEp_user", &Identity::is_pEp_user, "True if this is an identity of a pEp user")
-        .def("__deepcopy__", &Identity::deepcopy)
-        .def("update", &Identity::update, "update Identity")
-        .def("__copy__", &Identity::copy);
-
-    identity_class.attr("PEP_OWN_USERID") = "pEp_own_userId";
-
-    auto blob_class = class_<Message::Blob>("Blob",
-    "Blob(data, mime_type='', filename='')\n"
-    "\n"
-    "Binary large object\n"
-    "\n"
-    "   data            bytes-like object\n"
-    "   mime_type       MIME type for the data\n"
-    "   filename        filename to store the data\n" ,
-            boost::python::init< object, char const*, char const* >(args("data", "mime_type", "filename")))
-        .def(boost::python::init<object, string>())
-        .def(boost::python::init<object>())
-        .def("__repr__", &Message::Blob::_repr)
-        .def("__len__", &Message::Blob::size, "size of Blob data in bytes")
-        .def("decode", (string(Message::Blob::*)()) &Message::Blob::decode)
-        .def("decode", (string(Message::Blob::*)(string)) &Message::Blob::decode,
-    "text = blob.decode(encoding='')\n"
-    "\n"
-    "decode Blob data into string depending on MIME type if encoding=''\n"
-    "\n"
-    "   mime_type='application/pEp.sync'      decode as 'pEp.sync'\n"
-    "   mime_type='application/pEp.keyreset'  decode as 'pEp.keyreset'\n"
-    "   other mime_type                       decode as 'ascii' by default\n"
+                .add_property("rating", &Identity::rating, "rating of Identity")
+                .add_property("color", &Identity::color, "color of Identity as PEP_color")
+                .add_property("is_pEp_user", &Identity::is_pEp_user, "True if this is an identity of a pEp user")
+                .def("__deepcopy__", &Identity::deepcopy)
+                .def("update", &Identity::update, "update Identity")
+                .def("__copy__", &Identity::copy);
+
+                identity_class.attr("PEP_OWN_USERID") = "pEp_own_userId";
+
+                auto blob_class = class_<Message::Blob>("Blob",
+                "Blob(data, mime_type='', filename='')\n"
+                "\n"
+                "Binary large object\n"
+                "\n"
+                "   data            bytes-like object\n"
+                "   mime_type       MIME type for the data\n"
+                "   filename        filename to store the data\n",
+                boost::python::init< object, char const*, char const* >(args("data", "mime_type", "filename")))
+                .def(boost::python::init<object, string>())
+                .def(boost::python::init<object>())
+                .def("__repr__", &Message::Blob::_repr)
+                .def("__len__", &Message::Blob::size, "size of Blob data in bytes")
+                .def("decode", (string(Message::Blob::*)()) &Message::Blob::decode)
+                .def("decode", (string(Message::Blob::*)(string)) &Message::Blob::decode,
+                "text = blob.decode(encoding='')\n"
+                "\n"
+                "decode Blob data into string depending on MIME type if encoding=''\n"
+                "\n"
+                "   mime_type='application/pEp.sync'      decode as 'pEp.sync'\n"
+                "   mime_type='application/pEp.keyreset'  decode as 'pEp.keyreset'\n"
+                "   other mime_type                       decode as 'ascii' by default\n"
                 )
-        .add_property("mime_type", (string(Message::Blob::*)()) &Message::Blob::mime_type,
+                .add_property("mime_type", (string(Message::Blob::*)()) &Message::Blob::mime_type,
                 (void(Message::Blob::*)(string)) &Message::Blob::mime_type,
                 "MIME type of object in Blob")
-        .add_property("filename", (string(Message::Blob::*)()) &Message::Blob::filename,
+                .add_property("filename", (string(Message::Blob::*)()) &Message::Blob::filename,
                 (void(Message::Blob::*)(string)) &Message::Blob::filename,
                 "filename of object in Blob");
 
-    ((PyTypeObject *)(void *)blob_class.ptr())->tp_as_buffer = &Message::Blob::bp;
-
-    auto message_class = class_<Message>("Message",
-    "Message(dir=1, from=None)\n"
-    "\n"
-    "new p≡p message\n"
-    "\n"
-    "   dir         1 for outgoing, 2 for incoming\n"
-    "   from        Identity() of sender\n"
-    "\n"
-    "Message(mime_text)\n"
-    "\n"
-    "new incoming p≡p message\n"
-    "\n"
-    "   mime_text       text in Multipurpose Internet Mail Extensions format\n"
+                ((PyTypeObject *)(void *)blob_class.ptr())->tp_as_buffer = &Message::Blob::bp;
+
+                auto message_class = class_<Message>("Message",
+                "Message(dir=1, from=None)\n"
+                "\n"
+                "new p≡p message\n"
+                "\n"
+                "   dir         1 for outgoing, 2 for incoming\n"
+                "   from        Identity() of sender\n"
+                "\n"
+                "Message(mime_text)\n"
+                "\n"
+                "new incoming p≡p message\n"
+                "\n"
+                "   mime_text       text in Multipurpose Internet Mail Extensions format\n"
                 )
-        .def(boost::python::init<int>())
-        .def(boost::python::init<int, Identity *>())
-        .def(boost::python::init<string>())
-        .def("__str__", &Message::_str,
-    "the string representation of a Message is it's MIME text"
+                .def(boost::python::init<int>())
+                .def(boost::python::init<int, Identity *>())
+                .def(boost::python::init<string>())
+                .def("__str__", &Message::_str,
+                "the string representation of a Message is it's MIME text"
                 )
-        .def("__repr__", &Message::_repr)
-        .add_property("dir", (int(Message::*)())
+                .def("__repr__", &Message::_repr)
+                .add_property("dir", (int(Message::*)())
                 (PEP_msg_direction(Message::*)()) &Message::dir,
                 (void(Message::*)(int))
                 (void(Message::*)(PEP_msg_direction)) &Message::dir,
                 "0: incoming, 1: outgoing message")
-        .add_property("id", (string(Message::*)()) &Message::id,
+                .add_property("id", (string(Message::*)()) &Message::id,
                 (void(Message::*)(string)) &Message::id,
                 "message ID")
-        .add_property("shortmsg", (string(Message::*)()) &Message::shortmsg,
+                .add_property("shortmsg", (string(Message::*)()) &Message::shortmsg,
                 (void(Message::*)(string)) &Message::shortmsg,
                 "subject or short message")
-        .add_property("longmsg", (string(Message::*)()) &Message::longmsg,
+                .add_property("longmsg", (string(Message::*)()) &Message::longmsg,
                 (void(Message::*)(string)) &Message::longmsg,
                 "body or long version of message")
-        .add_property("longmsg_formatted", (string(Message::*)()) &Message::longmsg_formatted,
+                .add_property("longmsg_formatted", (string(Message::*)()) &Message::longmsg_formatted,
                 (void(Message::*)(string)) &Message::longmsg_formatted,
                 "HTML body or fromatted long version of message")
-        .add_property("attachments", (boost::python::tuple(Message::*)()) &Message::attachments,
+                .add_property("attachments", (boost::python::tuple(Message::*)()) &Message::attachments,
                 (void(Message::*)(boost::python::list)) &Message::attachments,
                 "tuple of Blobs with attachments; setting moves Blobs to attachment tuple")
-        .add_property("sent", (time_t(Message::*)()) &Message::sent,
+                .add_property("sent", (time_t(Message::*)()) &Message::sent,
                 (void(Message::*)(time_t)) &Message::sent,
                 "time when message was sent in UTC seconds since epoch")
-        .add_property("recv", (time_t(Message::*)()) &Message::recv,
+                .add_property("recv", (time_t(Message::*)()) &Message::recv,
                 (void(Message::*)(time_t)) &Message::recv,
                 "time when message was received in UTC seconds since epoch")
-        .add_property("from_", (Identity(Message::*)()) &Message::from,
+                .add_property("from_", (Identity(Message::*)()) &Message::from,
                 (void(Message::*)(object)) &Message::from,
                 "identity where message is from")
-        .add_property("to", (boost::python::list(Message::*)()) &Message::to,
+                .add_property("to", (boost::python::list(Message::*)()) &Message::to,
                 (void(Message::*)(boost::python::list)) &Message::to,
                 "list of identities message is going to")
-        .add_property("recv_by", (Identity(Message::*)()) &Message::recv_by,
+                .add_property("recv_by", (Identity(Message::*)()) &Message::recv_by,
                 (void(Message::*)(object)) &Message::recv_by,
                 "identity where message was received by")
-        .add_property("cc", (boost::python::list(Message::*)()) &Message::cc,
+                .add_property("cc", (boost::python::list(Message::*)()) &Message::cc,
                 (void(Message::*)(boost::python::list)) &Message::cc,
                 "list of identities message is going cc")
-        .add_property("bcc", (boost::python::list(Message::*)()) &Message::bcc,
+                .add_property("bcc", (boost::python::list(Message::*)()) &Message::bcc,
                 (void(Message::*)(boost::python::list)) &Message::bcc,
                 "list of identities message is going bcc")
-        .add_property("reply_to", (boost::python::list(Message::*)()) &Message::reply_to,
+                .add_property("reply_to", (boost::python::list(Message::*)()) &Message::reply_to,
                 (void(Message::*)(boost::python::list)) &Message::reply_to,
                 "list of identities where message will be replied to")
-        .add_property("in_reply_to", (boost::python::list(Message::*)()) &Message::in_reply_to,
+                .add_property("in_reply_to", (boost::python::list(Message::*)()) &Message::in_reply_to,
                 (void(Message::*)(boost::python::list)) &Message::in_reply_to,
                 "in_reply_to list")
-        .add_property("references", (boost::python::list(Message::*)()) &Message::references,
+                .add_property("references", (boost::python::list(Message::*)()) &Message::references,
                 (void(Message::*)(boost::python::list)) &Message::references,
                 "message IDs of messages this one is referring to")
-        .add_property("keywords", (boost::python::list(Message::*)()) &Message::keywords,
+                .add_property("keywords", (boost::python::list(Message::*)()) &Message::keywords,
                 (void(Message::*)(boost::python::list)) &Message::keywords,
                 "keywords this message should be stored under")
-        .add_property("comments", (string(Message::*)()) &Message::comments,
+                .add_property("comments", (string(Message::*)()) &Message::comments,
                 (void(Message::*)(string)) &Message::comments,
                 "comments added to message")
-        .add_property("opt_fields", (dict(Message::*)()) &Message::opt_fields,
+                .add_property("opt_fields", (dict(Message::*)()) &Message::opt_fields,
                 (void(Message::*)(dict)) &Message::opt_fields,
                 "opt_fields of message")
-        .add_property("enc_format", (int(Message::*)())
+                .add_property("enc_format", (int(Message::*)())
                 (PEP_enc_format(Message::*)()) &Message::enc_format,
                 (void(Message::*)(int))
                 (void(Message::*)(PEP_enc_format)) &Message::enc_format,
                 "0: unencrypted, 1: inline PGP, 2: S/MIME, 3: PGP/MIME, 4: p≡p format")
-        .def("encrypt", (Message(Message::*)())&Message::encrypt)
-        .def("encrypt", (Message(Message::*)(boost::python::list))&Message::_encrypt)
-        .def("encrypt", (Message(Message::*)(boost::python::list,int))&Message::_encrypt)
-        .def("encrypt", (Message(Message::*)(boost::python::list,int,int))&Message::_encrypt,
-    "msg2 = msg1.encrypt(extra_keys=[], enc_format='pEp', flags=0)\n"
-    "\n"
-    "encrypts a p≡p message and returns the encrypted message\n"
-    "\n"
-    "   extra_keys      list of strings with fingerprints for extra keys to use\n"
-    "                   for encryption\n"
-    "   enc_format      0 for none, 1 for partitioned, 2 for S/MIME,\n"
-    "                   3 for PGP/MIME, 4 for pEp\n"
-    "   flags           1 is force encryption\n"
+                .def("encrypt", (Message(Message::*)())&Message::encrypt)
+                .def("encrypt", (Message(Message::*)(boost::python::list))&Message::_encrypt)
+                .def("encrypt", (Message(Message::*)(boost::python::list, int))&Message::_encrypt)
+                .def("encrypt", (Message(Message::*)(boost::python::list, int, int))&Message::_encrypt,
+                "msg2 = msg1.encrypt(extra_keys=[], enc_format='pEp', flags=0)\n"
+                "\n"
+                "encrypts a p≡p message and returns the encrypted message\n"
+                "\n"
+                "   extra_keys      list of strings with fingerprints for extra keys to use\n"
+                "                   for encryption\n"
+                "   enc_format      0 for none, 1 for partitioned, 2 for S/MIME,\n"
+                "                   3 for PGP/MIME, 4 for pEp\n"
+                "   flags           1 is force encryption\n"
                 )
-        .def("decrypt", &Message::decrypt, boost::python::arg("flags")=0,
-    "msg2, keys, rating, flags = msg1.decrypt()\n"
-    "\n"
-    "decrypts a p≡p message and returns a tuple with data\n"
-    "\n"
-    "   msg             the decrypted p≡p message\n"
-    "   keys            a list of keys being used\n"
-    "   rating          the rating of the message as integer\n"
-    "   flags           flags set while decryption\n"
+                .def("decrypt", &Message::decrypt, boost::python::arg("flags")=0,
+                "msg2, keys, rating, flags = msg1.decrypt()\n"
+                "\n"
+                "decrypts a p≡p message and returns a tuple with data\n"
+                "\n"
+                "   msg             the decrypted p≡p message\n"
+                "   keys            a list of keys being used\n"
+                "   rating          the rating of the message as integer\n"
+                "   flags           flags set while decryption\n"
                 )
-        .add_property("outgoing_rating", &Message::outgoing_rating, "rating outgoing message will have")
-        .add_property("outgoing_color", &Message::outgoing_color, "color outgoing message will have as PEP_color")
-        .def("__deepcopy__", &Message::deepcopy)
-        .def("__copy__", &Message::copy);
-
-    // basic API and key management API
-
-    def("update_identity", &update_identity,
-    "update_identity(ident)\n"
-    "\n"
-    "update identity information\n"
-    "call this to complete identity information when you at least have an address\n"
-            );
-    def("myself", &myself,
-    "myself(ident)\n"
-    "\n"
-    "ensures that the own identity is being complete\n"
-    "supply ident.address and ident.username\n"
-            );
-    def("trust_personal_key", &trust_personal_key,
-    "trust_personal_key(ident)\n"
-    "\n"
-    "mark a key as trusted with a person\n"
-            );
-
-    enum_<identity_flags>("identity_flags")
-        .value("PEP_idf_not_for_sync", PEP_idf_not_for_sync)
-        .value("PEP_idf_list", PEP_idf_list)
-        .value("PEP_idf_devicegroup", PEP_idf_devicegroup);
-
-    def("set_identity_flags", &set_identity_flags,
-    "set_identity_flags(ident, flags)\n"
-    "\n"
-    "set identity flags\n"
-            );
-
-    def("unset_identity_flags", &unset_identity_flags,
-    "unset_identity_flags(ident, flags)\n"
-    "\n"
-    "unset identity flags\n"
-            );
-
-    def("key_reset_trust", &key_reset_trust,
-            "key_reset_trust(ident)\n"
-            "\n"
-            "reset trust bit or explicitly mistrusted status for an identity and "
-            "its accompanying key/user_id pair\n"
-        );
-
-    def("import_key", &import_key,
-            "private_key_list = import_key(key_data)\n"
-            "\n"
-            "import key(s) from key_data\n"
-        );
-
-    def("export_key", &export_key,
-            "key_data = export_key(identity)\n"
-            "\n"
-            "export key(s) of identity\n"
-        );
-
-    def("export_secret_key", &export_secret_key,
-            "key_data = export_seret_key(identity)\n"
-            "\n"
-            "export secret key(s) of identity\n"
-        );
-
-    def("set_own_key", &set_own_key,
-            "set_own_key(me, fpr)\n"
-            "\n"
-            "mark a key as an own key, and make it the default key\n"
-            "\n"
-            "me         Own identity for which to add the existing key\n"
-            "fpr        The fingerprint of the key to be added\n"
-            "\n"
-            "me->address, me->user_id and me->username must be set to valid data\n"
-            "myself() is called by set_own_key() without key generation\n"
-            "me->flags are ignored\n"
-            "me->address must not be an alias\n"
-            "me->fpr will be ignored and replaced by fpr\n"
-        );
-
-    // message API
-
-    enum_<PEP_rating>("rating")
-        .value("_undefined", PEP_rating_undefined)
-        .value("cannot_decrypt", PEP_rating_cannot_decrypt)
-        .value("have_no_key", PEP_rating_have_no_key)
-        .value("unencrypted", PEP_rating_unencrypted)
-        .value("unreliable", PEP_rating_unreliable)
-        .value("reliable", PEP_rating_reliable)
-        .value("trusted", PEP_rating_trusted)
-        .value("trusted_and_anonymized", PEP_rating_trusted_and_anonymized)
-        .value("fully_anonymous", PEP_rating_fully_anonymous)
-        .value("mistrust", PEP_rating_mistrust)
-        .value("b0rken", PEP_rating_b0rken)
-        .value("under_attack", PEP_rating_under_attack);
-
-    enum_<PEP_color>("colorvalue")
-        .value("no_color", PEP_color_no_color)
-        .value("yellow", PEP_color_yellow)
-        .value("green", PEP_color_green)
-        .value("red", PEP_color_red);
-
-
-    def("incoming_message", &incoming_message,
-    "msg = incoming_message(mime_text)\n"
-    "\n"
-    "create an incoming message from a MIME text"
-            );
-    def("outgoing_message", &outgoing_message,
-    "msg = outgoing_message(ident)\n"
-    "\n"
-    "create an outgoing message using an own identity"
-            );
-    def("color", &_color,
-    "c = color(rating)\n"
-    "\n"
-    "calculate color value out of rating. Returns PEP_color"
-            );
-    def("trustwords", &_trustwords,
-    "text = trustwords(ident_own, ident_partner)\n"
-    "\n"
-    "calculate trustwords for two Identities");
-
-    // Sync API
-
-    enum_<sync_handshake_signal>("sync_handshake_signal")
-        .value("SYNC_NOTIFY_UNDEFINED"             , SYNC_NOTIFY_UNDEFINED)
-        .value("SYNC_NOTIFY_INIT_ADD_OUR_DEVICE"   , SYNC_NOTIFY_INIT_ADD_OUR_DEVICE)
-        .value("SYNC_NOTIFY_INIT_ADD_OTHER_DEVICE" , SYNC_NOTIFY_INIT_ADD_OTHER_DEVICE)
-        .value("SYNC_NOTIFY_INIT_FORM_GROUP"       , SYNC_NOTIFY_INIT_FORM_GROUP)
-        .value("SYNC_NOTIFY_TIMEOUT"               , SYNC_NOTIFY_TIMEOUT)
-        .value("SYNC_NOTIFY_ACCEPTED_DEVICE_ADDED" , SYNC_NOTIFY_ACCEPTED_DEVICE_ADDED)
-        .value("SYNC_NOTIFY_ACCEPTED_GROUP_CREATED", SYNC_NOTIFY_ACCEPTED_GROUP_CREATED)
-        .value("SYNC_NOTIFY_ACCEPTED_DEVICE_ACCEPTED", SYNC_NOTIFY_ACCEPTED_DEVICE_ACCEPTED)
-        .value("SYNC_NOTIFY_SOLE"                  , SYNC_NOTIFY_SOLE)
-        .value("SYNC_NOTIFY_IN_GROUP"              , SYNC_NOTIFY_IN_GROUP);
+                .add_property("outgoing_rating", &Message::outgoing_rating, "rating outgoing message will have")
+                .add_property("outgoing_color", &Message::outgoing_color, "color outgoing message will have as PEP_color")
+                .def("__deepcopy__", &Message::deepcopy)
+                .def("__copy__", &Message::copy);
+
+                // basic API and key management API
+
+                def("update_identity", &update_identity,
+                "update_identity(ident)\n"
+                "\n"
+                "update identity information\n"
+                "call this to complete identity information when you at least have an address\n"
+                );
+                def("myself", &myself,
+                "myself(ident)\n"
+                "\n"
+                "ensures that the own identity is being complete\n"
+                "supply ident.address and ident.username\n"
+                );
+                def("trust_personal_key", &trust_personal_key,
+                "trust_personal_key(ident)\n"
+                "\n"
+                "mark a key as trusted with a person\n"
+                );
+
+                enum_<identity_flags>("identity_flags")
+                .value("PEP_idf_not_for_sync", PEP_idf_not_for_sync)
+                .value("PEP_idf_list", PEP_idf_list)
+                .value("PEP_idf_devicegroup", PEP_idf_devicegroup);
+
+                def("set_identity_flags", &set_identity_flags,
+                "set_identity_flags(ident, flags)\n"
+                "\n"
+                "set identity flags\n"
+                );
+
+                def("unset_identity_flags", &unset_identity_flags,
+                "unset_identity_flags(ident, flags)\n"
+                "\n"
+                "unset identity flags\n"
+                );
+
+                def("key_reset_trust", &key_reset_trust,
+                "key_reset_trust(ident)\n"
+                "\n"
+                "reset trust bit or explicitly mistrusted status for an identity and "
+                "its accompanying key/user_id pair\n"
+                );
+
+                def("import_key", &import_key,
+                "private_key_list = import_key(key_data)\n"
+                "\n"
+                "import key(s) from key_data\n"
+                );
+
+                def("export_key", &export_key,
+                "key_data = export_key(identity)\n"
+                "\n"
+                "export key(s) of identity\n"
+                );
+
+                def("export_secret_key", &export_secret_key,
+                "key_data = export_seret_key(identity)\n"
+                "\n"
+                "export secret key(s) of identity\n"
+                );
+
+                def("set_own_key", &set_own_key,
+                "set_own_key(me, fpr)\n"
+                "\n"
+                "mark a key as an own key, and make it the default key\n"
+                "\n"
+                "me         Own identity for which to add the existing key\n"
+                "fpr        The fingerprint of the key to be added\n"
+                "\n"
+                "me->address, me->user_id and me->username must be set to valid data\n"
+                "myself() is called by set_own_key() without key generation\n"
+                "me->flags are ignored\n"
+                "me->address must not be an alias\n"
+                "me->fpr will be ignored and replaced by fpr\n"
+                );
+
+                // message API
+
+                enum_<PEP_rating>("rating")
+                .value("_undefined", PEP_rating_undefined)
+                .value("cannot_decrypt", PEP_rating_cannot_decrypt)
+                .value("have_no_key", PEP_rating_have_no_key)
+                .value("unencrypted", PEP_rating_unencrypted)
+                .value("unreliable", PEP_rating_unreliable)
+                .value("reliable", PEP_rating_reliable)
+                .value("trusted", PEP_rating_trusted)
+                .value("trusted_and_anonymized", PEP_rating_trusted_and_anonymized)
+                .value("fully_anonymous", PEP_rating_fully_anonymous)
+                .value("mistrust", PEP_rating_mistrust)
+                .value("b0rken", PEP_rating_b0rken)
+                .value("under_attack", PEP_rating_under_attack);
+
+                enum_<PEP_color>("colorvalue")
+                .value("no_color", PEP_color_no_color)
+                .value("yellow", PEP_color_yellow)
+                .value("green", PEP_color_green)
+                .value("red", PEP_color_red);
+
+
+                def("incoming_message", &incoming_message,
+                "msg = incoming_message(mime_text)\n"
+                "\n"
+                "create an incoming message from a MIME text"
+                );
+                def("outgoing_message", &outgoing_message,
+                "msg = outgoing_message(ident)\n"
+                "\n"
+                "create an outgoing message using an own identity"
+                );
+                def("color", &_color,
+                "c = color(rating)\n"
+                "\n"
+                "calculate color value out of rating. Returns PEP_color"
+                );
+                def("trustwords", &_trustwords,
+                "text = trustwords(ident_own, ident_partner)\n"
+                "\n"
+                "calculate trustwords for two Identities");
+
+                // Sync API
+
+                enum_<sync_handshake_signal>("sync_handshake_signal")
+                .value("SYNC_NOTIFY_UNDEFINED", SYNC_NOTIFY_UNDEFINED)
+                .value("SYNC_NOTIFY_INIT_ADD_OUR_DEVICE", SYNC_NOTIFY_INIT_ADD_OUR_DEVICE)
+                .value("SYNC_NOTIFY_INIT_ADD_OTHER_DEVICE", SYNC_NOTIFY_INIT_ADD_OTHER_DEVICE)
+                .value("SYNC_NOTIFY_INIT_FORM_GROUP", SYNC_NOTIFY_INIT_FORM_GROUP)
+                .value("SYNC_NOTIFY_TIMEOUT", SYNC_NOTIFY_TIMEOUT)
+                .value("SYNC_NOTIFY_ACCEPTED_DEVICE_ADDED", SYNC_NOTIFY_ACCEPTED_DEVICE_ADDED)
+                .value("SYNC_NOTIFY_ACCEPTED_GROUP_CREATED", SYNC_NOTIFY_ACCEPTED_GROUP_CREATED)
+                .value("SYNC_NOTIFY_ACCEPTED_DEVICE_ACCEPTED", SYNC_NOTIFY_ACCEPTED_DEVICE_ACCEPTED)
+                .value("SYNC_NOTIFY_SOLE", SYNC_NOTIFY_SOLE)
+                .value("SYNC_NOTIFY_IN_GROUP", SYNC_NOTIFY_IN_GROUP);
 
 //    auto user_interface_class = class_<UserInterface, UserInterface_callback, boost::noncopyable>(
 //            "UserInterface",
@@ -627,47 +610,47 @@ BOOST_PYTHON_MODULE(native_pEp)
 //    "call to deliver the handshake result of the handshake dialog"
 //    );
 
-    def("deliver_handshake_result", &deliverHandshakeResult, boost::python::arg("identities")=object(),
-        "deliverHandshakeResult(self, result, identities=None)\n"
-        "\n"
-        "   result          -1: cancel, 0: accepted, 1: rejected\n"
-        "   identities      list of identities to share or None for all\n"
-        "\n"
-        "call to deliver the handshake result of the handshake dialog"
-        );
-
-    def("start_sync", &start_sync,
-        "start_sync()\n"
-        "\n"
-        "starts the sync thread"
-       );
-
-    def("shutdown_sync", &shutdown_sync,
-            "shutdown_sync()\n"
-            "\n"
-            "call this from another thread to shut down the sync thread\n"
-       );
-
-    def("debug_color", &debug_color,
-            "for debug builds set ANSI color value");
-
-    def("leave_device_group", &leave_device_group,
-            "leave_device_group()\n"
-            "\n"
-            "call this for a grouped device, which should leave\n"
-       );
-
-    def("is_sync_active", &is_sync_active,
-            "is_sync_active()\n"
-            "\n"
-            "True if sync is active, False otherwise\n"
-       );
-
-
-    // codecs
-    call< object >(((object)(import("codecs").attr("register"))).ptr(), make_function(sync_search));
-    call< object >(((object)(import("codecs").attr("register"))).ptr(), make_function(distribution_search));
-}
-
-} // namespace PythonAdapter
+                def("deliver_handshake_result", &deliverHandshakeResult, boost::python::arg("identities")=object(),
+                "deliverHandshakeResult(self, result, identities=None)\n"
+                "\n"
+                "   result          -1: cancel, 0: accepted, 1: rejected\n"
+                "   identities      list of identities to share or None for all\n"
+                "\n"
+                "call to deliver the handshake result of the handshake dialog"
+                );
+
+                def("start_sync", &start_sync,
+                "start_sync()\n"
+                "\n"
+                "starts the sync thread"
+                );
+
+                def("shutdown_sync", &shutdown_sync,
+                "shutdown_sync()\n"
+                "\n"
+                "call this from another thread to shut down the sync thread\n"
+                );
+
+                def("debug_color", &debug_color,
+                "for debug builds set ANSI color value");
+
+                def("leave_device_group", &leave_device_group,
+                "leave_device_group()\n"
+                "\n"
+                "call this for a grouped device, which should leave\n"
+                );
+
+                def("is_sync_active", &is_sync_active,
+                "is_sync_active()\n"
+                "\n"
+                "True if sync is active, False otherwise\n"
+                );
+
+
+                // codecs
+                call< object >(((object)(import("codecs").attr("register"))).ptr(), make_function(sync_search));
+                call< object >(((object)(import("codecs").attr("register"))).ptr(), make_function(distribution_search));
+        }
+
+    } // namespace PythonAdapter
 } // namespace pEp
diff --git a/src/pEp/native_pEp/pEpmodule.hh b/src/pEp/native_pEp/pEpmodule.hh
index 0b72c96..8ae3c25 100644
--- a/src/pEp/native_pEp/pEpmodule.hh
+++ b/src/pEp/native_pEp/pEpmodule.hh
@@ -11,18 +11,25 @@
 #include "message.hh"
 
 namespace pEp {
-namespace PythonAdapter {
-
-extern string device_name;
-void config_passive_mode(bool enable);
-void config_unencrypted_subject(bool enable);
-void key_reset_user(string user_id, string fpr);
-void key_reset_all_own_keys();
-void _throw_status(PEP_STATUS status);
-PEP_STATUS _messageToSend(::message *msg);
-PEP_STATUS notifyHandshake(pEp_identity *me, pEp_identity *partner, sync_handshake_signal signal);
-
-} /* namespace PythonAdapter */
+    namespace PythonAdapter {
+
+        extern string device_name;
+
+        void config_passive_mode(bool enable);
+
+        void config_unencrypted_subject(bool enable);
+
+        void key_reset_user(string user_id, string fpr);
+
+        void key_reset_all_own_keys();
+
+        void _throw_status(PEP_STATUS status);
+
+        PEP_STATUS _messageToSend(::message *msg);
+
+        PEP_STATUS notifyHandshake(pEp_identity *me, pEp_identity *partner, sync_handshake_signal signal);
+
+    } /* namespace PythonAdapter */
 } /* namespace pEp */
 
 #endif /* PEPMODULE_HH */
\ No newline at end of file
diff --git a/src/pEp/native_pEp/str_attr.cc b/src/pEp/native_pEp/str_attr.cc
index 96810ad..74f44ee 100644
--- a/src/pEp/native_pEp/str_attr.cc
+++ b/src/pEp/native_pEp/str_attr.cc
@@ -10,175 +10,163 @@
 #include "str_attr.hh"
 
 namespace pEp {
-namespace PythonAdapter {
-using namespace std;
-using namespace boost::python;
-using namespace boost::locale;
-
-object repr(object s)
-{
-    return s.attr("__repr__")();
-}
-
-string repr(string s)
-{
-    str _s = s.c_str();
-    object _r = _s.attr("__repr__")();
-    string r = extract< string >(_r);
-    return r;
-}
-
-string str_attr(char *&str)
-{
-    if (!str)
-        return string("");
-    return string(str);
-}
-
-void str_attr(char *&str, string value)
-{
-    string normalized = normalize(value, norm_nfc);
-    free(str);
-    str = strdup(normalized.c_str());
-    if (!str)
-        throw bad_alloc();
-}
-
-time_t timestamp_attr(timestamp *&ts)
-{
-    if (!ts)
-        return 0;
-
-    return timegm(ts);
-}
-
-void timestamp_attr(timestamp *&ts, time_t value)
-{
-    free_timestamp(ts);
-    ts = new_timestamp(value);
-}
-
-boost::python::list strlist_attr(stringlist_t *&sl)
-{
-    boost::python::list result;
-
-    for (stringlist_t *_sl = sl; _sl && _sl->value; _sl = _sl->next) {
-        string s(_sl->value);
-        result.append(object(s));
-    }
-
-    return result;
-}
-
-void strlist_attr(stringlist_t *&sl, boost::python::list value)
-{
-    stringlist_t *_sl = new_stringlist(NULL);
-    if (!_sl)
-        throw bad_alloc();
-
-    stringlist_t *_s = _sl;
-    for (int i=0; i<len(value); i++) {
-        extract< string > extract_string(value[i]);
-        if (!extract_string.check()) {
-            free_stringlist(_sl);
+    namespace PythonAdapter {
+        using namespace std;
+        using namespace boost::python;
+        using namespace boost::locale;
+
+        object repr(object s) {
+            return s.attr("__repr__")();
         }
-        string s = extract_string();
-        s = normalize(s, norm_nfc);
-        _s = stringlist_add(_s, s.c_str());
-        if (!_s) {
-            free_stringlist(_sl);
-            throw bad_alloc();
+
+        string repr(string s) {
+            str _s = s.c_str();
+            object _r = _s.attr("__repr__")();
+            string r = extract<string>(_r);
+            return r;
         }
-    }
 
-    free_stringlist(sl);
-    sl = _sl;
-}
+        string str_attr(char *&str) {
+            if (!str)
+                return string("");
+            return string(str);
+        }
 
-dict strdict_attr(stringpair_list_t *&spl)
-{
-    dict result;
+        void str_attr(char *&str, string value) {
+            string normalized = normalize(value, norm_nfc);
+            free(str);
+            str = strdup(normalized.c_str());
+            if (!str)
+                throw bad_alloc();
+        }
 
-    for (stringpair_list_t *_spl = spl; _spl && _spl->value; _spl =
-            _spl->next) {
-        stringpair_t *p = _spl->value;
-        if (p->key && p->value) {
-            string key(p->key);
-            string value(p->value);
+        time_t timestamp_attr(timestamp *&ts) {
+            if (!ts)
+                return 0;
 
-            result[key] = value;
+            return timegm(ts);
         }
-    }
-
-    return result;
-}
-
-void strdict_attr(stringpair_list_t *&spl, dict value)
-{
-    stringpair_list_t *_spl = new_stringpair_list(NULL);
-    if (!_spl)
-        throw bad_alloc();
-
-    stringpair_list_t *_s = _spl;
-    for (int i=0; i<len(value); i++) {
-        extract< string > extract_key(value.keys()[i]);
-        extract< string > extract_value(value.values()[i]);
-
-        if (!(extract_key.check() && extract_value.check()))
-            free_stringpair_list(_spl);
-
-        string key = extract_key();
-        key = normalize(key, norm_nfc);
-        string _value = extract_value();
-        _value = normalize(_value, norm_nfc);
-        stringpair_t *pair = new_stringpair(key.c_str(), _value.c_str());
-        if (!pair) {
-            free_stringpair_list(_spl);
-            throw bad_alloc();
+
+        void timestamp_attr(timestamp *&ts, time_t value) {
+            free_timestamp(ts);
+            ts = new_timestamp(value);
         }
-        _s = stringpair_list_add(_s, pair);
-        if (!_s) {
-            free_stringpair_list(_spl);
-            throw bad_alloc();
+
+        boost::python::list strlist_attr(stringlist_t *&sl) {
+            boost::python::list result;
+
+            for (stringlist_t *_sl = sl; _sl && _sl->value; _sl = _sl->next) {
+                string s(_sl->value);
+                result.append(object(s));
+            }
+
+            return result;
         }
-    }
-
-    free_stringpair_list(spl);
-    spl = _spl;
-}
-
-stringlist_t *to_stringlist(boost::python::list l)
-{
-    stringlist_t *result = new_stringlist(NULL);
-    if (!result)
-        throw bad_alloc();
-
-    stringlist_t *_s = result;
-    for (int i=0; i<len(l); i++) {
-        extract< string > extract_string(l[i]);
-        if (!extract_string.check())
-            free_stringlist(result);
-        string s = extract_string();
-        _s = stringlist_add(_s, s.c_str());
-        if (!_s) {
-            free_stringlist(result);
-            throw bad_alloc();
+
+        void strlist_attr(stringlist_t *&sl, boost::python::list value) {
+            stringlist_t *_sl = new_stringlist(NULL);
+            if (!_sl)
+                throw bad_alloc();
+
+            stringlist_t *_s = _sl;
+            for (int i = 0; i < len(value); i++) {
+                extract <string> extract_string(value[i]);
+                if (!extract_string.check()) {
+                    free_stringlist(_sl);
+                }
+                string s = extract_string();
+                s = normalize(s, norm_nfc);
+                _s = stringlist_add(_s, s.c_str());
+                if (!_s) {
+                    free_stringlist(_sl);
+                    throw bad_alloc();
+                }
+            }
+
+            free_stringlist(sl);
+            sl = _sl;
         }
-    }
-
-    return result;
-}
-
-boost::python::list from_stringlist(const stringlist_t *sl)
-{
-    boost::python::list result;
-    for (const stringlist_t *_sl = sl; _sl && _sl->value; _sl = _sl->next) {
-        string s = _sl->value;
-        result.append(s);
-    }
-    return result;
-}
-
-} // namespace PythonAdapter
+
+        dict strdict_attr(stringpair_list_t *&spl) {
+            dict result;
+
+            for (stringpair_list_t *_spl = spl; _spl && _spl->value; _spl =
+                                                                             _spl->next) {
+                stringpair_t *p = _spl->value;
+                if (p->key && p->value) {
+                    string key(p->key);
+                    string value(p->value);
+
+                    result[key] = value;
+                }
+            }
+
+            return result;
+        }
+
+        void strdict_attr(stringpair_list_t *&spl, dict value) {
+            stringpair_list_t *_spl = new_stringpair_list(NULL);
+            if (!_spl)
+                throw bad_alloc();
+
+            stringpair_list_t *_s = _spl;
+            for (int i = 0; i < len(value); i++) {
+                extract <string> extract_key(value.keys()[i]);
+                extract <string> extract_value(value.values()[i]);
+
+                if (!(extract_key.check() && extract_value.check()))
+                    free_stringpair_list(_spl);
+
+                string key = extract_key();
+                key = normalize(key, norm_nfc);
+                string _value = extract_value();
+                _value = normalize(_value, norm_nfc);
+                stringpair_t *pair = new_stringpair(key.c_str(), _value.c_str());
+                if (!pair) {
+                    free_stringpair_list(_spl);
+                    throw bad_alloc();
+                }
+                _s = stringpair_list_add(_s, pair);
+                if (!_s) {
+                    free_stringpair_list(_spl);
+                    throw bad_alloc();
+                }
+            }
+
+            free_stringpair_list(spl);
+            spl = _spl;
+        }
+
+        stringlist_t *to_stringlist(boost::python::list l) {
+            stringlist_t *result = new_stringlist(NULL);
+            if (!result)
+                throw bad_alloc();
+
+            stringlist_t *_s = result;
+            for (int i = 0; i < len(l); i++) {
+                extract <string> extract_string(l[i]);
+                if (!extract_string.check())
+                    free_stringlist(result);
+                string s = extract_string();
+                _s = stringlist_add(_s, s.c_str());
+                if (!_s) {
+                    free_stringlist(result);
+                    throw bad_alloc();
+                }
+            }
+
+            return result;
+        }
+
+        boost::python::list from_stringlist(const stringlist_t *sl) {
+            boost::python::list result;
+            for (const stringlist_t *_sl = sl; _sl && _sl->value; _sl = _sl->next) {
+                string s = _sl->value;
+                result.append(s);
+            }
+            return result;
+        }
+
+    } // namespace PythonAdapter
 } // namespace pEp {
 
diff --git a/src/pEp/native_pEp/user_interface.cc b/src/pEp/native_pEp/user_interface.cc
index 22be5db..f31ad82 100644
--- a/src/pEp/native_pEp/user_interface.cc
+++ b/src/pEp/native_pEp/user_interface.cc
@@ -8,82 +8,76 @@
 #include "user_interface.hh"
 
 namespace pEp {
-namespace PythonAdapter {
-using namespace std;
-using namespace boost::python;
-
-UserInterface *UserInterface::_ui = nullptr;
-
-UserInterface::UserInterface()
-{
-    if (_ui)
-        throw runtime_error("only one UserInterface thread allowed");
-    _ui = this;
-}
-
-UserInterface::~UserInterface()
-{
-    _ui = nullptr;
-}
-
-UserInterface_callback::UserInterface_callback(PyObject *self) :
-    UserInterface(), _self(self)
-{
+    namespace PythonAdapter {
+        using namespace std;
+        using namespace boost::python;
+
+        UserInterface *UserInterface::_ui = nullptr;
+
+        UserInterface::UserInterface() {
+            if (_ui)
+                throw runtime_error("only one UserInterface thread allowed");
+            _ui = this;
+        }
+
+        UserInterface::~UserInterface() {
+            _ui = nullptr;
+        }
+
+        UserInterface_callback::UserInterface_callback(PyObject *self) :
+                UserInterface(), _self(self) {
 //    adapter.ui_object(self);
 //    PEP_STATUS status = ::register_sync_callbacks(Adapter::session(),
 //            (void *) this, _notifyHandshake, retrieve_next_sync_event);
 //    assert(status == PEP_STATUS_OK);
 //    if (status)
 //        _throw_status(status);
-}
+        }
 
-UserInterface_callback::~UserInterface_callback()
-{
+        UserInterface_callback::~UserInterface_callback() {
 //    ::unregister_sync_callbacks(Adapter::session());
-}
-
-PEP_STATUS UserInterface::_notifyHandshake(
-        pEp_identity *me, pEp_identity *partner,
-        sync_handshake_signal signal
-    )
-{
-    if (!(me && partner))
-        return PEP_ILLEGAL_VALUE;
-
-    auto that = dynamic_cast< UserInterface_callback * >(_ui);
-    that->notifyHandshake(Identity(me), Identity(partner), signal);
-
-    return PEP_STATUS_OK;
-}
-
-void UserInterface::deliverHandshakeResult(int result, object identities)
-{
-    identity_list *shared_identities = nullptr;
-    if (identities != boost::python::api::object() && boost::python::len(identities)) {
-        shared_identities = new_identity_list(nullptr);
-        if (!shared_identities)
-            throw bad_alloc();
-
-        try {
-            identity_list *si = shared_identities;
-            for (int i=0; i < boost::python::len(identities); ++i) {
-                Identity ident = extract< Identity >(identities[i]);
-                si = identity_list_add(si, ident);
-                if (!si)
+        }
+
+        PEP_STATUS UserInterface::_notifyHandshake(
+                pEp_identity *me, pEp_identity *partner,
+                sync_handshake_signal signal
+        ) {
+            if (!(me && partner))
+                return PEP_ILLEGAL_VALUE;
+
+            auto that = dynamic_cast< UserInterface_callback * >(_ui);
+            that->notifyHandshake(Identity(me), Identity(partner), signal);
+
+            return PEP_STATUS_OK;
+        }
+
+        void UserInterface::deliverHandshakeResult(int result, object identities) {
+            identity_list *shared_identities = nullptr;
+            if (identities != boost::python::api::object() && boost::python::len(identities)) {
+                shared_identities = new_identity_list(nullptr);
+                if (!shared_identities)
                     throw bad_alloc();
+
+                try {
+                    identity_list *si = shared_identities;
+                    for (int i = 0; i < boost::python::len(identities); ++i) {
+                        Identity ident = extract<Identity>(identities[i]);
+                        si = identity_list_add(si, ident);
+                        if (!si)
+                            throw bad_alloc();
+                    }
+                }
+                catch (exception &ex) {
+                    free_identity_list(shared_identities);
+                    throw ex;
+                }
             }
-        }
-        catch (exception& ex) {
+
+            PEP_STATUS status = ::deliverHandshakeResult(Adapter::session(),
+                                                         (sync_handshake_result) result, shared_identities);
             free_identity_list(shared_identities);
-            throw ex;
+            _throw_status(status);
         }
-    }
-
-    PEP_STATUS status = ::deliverHandshakeResult(Adapter::session(),
-            (sync_handshake_result) result, shared_identities);
-    free_identity_list(shared_identities);
-    _throw_status(status);
-}
 
 //PEP_rating UserInterface::get_key_rating_for_user(string user_id, string fpr)
 //{
@@ -119,12 +113,11 @@ void UserInterface::deliverHandshakeResult(int result, object identities)
 //    return adapter.queue().pop_front();
 //}
 
-void UserInterface_callback::notifyHandshake(
-    Identity me, Identity partner, sync_handshake_signal signal)
-{
-    call_method< void >(_self, "notifyHandshake", me, partner, signal);
-}
+        void UserInterface_callback::notifyHandshake(
+                Identity me, Identity partner, sync_handshake_signal signal) {
+            call_method<void>(_self, "notifyHandshake", me, partner, signal);
+        }
 
-} // namespace PythonAdapter
+    } // namespace PythonAdapter
 } // namespace pEp {
 
diff --git a/src/pEp/native_pEp/user_interface.hh b/src/pEp/native_pEp/user_interface.hh
index f609a41..59e17fe 100644
--- a/src/pEp/native_pEp/user_interface.hh
+++ b/src/pEp/native_pEp/user_interface.hh
@@ -16,44 +16,45 @@
 
 
 namespace pEp {
-namespace PythonAdapter {
+    namespace PythonAdapter {
 
-class UserInterface {
-    static UserInterface *_ui;
-public:
-    UserInterface();
-    virtual ~UserInterface();
+        class UserInterface {
+            static UserInterface *_ui;
+        public:
+            UserInterface();
 
-    virtual void notifyHandshake(
-        Identity me,
-        Identity partner,
-        sync_handshake_signal signal)
-    {
-        throw runtime_error("override this method");
-    }
+            virtual ~UserInterface();
 
-    virtual void deliverHandshakeResult(int result, object identities);
+            virtual void notifyHandshake(
+                    Identity me,
+                    Identity partner,
+                    sync_handshake_signal signal) {
+                throw runtime_error("override this method");
+            }
+
+            virtual void deliverHandshakeResult(int result, object identities);
 
 //     PEP_rating get_key_rating_for_user(string user_id, string fpr);
 
-protected:
-    static PEP_STATUS _notifyHandshake(pEp_identity *me, pEp_identity *partner, sync_handshake_signal signal);
-};
+        protected:
+            static PEP_STATUS _notifyHandshake(pEp_identity *me, pEp_identity *partner, sync_handshake_signal signal);
+        };
+
+        class UserInterface_callback : public UserInterface {
+            PyObject *_self;
+        public:
+            UserInterface_callback(PyObject *self);
 
-class UserInterface_callback : public UserInterface {
-    PyObject *_self;
-public:
-    UserInterface_callback(PyObject *self);
-    ~UserInterface_callback();
+            ~UserInterface_callback();
 
-    void notifyHandshake(
-        Identity me,
-        Identity partner,
-        sync_handshake_signal signal
-    );
-};
+            void notifyHandshake(
+                    Identity me,
+                    Identity partner,
+                    sync_handshake_signal signal
+            );
+        };
 
-} /* namespace PythonAdapter */
+    } /* namespace PythonAdapter */
 } /* namespace pEp */
 
 #endif /* USER_INTERFACE_HH */