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()));
   }
 }
 
@@ -242,6 +259,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();

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

ruby/engine/RubyEngine.cpp

@@ -5,6 +5,7 @@
 
 #include "RubyEngine.hpp"
 #include "InitRubyBindings.hpp"
+#include "RubyException.hpp"
 #include <embedded_files.hxx>
 #include <csignal>
 #include <stdexcept>
@@ -118,6 +119,92 @@ void* RubyEngine::getAs_impl(ScriptObject& obj, const std::type_info& ti) {
   return return_value;
 }
 
+std::string RubyEngine::inferMeasureClassName(const openstudio::path& measureScriptPath) {
+
+  auto inferClassNameCmd = fmt::format(R"ruby(
+ObjectSpace.garbage_collect
+ObjectSpace.garbage_collect
+# Measure should be at root level (not inside a module) so we can just get constants
+measurePath = '{}'
+prev = Object.constants
+puts "prev = #{{prev}}"
+load measurePath # need load in case have seen this script before
+just_defined = Object.constants - prev
+puts "just_defined = #{{just_defined}}"
+just_defined.select!{{|c| Object.const_get(c).ancestors.include?(OpenStudio::Measure::OSMeasure)}}
+puts "just_defined, filtered = #{{just_defined}}"
+
+if just_defined.empty?
+  raise "Unable to extract OpenStudio::Measure::OSMeasure object from " +
+       measurePath + ". The script should contain a class that derives " +
+      "from OpenStudio::Measure::OSMeasure and should close with a line stating " +
+      "the class name followed by .new.registerWithApplication."
+end
+if just_defined.size > 1
+  raise "Found more than one OSMeasure at #{{measurePath}}: #{{just_defined}}"
+end
+c = just_defined[0]
+class_info = Object.const_get(c)
+$measure_name = class_info.to_s
+
+# Undef what we loaded
+just_defined.each {{|x| Object.send(:remove_const, x) }}
+ObjectSpace.garbage_collect
+ObjectSpace.garbage_collect
+)ruby",
+                                       measureScriptPath.generic_string());
+
+  std::string className;
+
+  try {
+    exec(inferClassNameCmd);
+    ScriptObject measureClassNameObject = eval("$measure_name");
+    // measureClassNameObject = rubyEngine->eval(fmt::format("{}.new()", className));
+    // ScriptObject measureClassNameObject = rubyEngine->eval(inferClassName);
+    className = *getAs<std::string*>(measureClassNameObject);
+  } catch (const RubyException& e) {
+    auto msg = fmt::format("Failed to infer measure name from {}: {}\nlocation={}", measureScriptPath.generic_string(), e.what(), e.location());
+    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 RubyEngine::loadMeasure(const openstudio::path& measureScriptPath, std::string_view className) {
+
+  ScriptObject result;
+  try {
+    auto importCmd = fmt::format("load '{}'", measureScriptPath.generic_string());
+    exec(importCmd);
+  } catch (const RubyException& e) {
+    auto msg =
+      fmt::format("Failed to load measure '{}' from '{}': {}\nlocation={}", className, measureScriptPath.generic_string(), e.what(), e.location());
+    fmt::print(stderr, "{}\n", msg);
+  }
+  try {
+    result = eval(fmt::format("{}.new()", className));
+  } catch (const RubyException& e) {
+    auto msg = fmt::format("Failed to instantiate measure '{}' from '{}': {}\nlocation={}", className, measureScriptPath.generic_string(), e.what(),
+                           e.location());
+    fmt::print(stderr, "{}\n", msg);
+  }
+  return result;
+}
+
+int RubyEngine::numberOfArguments(ScriptObject& methodObject, std::string_view methodName) {
+  auto val = std::any_cast<VALUE>(methodObject.object);
+  ID method_id = rb_intern(methodName.data());
+  // Ruby IS SO WEIRD. This will return n for methods that take a fixed number of arguments, and -n - 1 where n is the number of required arguments...
+  // def f() => 0
+  // def f(a) => 1
+  // def f(a = nil) => -1! Because WHY NOT, right?
+  // def f(a, c = nil) => -2
+  // def f(a, b = nil, c = nil) => also -2
+  return rb_obj_method_arity(val, method_id);
+}
+
 }  // namespace openstudio
 
 extern "C"

ruby/engine/RubyEngine.hpp

@@ -33,6 +33,12 @@ class RubyEngine final : public ScriptEngine
                                  const openstudio::path& gemHomeDir, const openstudio::path& bundleGemFilePath,
                                  const openstudio::path& bundleGemDirPath, const std::string& bundleWithoutGroups) 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:
   // convert the underlying object to the correct type, then return it as a void *
   // so the above template function can provide it back to the caller.