diff --git a/src/pEp/_pEp/basic_api.cc b/src/pEp/_pEp/basic_api.cc
index b21b38a..5aa7f06 100644
--- a/src/pEp/_pEp/basic_api.cc
+++ b/src/pEp/_pEp/basic_api.cc
@@ -13,149 +13,152 @@
 #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) {
-                    ::free_identity_list(private_keys);
-                    throw bad_alloc();
-                }
-                result.append(Identity(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);
-            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;
+            throw bad_alloc();
         }
-
-        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
+        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
 
 
diff --git a/src/pEp/_pEp/basic_api.hh b/src/pEp/_pEp/basic_api.hh
index 68f41e7..d88dd16 100644
--- a/src/pEp/_pEp/basic_api.hh
+++ b/src/pEp/_pEp/basic_api.hh
@@ -8,31 +8,31 @@
 #include "identity.hh"
 
 namespace pEp {
-    namespace PythonAdapter {
+namespace PythonAdapter {
 
-        void update_identity(Identity &ident);
+void update_identity(Identity &ident);
 
-        void myself(Identity &ident);
+void myself(Identity &ident);
 
-        string _trustwords(Identity me, Identity partner, string lang, bool full);
+string _trustwords(Identity me, Identity partner, string lang, bool full);
 
-        void trust_personal_key(Identity ident);
+void trust_personal_key(Identity ident);
 
-        void set_identity_flags(Identity ident, ::identity_flags_t flags);
+void set_identity_flags(Identity ident, ::identity_flags_t flags);
 
-        void unset_identity_flags(Identity ident, ::identity_flags_t flags);
+void unset_identity_flags(Identity ident, ::identity_flags_t flags);
 
-        void key_reset_trust(Identity ident);
+void key_reset_trust(Identity ident);
 
-        boost::python::list import_key(string key_data);
+boost::python::list import_key(string key_data);
 
-        string export_key(Identity ident);
+string export_key(Identity ident);
 
-        string export_secret_key(Identity ident);
+string export_secret_key(Identity ident);
 
-        void set_own_key(Identity &ident, string fpr);
+void set_own_key(Identity &ident, string fpr);
 
-    } /* namespace PythonAdapter */
+} /* namespace PythonAdapter */
 } /* namespace pEp */
 
 #endif /* BASIC_API_HH */
diff --git a/src/pEp/_pEp/identity.cc b/src/pEp/_pEp/identity.cc
index 3c56681..73cdbaa 100644
--- a/src/pEp/_pEp/identity.cc
+++ b/src/pEp/_pEp/identity.cc
@@ -17,153 +17,162 @@
 #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);
-        }
+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) {
@@ -182,75 +191,80 @@ namespace pEp {
 //            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;
+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();
         }
-
-        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);
+        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);
-            ::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;
+        _i = ::identity_list_add(_i, _dup);
+        if (!_i) {
+            ::free_identity_list(_il);
+            throw bad_alloc();
         }
+    }
 
-        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;
-        }
+    ::free_identity_list(il);
+    il = _il;
+}
 
-    } // namespace PythonAdapter
+} // namespace PythonAdapter
 } // namespace pEp
 
diff --git a/src/pEp/_pEp/identity.hh b/src/pEp/_pEp/identity.hh
index 06e2335..e8885bf 100644
--- a/src/pEp/_pEp/identity.hh
+++ b/src/pEp/_pEp/identity.hh
@@ -21,84 +21,82 @@
 #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(const Identity &second);
 
-            Identity(::pEp_identity *ident);
+    Identity(::pEp_identity *ident);
 
-            virtual ~Identity();
+    virtual ~Identity();
 
-            operator ::pEp_identity *();
+    operator ::pEp_identity *();
 
-            operator const ::pEp_identity *() const;
+    operator const ::pEp_identity *() const;
 
-            string _repr();
+    string _repr();
 
-            string _str();
+    string _str();
 
-            string address() { return str_attr(_ident->address); }
+    string address() { return str_attr(_ident->address); }
 
-            void address(string value) { str_attr(_ident->address, value); }
+    void address(string value) { str_attr(_ident->address, value); }
 
-            string fpr() { return str_attr(_ident->fpr); }
+    string fpr() { return str_attr(_ident->fpr); }
 
-            void fpr(string value) { str_attr(_ident->fpr, value); }
+    void fpr(string value) { str_attr(_ident->fpr, value); }
 
-            string user_id() { return str_attr(_ident->user_id); }
+    string user_id() { return str_attr(_ident->user_id); }
 
-            void user_id(string value) { str_attr(_ident->user_id, value); }
+    void user_id(string value) { str_attr(_ident->user_id, value); }
 
-            string username() { return str_attr(_ident->username); }
+    string username() { return str_attr(_ident->username); }
 
-            void username(string value);
+    void username(string value);
 
-            ::PEP_comm_type comm_type() { return _ident->comm_type; }
+    ::PEP_comm_type comm_type() { return _ident->comm_type; }
 
-            void comm_type(::PEP_comm_type value) { _ident->comm_type = value; };
+    void comm_type(::PEP_comm_type value) { _ident->comm_type = value; };
 
-            std::string lang();
+    std::string lang();
 
-            void lang(std::string value);
+    void lang(std::string value);
 
-            ::identity_flags_t flags() { return _ident->flags; }
+    ::identity_flags_t flags() { return _ident->flags; }
 
-            void flags(::identity_flags_t flags) { _ident->flags = flags; }
+    void flags(::identity_flags_t flags) { _ident->flags = flags; }
 
-            int rating();
+    int rating();
 
-            ::PEP_color color();
+    ::PEP_color color();
 
-            Identity copy();
+    Identity copy();
 
-            Identity deepcopy(dict &memo);
+    Identity deepcopy(dict &memo);
 
-            virtual void update();
+    virtual void update();
 
-            void key_reset(string fpr = "");
+    void key_reset(string fpr = "");
 
-            void key_mistrusted();
+    void key_mistrusted();
 
-            bool is_pEp_user();
+    bool is_pEp_user();
 
-            void enable_for_sync();
+    void enable_for_sync();
 
-            void disable_for_sync();
-        };
+    void disable_for_sync();
+};
 
 //        class Myself : public Identity {
 //        public:
@@ -107,15 +105,15 @@ namespace pEp {
 //            virtual void update();
 //        };
 
-        Identity identity_attr(::pEp_identity *&ident);
+Identity identity_attr(::pEp_identity *&ident);
 
-        void identity_attr(::pEp_identity *&ident, object value);
+void identity_attr(::pEp_identity *&ident, object value);
 
-        boost::python::list identitylist_attr(::identity_list *&il);
+boost::python::list identitylist_attr(::identity_list *&il);
 
-        void identitylist_attr(::identity_list *&il, boost::python::list value);
+void identitylist_attr(::identity_list *&il, boost::python::list value);
 
-    } // namespace PythonAdapter
+} // namespace PythonAdapter
 } // namespace pEp
 
 #endif /* IDENTITY_HH */
diff --git a/src/pEp/_pEp/message.cc b/src/pEp/_pEp/message.cc
index 3728eb3..1baf6b1 100644
--- a/src/pEp/_pEp/message.cc
+++ b/src/pEp/_pEp/message.cc
@@ -19,367 +19,383 @@
 #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();
+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);
         }
-
-        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)
-                        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());
-            }
-        }
-
-        Message::Message(const Message &second)
-                : _msg(second._msg) {
-            if (!_msg.get())
-                throw bad_alloc();
-        }
-
-        Message::Message(::message *msg)
-                : _msg(::message_dup(msg), &::free_message) {
-
-        }
-
-        Message::~Message() {
-
-        }
-
-        Message::operator ::message *() {
-            return _msg.get();
+        string filename;
+        if (_bl->filename) {
+            filename = string(_bl->filename);
         }
-
-        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 << "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);
-                    }
-                    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;
+        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";
         }
 
-        Message Message::encrypt() {
-            boost::python::list extra;
-            return encrypt_message(*this, extra, ::PEP_enc_PGP_MIME, 0);
+        if (_mime_type == "application/pEp.keyreset") {
+            encoding = "pep.distribution";
         }
 
-        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());
-        }
+    }
+    object codecs = import("codecs");
+    object _decode = codecs.attr("decode");
+    return call<string>(_decode.ptr(), this, encoding);
+}
 
-        Message Message::copy() {
-            ::message *dup = ::message_dup(*this);
-            if (!dup)
-                throw bad_alloc();
-            return Message(dup);
-        }
-
-        Message Message::deepcopy(dict &) {
-            return copy();
-        }
+PyBufferProcs Message::Blob::bp = {getbuffer, NULL};
 
-        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");
+Message::Message(int dir, Identity *from)
+    : _msg(new_message((::PEP_msg_direction)dir), &::free_message) {
+    if (!_msg) {
+        throw bad_alloc();
+    }
 
-            ::myself(Adapter::session(), me);
-            auto m = Message(::PEP_dir_outgoing, &me);
-            return m;
+    if (from) {
+        _msg->from = ::identity_dup(*from);
+        if (!_msg->from) {
+            throw bad_alloc();
         }
-
-        static object update(Identity ident) {
-            if (ident.address().empty())
-                throw runtime_error("at least address needed");
-            ::update_identity(Adapter::session(), ident);
-            return object(ident);
+        _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);
         }
 
-        static boost::python::list update(boost::python::list il) {
-            for (int i = 0; i < len(il); i++) {
-                update(extract<Identity>(il[i]));
-            }
-
-            return il;
+        if (!_cpy) {
+            throw bad_alloc();
         }
 
-        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()));
+        _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());
+    }
+}
+
+Message::Message(const Message &second)
+    : _msg(second._msg) {
+    if (!_msg.get()) {
+        throw bad_alloc();
+    }
+}
+
+Message::Message(::message *msg)
+    : _msg(::message_dup(msg), &::free_message) {}
+
+Message::~Message() {}
+
+Message::operator ::message *() {
+    return _msg.get();
+}
+
+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 << "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);
             }
-            catch (out_of_range &) {}
-
-            m.to(update(m.to()));
-            m.cc(update(m.cc()));
-            m.reply_to(update(m.reply_to()));
-
-            return m;
+            throw bad_alloc();
         }
-
-    } // namespace PythonAdapter
+    }
+
+    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
diff --git a/src/pEp/_pEp/message.hh b/src/pEp/_pEp/message.hh
index ac53aa3..620b8a7 100644
--- a/src/pEp/_pEp/message.hh
+++ b/src/pEp/_pEp/message.hh
@@ -18,177 +18,176 @@
 #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);
+      public:
+        Blob(::bloblist_t *bl = ::new_bloblist(NULL, 0, NULL, NULL), bool chained = false);
 
-                Blob(object data, string mime_type = "", string filename = "");
+        Blob(object data, string mime_type = "", string filename = "");
 
-                Blob(const Blob &second);
+        Blob(const Blob &second);
 
-                ~Blob();
+        ~Blob();
 
-                string _repr();
+        string _repr();
 
-                string mime_type() { return _bl ? str_attr(_bl->mime_type) : ""; }
+        string mime_type() { return _bl ? str_attr(_bl->mime_type) : ""; }
 
-                void mime_type(string value) { str_attr(_bl->mime_type, value); }
+        void mime_type(string value) { str_attr(_bl->mime_type, value); }
 
-                string filename() { return str_attr(_bl->filename); }
+        string filename() { return str_attr(_bl->filename); }
 
-                void filename(string value) { str_attr(_bl->filename, value); }
+        void filename(string value) { str_attr(_bl->filename, value); }
 
-                size_t size() { return _bl->size; }
+        size_t size() { return _bl->size; }
 
-                string decode(string encoding);
+        string decode(string encoding);
 
-                string decode() { return decode(""); }
+        string decode() { return decode(""); }
 
-                static PyBufferProcs bp;
+        static PyBufferProcs bp;
 
-                friend class Message;
+        friend class Message;
 
-            protected:
-                static int getbuffer(PyObject *self, Py_buffer *view, int flags);
-            };
+      protected:
+        static int getbuffer(PyObject *self, Py_buffer *view, int flags);
+    };
 
-            Message(int dir = ::PEP_dir_outgoing, Identity *from = NULL);
+    Message(int dir = ::PEP_dir_outgoing, Identity *from = NULL);
 
-            Message(string mimetext);
+    Message(string mimetext);
 
-            Message(const Message &second);
+    Message(const Message &second);
 
-            Message(::message *msg);
+    Message(::message *msg);
 
-            ~Message();
+    ~Message();
 
-            operator ::message *();
+    operator ::message *();
 
-            operator const ::message *() const;
+    operator const ::message *() const;
 
-            string _str();
+    string _str();
 
-            string _repr();
+    string _repr();
 
-            ::PEP_msg_direction dir() { return _msg->dir; }
+    ::PEP_msg_direction dir() { return _msg->dir; }
 
-            void dir(::PEP_msg_direction value) { _msg->dir = value; }
+    void dir(::PEP_msg_direction value) { _msg->dir = value; }
 
-            string id() { return str_attr(_msg->id); }
+    string id() { return str_attr(_msg->id); }
 
-            void id(string value) { str_attr(_msg->id, value); }
+    void id(string value) { str_attr(_msg->id, value); }
 
-            string shortmsg() { return str_attr(_msg->shortmsg); }
+    string shortmsg() { return str_attr(_msg->shortmsg); }
 
-            void shortmsg(string value) { str_attr(_msg->shortmsg, value); }
+    void shortmsg(string value) { str_attr(_msg->shortmsg, value); }
 
-            string longmsg() { return str_attr(_msg->longmsg); }
+    string longmsg() { return str_attr(_msg->longmsg); }
 
-            void longmsg(string value) { str_attr(_msg->longmsg, value); }
+    void longmsg(string value) { str_attr(_msg->longmsg, value); }
 
-            string longmsg_formatted() { return str_attr(_msg->longmsg_formatted); }
+    string longmsg_formatted() { return str_attr(_msg->longmsg_formatted); }
 
-            void longmsg_formatted(string value) { str_attr(_msg->longmsg_formatted, value); }
+    void longmsg_formatted(string value) { str_attr(_msg->longmsg_formatted, value); }
 
-            boost::python::tuple attachments();
+    boost::python::tuple attachments();
 
-            void attachments(boost::python::list value);
+    void attachments(boost::python::list value);
 
-            time_t sent() { return timestamp_attr(_msg->sent); }
+    time_t sent() { return timestamp_attr(_msg->sent); }
 
-            void sent(time_t value) { timestamp_attr(_msg->sent, value); }
+    void sent(time_t value) { timestamp_attr(_msg->sent, value); }
 
-            time_t recv() { return timestamp_attr(_msg->recv); }
+    time_t recv() { return timestamp_attr(_msg->recv); }
 
-            void recv(time_t value) { timestamp_attr(_msg->recv, value); }
+    void recv(time_t value) { timestamp_attr(_msg->recv, value); }
 
-            Identity from() { return identity_attr(_msg->from); }
+    Identity from() { return identity_attr(_msg->from); }
 
-            void from(object value) { identity_attr(_msg->from, value); }
+    void from(object value) { identity_attr(_msg->from, value); }
 
-            boost::python::list to() { return identitylist_attr(_msg->to); }
+    boost::python::list to() { return identitylist_attr(_msg->to); }
 
-            void to(boost::python::list value) { identitylist_attr(_msg->to, value); }
+    void to(boost::python::list value) { identitylist_attr(_msg->to, value); }
 
-            Identity recv_by() { return identity_attr(_msg->recv_by); }
+    Identity recv_by() { return identity_attr(_msg->recv_by); }
 
-            void recv_by(object value) { identity_attr(_msg->recv_by, value); }
+    void recv_by(object value) { identity_attr(_msg->recv_by, value); }
 
-            boost::python::list cc() { return identitylist_attr(_msg->cc); }
+    boost::python::list cc() { return identitylist_attr(_msg->cc); }
 
-            void cc(boost::python::list value) { identitylist_attr(_msg->cc, value); }
+    void cc(boost::python::list value) { identitylist_attr(_msg->cc, value); }
 
-            boost::python::list bcc() { return identitylist_attr(_msg->bcc); }
+    boost::python::list bcc() { return identitylist_attr(_msg->bcc); }
 
-            void bcc(boost::python::list value) { identitylist_attr(_msg->bcc, value); }
+    void bcc(boost::python::list value) { identitylist_attr(_msg->bcc, value); }
 
-            boost::python::list reply_to() { return identitylist_attr(_msg->reply_to); }
+    boost::python::list reply_to() { return identitylist_attr(_msg->reply_to); }
 
-            void reply_to(boost::python::list value) { identitylist_attr(_msg->reply_to, value); }
+    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); }
+    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); }
+    void in_reply_to(boost::python::list value) { strlist_attr(_msg->in_reply_to, value); }
 
-            boost::python::list references() { return strlist_attr(_msg->references); }
+    boost::python::list references() { return strlist_attr(_msg->references); }
 
-            void references(boost::python::list value) { strlist_attr(_msg->references, value); }
+    void references(boost::python::list value) { strlist_attr(_msg->references, value); }
 
-            boost::python::list keywords() { return strlist_attr(_msg->keywords); }
+    boost::python::list keywords() { return strlist_attr(_msg->keywords); }
 
-            void keywords(boost::python::list value) { strlist_attr(_msg->keywords, value); }
+    void keywords(boost::python::list value) { strlist_attr(_msg->keywords, value); }
 
-            string comments() { return str_attr(_msg->comments); }
+    string comments() { return str_attr(_msg->comments); }
 
-            void comments(string value) { str_attr(_msg->comments, value); }
+    void comments(string value) { str_attr(_msg->comments, value); }
 
-            dict opt_fields() { return strdict_attr(_msg->opt_fields); }
+    dict opt_fields() { return strdict_attr(_msg->opt_fields); }
 
-            void opt_fields(dict value) { return strdict_attr(_msg->opt_fields, value); }
+    void opt_fields(dict value) { return strdict_attr(_msg->opt_fields, value); }
 
-            ::PEP_enc_format enc_format() { return _msg->enc_format; }
+    ::PEP_enc_format enc_format() { return _msg->enc_format; }
 
-            void enc_format(::PEP_enc_format value) { _msg->enc_format = value; }
+    void enc_format(::PEP_enc_format value) { _msg->enc_format = value; }
 
-            Message encrypt();
+    Message encrypt();
 
-            Message _encrypt(boost::python::list extra, int enc_format = 4, int flags = 0);
+    Message _encrypt(boost::python::list extra, int enc_format = 4, int flags = 0);
 
-            boost::python::tuple decrypt(int flags = 0);
+    boost::python::tuple decrypt(int flags = 0);
 
-            ::PEP_rating outgoing_rating();
+    ::PEP_rating outgoing_rating();
 
-            ::PEP_color outgoing_color();
+    ::PEP_color outgoing_color();
 
-            Message deepcopy(dict &memo);
+    Message deepcopy(dict &memo);
 
-            Message copy();
-        };
+    Message copy();
+};
 
-        Message outgoing_message(Identity me);
+Message outgoing_message(Identity me);
 
-        Message incoming_message(string mime_text);
+Message incoming_message(string mime_text);
 
-    } /* namespace PythonAdapter */
+} /* namespace PythonAdapter */
 } /* namespace pEp */
 
 #endif /* MESSAGE_HH */
diff --git a/src/pEp/_pEp/message_api.cc b/src/pEp/_pEp/message_api.cc
index 8e4cd53..de2a454 100644
--- a/src/pEp/_pEp/message_api.cc
+++ b/src/pEp/_pEp/message_api.cc
@@ -13,150 +13,156 @@
 #include "basic_api.hh"
 
 namespace pEp {
-    namespace PythonAdapter {
-        using namespace std;
-        using namespace boost::python;
+namespace PythonAdapter {
+using namespace std;
+using namespace boost::python;
+
 //        namespace bp = 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
+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/_pEp/message_api.hh b/src/pEp/_pEp/message_api.hh
index 16d3605..177ca38 100644
--- a/src/pEp/_pEp/message_api.hh
+++ b/src/pEp/_pEp/message_api.hh
@@ -7,24 +7,19 @@
 #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);
+boost::python::tuple decrypt_message(Message src, int flags = 0);
 
-        ::PEP_color _color(int rating);
+::PEP_color _color(int rating);
 
-        object sync_search(string name);
+object sync_search(string name);
 
-        object distribution_search(string name);
+object distribution_search(string name);
 
-    } /* namespace PythonAdapter */
+} /* namespace PythonAdapter */
 } /* namespace pEp */
 
 #endif /* MESSAGE_API_HH */
diff --git a/src/pEp/_pEp/pEpmodule.cc b/src/pEp/_pEp/pEpmodule.cc
index af04f20..3b5bcc3 100644
--- a/src/pEp/_pEp/pEpmodule.cc
+++ b/src/pEp/_pEp/pEpmodule.cc
@@ -27,629 +27,446 @@
 //#include "user_interface.hh"
 
 namespace pEp {
-    namespace PythonAdapter {
-        using namespace std;
-        using namespace boost::python;
-
-        static const char *version_string = "p≡p Python adapter version 0.3";
-
-        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();
+namespace PythonAdapter {
+using namespace std;
+using namespace boost::python;
+
+static const char *version_string = "p≡p Python adapter version 0.3";
+
+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();
         }
 
-        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)
+        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();
-
-                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);
+        } catch (exception &ex) {
+            ::free_identity_list(shared_identities);
+            throw ex;
         }
-
-        BOOST_PYTHON_MODULE(_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().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,
-                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.")
-
-                .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,
-                "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,
-                "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,
-                (void(Identity::*)(string)) &Identity::address,
-                "email address or URI")
-                .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,
-                (void(Identity::*)(string)) &Identity::user_id,
-                "ID of person associated or 'pEp_own_userId' if own identity")
-                .add_property("username", (string(Identity::*)()) &Identity::username,
-                (void(Identity::*)(string)) &Identity::username,
-                "name in full of person associated")
-                .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,
-                (void(Identity::*)(string)) &Identity::lang,
-                "ISO 639-1 language code")
-                .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("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,
-                (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"
-                )
-                .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::*)())
-                (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,
-                (void(Message::*)(string)) &Message::id,
-                "message ID")
-                .add_property("shortmsg", (string(Message::*)()) &Message::shortmsg,
-                (void(Message::*)(string)) &Message::shortmsg,
-                "subject or short message")
-                .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,
-                (void(Message::*)(string)) &Message::longmsg_formatted,
-                "HTML body or fromatted long version of message")
-                .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,
-                (void(Message::*)(time_t)) &Message::sent,
-                "time when message was sent in UTC seconds since epoch")
-                .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,
-                (void(Message::*)(object)) &Message::from,
-                "identity where message is from")
-                .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,
-                (void(Message::*)(object)) &Message::recv_by,
-                "identity where message was received by")
-                .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,
-                (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,
-                (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,
-                (void(Message::*)(boost::python::list)) &Message::in_reply_to,
-                "in_reply_to list")
-                .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,
-                (void(Message::*)(boost::python::list)) &Message::keywords,
-                "keywords this message should be stored under")
-                .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,
-                (void(Message::*)(dict)) &Message::opt_fields,
-                "opt_fields of 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("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);
-
-//    auto user_interface_class = class_<UserInterface, UserInterface_callback, boost::noncopyable>(
-//            "UserInterface",
-//    "class MyUserInterface(UserInterface):\n"
-//    "   def notifyHandshake(self, me, partner):\n"
-//    "       ...\n"
-//    "\n"
-//    "p≡p User Interface class\n"
-//    "To be used as a mixin\n"
-//    )
-//        .def("notifyHandshake", &UserInterface::notifyHandshake,
-//    "notifyHandshake(self, me, partner)\n"
-//    "\n"
-//    "   me              own identity\n"
-//    "   partner         identity of communication partner\n"
-//    "\n"
-//    "overwrite this method with an implementation of a handshake dialog")
-//        .def("deliverHandshakeResult", &UserInterface::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("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
+    }
+
+    ::PEP_STATUS status = ::deliverHandshakeResult(Adapter::session(), (::sync_handshake_result)result, shared_identities);
+    free_identity_list(shared_identities);
+    _throw_status(status);
+}
+
+BOOST_PYTHON_MODULE (_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().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, 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.")
+
+        .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, "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, "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, (void (Identity::*)(string))&Identity::address, "email address or URI").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, (void (Identity::*)(string))&Identity::user_id, "ID of person associated or 'pEp_own_userId' if own identity")
+        .add_property("username", (string(Identity::*)())&Identity::username, (void (Identity::*)(string))&Identity::username, "name in full of person associated")
+        .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, (void (Identity::*)(string))&Identity::lang, "ISO 639-1 language code").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("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, (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").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::*)())(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, (void (Message::*)(string))&Message::id, "message ID").add_property("shortmsg", (string(Message::*)())&Message::shortmsg, (void (Message::*)(string))&Message::shortmsg, "subject or short message")
+        .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, (void (Message::*)(string))&Message::longmsg_formatted, "HTML body or fromatted long version of message")
+        .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, (void (Message::*)(time_t))&Message::sent, "time when message was sent in UTC seconds since epoch")
+        .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, (void (Message::*)(object))&Message::from, "identity where message is from")
+        .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, (void (Message::*)(object))&Message::recv_by, "identity where message was received by")
+        .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, (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, (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, (void (Message::*)(boost::python::list))&Message::in_reply_to, "in_reply_to list")
+        .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, (void (Message::*)(boost::python::list))&Message::keywords, "keywords this message should be stored under")
+        .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, (void (Message::*)(dict))&Message::opt_fields, "opt_fields of 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("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);
+
+    //    auto user_interface_class = class_<UserInterface, UserInterface_callback, boost::noncopyable>(
+    //            "UserInterface",
+    //    "class MyUserInterface(UserInterface):\n"
+    //    "   def notifyHandshake(self, me, partner):\n"
+    //    "       ...\n"
+    //    "\n"
+    //    "p≡p User Interface class\n"
+    //    "To be used as a mixin\n"
+    //    )
+    //        .def("notifyHandshake", &UserInterface::notifyHandshake,
+    //    "notifyHandshake(self, me, partner)\n"
+    //    "\n"
+    //    "   me              own identity\n"
+    //    "   partner         identity of communication partner\n"
+    //    "\n"
+    //    "overwrite this method with an implementation of a handshake dialog")
+    //        .def("deliverHandshakeResult", &UserInterface::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("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/_pEp/pEpmodule.hh b/src/pEp/_pEp/pEpmodule.hh
index 4739663..829eac1 100644
--- a/src/pEp/_pEp/pEpmodule.hh
+++ b/src/pEp/_pEp/pEpmodule.hh
@@ -11,25 +11,25 @@
 #include "message.hh"
 
 namespace pEp {
-    namespace PythonAdapter {
+namespace PythonAdapter {
 
-        extern string device_name;
+extern string device_name;
 
-        void config_passive_mode(bool enable);
+void config_passive_mode(bool enable);
 
-        void config_unencrypted_subject(bool enable);
+void config_unencrypted_subject(bool enable);
 
-        void key_reset_user(string user_id, string fpr);
+void key_reset_user(string user_id, string fpr);
 
-        void key_reset_all_own_keys();
+void key_reset_all_own_keys();
 
-        void _throw_status(::PEP_STATUS status);
+void _throw_status(::PEP_STATUS status);
 
-        ::PEP_STATUS _messageToSend(::message *msg);
+::PEP_STATUS _messageToSend(::message *msg);
 
-        ::PEP_STATUS notifyHandshake(::pEp_identity *me, ::pEp_identity *partner, ::sync_handshake_signal signal);
+::PEP_STATUS notifyHandshake(::pEp_identity *me, ::pEp_identity *partner, ::sync_handshake_signal signal);
 
-    } /* namespace PythonAdapter */
+} /* namespace PythonAdapter */
 } /* namespace pEp */
 
 #endif /* PEPMODULE_HH */
diff --git a/src/pEp/_pEp/str_attr.cc b/src/pEp/_pEp/str_attr.cc
index ddf4054..2092285 100644
--- a/src/pEp/_pEp/str_attr.cc
+++ b/src/pEp/_pEp/str_attr.cc
@@ -10,163 +10,170 @@
 #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__")();
+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);
         }
-
-        string repr(string s) {
-            str _s = s.c_str();
-            object _r = _s.attr("__repr__")();
-            string r = extract<string>(_r);
-            return r;
+        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 str_attr(char *&str) {
-            if (!str)
-                return string("");
-            return string(str);
-        }
+    free_stringlist(sl);
+    sl = _sl;
+}
 
-        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();
-        }
+dict strdict_attr(::stringpair_list_t *&spl) {
+    dict result;
 
-        time_t timestamp_attr(::timestamp *&ts) {
-            if (!ts)
-                return 0;
+    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);
 
-            return timegm(ts);
+            result[key] = value;
         }
+    }
 
-        void timestamp_attr(::timestamp *&ts, time_t value) {
-            free_timestamp(ts);
-            ts = ::new_timestamp(value);
-        }
+    return result;
+}
 
-        boost::python::list strlist_attr(::stringlist_t *&sl) {
-            boost::python::list result;
+void strdict_attr(::stringpair_list_t *&spl, dict value) {
+    ::stringpair_list_t *_spl = ::new_stringpair_list(NULL);
+    if (!_spl) {
+        throw bad_alloc();
+    }
 
-            for (::stringlist_t *_sl = sl; _sl && _sl->value; _sl = _sl->next) {
-                string s(_sl->value);
-                result.append(object(s));
-            }
+    ::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]);
 
-            return result;
+        if (!(extract_key.check() && extract_value.check())) {
+            free_stringpair_list(_spl);
         }
 
-        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;
+        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();
         }
-
-        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;
+        _s = stringpair_list_add(_s, pair);
+        if (!_s) {
+            free_stringpair_list(_spl);
+            throw bad_alloc();
         }
-
-        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;
+    }
+
+    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);
         }
-
-        ::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;
+        string s = extract_string();
+        _s = stringlist_add(_s, s.c_str());
+        if (!_s) {
+            free_stringlist(result);
+            throw bad_alloc();
         }
+    }
 
-        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;
-        }
+    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 PythonAdapter
 } // namespace pEp {
 
diff --git a/src/pEp/_pEp/str_attr.hh b/src/pEp/_pEp/str_attr.hh
index f9e7841..d5d4d0c 100644
--- a/src/pEp/_pEp/str_attr.hh
+++ b/src/pEp/_pEp/str_attr.hh
@@ -20,21 +20,27 @@ using boost::python::object;
 using boost::python::dict;
 
 object repr(object s);
+
 string repr(string s);
 
 string str_attr(char *&str);
+
 void str_attr(char *&str, string value);
 
 time_t timestamp_attr(::timestamp *&ts);
+
 void timestamp_attr(::timestamp *&ts, time_t value);
 
 boost::python::list strlist_attr(::stringlist_t *&sl);
+
 void strlist_attr(::stringlist_t *&sl, boost::python::list value);
 
 dict strdict_attr(::stringpair_list_t *&spl);
+
 void strdict_attr(::stringpair_list_t *&spl, dict value);
 
 ::stringlist_t *to_stringlist(boost::python::list l);
+
 boost::python::list from_stringlist(const ::stringlist_t *sl);
 
 } /* namespace PythonAdapter */
diff --git a/src/pEp/_pEp/user_interface.cc b/src/pEp/_pEp/user_interface.cc
index f11e6d2..76137f7 100644
--- a/src/pEp/_pEp/user_interface.cc
+++ b/src/pEp/_pEp/user_interface.cc
@@ -8,76 +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;
+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() {
+    //    ::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();
         }
 
-        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() {
-//    ::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)
+        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();
-
-                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);
+        } catch (exception &ex) {
             free_identity_list(shared_identities);
-            _throw_status(status);
+            throw ex;
         }
+    }
+
+    ::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)
 //{
@@ -113,11 +113,10 @@ namespace pEp {
 //    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/_pEp/user_interface.hh b/src/pEp/_pEp/user_interface.hh
index 0b3ac6f..975eb32 100644
--- a/src/pEp/_pEp/user_interface.hh
+++ b/src/pEp/_pEp/user_interface.hh
@@ -14,47 +14,39 @@
 // local
 #include "pEpmodule.hh"
 
-
 namespace pEp {
-    namespace PythonAdapter {
+namespace PythonAdapter {
 
-        class UserInterface {
-            static UserInterface *_ui;
-        public:
-            UserInterface();
+class UserInterface {
+    static UserInterface *_ui;
+  public:
+    UserInterface();
 
-            virtual ~UserInterface();
+    virtual ~UserInterface();
 
-            virtual void notifyHandshake(
-                    Identity me,
-                    Identity partner,
-                    sync_handshake_signal signal) {
-                throw runtime_error("override this method");
-            }
+    virtual void notifyHandshake(Identity me, Identity partner, sync_handshake_signal signal) {
+        throw runtime_error("override this method");
+    }
 
-            virtual void deliverHandshakeResult(int result, object identities);
+    virtual void deliverHandshakeResult(int result, object identities);
 
-//     PEP_rating get_key_rating_for_user(string user_id, string fpr);
+    //     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 */