pythonfmu3 0.1.12__tar.gz → 0.1.13__tar.gz

{pythonfmu3-0.1.12/pythonfmu3.egg-info → pythonfmu3-0.1.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pythonfmu3
-Version: 0.1.12
+Version: 0.1.13
 Summary: A lightweight framework that enables the packaging of Python3.x code as co-simulation FMUs.
 Home-page: https://github.com/stephensmith25/PythonFMU3
 Author: Stephen Smith

pythonfmu3-0.1.13/pythonfmu3/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.13"

{pythonfmu3-0.1.12 → pythonfmu3-0.1.13}/pythonfmu3/fmi3slave.py

@@ -188,7 +188,7 @@ class Fmi3Slave(ABC):
             raise Exception(f"Unsupported type {type(var)}!")
         var.start = refs if len(getattr(var, "dimensions", [])) > 0 else refs[0]
 
-    def register_variable(self, var: ModelVariable, nested: bool = True, units: str = "", var_type: Any = None):
+    def register_variable(self, var: ModelVariable, nested: bool = True, var_type: Any = None):
         """Register a variable as FMU interface.
         
         Args:

pythonfmu3-0.1.13/pythonfmu3/pythonfmu-export/src/pythonfmu/IPyState.hpp

@@ -0,0 +1,18 @@
+#ifndef PYTHONFMU_IPYTHONSTATE_HPP
+#define PYTHONFMU_IPYTHONSTATE_HPP
+
+namespace pythonfmu
+{
+    class IPyState
+    {
+    public:
+        IPyState() = default;
+        IPyState(IPyState const& other) = delete;
+        IPyState(IPyState&& other) = delete;
+        IPyState& operator=(IPyState const& other) = delete;
+        IPyState& operator=(IPyState&& other) = delete;
+        virtual ~IPyState() = default;
+    };
+}
+
+#endif //PYTHONFMU_IPYTHONSTATE_HPP

{pythonfmu3-0.1.12 → pythonfmu3-0.1.13}/pythonfmu3/pythonfmu-export/src/pythonfmu/PySlaveInstance.cpp

@@ -1,4 +1,5 @@
 
+#include "pythonfmu/IPyState.hpp"
 #include "pythonfmu/PySlaveInstance.hpp"
 
 #include "pythonfmu/PyState.hpp"
@@ -7,6 +8,7 @@
 
 #include <fstream>
 #include <functional>
+#include <mutex>
 #include <regex>
 #include <sstream>
 #include <utility>
@@ -44,8 +46,9 @@ inline void py_safe_run(const std::function<void(PyGILState_STATE gilState)>& f)
     PyGILState_Release(gil_state);
 }
 
-PySlaveInstance::PySlaveInstance(std::string instanceName, std::string resources, const cppfmu::Logger& logger, const bool visible)
-    : instanceName_(std::move(instanceName))
+PySlaveInstance::PySlaveInstance(std::string instanceName, std::string resources, const cppfmu::Logger& logger, const bool visible, std::shared_ptr<IPyState> pyState)
+    : pyState_{ std::move(pyState) }
+    , instanceName_(std::move(instanceName))
     , resources_(std::move(resources))
     , logger_(logger)
     , visible_(visible)
@@ -625,7 +628,10 @@ PySlaveInstance::~PySlaveInstance()
 
 } // namespace pythonfmu
 
-std::unique_ptr<pythonfmu::PyState> pyState = nullptr;
+namespace {
+    std::mutex pyStateMutex{};
+    std::shared_ptr<pythonfmu::PyState> pyState{};
+}
 
 std::unique_ptr<cppfmu::SlaveInstance> CppfmuInstantiateSlave(
     cppfmu::FMIString instanceName,
@@ -650,9 +656,57 @@ std::unique_ptr<cppfmu::SlaveInstance> CppfmuInstantiateSlave(
 #endif
     }
 
-    if (pyState == nullptr) {
-        pyState = std::make_unique<pythonfmu::PyState>();
+    {
+        auto const ensurePyStateAlive = [&]() {
+            auto const lock = std::lock_guard{pyStateMutex};
+            if (nullptr == pyState) pyState = std::make_shared<pythonfmu::PyState>();
+            };
+
+        ensurePyStateAlive();
+        return std::make_unique<pythonfmu::PySlaveInstance>(
+            instanceName, resources, logger, visible, pyState);
     }
+}
+
+extern "C" {
+
+    // The PyState instance owns it's own thread for constructing and destroying the Py* from the same thread.
+    // Creation of an std::thread increments ref counter of a shared library. So, when the client unloads the library
+    // the library won't be freed, as std::thread is alive, and the std::thread itself waits for de-initialization request.
+    // Thus, use DllMain on Windows and __attribute__((destructor)) on Linux for signaling to the PyState about de-initialization.
+    void finalizePythonInterpreter()
+    {
+        pyState = nullptr;
+    }
+}
 
-    return std::make_unique<pythonfmu::PySlaveInstance>(instanceName, resources, logger, visible);
+namespace
+{
+#ifdef _WIN32
+#include <windows.h>
+
+    BOOL APIENTRY DllMain(HMODULE hModule,
+        DWORD ul_reason_for_call,
+        LPVOID lpReserved)
+    {
+        switch (ul_reason_for_call) {
+            case DLL_PROCESS_ATTACH:
+                break;
+            case DLL_THREAD_ATTACH:
+            case DLL_THREAD_DETACH:
+                break;
+            case DLL_PROCESS_DETACH:
+                finalizePythonInterpreter();
+                break;
+        }
+        return TRUE;
+}
+#elif defined(__linux__)
+    __attribute__((destructor)) void onLibraryUnload()
+    {
+        finalizePythonInterpreter();
+}
+#else
+#error port the code
+#endif
 }

{pythonfmu3-0.1.12 → pythonfmu3-0.1.13}/pythonfmu3/pythonfmu-export/src/pythonfmu/PySlaveInstance.hpp

@@ -3,6 +3,7 @@
 #define PYTHONFMU_SLAVEINSTANCE_HPP
 
 #include "cppfmu/cppfmu_cs.hpp"
+#include "pythonfmu/IPyState.hpp"
 
 #include <Python.h>
 #include <string>
@@ -15,7 +16,7 @@ class PySlaveInstance : public cppfmu::SlaveInstance
 {
 
 public:
-    PySlaveInstance(std::string instanceName, std::string resources, const cppfmu::Logger& logger, bool visible);
+    PySlaveInstance(std::string instanceName, std::string resources, const cppfmu::Logger& logger, bool visible, std::shared_ptr<IPyState> pyState);
 
     void initialize(PyGILState_STATE gilState);
 
@@ -53,6 +54,7 @@ public:
     ~PySlaveInstance() override;
 
 private:
+    std::shared_ptr<IPyState> pyState_;
     PyObject* pClass_;
     PyObject* pInstance_{};
     PyObject* pMessages_{};

pythonfmu3-0.1.13/pythonfmu3/pythonfmu-export/src/pythonfmu/PyState.hpp

@@ -0,0 +1,85 @@
+
+#ifndef PYTHONFMU_PYTHONSTATE_HPP
+#define PYTHONFMU_PYTHONSTATE_HPP
+
+#include "IPyState.hpp"
+#include <Python.h>
+#include <condition_variable>
+#include <iostream>
+#include <mutex>
+#include <thread>
+
+namespace pythonfmu
+{
+    class PyState : public IPyState
+    {
+    public:
+        PyState()
+            : _initDeinitPyThread_{ &PyState::Worker, this }
+        {
+            auto lock = std::unique_lock{ mutex_ };
+            conditionalVariable_.wait(lock, [&] { return consructed_; });
+        }
+
+        ~PyState() override
+        {
+            {
+                auto const lock = std::lock_guard{ mutex_ };
+                destroyRequested_ = true;
+            }
+            conditionalVariable_.notify_one();
+            if (_initDeinitPyThread_.joinable()) _initDeinitPyThread_.join();
+        }
+
+    private:
+
+        // In accordance to the documentation https://docs.python.org/3/c-api/init.html#c.Py_FinalizeEx 
+        // the Py_Initialize/Py_Finalize should be called from the same
+        // thread. The FMI standard allows to call fmi functions from different threads, also different threads
+        // could be used for loading unloading the FMU libraries. There is a deadlock, when the simulation tool 
+        // unloads the FMU library from the thread which is differs from the thread where the Py_Initialize was called.
+        // Create a new thread which is used for calling Py_Initialize and Py_Deinitialize. The thread waits for
+        // notification from destructor and then calls Py_Deinitialize.
+
+        void Worker()
+        {
+            // It will be nullptr in case when some other tool already called Py_IsInitialized.
+            // There is no need to call Py_Finalize thus, this thread can exit ASAP.
+            auto const mainPyThread = []() -> PyThreadState* {
+                auto const justInitialized = !Py_IsInitialized();
+                if (justInitialized) {
+                    Py_SetProgramName(L"./PythonFMU");
+                    Py_Initialize();
+#if PY_VERSION_HEX < 0x03070000
+                    PyEval_InitThreads();
+#endif
+                    return PyEval_SaveThread();
+                }
+                return nullptr;
+                }();
+
+                {
+                    auto const lock = std::lock_guard{ mutex_ };
+                    consructed_ = true;
+                }
+                conditionalVariable_.notify_one();
+
+                if (nullptr != mainPyThread) {
+                    auto lock = std::unique_lock{ mutex_ };
+                    conditionalVariable_.wait(lock, [&] { return destroyRequested_; });
+
+                    PyEval_RestoreThread(mainPyThread);
+                    Py_Finalize();
+                }
+        }
+
+        bool consructed_ = false;
+        bool destroyRequested_ = false;
+        std::condition_variable conditionalVariable_;
+        std::mutex mutex_;
+        std::thread _initDeinitPyThread_;
+    };
+
+} // namespace pythonfmu
+
+#endif //PYTHONFMU_PYTHONSTATE_HPP

{pythonfmu3-0.1.12 → pythonfmu3-0.1.13}/pythonfmu3/variables.py

@@ -144,7 +144,7 @@ class Dimension(object):
         if self.start:
             return self.start
         else:
-            result = next((var for var in vars if var.value_reference == self.value_reference), None)  
+            result = next((value for vr, value in vars.items() if vr == int(self.value_reference)), None)  
             return result.getter()
 
     def to_xml(self) -> Element:

{pythonfmu3-0.1.12 → pythonfmu3-0.1.13/pythonfmu3.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pythonfmu3
-Version: 0.1.12
+Version: 0.1.13
 Summary: A lightweight framework that enables the packaging of Python3.x code as co-simulation FMUs.
 Home-page: https://github.com/stephensmith25/PythonFMU3
 Author: Stephen Smith

{pythonfmu3-0.1.12 → pythonfmu3-0.1.13}/pythonfmu3.egg-info/SOURCES.txt

@@ -35,6 +35,7 @@ pythonfmu3/pythonfmu-export/src/cppfmu/fmi_functions.cpp
 pythonfmu3/pythonfmu-export/src/fmi/fmi3FunctionTypes.h
 pythonfmu3/pythonfmu-export/src/fmi/fmi3Functions.h
 pythonfmu3/pythonfmu-export/src/fmi/fmi3PlatformTypes.h
+pythonfmu3/pythonfmu-export/src/pythonfmu/IPyState.hpp
 pythonfmu3/pythonfmu-export/src/pythonfmu/PySlaveInstance.cpp
 pythonfmu3/pythonfmu-export/src/pythonfmu/PySlaveInstance.hpp
 pythonfmu3/pythonfmu-export/src/pythonfmu/PyState.hpp

pythonfmu3-0.1.12/pythonfmu3/_version.py

@@ -1 +0,0 @@
-__version__ = "0.1.12"

pythonfmu3-0.1.12/pythonfmu3/pythonfmu-export/src/pythonfmu/PyState.hpp

@@ -1,41 +0,0 @@
-
-#ifndef PYTHONFMU_PYTHONSTATE_HPP
-#define PYTHONFMU_PYTHONSTATE_HPP
-
-#include <Python.h>
-#include <iostream>
-
-namespace pythonfmu
-{
-
-class PyState
-{
-public:
-    PyState()
-    {
-        was_initialized_ = Py_IsInitialized();
-
-        if (!was_initialized_) {
-            Py_SetProgramName(L"./PythonFMU");
-            Py_Initialize();
-            PyEval_InitThreads();
-            _mainPyThread = PyEval_SaveThread();
-        }
-    }
-
-    ~PyState()
-    {
-        if (!was_initialized_) {
-            PyEval_RestoreThread(_mainPyThread);
-            Py_Finalize();
-        }
-    }
-
-private:
-    bool was_initialized_;
-    PyThreadState* _mainPyThread;
-};
-
-} // namespace pythonfmu
-
-#endif //PYTHONFMU_PYTHONSTATE_HPP