Fix #4885 - Rewrite MeasureManager in C++

.gitignore

@@ -20,4 +20,13 @@ clang_format.patch
 
 .DS_Store
 __pycache__/
-*.pyc
+*.pyc
+
+# Unit test / coverage reports
+htmlcov/
+.coverage
+.coverage.*
+.cache
+coverage.xml
+.pytest_cache/
+junit.xml

python/engine/PythonEngine.cpp

@@ -7,9 +7,10 @@
 #include <utilities/core/ApplicationPathHelpers.hpp>
 #include "../../src/utilities/core/Filesystem.hpp"
 #include <fmt/format.h>
+
 #include <stdexcept>
 #include <string>
-#include <iostream>
+#include <type_traits>
 
 #ifdef __GNUC__
 #  pragma GCC diagnostic push
@@ -27,15 +28,31 @@
 namespace openstudio {
 
 void addToPythonPath(const openstudio::path& includePath) {
-  if (!includePath.empty()) {
-    PyObject* sys = PyImport_ImportModule("sys");
-    PyObject* sysPath = PyObject_GetAttrString(sys, "path");
-    Py_DECREF(sys);  // PyImport_ImportModule returns a new reference, decrement it
 
-    // fmt::print("Prepending '{}' to sys.path\n", includePath);
-    PyObject* unicodeIncludePath = PyUnicode_FromString(includePath.string().c_str());
-    PyList_Insert(sysPath, 0, unicodeIncludePath);
-    Py_DECREF(sysPath);  // PyObject_GetAttrString returns a new reference, decrement it
+  if (includePath.empty()) {
+    return;
+  }
+
+  // fmt::print("Prepending '{}' to sys.path\n", includePath);
+
+  PyObject* unicodeIncludePath = nullptr;
+  if constexpr (std::is_same_v<typename openstudio::path::value_type, wchar_t>) {
+    const std::wstring ws = includePath.generic_wstring();
+    unicodeIncludePath = PyUnicode_FromWideChar(ws.c_str(), static_cast<Py_ssize_t>(ws.size()));  // New reference
+  } else {
+    const std::string s = includePath.generic_string();
+    unicodeIncludePath = PyUnicode_FromString(s.c_str());  // New reference
+  }
+
+  if (unicodeIncludePath == nullptr) {
+    throw std::runtime_error(fmt::format("Unable to convert path '{}' for addition to sys.path in Python", includePath.generic_string()));
+  }
+
+  PyObject* sysPath = PySys_GetObject("path");  // Borrowed reference
+  int ret = PyList_Insert(sysPath, 0, unicodeIncludePath);
+  Py_DECREF(unicodeIncludePath);
+  if (ret != 0) {
+    throw std::runtime_error(fmt::format("Unable to add path '{}' to the sys.path in Python", includePath.generic_string()));
   }
 }
 
@@ -113,6 +130,18 @@ PythonEngine::~PythonEngine() {
 }
 
 void PythonEngine::importOpenStudio() {
+#if defined(__APPLE__)
+  // RTLD_LOCAL is import an Apple so that that Python and Ruby do not conflict
+  const std::string set_dlflags_cmd = R"(
+import sys
+import os
+pre_os_dl_open_flags = sys.getdlopenflags()
+sys.setdlopenflags(os.RTLD_LOCAL)
+  )";
+
+  exec(set_dlflags_cmd.c_str());
+#endif
+
   // generic_string() converts to a POSIX path, with forward slashes, so that pyimport doesn't choke on backslashes understood as escape sequence
   if (moduleIsRunningFromBuildDirectory()) {
     const auto bindingsDir = getOpenStudioModuleDirectory();
@@ -123,6 +152,15 @@ void PythonEngine::importOpenStudio() {
   }
   // Somehow that doesn't suffice to register it...
   exec("import openstudio");
+
+#if defined(__APPLE__)
+  // Reset the dlopen flags to the value prior to importOpenStudio
+  const std::string reset_dlflags_cmd = R"(
+sys.setdlopenflags(pre_os_dl_open_flags)
+  )";
+
+  exec(reset_dlflags_cmd.c_str());
+#endif
 }
 
 struct PythonObject
@@ -242,6 +280,95 @@ void* PythonEngine::getAs_impl(ScriptObject& obj, const std::type_info& ti) {
 
   return return_value;
 }
+
+std::string PythonEngine::inferMeasureClassName(const openstudio::path& measureScriptPath) {
+
+  auto inferClassNameCmd = fmt::format(R"python(
+import importlib.util
+import inspect
+spec = importlib.util.spec_from_file_location(f"throwaway", "{}")
+
+module = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(module)
+class_members = inspect.getmembers(module, lambda x: inspect.isclass(x) and issubclass(x, openstudio.measure.OSMeasure))
+assert len(class_members) == 1
+measure_name, measure_typeinfo = class_members[0]
+)python",
+                                       measureScriptPath.generic_string());
+
+  std::string className;
+  try {
+    exec(inferClassNameCmd);
+    ScriptObject measureClassNameObject = eval("measure_name");
+    className = *getAs<std::string*>(measureClassNameObject);
+  } catch (const std::runtime_error& e) {
+    auto msg = fmt::format("Failed to infer measure name from {}: {}", measureScriptPath.generic_string(), e.what());
+    fmt::print(stderr, "{}\n", msg);
+  }
+
+  return className;
+}
+
+// Ideally this would return a openstudio::measure::OSMeasure* or a shared_ptr<openstudio::measure::OSMeasure> but this poses memory management
+// issue for the underlying ScriptObject (and VALUE or PyObject), so just return the ScriptObject
+ScriptObject PythonEngine::loadMeasure(const openstudio::path& measureScriptPath, std::string_view className) {
+
+  ScriptObject result;
+
+  auto importCmd = fmt::format(R"python(
+import importlib.util
+spec = importlib.util.spec_from_file_location('{}', r'{}')
+module = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(module)
+)python",
+                               className, measureScriptPath.generic_string());
+
+  // fmt::print("\nimportCmd:\n{}\n", importCmd);
+  try {
+    exec(importCmd);
+  } catch (const std::runtime_error& e) {
+    auto msg = fmt::format("Failed to load measure '{}' from '{}': {}", className, measureScriptPath.generic_string(), e.what());
+    fmt::print(stderr, "{}\n", msg);
+  }
+
+  try {
+    result = eval(fmt::format("module.{}()", className));
+  } catch (const std::runtime_error& e) {
+    auto msg = fmt::format("Failed to instantiate measure '{}' from '{}': {}", className, measureScriptPath.generic_string(), e.what());
+    fmt::print(stderr, "{}\n", msg);
+  }
+
+  return result;
+}
+
+int PythonEngine::numberOfArguments(ScriptObject& classInstanceObject, std::string_view methodName) {
+
+  int numberOfArguments = -1;
+
+  auto val = std::any_cast<PythonObject>(classInstanceObject.object);
+  if (PyObject_HasAttrString(val.obj_, methodName.data()) == 0) {
+    // FAILED
+    return numberOfArguments;
+  }
+
+  PyObject* method = PyObject_GetAttrString(val.obj_, methodName.data());  // New reference
+  if (PyMethod_Check(method)) {
+    PyObject* func = PyMethod_Function(method);   // Borrowed
+    if (auto* code = PyFunction_GetCode(func)) {  // Borrowed
+      auto* co = (PyCodeObject*)code;
+      numberOfArguments = co->co_argcount - 1;  // This includes `self`
+    }
+  } else if (PyFunction_Check(method)) {
+    // Shouldn't enter this block here
+    if (auto code = PyFunction_GetCode(method)) {
+      auto* co = (PyCodeObject*)code;
+      numberOfArguments = co->co_argcount;
+    }
+  }
+  Py_DECREF(method);
+  return numberOfArguments;
+}
+
 }  // namespace openstudio
 
 extern "C"

python/engine/PythonEngine.hpp

@@ -32,6 +32,12 @@ class PythonEngine final : public ScriptEngine
 
   virtual void setupPythonPath(const std::vector<openstudio::path>& includeDirs) override;
 
+  virtual std::string inferMeasureClassName(const openstudio::path& measureScriptPath) override;
+
+  virtual ScriptObject loadMeasure(const openstudio::path& measureScriptPath, std::string_view className) override;
+
+  virtual int numberOfArguments(ScriptObject& methodObject, std::string_view methodName) override;
+
  protected:
   void* getAs_impl(ScriptObject& obj, const std::type_info&) override;
   void importOpenStudio();

resources/Examples/compact_osw/compact_python_then_ruby.osw

@@ -0,0 +1,22 @@
+{
+	"weather_file": "srrl_2013_amy.epw",
+	"seed_file": "seb.osm",
+	"steps": [
+		{
+			"measure_dir_name": "IncreaseRoofRValuePython",
+			"arguments": {
+				"r_value": 45
+			}
+		},
+		{
+			"measure_dir_name": "SetEplusInfiltration",
+			"arguments": {
+				"flowPerZoneFloorArea": 10.76
+			}
+		},
+		{
+			"measure_dir_name": "Standard Reports",
+			"arguments": {}
+		}
+	]
+}

ruby/bindings/InitRubyBindings.cpp

@@ -356,6 +356,76 @@ module Ruleset
   end
 
 end # module Ruleset
+
+module Measure
+class RubyMeasureInfoBinding < OpenStudio::Measure::MeasureInfoBinding
+  def initialize
+    super() # needed
+    @info = nil
+  end
+  def setMeasureInfo(info)
+    @info = info
+  end
+  def measure_info
+    @info
+  end
+  def error
+    @info.error.to_s
+  end
+  def measureType
+    @info.measureType.valueName.to_s
+  end
+  def className
+    @info.className.to_s
+  end
+  def name
+    @info.name.to_s
+  end
+  def description
+    @info.description.to_s
+  end
+  def taxonomy
+    @info.taxonomy.to_s
+  end
+  def modelerDescription
+    @info.modelerDescription.to_s
+  end
+  def arguments
+    @info.arguments.map{|a| a.toJSON()}
+  end
+  def outputs
+    @info.outputs.map{|a| a.toJSON()}
+  end
+  def get_binding
+    result = binding()
+    return result
+  end
+  def renderFile(readme_in_path)
+    require 'erb'
+    begin
+      readme_out_path = File.join(File.dirname(readme_in_path), File.basename(readme_in_path, File.extname(readme_in_path)))
+      readme_in = File.read(readme_in_path)
+      renderer = ERB.new(readme_in)
+      readme_out = renderer.result(get_binding())
+    rescue
+      info = OpenStudio::Measure::OSMeasureInfo.new(e.message)
+      return false # @info
+    end
+    # write README.md file
+    File.open(readme_out_path, 'w') do |file|
+      file << readme_out
+      # make sure data is written to the disk one way or the other
+      begin
+        file.fsync
+      rescue StandardError
+        file.flush
+      end
+    end
+    return true #  @info
+  end
+end
+end # module Measure
+
 end # module OpenStudio
 
 module OpenStudio