AlgorithmAdapter.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
#include "MantidPythonInterface/api/PythonAlgorithm/AlgorithmAdapter.h"
#include "MantidAPI/DataProcessorAlgorithm.h"
#include "MantidKernel/WarningSuppressions.h"
#include "MantidPythonInterface/core/CallMethod.h"
#include "MantidPythonInterface/core/Converters/PySequenceToVector.h"
#include "MantidPythonInterface/core/GlobalInterpreterLock.h"
#include "MantidPythonInterface/core/WrapperHelpers.h"
#include "MantidPythonInterface/kernel/Registry/PropertyWithValueFactory.h"
 
#include <boost/python/class.hpp>
#include <boost/python/dict.hpp>
 
namespace {
auto PYALG_STRUCTURE_DOCS = "https://docs.mantidproject.org/tutorials/extending_mantid_with_python/"
                            "python_algorithms/01_basic_algorithm_structure.html#basic-algorithm-structure";
}
 
//-----------------------------------------------------------------------------
// AlgorithmAdapter definition
//-----------------------------------------------------------------------------
namespace Mantid::PythonInterface {
using namespace boost::python;
 
template <typename BaseAlgorithm>
AlgorithmAdapter<BaseAlgorithm>::AlgorithmAdapter(PyObject *self)
    : BaseAlgorithm(), m_self(self), m_isRunningObj(nullptr), m_wikiSummary("") {
  // Only cache the isRunning attribute if it is overridden by the
  // inheriting type otherwise we end up with an infinite recursive call
  // as isRunning always exists from the interface
  if (typeHasAttribute(self, "isRunning"))
    m_isRunningObj = PyObject_GetAttrString(self, "isRunning");
}
 
template <typename BaseAlgorithm> const std::string AlgorithmAdapter<BaseAlgorithm>::name() const {
  return std::string(getSelf()->ob_type->tp_name);
}
 
template <typename BaseAlgorithm> int AlgorithmAdapter<BaseAlgorithm>::version() const {
  try {
    return callMethod<int>(getSelf(), "version");
  } catch (UndefinedAttributeError &) {
    return 1;
  }
}
 
template <typename BaseAlgorithm> bool AlgorithmAdapter<BaseAlgorithm>::checkGroups() {
  try {
    return callMethod<bool>(getSelf(), "checkGroups");
  } catch (UndefinedAttributeError &) {
    return BaseAlgorithm::checkGroups();
  }
}
 
template <typename BaseAlgorithm> const std::string AlgorithmAdapter<BaseAlgorithm>::category() const {
  const static std::string defaultCategory = "PythonAlgorithms";
  std::string category = defaultCategory;
  try {
    category = callMethod<std::string>(getSelf(), "category");
  } catch (UndefinedAttributeError &) {
  }
  if (category == defaultCategory) {
    // output a warning
    this->getLogger().warning() << "Python Algorithm " << this->name() << " v" << this->version()
                                << " does not have a category defined. See " << PYALG_STRUCTURE_DOCS << "\n";
  }
  return category;
}
 
template <typename BaseAlgorithm> const std::vector<std::string> AlgorithmAdapter<BaseAlgorithm>::seeAlso() const {
  try {
    // The GIL is required so that the reference count of the
    // list object can be decremented safely
    GlobalInterpreterLock gil;
    return Converters::PySequenceToVector<std::string>(callMethod<list>(getSelf(), "seeAlso"))();
  } catch (UndefinedAttributeError &) {
    return {};
  }
}
 
template <typename BaseAlgorithm> const std::string AlgorithmAdapter<BaseAlgorithm>::alias() const {
  try {
    return callMethod<std::string>(getSelf(), "alias");
  } catch (UndefinedAttributeError &) {
    return BaseAlgorithm::alias();
  }
}
 
template <typename BaseAlgorithm> const std::string AlgorithmAdapter<BaseAlgorithm>::aliasDeprecated() const {
  try {
    return callMethod<std::string>(getSelf(), "aliasDeprecated");
  } catch (UndefinedAttributeError &) {
    return BaseAlgorithm::aliasDeprecated();
  }
}
 
template <typename BaseAlgorithm> const std::string AlgorithmAdapter<BaseAlgorithm>::summary() const {
  try {
    return callMethod<std::string>(getSelf(), "summary");
  } catch (UndefinedAttributeError &) {
    return m_wikiSummary;
  }
}
 
template <typename BaseAlgorithm> const std::string AlgorithmAdapter<BaseAlgorithm>::helpURL() const {
  try {
    return callMethod<std::string>(getSelf(), "helpURL");
  } catch (UndefinedAttributeError &) {
    return std::string();
  }
}
 
template <typename BaseAlgorithm> bool AlgorithmAdapter<BaseAlgorithm>::isRunning() const {
  if (!m_isRunningObj) {
    return SuperClass::isRunning();
  } else {
    GlobalInterpreterLock gil;
 
    GNU_DIAG_OFF("parentheses-equality")
    PyObject *result = PyObject_CallObject(m_isRunningObj, nullptr);
    if (PyErr_Occurred())
      throw PythonException();
    if (PyBool_Check(result)) {
      return static_cast<bool>(PyLong_AsLong(result));
    } else
      throw std::runtime_error("Algorithm.isRunning - Expected bool return type.");
  }
  GNU_DIAG_ON("parentheses-equality")
}
 
template <typename BaseAlgorithm> void AlgorithmAdapter<BaseAlgorithm>::cancel() {
  try {
    return callMethod<void>(getSelf(), "cancel");
  } catch (UndefinedAttributeError &) {
    SuperClass::cancel();
  }
}
 
template <typename BaseAlgorithm> std::map<std::string, std::string> AlgorithmAdapter<BaseAlgorithm>::validateInputs() {
  using boost::python::dict;
  std::map<std::string, std::string> resultMap;
 
  try {
    GlobalInterpreterLock gil;
    dict resultDict = callMethod<dict>(getSelf(), "validateInputs");
    // convert to a map<string,string>
    boost::python::list keys = resultDict.keys();
    size_t numItems = boost::python::len(keys);
    for (size_t i = 0; i < numItems; ++i) {
      boost::python::object key = keys[i];
      boost::python::object value = resultDict[key];
      if (value) {
        try {
          std::string keyAsString = boost::python::extract<std::string>(key);
          std::string valueAsString = boost::python::extract<std::string>(value);
          resultMap[std::move(keyAsString)] = std::move(valueAsString);
        } catch (boost::python::error_already_set &) {
          this->getLogger().error() << "In validateInputs(self): Invalid type for key/value pair "
                                    << "detected in dict.\n"
                                    << "All keys and values must be strings\n";
        }
      }
    }
  } catch (UndefinedAttributeError &) {
    return resultMap;
  }
 
  return resultMap;
}
 
template <typename BaseAlgorithm> void AlgorithmAdapter<BaseAlgorithm>::setWikiSummary(const std::string &summary) {
  std::string msg = "self.setWikiSummary() is deprecated and will be removed in a future "
                    "release.\n"
                    "To ensure continued functionality remove the line containing "
                    "'self.setWikiSummary'\n"
                    "and add a new function outside of the current one defined like so:\n"
                    "def summary(self):\n"
                    "    \"" +
                    summary + "\"\n";
 
  PyErr_Warn(PyExc_DeprecationWarning, msg.c_str());
  m_wikiSummary = summary;
}
 
template <typename BaseAlgorithm>
void AlgorithmAdapter<BaseAlgorithm>::declarePyAlgProperty(boost::python::object &self, Kernel::Property *prop,
                                                           const std::string &doc) {
  BaseAlgorithm &caller = extract<BaseAlgorithm &>(self);
  // We need to clone the property so that python doesn't own the object that
  // gets inserted
  // into the manager
  caller.declareProperty(std::unique_ptr<Kernel::Property>(prop->clone()), doc);
}
 
template <typename BaseAlgorithm>
void AlgorithmAdapter<BaseAlgorithm>::declarePyAlgProperty(boost::python::object &self, const std::string &name,
                                                           const boost::python::object &defaultValue,
                                                           const boost::python::object &validator,
                                                           const std::string &doc, const int direction) {
  BaseAlgorithm &caller = extract<BaseAlgorithm &>(self);
  auto prop = std::unique_ptr<Kernel::Property>(
      Registry::PropertyWithValueFactory::create(name, defaultValue, validator, direction));
  caller.declareProperty(std::move(prop), doc);
}
 
template <typename BaseAlgorithm>
void AlgorithmAdapter<BaseAlgorithm>::declarePyAlgProperty(boost::python::object &self, const std::string &name,
                                                           const boost::python::object &defaultValue,
                                                           const std::string &doc, const int direction) {
  BaseAlgorithm &caller = extract<BaseAlgorithm &>(self);
  auto prop =
      std::unique_ptr<Kernel::Property>(Registry::PropertyWithValueFactory::create(name, defaultValue, direction));
  caller.declareProperty(std::move(prop), doc);
}
 
template <typename BaseAlgorithm>
void AlgorithmAdapter<BaseAlgorithm>::declarePyAlgProperty(boost::python::object &self, const std::string &name,
                                                           const boost::python::object &defaultValue,
                                                           const int direction) {
  declarePyAlgProperty(self, name, defaultValue, "", direction);
}
 
template <typename BaseAlgorithm>
void AlgorithmAdapter<BaseAlgorithm>::declareOrReplacePyAlgProperty(boost::python::object &self,
                                                                    const std::string &name,
                                                                    const boost::python::object &defaultValue,
                                                                    const boost::python::object &validator,
                                                                    const std::string &doc, const int direction) {
  BaseAlgorithm &caller = extract<BaseAlgorithm &>(self);
  auto prop = std::unique_ptr<Kernel::Property>(
      Registry::PropertyWithValueFactory::create(name, defaultValue, validator, direction));
  caller.declareOrReplaceProperty(std::move(prop), doc);
}
 
//---------------------------------------------------------------------------------------------
// Private members
//---------------------------------------------------------------------------------------------
 
template <typename BaseAlgorithm> void AlgorithmAdapter<BaseAlgorithm>::init() {
  callMethod<void>(getSelf(), "PyInit");
}
 
template <typename BaseAlgorithm> void AlgorithmAdapter<BaseAlgorithm>::exec() {
  try {
    callMethod<void>(getSelf(), "PyExec");
  } catch (Mantid::PythonInterface::PythonException &) {
    if (BaseAlgorithm::getCancel())
      throw Mantid::API::Algorithm::CancelException();
    else
      throw;
  }
}
 
//-----------------------------------------------------------------------------------------------------------------------------
// Concrete instantiations (allows explicit locating of tempate-body definitions)
//-----------------------------------------------------------------------------------------------------------------------------
 
template class AlgorithmAdapter<API::Algorithm>;
 
template class AlgorithmAdapter<API::DataProcessorAlgorithm>;
} // namespace Mantid::PythonInterface