simplify result checking and error handling

GUI/View/Project/PyImportAssistant.cpp

@@ -103,21 +103,13 @@ QString readFile(const QString& fileName)
 std::unique_ptr<MultiLayer> code2sample(const QString& snippet, const QString& funcName)
 {
     QApplication::setOverrideCursor(Qt::WaitCursor);
-    void* result_ptr = nullptr;
-    PyObjectPtr result{PyInterpreter::createMultiLayerFromPython(
-        result_ptr, snippet.toStdString(), funcName.toStdString(), bornagainDir())};
 
-    std::unique_ptr<MultiLayer> multilayer_ptr(reinterpret_cast<MultiLayer*>(result_ptr)->clone());
-
-    if (!result.valid()) {
-        QApplication::restoreOverrideCursor();
-        QString message("Exception thrown while executing Python code to create sample.\n\n");
-        DetailedMessageBox(GUI::Global::mainWindow, "Python failure", message, "").exec();
-    }
+    void* result_ptr = PyInterpreter::createMultiLayerFromPython(
+        snippet.toStdString(), funcName.toStdString(), bornagainDir());
 
     QApplication::restoreOverrideCursor();
 
-    return multilayer_ptr;
+    return std::unique_ptr<MultiLayer>{reinterpret_cast<MultiLayer*>(result_ptr)->clone()};
 }
 
 //! Lets user select a function name which generates a MultiLayer.

PyCore/Embed/PyInterpreter.cpp

@@ -31,8 +31,8 @@ References:
 #include "PyCore/Embed/PyCore.h"
 #undef INCLUDE_NUMPY
 
-#include "PyCore/Embed/PyInterpreter.h"
 #include "Base/Util/Assert.h"
+#include "PyCore/Embed/PyInterpreter.h"
 #include <cstddef>   // NULL
 #include <cstring>   // memcpy
 #include <iostream>  // cerr
@@ -181,7 +181,7 @@ PyObjectPtr PyInterpreter::import(const std::string& pymodule_name, const std::s
 
     PyInterpreter::Numpy::initialize();
 
-    if(!path.empty())
+    if (!path.empty())
         addPythonPath(path);
 
     // import the module
@@ -582,7 +582,7 @@ double* PyInterpreter::Numpy::getDataPtr(PyObject* pyobject_ptr)
 
 PyObjectPtr PyInterpreter::BornAgain::import(const std::string& path)
 {
-    if(!path.empty())
+    if (!path.empty())
         PyInterpreter::addPythonPath(path);
 
 #ifndef _WIN32

PyCore/Sample/ImportMultiLayer.cpp

@@ -24,8 +24,8 @@
 
 namespace PyInterpreter {
 
-PyObjectPtr createMultiLayerFromPython(void*& multilayer_ptr, const std::string& script,
-                                       const std::string& functionName, const std::string& path)
+void* createMultiLayerFromPython(const std::string& script, const std::string& functionName,
+                                 const std::string& path)
 {
     PyObjectPtr tmpModule{PyInterpreter::BornAgain::importScript(script, path)};
 
@@ -37,32 +37,29 @@ PyObjectPtr createMultiLayerFromPython(void*& multilayer_ptr, const std::string&
                                                   + functionName + "'"));
 
     // create a `MultiLayer` Python object via calling the function
-    PyObject* instance = PyObject_CallFunctionObjArgs(pAddFn, NULL);
+    PyObject* ret1 = PyObject_CallFunctionObjArgs(pAddFn, NULL);
 
     // clean up
     Py_DecRef(pAddFn);
 
-    if (!instance)
-        throw std::runtime_error(errorDescription(
-            "PyInterpreter::BornAgain: Cannot call the function '" + functionName + "'"));
+    if (!ret1)
+        throw std::runtime_error(
+            errorDescription("Failed execting Python function '" + functionName + "'"));
 
-    // Construct a C++ object from the Python object
-    /* NOTE:
-       This conversion requires a SWIG-produced Python API.
-     */
+    // Construct a C++ object from the Python object.
+    // This conversion requires a SWIG-produced Python API.
 
     void* argp1 = 0;
     swig_type_info* pTypeInfo = SWIG_TypeQuery("MultiLayer *");
 
-    const int res = SWIG_ConvertPtr(instance, &argp1, pTypeInfo, 0);
+    const int res = SWIG_ConvertPtr(ret1, &argp1, pTypeInfo, 0);
     if (!SWIG_IsOK(res)) {
-        Py_DecRef(instance);
+        Py_DecRef(ret1);
         throw std::runtime_error(
-            errorDescription("Call of '" + functionName + "' did not yield MultiLayer instance"));
+            errorDescription("Function " + functionName + " did not yield MultiLayer instance"));
     }
 
-    multilayer_ptr = reinterpret_cast<void*>(argp1);
-    return {instance};
+    return reinterpret_cast<void*>(argp1);
 }
 
 } // namespace PyInterpreter

PyCore/Sample/ImportMultiLayer.h

@@ -32,9 +32,8 @@ namespace PyInterpreter {
 // `MultiLayer` instance in C++ (memory should be managed by the caller).
 //! The returned value is the PyObject corresponding the intermediate _Python_ instance of
 //! of the `MultiLayer` class.
-PyObjectPtr createMultiLayerFromPython(void*& multilayer_ptr, const std::string& script,
-                                       const std::string& functionName,
-                                       const std::string& path = "");
+void* createMultiLayerFromPython(const std::string& script, const std::string& functionName,
+                                 const std::string& path = "");
 
 } // namespace PyInterpreter