Sync changes from v25-0-1 (#14)

Co-authored-by: ADO Sync <ado-sync@bentley.com>

Author: ChrisWu2024

InternalAPI/MSPyCommon.h

@@ -329,58 +329,66 @@ py::class_<bvector<ValueType>, holder_type> bind_PointerVector(py::handle scope,
     return cls;
     }
 
-// Convert Python list to an existing C++ array
+template <typename T>
+T ConvertItemFromPyObject(const py::handle& item) {
+    if (!py::isinstance<T>(item)) {
+        throw std::invalid_argument("All items in the list must be of the correct item type");
+    }
+    return item.cast<T>();
+}
+
+inline double ConvertItemFromPyObject(const py::handle& item) {
+    if (!PyFloat_Check(item.ptr()) && !PyLong_Check(item.ptr())) {
+        throw std::invalid_argument("Expected all items to be convertible to double");
+    }
+    return item.cast<double>();
+}
+
+template <typename T>
+py::object ConvertItemToPyObject(const T& item) {
+    return py::cast(item);
+}
+
+inline py::object ConvertItemToPyObject(const double& item) {
+    return py::float_(item);
+}
+
+//Convert Python list to an existing C++ array
 template <typename arrayType, typename itemType>
-void ConvertPyListToCppArray(py::list const& pyList, arrayType& cppArray)
-{
+void ConvertPyListToCppArray(const py::list& pyList, arrayType& cppArray) {
     cppArray.clear();
-    for (auto item : pyList)
-    {
-        if (!py::isinstance<itemType>(item))
-        {
-            throw std::invalid_argument("All items in the list must be of the correct item type");
-        }
-        auto cppItem = item.cast<itemType>();
+    for (const auto& item : pyList) {
+        itemType cppItem = ConvertItemFromPyObject<itemType>(item);
         cppArray.push_back(cppItem);
     }
 }
 
 // Convert Python list to a new C++ array
 template <typename arrayType, typename itemType>
-arrayType ConvertPyListToCppArray(py::list const& pyList)
-{
+arrayType ConvertPyListToCppArray(const py::list& pyList) {
     arrayType cppArray;
-    for (auto item : pyList)
-    {
-        if (!py::isinstance<itemType>(item))
-        {
-            throw std::invalid_argument("All items in the list must be of the correct item type");
-        }
-        auto cppItem = item.cast<itemType>();
+    for (const auto& item : pyList) {
+        itemType cppItem = ConvertItemFromPyObject<itemType>(item);
         cppArray.push_back(cppItem);
     }
     return cppArray;
 }
 
 // Convert C++ array to an existing Python list
 template <typename arrayType, typename itemType>
-void ConvertCppArrayToPyList(py::list& pyList, arrayType const& cppArray)
-{
+void ConvertCppArrayToPyList(py::list& pyList, const arrayType& cppArray) {
     pyList.attr("clear")();
-    for (const itemType& item : cppArray)
-    {
-        pyList.append(py::cast(item));
+    for (const itemType& item : cppArray) {
+        pyList.append(ConvertItemToPyObject(item));
     }
 }
 
 // Convert C++ array to a new Python list
 template <typename arrayType, typename itemType>
-py::list ConvertCppArrayToPyList(arrayType const& cppArray)
-{
+py::list ConvertCppArrayToPyList(const arrayType& cppArray) {
     py::list pyList;
-    for (const itemType& item : cppArray)
-    {
-        pyList.append(py::cast(item));
+    for (const itemType& item : cppArray) {
+        pyList.append(ConvertItemToPyObject(item));
     }
     return pyList;
 }
@@ -396,4 +404,4 @@ py::list ConvertCppArrayToPyList(arrayType const& cppArray)
     ConvertCppArrayToPyList<cppArrayType, cppItemType>(pyList, cppArray);
 
 #define CONVERT_CPPARRAY_TO_NEW_PYLIST(pyList, cppArray, cppArrayType, cppItemType) \
-    py::list pyList = ConvertCppArrayToPyList<cppArrayType, cppItemType>(cppArray);
+    py::list pyList = ConvertCppArrayToPyList<cppArrayType, cppItemType>(cppArray);

InternalAPI/MSPythonEngine.h

@@ -131,6 +131,7 @@ struct PythonScriptEngine : public ScriptEngine
     virtual ScriptValuePtr      eval(WCharCP expr, ScriptContext* global = nullptr, ScriptContext* locals = nullptr);
     virtual void                exec(WCharCP stms, WCharCP funcName, ScriptContext* global = nullptr, ScriptContext* locals = nullptr);
     virtual void                eval_file(WCharCP fileName, WCharCP funcName, ScriptContext* global = nullptr, ScriptContext* locals = nullptr);
+    virtual void                evalPYC(WStringCR pythonFileName, ScriptContext* global = nullptr, ScriptContext* locals = nullptr);
 private:
     void                        InitSearchPath();
     };

InternalAPI/OpqueTypes_Geom.h

@@ -51,3 +51,5 @@ DEFINE_BVECTOR_TYPE(FloatRgb, FloatRgbArray);
 DEFINE_BVECTOR_TYPE(RgbFactor, RgbFactorArray);
 DEFINE_BVECTOR_TYPE(FacetFaceData, FacetFaceDataArray);
 DEFINE_BVECTOR_TYPE(PolyfaceEdgeChain, PolyfaceEdgeChainArray);
+DEFINE_BVECTOR_TYPE(GeoPoint, GeoPointArray);
+DEFINE_BVECTOR_TYPE(GeoPoint2d, GeoPoint2dArray);

MSPythonCore/ScriptEngineManager/source/MSPythonEngine.cpp

@@ -8,6 +8,8 @@
 #include "MSPythonPCH.h"
 #include "..\\MsPythonCore.r.h"
 #include <iostream>
+#include <fstream>
+#include <vector>
 // Default entry point function for script
 #define DEFAULT_FUNC_NAME       L"PyMain"
 
@@ -697,6 +699,128 @@ void print_dict(const py::dict& dict)
     std::cout << std::endl;
     }
 
+    /*---------------------------------------------------------------------------------**//*** 
+ @bsimethod                                                                       2/2023 
+ +---------------+---------------+---------------+---------------+---------------+------*/ 
+void PythonScriptEngine::evalPYC(WStringCR pythonFileName, ScriptContext* global, ScriptContext* locals)
+    {
+    ScriptContextPtr globalCtx(global), localCtx(locals);
+    py::dict globalDict, localDict;
+
+    if (m_engineProcessing)
+        {
+        ScriptEngineManager::Get().InjectError("Cannot have two instances of Python executing at the same time");
+        return ;
+        }
+    // Create context when necessary
+    if (globalCtx.IsNull())
+        globalCtx = createContext(true);
+    if (localCtx.IsNull())
+        localCtx = createContext(false);
+
+    // Obtain py::dict from context that is specific for PyEngine
+    auto pyGlobalDict = dynamic_cast<PythonScriptContext*>(globalCtx.get());
+    if (nullptr != pyGlobalDict)
+        globalDict = pyGlobalDict->m_dict;
+
+    auto pyLocalDict = dynamic_cast<PythonScriptContext*>(localCtx.get());
+    if (nullptr != pyLocalDict)
+        localDict = pyLocalDict->m_dict;
+    m_engineProcessing = true;
+    // Evaluate expression and capture return value.
+    ScriptEngineManager::Get().ClearException();
+    try
+        {
+        // Convert WString to std::string for file operations
+        std::string pyc_file_path;
+        Utf8String temp;
+        temp.Assign(pythonFileName.c_str());
+        pyc_file_path = temp.c_str();
+
+        // Get the __main__ module and backup its current dictionary
+        py::module main_module = py::module::import("__main__");
+        py::dict original_main_dict = main_module.attr("__dict__");
+        
+        // Create a backup of the original dictionary
+        py::dict backup_dict = original_main_dict.cast<py::dict>();
+        
+        // Temporarily replace __main__.__dict__ with our custom globalDict
+        // First, copy essential built-ins to our globalDict if they don't exist
+        if (!globalDict.contains("__builtins__"))
+            {
+            if (original_main_dict.contains("__builtins__"))
+                {
+                globalDict["__builtins__"] = original_main_dict["__builtins__"];
+                }
+            else
+                {
+                py::module builtins_module = py::module::import("builtins");
+                globalDict["__builtins__"] = builtins_module;
+                }
+            }
+        if (!globalDict.contains("__name__"))
+            {
+            globalDict["__name__"] = "__main__";
+            }
+        if (!globalDict.contains("__file__"))
+            {
+            globalDict["__file__"] = py::cast(pyc_file_path);
+            }
+            
+        // Replace the main module's dictionary
+        main_module.attr("__dict__").attr("clear")();
+        main_module.attr("__dict__").attr("update")(globalDict);
+
+        // Open the .pyc file
+        FILE* fp = fopen(pyc_file_path.c_str(), "rb");
+        if (!fp) 
+            {
+            // Restore original dictionary before returning
+            main_module.attr("__dict__").attr("clear")();
+            main_module.attr("__dict__").attr("update")(backup_dict);
+            
+            ScriptEngineManager::Get().InjectError("Cannot open PYC file");
+            m_engineProcessing = false;
+            return ;
+            }
+
+        // Set up compilation flags for .pyc files
+        PyCompilerFlags flags;
+        flags.cf_flags = 0;
+
+        // Execute the .pyc file using PyRun_SimpleFileExFlags
+        // This will now use our custom globalDict via __main__.__dict__
+        mdlErrno = 0;
+        int result = PyRun_SimpleFileExFlags(fp, pyc_file_path.c_str(), 1, &flags);
+        
+        // Copy any new variables back to our globalDict
+        py::dict updated_main_dict = main_module.attr("__dict__");
+        for (auto item : updated_main_dict)
+            {
+            globalDict[item.first] = item.second;
+            }
+        
+        // Restore the original __main__ dictionary
+        main_module.attr("__dict__").attr("clear")();
+        main_module.attr("__dict__").attr("update")(backup_dict);
+        
+        if (result != 0) 
+            {
+            ScriptEngineManager::Get().InjectError("Error executing PYC file");
+            mdlErrno = MDLERR_PYTHONEXECUTIONERROR;
+            }        
+        }
+    catch (py::error_already_set& err)
+        {
+        ScriptEngineManager::Get().InjectException(err);
+        mdlErrno = MDLERR_PYTHONEXECUTIONERROR;
+        }
+
+    m_engineProcessing = false;    
+
+
+    }
+
 /*---------------------------------------------------------------------------------**//*** 
  @bsimethod                                                                       2/2023 
  +---------------+---------------+---------------+---------------+---------------+------*/ 

MSPythonCore/ScriptEngineManager/source/ScriptEngineManager.cpp

@@ -304,18 +304,24 @@ bool ScriptEngineManager::AddNotifier(ScriptNotifierP notifier)
     UstnScriptNotifier* beConsole = dynamic_cast<UstnScriptNotifier*> (notifier);
     bool isBeConsole = (nullptr != beConsole) ? true : false;
 
+    bool isActiveExist(false);
+
+    for (auto& it0 : *m_sinkList)
+        if (it0->GetActive())
+            {
+            isActiveExist = true;
+            break;
+            }
+
     if (isBeConsole)
         {
-        notifier->SetActive(true);
+        if (!isActiveExist)
+            notifier->SetActive(true);
         }
     else
         {
         for (auto& it0 : *m_sinkList)
-             {
-             beConsole = dynamic_cast<UstnScriptNotifier*> (it0);
-             if (nullptr == beConsole)
-                it0->SetActive(false);
-             }
+            it0->SetActive(false);
 
         notifier->SetActive(true);
         }