Create PythonObjectProperty -- ornl-next (#39951)

Sister to PR #39880

Co-authored-by: martyngigg <martyn.gigg@stfc.ac.uk>

Author: rboston628

Framework/PythonInterface/core/CMakeLists.txt

@@ -7,6 +7,8 @@ set(SRC_FILES
     src/ErrorHandling.cpp
     src/GlobalInterpreterLock.cpp
     src/NDArray.cpp
+    src/PythonObjectProperty.cpp
+    src/PythonObjectTypeValidator.cpp
     src/ReleaseGlobalInterpreterLock.cpp
     src/UninstallTrace.cpp
     src/PythonLoggingChannel.cpp
@@ -36,6 +38,8 @@ set(INC_FILES
     inc/MantidPythonInterface/core/PropertyWithValueExporter.h
     inc/MantidPythonInterface/core/PythonLoggingChannel.h
     inc/MantidPythonInterface/core/PythonObjectInstantiator.h
+    inc/MantidPythonInterface/core/PythonObjectProperty.h
+    inc/MantidPythonInterface/core/PythonObjectTypeValidator.h
     inc/MantidPythonInterface/core/PythonStdoutChannel.h
     inc/MantidPythonInterface/core/ReleaseGlobalInterpreterLock.h
     inc/MantidPythonInterface/core/StlExportDefinitions.h

Framework/PythonInterface/core/inc/MantidPythonInterface/core/PropertyWithValueExporter.h

@@ -19,7 +19,7 @@
 // Call the dtype helper function
 template <typename HeldType> std::string dtype(Mantid::Kernel::PropertyWithValue<HeldType> &self) {
   // Check for the special case of a string
-  if (std::is_same<HeldType, std::string>::value) {
+  if constexpr (std::is_same<HeldType, std::string>::value) {
     std::stringstream ss;
     std::string val = self.value();
     ss << "S" << val.size();

Framework/PythonInterface/core/inc/MantidPythonInterface/core/PythonObjectProperty.h

@@ -0,0 +1,123 @@
+// Mantid Repository : https://github.com/mantidproject/mantid
+//
+// Copyright © 2007 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 +
+#pragma once
+
+//----------------------------------------------------------------------
+// Includes
+//----------------------------------------------------------------------
+#include "MantidPythonInterface/core/DllConfig.h"
+
+#include "MantidKernel/IValidator.h"
+#include "MantidKernel/NullValidator.h"
+#include "MantidKernel/PropertyWithValue.h"
+
+#include <boost/python/object.hpp>
+
+// forward declare
+namespace Json {
+class Value;
+}
+
+namespace Mantid::Kernel {
+using PythonObject = boost::python::object;
+
+#ifndef __APPLE__
+/** NOTE:
+ *  For Linux builds (and maybe Windows), it is necessary that the below DLL export occur here.
+ *  This declaration normally lives in Framework/Kernel/PropertyWithValue.cpp.  However, because the boost library is
+ *  not linked in Kernel, this declaration can only occur inside the PythonInterface layer
+ *  For Linux builds, this MUST be instantiated BEFORE the declaration of PythonObjectProperty
+ */
+// Instantiate a copy of the class with our template type so we generate the symbols for the methods in the hxx header.
+template class MANTID_PYTHONINTERFACE_CORE_DLL PropertyWithValue<PythonObject>;
+#endif
+} // namespace Mantid::Kernel
+
+namespace Mantid::PythonInterface {
+
+using Mantid::Kernel::Direction;
+using Mantid::Kernel::IValidator_sptr;
+using Mantid::Kernel::NullValidator;
+using Mantid::Kernel::PythonObject;
+
+class MANTID_PYTHONINTERFACE_CORE_DLL PythonObjectProperty : public Mantid::Kernel::PropertyWithValue<PythonObject> {
+public:
+  // Convenience typedefs
+  using ValueType = PythonObject;
+  using BaseClass = Mantid::Kernel::PropertyWithValue<ValueType>;
+
+  /** No default constructor */
+  PythonObjectProperty() = delete;
+
+  /** Constructor
+   *  @param name ::         The name to assign to the property
+   *  @param defaultValue :: The default python object to assign to the property
+   *  @param validator ::    The validator to use for this property, if required.
+   *  @param direction ::    The direction (Input/Output/InOut) of this property
+   */
+  PythonObjectProperty(std::string const &name, PythonObject const &defaultValue,
+                       IValidator_sptr const &validator = std::make_shared<NullValidator>(),
+                       unsigned int const direction = Direction::Input)
+      : BaseClass(name, defaultValue, validator, direction) {}
+
+  /** Constructor that's useful for output properties or inputs with non-None default and no validator.
+   *  @param name ::         The name to assign to the property
+   *  @param defaultValue :: The default python object to assign to the property
+   *  @param direction ::    The direction (Input/Output/InOut) of this property
+   */
+  PythonObjectProperty(std::string const &name, PythonObject const &defaultValue,
+                       unsigned int const direction = Direction::Input)
+      : BaseClass(name, defaultValue, std::make_shared<NullValidator>(), direction) {}
+
+  /** Constructor
+   *  Will lead to the property having default value of None
+   *  @param name ::      The name to assign to the property
+   *  @param validator :: The validator to use for this property, if required
+   *  @param direction :: The direction (Input/Output/InOut) of this property
+   */
+  PythonObjectProperty(std::string const &name, IValidator_sptr const &validator,
+                       unsigned int const direction = Direction::Input)
+      : BaseClass(name, PythonObject(), validator, direction) {}
+
+  /** Constructor that's useful for output properties or inputs with default value None and no validator.
+   *  Will lead to the property having a default initial value of None and no validator
+   *  @param name ::      The name to assign to the property
+   *  @param direction :: The direction (Input/Output/InOut) of this property
+   */
+  PythonObjectProperty(std::string const &name, unsigned int const direction = Direction::Input)
+      : BaseClass(name, PythonObject(), std::make_shared<NullValidator>(), direction) {}
+
+  /** Constructor from which you can set the property's values through a string:
+   *  @param name ::      The name to assign to the property
+   *  @param strvalue ::     A string which will set the property being stored
+   *  @param validator :: The validator to use for this property, if required
+   *  @param direction :: The direction (Input/Output/InOut) of this property
+   *  @throw std::invalid_argument if the string passed is not compatible with a python object
+   */
+  PythonObjectProperty(std::string const &name, std::string const &strvalue,
+                       IValidator_sptr const &validator = std::make_shared<NullValidator>(),
+                       unsigned int const direction = Direction::Input)
+      : BaseClass(name, PythonObject(), strvalue, validator, direction) {}
+
+  /** Copy constructor */
+  PythonObjectProperty(PythonObjectProperty const &other) : BaseClass(other) {}
+
+  /** This is required by Property interface */
+  PythonObjectProperty *clone() const override { return new PythonObjectProperty(*this); }
+
+  // Unhide the base class assignment operator
+  using BaseClass::operator=;
+
+  std::string getDefault() const override;
+  std::string setValue(PythonObject const &obj);
+  std::string setValue(std::string const &value) override;
+  std::string setValueFromJson(Json::Value const &value) override;
+  std::string setDataItem(std::shared_ptr<Kernel::DataItem> const &value) override;
+  bool isDefault() const override;
+};
+
+} // namespace Mantid::PythonInterface

Framework/PythonInterface/core/inc/MantidPythonInterface/core/PythonObjectTypeValidator.h

@@ -0,0 +1,58 @@
+// Mantid Repository : https://github.com/mantidproject/mantid
+//
+// Copyright © 2025 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 +
+#pragma once
+
+//----------------------------------------------------------------------
+// Includes
+//----------------------------------------------------------------------
+#include "MantidPythonInterface/core/DllConfig.h"
+
+#include "MantidKernel/IValidator.h"
+
+#include <Python.h>
+#include <boost/python/extract.hpp>
+#include <boost/python/object.hpp>
+
+// forward declare
+namespace Json {
+class Value;
+}
+
+namespace {
+using namespace boost::python;
+static inline object const &validate_python_class(object const &pyclass) {
+  if (PyType_Check(pyclass.ptr())) {
+    return pyclass;
+  } else {
+    throw std::invalid_argument("Attempt to construct validator with an object instead of a class type");
+  }
+}
+} // namespace
+
+namespace Mantid::PythonInterface {
+
+using namespace boost::python;
+using Mantid::Kernel::IValidator_sptr;
+
+class MANTID_PYTHONINTERFACE_CORE_DLL PythonObjectTypeValidator : public Mantid::Kernel::IValidator {
+
+public:
+  PythonObjectTypeValidator() : pythonClass(object()) {};
+
+  PythonObjectTypeValidator(object const &pyclass) : pythonClass(validate_python_class(pyclass)) {}
+
+  ~PythonObjectTypeValidator() override = default;
+
+  IValidator_sptr clone() const override { return std::make_shared<PythonObjectTypeValidator>(*this); };
+
+private:
+  object pythonClass;
+
+  std::string check(boost::any const &value) const override;
+};
+
+} // namespace Mantid::PythonInterface