C ++ और पायथन या राउंड ट्रिप के बीच अपवाद यात्रा

सी ++ और पायथन की दोस्ती की कहानी के इस अध्याय में, Boost.Python का आश्चर्यजनक रूप से बहुत कम उपयोग होगा। आगे और पीछे अपवादों को स्थानांतरित करना अनिवार्य रूप से इस पुस्तकालय का कमजोर बिंदु है। हम मूल पायथन एपीआई का प्रबंधन करेंगे, और जहां Boost.Python का उपयोग करना संभव है।
फिर भी, Boost.Python एक ऐसा वातावरण बनाता है जिसमें C ++ से अपवाद एक मानक RuntimeError के रूप में Python में आते हैं, और C ++ का अपवाद टाइप error_already_set Python से वापस उत्पन्न होता है, जिसका अर्थ है कि कुछ आ गया है, इसे स्वयं पढ़ें। " और यहां हमारे लिए यह सही है कि हम अपवाद के बारे में आवश्यक जानकारी को घटाएं और एप्लिकेशन तर्क के अनुसार उपयुक्त वर्ग में परिवर्तित करने के लिए पायथन भाषा के सी-एपीआई का उपयोग करें।
ऐसी मुश्किलें क्यों? - तथ्य यह है कि पायथन में, सी ++ के विपरीत, अपवाद पाठ और इसके प्रकार के अलावा, ट्रेसबैक भी आता है - अपवाद के स्थान पर स्टैक। चलो मानक std का विस्तार करें :: इस स्टैकट्रेस के लिए एक अतिरिक्त पैरामीटर के साथ थोड़ा सा अपवाद, और साथ ही हम C ++ कक्षाओं से पायथन अपवाद कक्षाओं के लिए एक अपवाद कनवर्टर आगे और पीछे लिखेंगे।

पिछली श्रृंखला में

1. बूस्ट.पायथॉन। परिचय। पायथन में सी ++ रैपर।
2. बूस्ट.पायथॉन। विशिष्ट C ++ कक्षाएं रैपिंग।
3. बूस्ट.पायथॉन। C ++ और पाइथन के बीच टाइप कन्वर्टर्स बनाना।

परिचय

मान लीजिए कि अपवादों का एक निश्चित पदानुक्रम है जिसे अपवाद को हैंडल करते समय आपको C ++ में संबंधित वर्ग के रूप में और पायथन में एक-एक-एक तरीके से प्रतिनिधित्व करने की आवश्यकता है। यह विशेष रूप से सच है यदि आप जटिल पायथन स्क्रिप्टिंग के साथ C ++ एप्लिकेशन के तर्क को जोड़ते हैं, या यदि आप जटिल तर्क के साथ C ++ में पायथन के लिए एक मॉड्यूल लिख रहे हैं। जल्दी या बाद में, हम अपवाद हैंडलिंग में चलते हैं जो पायथन में C ++ से आया या इसके विपरीत।

बेशक, ज्यादातर मामलों में, मानक ++ost.ython तंत्र एक अपवाद को C ++ से पायथन में एक RuntimeException के रूप में अपवाद के रूप में आने वाले पाठ के रूप में परिवर्तित करने के लिए होता है :: क्या () आपके लिए पर्याप्त होगा। C ++ की तरफ, आपको टाइप करें error_already_set के अपवाद को पकड़ने और देशी पायथन एपीआई का उपयोग करने की आवश्यकता है, लेकिन आप अपवाद के प्रकार और पाठ को न केवल घटा सकते हैं, बल्कि ट्रेसबैक भी कर सकते हैं - वास्तव में अपवाद का इतिहास।
लेकिन पहले बातें पहले।

पायथन में C ++ से एक छोटा अपवाद यात्रा

इसलिए, आपने Boost.Python का उपयोग करते हुए C ++ में एक मॉड्यूल लिखा, इसे नियमित आयात के माध्यम से पायथन कोड में जोड़ा , और फ़ंक्शन या विधियों में से एक के रैपर का उपयोग करें। मान लीजिए कि C ++ कोड में सबसे आम अपवाद समान रूप से नियमित रूप से फेंक दिया जाता है। पायथन कोड में, आपको अपवाद से प्राप्त पाठ के साथ एक RuntimeException मिलेगी: क्या () अगर यह अपवाद std :: अपवाद से फेंका गया है।
यदि आप संतुष्ट हैं कि आपको अपवाद पाठ के अलावा कुछ भी प्राप्त नहीं होगा, तो आप कुछ और भी कर सकते हैं। हालांकि, यदि आपको त्रुटियों की एक सख्ती से परिभाषित वर्ग के अपवाद को पकड़ने की आवश्यकता है, तो आपको थोड़ा काम करने की आवश्यकता होगी।

वास्तव में, Boost.Python, C ++ में लिखे गए देशी पेन को छोड़कर मॉड्यूल के अपवाद के अपने अनुवाद को पंजीकृत करने की क्षमता प्रदान करता है। आपको केवल यह करने की आवश्यकता है: मॉड्यूल घोषणा समारोह में, टेम्पलेट फ़ंक्शन बूस्ट को कॉल करें :: python :: register_exception_translator <T, F> (F), जहां C C ++ में अपवाद का प्रकार है, और F वह फ़ंक्शन है जो इस प्रकार के अपवाद का संदर्भ लेता है और कैसे इस तरह, पायथन में पहले से ही बाहरी कोड के लिए आवश्यक प्रकार के अपवाद को पारित करने के अपने कर्तव्य को पूरा करना। सामान्य तौर पर, कुछ इस तरह से:

class error : public exception { ... }; ... void translate_error( error const& ); ... BOOST_PYTHON_MODULE( ... ) { ... register_exception_translator<error>( translate_error ); } ... void translate_error( error const& e ) { PyErr_SetString( PyExc_Exception, e.what() ); } 

यहाँ हमने पायथन में निर्मित प्रकार अपवाद के एक मानक अपवाद का उपयोग किया है, लेकिन आप बिल्कुल किसी भी अपवाद का उपयोग कर सकते हैं: PyObject * को ऑब्जेक्ट के माध्यम से आयात करने के लिए आयात के माध्यम से जुड़ा एक मानक , बाहरी :: ptr () या यहां तक ​​कि आपका स्वयं का बनाया हुआ PyErr_NewException के स्थान पर।

पूर्णता की खातिर, आइए कुछ और वर्ग जोड़ते हैं जिन्हें ZeroDivisionError और ValueError के एनालॉग के रूप में दिया जाएगा और पूर्ण खुशी के लिए हम उन्हें क्रमशः अपनी त्रुटि से विरासत में प्राप्त करेंगे, उन्हें क्रमशः शून्य_डिवीज़न -रियर और value_error कहेंगे:

 class error : public exception { public: error(); error( string const& message ); error( string const& message, string const& details ); virtual const char* what() const; virtual string const& get_message() const; virtual string const& get_details() const; virtual const char* type() const; private: string m_message; string m_details; }; class value_error : public error { public: value_error(); value_error( string const& message ); value_error( string const& message, string const& details ); virtual const char* type() const; }; class zero_division_error : public error { public: zero_division_error(); zero_division_error( string const& message ); zero_division_error( string const& message, string const& details ); virtual const char* type() const; }; 

उदाहरण के लिए ट्रेसबैक सहेजने के लिए हमें Python से C ++ के रास्ते में m_details फ़ील्ड की आवश्यकता होगी। और थोड़ी देर बाद डिबगिंग के लिए प्रकार () विधि की आवश्यकता होगी। सरल और स्पष्ट पदानुक्रम।

चलो हमारे अपवादों के लिए पायथन में अनुवादक कार्यों को पंजीकृत करें:

 void translate_error( error const& ); void translate_value_error( value_error const& ); void translate_zero_division_error( zero_division_error const& ); ... BOOST_PYTHON_MODULE( ... ) { ... register_exception_translator<error>( translate_error ); register_exception_translator<value_error>( translate_value_error ); register_exception_translator<zero_division_error>( translate_zero_division_error ); } ... void translate_error( error const& e ) { PyErr_SetString( PyExc_Exception, e.what() ); } void translate_value_error( value_error const& e ) { PyErr_SetString( PyExc_ValueError, e.what() ); } void translate_zero_division_error( zero_division_error const& e ) { PyErr_SetString( PyExc_ZeroDivisionError, e.what() ); } 

खैर, जो कुछ भी है वह C ++ की ओर से परीक्षण कार्यों को प्राप्त करने के लिए है, जो इन अपवादों को फेंक देंगे:

 double divide( double a, double b ) { if( abs( b ) < numeric_limits<double>::epsilon() ) throw zero_division_error(); return a / b; } double to_num( const char* val ) { double res; if( !val || !sscanf( val, "%LG", &res ) ) throw value_error(); return res; } void test( bool val ) { if( !val ) throw error( "Test failure.", "test" ); } 

क्यों नहीं, ये फ़ंक्शन किसी भी अन्य की तुलना में बदतर नहीं हैं और ठीक उसी तरह फेंकते हैं जो हमें चाहिए।
उन्हें लपेटें:

 ... BOOST_PYTHON_MODULE( python_module ) { register_exception_translator<error>( translate_error ); register_exception_translator<value_error>( translate_value_error ); register_exception_translator<zero_division_error>( translate_zero_division_error ); def( "divide", divide, args( "a", "b" ) ); def( "to_num", to_num, args( "val" ) ); def( "test", test, args( "val" ) ); } ... 

खैर, हम अपने मॉड्यूल का निर्माण करते हैं, आयात python_module निष्पादित करते हैं , आवश्यक मापदंडों के साथ अपने कार्यों को कॉल करते हैं, हमें आवश्यक अपवाद मिलते हैं (पायथन 3.x स्क्रिप्ट):

 import python_module as pm try: res = pm.divide( 1, 0 ) except ZeroDivisionError: print( "ZeroDivisionError - OK" ) except Exception as e: print( "Expected ZeroDivisionError, but exception of type '{t}' with text: '{e}'".format(t=type(e),e=e) ) else: print( "Expected ZeroDivisionError, but no exception raised! Result: {r}".format(r=res) ) try: res = pm.to_num( 'qwe' ) except ValueError: print( "ValueError - OK" ) except Exception as e: print( "Expected ValueError, but exception of type '{t}' with text: '{e}'".format(t=type(e),e=e) ) else: print( "Expected ValueError, but no exception raised! Result: {r}".format(r=res) ) try: res = pm.test( False ) except Exception as e: if type(e) is Exception: print( "Exception - OK" ) else: print( "Exception of type '{t}', expected type 'Exception', message: '{e}'".format(t=type(e),e=e) ) else: print( "Expected Exception, but no exception raised! Result: {r}".format(r=res) ) 

स्क्रिप्ट आउटपुट:
ZeroDivisionError - ठीक है
ValueError - ठीक है
अपवाद - ठीक है
अभी तक तो अच्छा है। विपरीत दिशा में चलते हैं।

पायथन से सी ++ के रास्ते हमारे अपवाद का रोमांच

आइए एक अलग परियोजना में अपवादों और परीक्षण कार्यों के प्रकारों का चयन करें, और हम उनके साथ एक अलग गतिशील रूप से जुड़े error_types लाइब्रेरी को इकट्ठा करेंगे। हम अजगर के लिए मॉड्यूल का निर्माण अलग से python_module प्रोजेक्ट में करेंगे।
अब चलो C ++ एप्लिकेशन प्राप्त करते हैं जहां हम पायथन से अपवादों को पकड़ेंगे , इसे catch_exception कहते हैं।
जरूरत है कि हमारे मॉड्यूल को आयात ("python_module") के माध्यम से कनेक्ट करना है, फिर attr ("divide"), attr ("to_num"), attr ("परीक्षण") के माध्यम से मॉड्यूल फ़ंक्शन तक पहुंचें। हम उन्हें कॉल करेंगे, वे C ++ कोड स्तर पर अपवादों को उठाएंगे, पायथन इंटरप्रेटर में जाएंगे और फिर C ++ एप्लिकेशन में फॉरवर्ड करेंगे, error_already_set अपवाद को फेंकते हुए - Boost.Python लाइब्रेरी अपवाद केवल ऐसे मामलों के लिए तैयार किया गया था।

प्रकार error_already_set का एक ऑब्जेक्ट, केवल अपवाद को पकड़ना महत्वपूर्ण है। सामान्य तौर पर, इस तरह के अपवाद को संभालना इस तरह दिखता है:

 catch( error_already_set const& ) { PyObject *exc, *val, *tb; PyErr_Fetch( &exc, &val, &tb ); PyErr_NormalizeException( &exc, &val, &tb ); handle<> hexc(exc), hval( allow_null( val ) ), htb( allow_null( tb ) ); throw error( extract<string>( !hval ? str( hexc ) : str( hval ) ) ); } 

इसलिए हमें हमेशा एक ही प्रकार का अपवाद मिलता है, लेकिन कम से कम हम अपवाद का पाठ निकाल सकते हैं। लेकिन हमें exc वैरिएबल में अपवाद का प्रकार मिलता है, अपवाद ऑब्जेक्ट वैल वैरिएबल में भी होता है, और यहां तक ​​कि ऑब्जेक्ट tb वेरिएबल में अपवाद के स्टैक के साथ भी होता है। यदि जीरो डिविज़न एअरर या वैल्यूअरर क्रमशः आते हैं, तो शून्य_डिविज़न_रोर और वेल्यू_रोर को होने वाले अपवाद को परिवर्तित करते हैं।

इसे रोको! हर कोई यह नहीं समझता है कि ये दो कार्य क्या हैं, क्यों सब कुछ PyObject * है, C-API में अपवाद कहां हैं यदि C में कोई नहीं हैं, तो अधिक जानकारी दें।
हां, शुद्ध सी में कोई अपवाद नहीं हैं, लेकिन पायथन में वे हैं और इसका एपीआई अपवाद के बारे में जानकारी खींचने की क्षमता प्रदान करता है। पायथन सी-एपीआई में, सभी मान और प्रकार, और सामान्य रूप से लगभग सब कुछ, को PyObject * के रूप में दर्शाया जाता है, इसलिए टाइप T का एक अपवाद E प्रकार PyObject * के मूल्यों की एक जोड़ी है, हम PyObject * को ट्रेसबैक सेव स्टैक में भी जोड़ते हैं जहां अपवाद हुआ। ।
PyErr_Fetch उस अपवाद के बारे में जानकारी प्राप्त कर सकता है जो हुआ, जिसके बाद अपवाद जानकारी को सामान्य किया जा सकता है (यदि आप आंतरिक टपल प्रतिनिधित्व में काम नहीं करना चाहते हैं) PyErr_NormalizeException के साथ।
इन कार्यों के एक जोड़े को कॉल करने के बाद, हम क्रमशः PyObject * प्रकार के तीन मूल्यों को भर देंगे: अपवाद का अपवाद वर्ग, उदाहरण (ऑब्जेक्ट) और स्टैक (ट्रेसबैक) को उस समय बचाया गया जब अपवाद फेंक दिया गया था।

इसके अलावा, Boost.Python के साथ काम करना बहुत अधिक सुविधाजनक है। हम PyObject * को बढ़ावा देने में :: python :: हैंडल <> को लपेटते हैं, जो Boost.Python लाइब्रेरी के किसी भी ऑब्जेक्ट के साथ संगत है, हमें बस python :: str को बढ़ावा देने की आवश्यकता है। Boost.Python में एक एनालॉग अजगर स्ट्रिंग में बदलने के बाद, हम C ++ भाषा के मानक देशी स्ट्रिंग std :: string को बढ़ा सकते हैं। यदि वांछित है, तो आप सामान्य कास्ट चार * का विस्तार कर सकते हैं।

पहले दो मापदंडों के साथ, सबकुछ स्पष्ट है, वे पूरी तरह से स्ट्रिंग के लिए reducible हैं, लेकिन ट्रेसबैक के साथ आपको अभी भी एक पठनीय रूप में बदलना होगा। ट्रेसबैक मॉड्यूल के साथ ऐसा करने का सबसे आसान तरीका है, हमारे तीन मापदंडों को format_exception फ़ंक्शन से गुजरना । ट्रेसबैक.फॉर्मट_एक्ससेप्शन (एक्‍स, वैल, टीबी) फ़ंक्शन हमें मानक पायथन भाषा सूची के रूप में स्ट्रिंग की एक सरणी लौटाएगा, जो उल्लेखनीय रूप से एक बड़ी मोटी स्ट्रिंग में मिलती है।
C ++ की तरफ, Boost.Python का उपयोग करते हुए, यह कुछ इस तरह दिखेगा:

  ... format_exception = import( "traceback" ).attr( "format_exception" ); return extract<string>( str( "" ).join( format_exception( exc, val, tb ) ) ); } 

आप एक अपवाद से एक स्ट्रिंग उत्पन्न करने के लिए एक सहायक कार्य कर सकते हैं। हालाँकि, समस्या यह है कि किसी फ़ंक्शन में कॉलिंग आयात () हर बार एक महंगी कॉल का कारण बनेगी, इसलिए आयात से प्राप्त ऑब्जेक्ट ("ट्रेसबैक") .attr ("format_exception") एक अलग ऑब्जेक्ट में फ़ंक्शन के परिणाम को बचाने के लिए सबसे अच्छा है, हमें भी बचाने की आवश्यकता है। आयात परिणाम ("python_module")। यह देखते हुए कि इसे Py_Initialize () और Py_Finalize () के बीच कहीं और करने की आवश्यकता होगी, फिर ऐसे वैरिएबल को स्टोर करने के लिए सिंगलटन फील्ड से बेहतर कुछ नहीं होगा।

सिंगलटन के माध्यम से पायथन एपीआई के साथ काम करें

तो, चलो एक सिंगलटन प्राप्त करते हैं, यह एप्लिकेशन को जटिल करेगा, लेकिन यह कोड को थोड़ा सरल करेगा और आपको दुभाषिया के साथ काम को सही ढंग से शुरू करने की अनुमति देगा, सभी सहायक वस्तुओं को बचाएगा और सब कुछ सही ढंग से पूरा करेगा:

 class python_interpreter { public: static double divide( double, double ); static double to_num( string const& ); static void test( bool ); static string format_error( handle<> const&, handle<> const&, handle<> const& ); private: object m_python_module; object m_format_exception; python_interpreter(); ~python_interpreter(); static python_interpreter& instance(); object& python_module(); string format_error( object const&, object const&, object const& ); }; 

कंस्ट्रक्टर इंटरप्रेटर के साथ काम को इनिशियलाइज़ करेगा, और डिस्ट्रक्टर स्टोर किए गए फ़ील्ड्स को साफ़ करेगा और इंटरप्रेटर के साथ काम को डी-इनिशियलाइज़ करेगा, python_module और format_error विधियाँ एक ही बार संबंधित मॉड्यूल्स को इम्पोर्ट करती हैं:

 python_interpreter::python_interpreter() { Py_Initialize(); } python_interpreter::~python_interpreter() { m_python_module = object(); m_format_exception = object(); Py_Finalize(); } double python_interpreter::divide( double a, double b ) { return extract<double>( instance().python_module().attr("divide")( a, b ) ); } double python_interpreter::to_num( string const& val ) { return extract<double>( instance().python_module().attr("to_num")( val ) ); } void python_interpreter::test( bool val ) { instance().python_module().attr("test")( val ); } string python_interpreter::format_error( handle<> const& exc, handle<> const& msg, handle<> const& tb ) { return instance().format_error( object(exc), object(msg), object(tb) ); } python_interpreter& python_interpreter::instance() { static python_interpreter single; return single; } object& python_interpreter::python_module() { if( m_python_module.is_none() ) m_python_module = import( "python_module" ); return m_python_module; } string python_interpreter::format_error( object const& exc, object const& val, object const& tb ) { if( m_format_exception.is_none() ) m_format_exception = import( "traceback" ).attr( "format_exception" ); return extract<string>( str( "" ).join( m_format_exception( exc, val, tb ) ) ); } 

कुल मिलाकर, हमें किसी भी C ++ एप्लिकेशन के लिए एक तैयार-निर्मित तंत्र लागू है जो पुस्तकालयों के एक समूह के साथ शक्तिशाली सहायक कार्यक्षमता के रूप में पायथन का उपयोग करता है।
यह हमारे अपवाद तंत्र की जांच करने का समय है!

पायथन से C ++ में अपवादों के अनुवाद के लिए तंत्र का परीक्षण

आइए एक सहायक कार्य करें:

 void rethrow_python_exception() { PyObject *exc, *val, *tb; PyErr_Fetch( &exc, &val, &tb ); PyErr_NormalizeException( &exc, &val, &tb ); handle<> hexc(exc), hval( allow_null( val ) ), htb( allow_null( tb ) ); string message, details; message = extract<string>( !hval ? str( hexc ) : str( hval ) ); details = !tb ? extract<string>( str( hexc ) ) : python_interpreter::format_error( hexc, hval, htb ); if( PyObject_IsSubclass( exc, PyExc_ZeroDivisionError ) ) throw zero_division_error( message, details ); else if( PyObject_IsSubclass( exc, PyExc_ValueError ) ) throw value_error( message, details ); else throw error( message, details ); } 

फिर प्रत्येक परीक्षण विधि के लिए अपवाद हैंडलिंग तंत्र निम्न स्कीम में घटाया जाता है, जैसे विभाजन के लिए:

  try { try { python_interpreter::divide( 1, 0 ); } catch( error_already_set const& ) { rethrow_python_exception(); } } catch( error const& e ) { output_error( e ); } 

यहाँ output_error सबसे सरल कार्य है जो अपवाद के बारे में जानकारी प्रदर्शित करता है, उदाहरण के लिए इस तरह:

 void output_error( error const& e ) { cerr << "\nError type: " << e.type() << "\nMessage: " << e.get_message() << "\nDetails: " << e.get_details() << endl; } 

यहां, वर्चुअल विधि प्रकार (), जिसे हमने बेस क्लास त्रुटि में पेश किया था, काम में आया।

हम to_num और परीक्षण के लिए समान अनुभाग बनाते हैं, और यह भी जांचते हैं कि क्या आता है यदि हम निष्पादन के माध्यम से पायथन में "1/0" लाइन निष्पादित करते हैं:

  try { try { exec( "1 / 0" ); } catch( error_already_set const& ) { rethrow_python_exception(); } } catch( error const& e ) { output_error( e ); } 

लॉन्च हो रहा है ...
आउटपुट कुछ इस तरह होना चाहिए:

त्रुटि प्रकार: zero_division_error
संदेश: शून्य से विभाजन!
विवरण: <वर्ग 'ZeroDivisionError'>

त्रुटि प्रकार: value_error
संदेश: अनुचित मूल्य!
विवरण: <वर्ग 'ValueError'>

त्रुटि प्रकार: त्रुटि
संदेश: परीक्षण विफलता।
विवरण: <वर्ग 'अपवाद'>

त्रुटि प्रकार: zero_division_error
संदेश: शून्य से विभाजन
विवरण: ट्रेसबैक (सबसे हालिया कॉल अंतिम):
ZeroDivisionError में फाइल "", लाइन 1, शून्य से विभाजन

उपसंहार

कुल: हमें पायथन से सी ++ और इसके विपरीत अपवाद के लिए एक-से-एक रूपांतरण तंत्र मिला।
माइनस तुरंत ध्यान देने योग्य है - ये अलग-अलग संस्थाएं हैं जो एक दूसरे से बिल्कुल असंबंधित हैं। इसका कारण यह है कि C ++ क्लास को पायथन से एक क्लास से विरासत में नहीं लिया जा सकता है, न ही इसके आसपास कोई दूसरा रास्ता हो सकता है। पायथन के लिए C ++ वर्ग के रैपर में वांछित अपवाद वर्ग को "एनकैप्सुलेट" करने का एक विकल्प है, लेकिन यह अभी भी अलग-अलग वर्ग होंगे जो बस अपनी भाषा में संबंधित लोगों में परिवर्तित होते हैं।
यदि आपके पास C ++ में अपवादों का एक जटिल पदानुक्रम है, तो सबसे आसान तरीका एक अलग .py मॉड्यूल में Pythr में एक एनालॉग प्राप्त करना है, क्योंकि PyErr_NewException के माध्यम से बनाना और फिर इसे कहीं पर संग्रहीत करना बहुत महंगा है और कोड में पठनीयता नहीं जोड़ेगा।
मैं आपके बारे में नहीं जानता, लेकिन जब Boost.Python को अपवादों का एक अच्छा अनुवादक मिलता है, या कम से कम एक बढ़ावा देने का इंतजार करता हूं, तो मुझे बहुत खुशी होती है :: अजगर :: पायथन वर्ग से एक रैपर को विरासत में पाने के लिए आधार। सामान्य तौर पर, Boost.Python एक उत्कृष्ट पुस्तकालय है, लेकिन C ++ की ओर से पायथन के अपवादों को पार्स करते समय यह पहलू रक्तस्रावी जोड़ देता है। अनुवाद समारोह के रजिस्टर के माध्यम से पायथन में अनुवाद register_exception_translator <E, F> (F) काफी सफल दिखता है और आपको C ++ में टाइप ए के अपवाद को पायथन पक्ष पर पूरी तरह से अलग वर्ग बी में परिवर्तित करने की अनुमति देता है, लेकिन कम से कम स्वचालित रूप से।
सिद्धांत रूप में, यह वर्णित करने के लिए आवश्यक नहीं है error_already_set जैसा कि ऊपर वर्णित है, आप पायथन से अपवादों को संभालने के लिए पायथन एपीआई का उपयोग करके अपने आवेदन के व्यवहार के लिए अपना नुस्खा चुन सकते हैं।

परियोजना का लिंक यहां (~ 223 KB) है । MSVS v11 प्रोजेक्ट बूस्ट 1.52 और पायथन 3.3 x64 के साथ बनाने के लिए कॉन्फ़िगर किया गया है।

उपयोगी लिंक

पिविकी - सी ++ अपवाद फेंकना
पायथन सी-एपीआई अपवाद हैंडलिंग
पायथन में सी ++ अपवाद अनुवादक को पंजीकृत करें