pythonfmu3 0.1.10__py3-none-any.whl → 0.1.16__py3-none-any.whl

pythonfmu3/__init__.py

@@ -4,4 +4,5 @@ from .enums import Fmi3Causality, Fmi3Initial, Fmi3Variability
 from .fmi3slave import Fmi3Slave
 from .variables import Boolean, Enumeration, Int32, Int64, UInt64, Float64, String, Dimension
 from .default_experiment import DefaultExperiment
-from .type_definitions import TypeDefinitions, Item, EnumerationType
+from .variable_types import Float64Type, EnumerationType
+from .unit import BaseUnit, Unit

pythonfmu3/_version.py

@@ -1 +1 @@
-__version__ = "0.1.10"
+__version__ = "0.1.16"

pythonfmu3/fmi3slave.py

@@ -11,10 +11,11 @@ from xml.etree.ElementTree import Element, SubElement
 
 from .logmsg import LogMsg
 from .default_experiment import DefaultExperiment
-from .type_definitions import TypeDefinitions
 from ._version import __version__ as VERSION
 from .enums import Fmi3Type, Fmi3Status, Fmi3Causality, Fmi3Initial, Fmi3Variability
 from .variables import Boolean, Enumeration, Int32, Int64, UInt64, Float64, ModelVariable, String
+from .variable_types import VariableType
+from .unit import Unit
 
 ModelOptions = namedtuple("ModelOptions", ["name", "value", "cli"])
 
@@ -54,7 +55,9 @@ class Fmi3Slave(ABC):
         self.modelName: Optional[str] = self.__class__.__name__
         self.description: Optional[str] = None
         self.default_experiment: Optional[DefaultExperiment] = None
-        self.type_definitions: Optional[TypeDefinitions] = None
+
+        self.type_definitions: Dict[str, VariableType] = {}
+        self.units: Dict[str, Unit] = {}
 
     def to_xml(self, model_options: Dict[str, str] = dict()) -> Element:
         """Build the XML representation of the model.
@@ -99,8 +102,15 @@ class Fmi3Slave(ABC):
 
         SubElement(root, "CoSimulation", attrib=options)
 
-        if self.type_definitions is not None:
-            root.append(self.type_definitions.to_xml())
+        if self.units:
+            unit_defs = SubElement(root, "UnitDefinitions")
+            for _, unit in self.units.items():
+                unit_defs.append(unit.to_xml())
+
+        if self.type_definitions:
+            type_defs = SubElement(root, "TypeDefinitions")
+            for _, val in self.type_definitions.items():
+                type_defs.append(val.to_xml())
 
         if len(self.log_categories) > 0:
             categories = SubElement(root, "LogCategories")
@@ -178,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):
+    def register_variable(self, var: ModelVariable, nested: bool = True, var_type: Any = None):
         """Register a variable as FMU interface.
         
         Args:
@@ -206,10 +216,18 @@ class Fmi3Slave(ABC):
                 var.setter = lambda v: setattr(owner, var.local_name, np.reshape(v, newshape=getattr(owner, var.local_name).shape))
             else:
                 var.setter = lambda v: setattr(owner, var.local_name, v)
+        
+        if var_type:
+            self.type_definitions[var_type.name] = var_type
+            var.declared_type = var_type.name
 
     def setup_experiment(self, start_time: float):
         pass
 
+    def register_units(self, units: List[Unit]):
+        for unit in units:
+            self.units[unit.name] = unit
+
     def enter_initialization_mode(self):
         pass
 

pythonfmu3/osutil.py

@@ -1,5 +1,4 @@
 import sys
-import platform
 
 import platform
 
@@ -8,7 +7,8 @@ def get_fmu_arch():
     system = platform.system()
     is_x86 = platform.machine() in ["i386", "AMD64", "x86_64"]
     platforms = {"Windows": "windows", "Linux": "linux", "Darwin": "darwin"}
-    return "x86_64" if is_x86 else "x86" + "-" + platforms.get(system, "unknown")
+    arch = "x86_64" if is_x86 else "x86"
+    return arch + "-" + platforms.get(system, "unknown")
 
 def get_platform() -> str:
     """Get FMU binary platform folder name."""

pythonfmu3/pythonfmu-export/src/cppfmu/cppfmu_common.hpp

@@ -105,11 +105,9 @@ public:
 
     Logger(
         FMIComponentEnvironment component,
-        String instanceName,
         fmi3LogMessageCallback logCallback,
         std::shared_ptr<Settings> settings)
         : m_component{component}
-        , m_instanceName(std::move(instanceName))
         , m_fmiLogger{logCallback}
         , m_settings{settings}
     {
@@ -154,7 +152,6 @@ public:
 
 private:
     const FMIComponentEnvironment m_component;
-    const String m_instanceName;
     const FMICallbackLogger m_fmiLogger;
     std::shared_ptr<Settings> m_settings;
 };

pythonfmu3/pythonfmu-export/src/cppfmu/fmi_functions.cpp

@@ -47,10 +47,10 @@ struct Component
         modelError = 1 << 12,
         modelFatal = 1 << 13,
     };
-    Component(cppfmu::FMIString instanceName,
+    Component(cppfmu::FMIComponentEnvironment instanceEnvironment,
         cppfmu::FMICallbackLogger logCallback,
         cppfmu::FMIBoolean loggingOn) : loggerSettings{std::make_shared<cppfmu::Logger::Settings>()},
-        logger{this, instanceName, logCallback, loggerSettings}, lastSuccessfulTime{std::numeric_limits<cppfmu::FMIFloat64>::quiet_NaN()}
+        logger{instanceEnvironment, logCallback, loggerSettings}, lastSuccessfulTime{std::numeric_limits<cppfmu::FMIFloat64>::quiet_NaN()}
     {
         loggerSettings->debugLoggingEnabled = (loggingOn == cppfmu::FMITrue);
     }
@@ -96,7 +96,8 @@ fmi3Instance fmi3InstantiateCoSimulation(
     fmi3IntermediateUpdateCallback intermediateUpdate )
 {
     try {
-        auto component = new Component(instanceName,
+        auto component = new Component(
+            environment,
             logMessage,
             loggingOn);
         component->slave = CppfmuInstantiateSlave(

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/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)
@@ -441,9 +444,14 @@ void PySlaveInstance::GetUInt64(const cppfmu::FMIValueReference* vr, std::size_t
         }
 
         for (int i = 0; i < nvr; i++) {
-            PyObject* value = PyList_GetItem(refs, i);
-            values[i] = static_cast<cppfmu::FMIUInt64>(PyLong_AsUnsignedLongLong(value));
+            PyObject* item = PyList_GetItem(refs, i);
+            PyObject* value = PyObject_GetAttrString(item, "value");
+            if (value && PyLong_Check(value))
+            {
+                values[i] = static_cast<cppfmu::FMIUInt64>(PyLong_AsUnsignedLongLong(value));
+            }
         }
+
         Py_DECREF(refs);
         clearLogBuffer();
     });
@@ -625,7 +633,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 +661,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" {
 
-    return std::make_unique<pythonfmu::PySlaveInstance>(instanceName, resources, logger, visible);
+    // 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;
+    }
+}
+
+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/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/pythonfmu-export/src/pythonfmu/PyState.hpp

@@ -2,40 +2,84 @@
 #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:
-    PyState()
+    class PyState : public IPyState
     {
-        was_initialized_ = Py_IsInitialized();
+    public:
+        PyState()
+            : _initDeinitPyThread_{ &PyState::Worker, this }
+        {
+            auto lock = std::unique_lock{ mutex_ };
+            conditionalVariable_.wait(lock, [&] { return consructed_; });
+        }
 
-        if (!was_initialized_) {
-            Py_SetProgramName(L"./PythonFMU");
-            Py_Initialize();
-            PyEval_InitThreads();
-            _mainPyThread = PyEval_SaveThread();
+        ~PyState() override
+        {
+            {
+                auto const lock = std::lock_guard{ mutex_ };
+                destroyRequested_ = true;
+            }
+            conditionalVariable_.notify_one();
+            if (_initDeinitPyThread_.joinable()) _initDeinitPyThread_.join();
         }
-    }
 
-    ~PyState()
-    {
-        if (!was_initialized_) {
-            PyEval_RestoreThread(_mainPyThread);
-            Py_Finalize();
+    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();
+                }
         }
-    }
 
-private:
-    bool was_initialized_;
-    PyThreadState* _mainPyThread;
-};
+        bool consructed_ = false;
+        bool destroyRequested_ = false;
+        std::condition_variable conditionalVariable_;
+        std::mutex mutex_;
+        std::thread _initDeinitPyThread_;
+    };
 
 } // namespace pythonfmu
 
-#endif //PYTHONFMU_PYTHONSTATE_HPP
+#endif //PYTHONFMU_PYTHONSTATE_HPP

pythonfmu3/tests/slaves/PythonSlaveWithException.py

@@ -1,4 +1,4 @@
-from pythonfmu3.fmi3slave import Fmi3Slave, Fmi3Causality, Float64
+from pythonfmu3.fmi3slave import Fmi3Slave, Fmi3Causality, Float64, Fmi3Variability
 
 
 class PythonSlaveWithException(Fmi3Slave):
@@ -8,6 +8,9 @@ class PythonSlaveWithException(Fmi3Slave):
 
         self.realIn = 22.0
         self.realOut = 0.0
+        self.time = 0
+
+        self.register_variable(Float64("time", causality=Fmi3Causality.independent, variability=Fmi3Variability.continuous))
         self.register_variable(Float64("realIn", causality=Fmi3Causality.input))
         self.register_variable(Float64("realOut", causality=Fmi3Causality.output))
 

pythonfmu3/tests/slaves/pythonslave.py

@@ -21,6 +21,9 @@ class PythonSlave(Fmi3Slave):
         self.realIn = 2. / 3.
         self.booleanParameter = False
         self.stringParameter = "dog"
+        self.time = 0
+
+        self.register_variable(Float64("time", causality=Fmi3Causality.independent, variability=Fmi3Variability.continuous))
         self.register_variable(
             Int32("intParam", causality=Fmi3Causality.parameter, variability=Fmi3Variability.tunable))
         self.register_variable(Float64("realIn", causality=Fmi3Causality.input))

pythonfmu3/tests/slaves/pythonslave_read_file.py

@@ -1,4 +1,4 @@
-from pythonfmu3.fmi3slave import Fmi3Slave, Fmi3Causality, Fmi3Variability, String, DefaultExperiment
+from pythonfmu3.fmi3slave import Fmi3Slave, Fmi3Causality, Fmi3Variability, String, DefaultExperiment, Float64
 
 
 class PythonSlaveReadFile(Fmi3Slave):
@@ -11,6 +11,9 @@ class PythonSlaveReadFile(Fmi3Slave):
         with (open(f'{self.resources}/hello.txt', 'r')) as file:
             data = file.read()
 
+        self.time = 0
+
+        self.register_variable(Float64("time", causality=Fmi3Causality.independent, variability=Fmi3Variability.continuous))
         self.register_variable(
             String("file_content", getter=lambda: data,
                    causality=Fmi3Causality.output,

pythonfmu3/tests/slaves/slavewithdep.py

@@ -1,5 +1,5 @@
 import math
-from pythonfmu3.fmi3slave import Fmi3Slave, Fmi3Causality, Float64
+from pythonfmu3.fmi3slave import Fmi3Slave, Fmi3Causality, Float64, Fmi3Variability
 from localmodule import get_amplitude, get_time_constant
 
 
@@ -10,6 +10,9 @@ class PythonSlaveWithDep(Fmi3Slave):
 
         self.realIn = 22.0
         self.realOut = 0.0
+        self.time = 0
+
+        self.register_variable(Float64("time", causality=Fmi3Causality.independent, variability=Fmi3Variability.continuous))
         self.register_variable(Float64("realIn", causality=Fmi3Causality.input))
         self.register_variable(Float64("realOut", causality=Fmi3Causality.output))
 

pythonfmu3/tests/test_integration.py

@@ -38,13 +38,12 @@ def test_integration_reset(tmp_path):
 
     md = fmpy.read_model_description(str(fmu))
     unzipdir = fmpy.extract(str(fmu))
-    model = fmpy.fmi3.FMI3Slave(guid=md.guid,
+    model = fmpy.fmi3.FMU3Slave(guid=md.guid,
                                 unzipDirectory=unzipdir,
                                 modelIdentifier=md.coSimulation.modelIdentifier,
                                 instanceName="instance"
                                 )
     model.instantiate()
-    model.setupExperiment()
     model.enterInitializationMode()
     model.exitInitializationMode()
 
@@ -52,13 +51,13 @@ def test_integration_reset(tmp_path):
     vr = vars["realOut"].valueReference
     dt = 0.1
 
-    initial_value = model.getReal([vr])[0]
+    initial_value = model.getFloat64([vr])[0]
     assert initial_value == pytest.approx(3.0, rel=1e-7)
     model.doStep(0.0, dt, True)
-    read = model.getReal([vr])[0]
+    read = model.getFloat64([vr])[0]
     assert read == pytest.approx(dt, rel=1e-7)
     model.reset()
-    read = model.getReal([vr])[0]
+    read = model.getFloat64([vr])[0]
     assert read == pytest.approx(initial_value, rel=1e-7)
 
     model.terminate()
@@ -77,13 +76,12 @@ def test_integration_get_state(tmp_path):
 
     md = fmpy.read_model_description(str(fmu))
     unzipdir = fmpy.extract(str(fmu))
-    model = fmpy.fmi3.FMI3Slave(guid=md.guid,
+    model = fmpy.fmi3.FMU3Slave(guid=md.guid,
                                 unzipDirectory=unzipdir,
                                 modelIdentifier=md.coSimulation.modelIdentifier,
                                 instanceName="instance"
                                 )
     model.instantiate()
-    model.setupExperiment()
     model.enterInitializationMode()
     model.exitInitializationMode()
 
@@ -98,15 +96,15 @@ def test_integration_get_state(tmp_path):
         t += dt
 
     step_model()
-    state = model.getFMUstate()
-    assert model.getReal([vr])[0] == pytest.approx(dt, rel=1e-7)
+    state = model.getFMUState()
+    assert model.getFloat64([vr])[0] == pytest.approx(dt, rel=1e-7)
     step_model()
-    assert model.getReal([vr])[0] == pytest.approx(dt * 2, rel=1e-7)
-    model.setFMUstate(state)
-    assert model.getReal([vr])[0] == pytest.approx(dt, rel=1e-7)
+    assert model.getFloat64([vr])[0] == pytest.approx(dt * 2, rel=1e-7)
+    model.setFMUState(state)
+    assert model.getFloat64([vr])[0] == pytest.approx(dt, rel=1e-7)
     step_model()
-    assert model.getReal([vr])[0] == pytest.approx(dt * 3, rel=1e-7)
-    model.freeFMUstate(state)
+    assert model.getFloat64([vr])[0] == pytest.approx(dt * 3, rel=1e-7)
+    model.freeFMUState(state)
 
     model.terminate()
     model.freeInstance()
@@ -126,14 +124,13 @@ def test_integration_get_serialize_state(tmp_path):
     md = fmpy.read_model_description(fmu)
     unzip_dir = fmpy.extract(fmu)
 
-    model = fmpy.fmi3.FMI3Slave(
+    model = fmpy.fmi3.FMU3Slave(
         guid=md.guid,
         unzipDirectory=unzip_dir,
         modelIdentifier=md.coSimulation.modelIdentifier,
         instanceName='instance1')
 
     model.instantiate()
-    model.setupExperiment()
     model.enterInitializationMode()
     model.exitInitializationMode()
 
@@ -148,22 +145,22 @@ def test_integration_get_serialize_state(tmp_path):
         t += dt
 
     step_model()
-    state = model.getFMUstate()
-    assert model.getReal(vrs)[0] == pytest.approx(dt, rel=1e-7)
+    state = model.getFMUState()
+    assert model.getFloat64(vrs)[0] == pytest.approx(dt, rel=1e-7)
     step_model()
-    assert model.getReal(vrs)[0] == pytest.approx(dt * 2, rel=1e-7)
-    model.setFMUstate(state)
-    assert model.getReal(vrs)[0] == pytest.approx(dt, rel=1e-7)
+    assert model.getFloat64(vrs)[0] == pytest.approx(dt * 2, rel=1e-7)
+    model.setFMUState(state)
+    assert model.getFloat64(vrs)[0] == pytest.approx(dt, rel=1e-7)
     step_model()
-    assert model.getReal(vrs)[0] == pytest.approx(dt * 3, rel=1e-7)
+    assert model.getFloat64(vrs)[0] == pytest.approx(dt * 3, rel=1e-7)
 
-    serialize_fmu_state = model.serializeFMUstate(state)
-    model.freeFMUstate(state)
-    de_serialize_fmu_state = model.deSerializeFMUstate(serialize_fmu_state)
-    model.setFMUstate(de_serialize_fmu_state)
-    assert model.getReal(vrs)[0] == pytest.approx(dt, rel=1e-7)
+    serialize_fmu_state = model.serializeFMUState(state)
+    model.freeFMUState(state)
+    de_serialize_fmu_state = model.deserializeFMUState(serialize_fmu_state)
+    model.setFMUState(de_serialize_fmu_state)
+    assert model.getFloat64(vrs)[0] == pytest.approx(dt, rel=1e-7)
 
-    model.freeFMUstate(de_serialize_fmu_state)
+    model.freeFMUState(de_serialize_fmu_state)
 
     model.terminate()
     model.freeInstance()
@@ -178,14 +175,13 @@ def test_integration_get(tmp_path):
     md = fmpy.read_model_description(fmu)
     unzip_dir = fmpy.extract(fmu)
 
-    model = fmpy.fmi3.FMI3Slave(
+    model = fmpy.fmi3.FMU3Slave(
         guid=md.guid,
         unzipDirectory=unzip_dir,
         modelIdentifier=md.coSimulation.modelIdentifier,
         instanceName='instance1')
 
     model.instantiate()
-    model.setupExperiment()
     model.enterInitializationMode()
     model.exitInitializationMode()
 
@@ -207,14 +203,14 @@ def test_integration_get(tmp_path):
     for key, value in to_test.items():
         var = variables[key]
         vrs = [var.valueReference]
-        if var.type == "Integer":
-            model_value = model.getInteger(vrs)[0]
-        elif var.type == "Real":
-            model_value = model.getReal(vrs)[0]
+        if var.type == "Int32":
+            model_value = model.getInt32(vrs)[0]
+        elif var.type == "Float64":
+            model_value = model.getFloat64(vrs)[0]
         elif var.type == "Boolean":
             model_value = model.getBoolean(vrs)[0]
         elif var.type == "String":
-            model_value = model.getString(vrs)[0].decode("UTF-8")
+            model_value = model.getString(vrs)[0]
         else:
             pytest.xfail("Unsupported type")
 
@@ -234,20 +230,19 @@ def test_integration_read_from_file(tmp_path):
     md = fmpy.read_model_description(fmu)
     unzip_dir = fmpy.extract(fmu)
 
-    model = fmpy.fmi3.FMI3Slave(
+    model = fmpy.fmi3.FMU3Slave(
         guid=md.guid,
         unzipDirectory=unzip_dir,
         modelIdentifier=md.coSimulation.modelIdentifier,
         instanceName='instance1')
 
     model.instantiate()
-    model.setupExperiment()
     model.enterInitializationMode()
     model.exitInitializationMode()
 
     variables = mapped(md)
     var = variables["file_content"]
-    model_value = model.getString([var.valueReference])[0].decode("UTF-8")
+    model_value = model.getString([var.valueReference])[0]
 
     with (open(project_file, 'r')) as file:
         data = file.read()
@@ -267,14 +262,13 @@ def test_integration_set(tmp_path):
     md = fmpy.read_model_description(fmu)
     unzip_dir = fmpy.extract(fmu)
 
-    model = fmpy.fmi3.FMI3Slave(
+    model = fmpy.fmi3.FMU3Slave(
         guid=md.guid,
         unzipDirectory=unzip_dir,
         modelIdentifier=md.coSimulation.modelIdentifier,
         instanceName='instance1')
 
     model.instantiate()
-    model.setupExperiment()
     model.enterInitializationMode()
     model.exitInitializationMode()
 
@@ -292,18 +286,18 @@ def test_integration_set(tmp_path):
     for key, value in to_test.items():
         var = variables[key]
         vrs = [var.valueReference]
-        if var.type == "Integer":
-            model.setInteger(vrs, [value])
-            model_value = model.getInteger(vrs)[0]
-        elif var.type == "Real":
-            model.setReal(vrs, [value])
-            model_value = model.getReal(vrs)[0]
+        if var.type == "Int32":
+            model.setInt32(vrs, [value])
+            model_value = model.getInt32(vrs)[0]
+        elif var.type == "Float64":
+            model.setFloat64(vrs, [value])
+            model_value = model.getFloat64(vrs)[0]
         elif var.type == "Boolean":
             model.setBoolean(vrs, [value])
             model_value = model.getBoolean(vrs)[0]
         elif var.type == "String":
             model.setString(vrs, [value])
-            model_value = model.getString(vrs)[0].decode("UTF-8")
+            model_value = model.getString(vrs)[0]
         else:
             pytest.xfail("Unsupported type")
 

pythonfmu3/tests/test_multiple_fmus.py

@@ -22,7 +22,7 @@ def mapped(md):
 @pytest.mark.integration
 def test_integration_multiple_fmus(tmp_path):
     slave1_code = """import math
-from pythonfmu3.Fmi3Slave import Fmi3Slave, Fmi3Causality, Int32, Float64, Boolean, String
+from pythonfmu3 import Fmi3Slave, Fmi3Causality, Fmi3Variability, Int32, Float64, Boolean, String
 
 
 class Slave1(Fmi3Slave):
@@ -32,6 +32,8 @@ class Slave1(Fmi3Slave):
 
         self.realIn = 22.0
         self.realOut = 0.0
+        self.time = 0
+        self.register_variable(Float64("time", causality=Fmi3Causality.independent, variability=Fmi3Variability.continuous))
         self.register_variable(Float64("realIn", causality=Fmi3Causality.input))
         self.register_variable(Float64("realOut", causality=Fmi3Causality.output))
 
@@ -41,7 +43,7 @@ class Slave1(Fmi3Slave):
         return True
 """
 
-    slave2_code = """from pythonfmu3.Fmi3Slave import Fmi3Slave, Fmi3Causality, Int32, Float64, Boolean, String
+    slave2_code = """from pythonfmu3 import Fmi3Slave, Fmi3Causality, Fmi3Variability, Int32, Float64, Boolean, String
 
 
 class Slave2(Fmi3Slave):
@@ -51,6 +53,8 @@ class Slave2(Fmi3Slave):
 
         self.realIn = 22.0
         self.realOut = 0.0
+        self.time = 0
+        self.register_variable(Float64("time", causality=Fmi3Causality.independent, variability=Fmi3Variability.continuous))
         self.register_variable(Float64("realIn", causality=Fmi3Causality.input))
         self.register_variable(Float64("realOut", causality=Fmi3Causality.output))
 
@@ -84,21 +88,20 @@ class Slave2(Fmi3Slave):
     md1 = fmpy.read_model_description(fmu1)
     unzip_dir = fmpy.extract(fmu1)
 
-    model1 = fmpy.fmi3.FMI3Slave(
+    model1 = fmpy.fmi3.FMU3Slave(
         guid=md1.guid,
         unzipDirectory=unzip_dir,
         modelIdentifier=md1.coSimulation.modelIdentifier,
         instanceName='instance1')
 
     model1.instantiate()
-    model1.setupExperiment()
     model1.enterInitializationMode()
     model1.exitInitializationMode()
 
     md2 = fmpy.read_model_description(fmu2)
     unzip_dir = fmpy.extract(fmu2)
 
-    model2 = fmpy.fmi3.FMI3Slave(
+    model2 = fmpy.fmi3.FMU3Slave(
         guid=md2.guid,
         unzipDirectory=unzip_dir,
         modelIdentifier=md2.coSimulation.modelIdentifier,
@@ -111,11 +114,10 @@ class Slave2(Fmi3Slave):
     realIn = variables2["realIn"]
 
     model2.instantiate()
-    model2.setupExperiment()
     model2.enterInitializationMode()
 
-    value = model1.getReal([realOut.valueReference])[0]
-    model2.setReal([realIn.valueReference], [value])
+    value = model1.getFloat64([realOut.valueReference])[0]
+    model2.setFloat64([realIn.valueReference], [value])
 
     model2.exitInitializationMode()
 
@@ -125,12 +127,12 @@ class Slave2(Fmi3Slave):
 
     while time < stop_time:
 
-        model2.setReal([realIn.valueReference], [value])
+        model2.setFloat64([realIn.valueReference], [value])
 
         model1.doStep(time, step_size)
         model2.doStep(time, step_size)
 
-        value = model1.getReal([realOut.valueReference])[0]
+        value = model1.getFloat64([realOut.valueReference])[0]
 
         time += step_size
 

pythonfmu3/tests/test_variables.py

@@ -295,7 +295,9 @@ def test_String_to_xml(name, start):
     r = String(name, start)
     xml = r.to_xml()
     if start is not None:
-        assert xml.attrib['start'] == str(start)
+        start_elements = xml.findall('.//Start')
+        assert len(start_elements) == 1
+        assert start_elements[0].attrib['value'] == str(start)
 
 
 @pytest.mark.requirements("numpy")  

pythonfmu3/unit.py

@@ -0,0 +1,62 @@
+from xml.etree.ElementTree import Element
+
+class BaseUnit(object):
+    tag = "BaseUnit"
+    base_units = {
+        "kg": 0,
+        "m": 0,
+        "s": 0,
+        "A": 0,
+        "K": 0,
+        "mol": 0,
+        "cd": 0,
+        "rad": 0,
+    }
+
+    def __init__(self, factor=1.0, offset=0.0, **kwargs) -> None:
+        self._factor = factor
+        self._offset = offset
+        self._units = {**BaseUnit.base_units, **kwargs}
+
+    @property
+    def units(self):
+        return {key: str(value) for key, value in self._units.items() if value != 0}
+
+    def to_xml(self):
+      """Convert the variable to XML node.
+
+      Returns
+          xml.etree.ElementTree.Element: XML node
+      """
+      attrib = dict()
+      if self._factor != 1.0:
+        attrib["factor"] = str(self._factor)
+      if self._offset != 0.0:
+        attrib["offset"] = str(self._offset)
+      attrib.update(self.units)
+      ele = Element(self.tag, attrib)
+      return ele
+
+
+class Unit(object):
+    tag = "Unit"
+
+    def __init__(self, name, **kwargs):
+        self._name = name
+        self._base_unit = BaseUnit(**kwargs)
+
+    @property
+    def name(self) -> str:
+       return self._name
+
+    def to_xml(self) -> Element:
+      """Convert the variable to XML node.
+
+      Returns
+          xml.etree.ElementTree.Element: XML node
+      """
+      attrib = dict()
+      attrib["name"] = self._name
+      ele = Element(self.tag, attrib)
+      ele.append(self._base_unit.to_xml())
+      return ele

pythonfmu3/{type_definitions.py → variable_types.py}

@@ -1,13 +1,20 @@
 from enum import Enum
-from typing import Any, Optional, List
+from typing import Optional
 from xml.etree.ElementTree import Element
 
+class VariableType(object):
 
-class TypeDefinitions(object):
-    tag = "TypeDefinitions"
-
-    def __init__(self, types: List[Any]):
-        self.types = types
+    def __init__(self, tag, name, **kwargs):
+        self._tag = tag
+        self._attrs = {
+            "name": name,
+        }
+        self._attrs.update(**kwargs)
+    
+    @property
+    def name(self) -> str:
+        """str: Variable name"""
+        return self._attrs["name"]
 
     def to_xml(self) -> Element:
         """Convert the variable to XML node.
@@ -16,19 +23,25 @@ class TypeDefinitions(object):
             xml.etree.ElementTree.Element: XML node
         """
         attrib = dict()
-        ele = Element(self.tag, attrib)
-        for definition in self.types:
-            ele.append(definition.to_xml())
-        return ele
+        for key, value in self._attrs.items():
+            if value is not None:
+                attrib[key] = str(value.name if isinstance(value, Enum) else value)
+        return Element(self._tag, attrib)
+
+class Float64Type(VariableType):
+    tag = "Float64Type"
+
+    def __init__(self, name, **kwargs):
+        super().__init__(self.tag, name, **kwargs)
 
 
 class Item(object):
     tag = "Item"
 
-    def __init__(self, name: str, value: str, description: str = ""):
+    def __init__(self, name: str, value: int, description: str = "", **kwargs):
         self.__attrs = {
             "name": name,
-            "value": value,
+            "value": str(value),
             "description": description
         }
 
@@ -61,18 +74,21 @@ class Item(object):
                f"value={self.value}, " \
                f"description={self.description})"
 
-
-class EnumerationType(object):
+class EnumerationType(VariableType):
     tag = "EnumerationType"
 
-    def __init__(self, name: str, items = List[Item]):
-        self.__attrs = {
-            "name": name
-        }
-        self._items = items
+    def __init__(self, name: str, values: Optional[Enum] = None,  **kwargs):
+        super().__init__(self.tag, name, **kwargs)
+        self._items = {}
+        
+        for val in values:
+            self.add_value(name = val.name, value = val.value)
 
-    def name(self) -> str:
-        return self.__attrs["name"]
+    def add_value(self, name: str, value: int, description: str = "", **kwargs):
+        self._items[name] = Item(name, value, description, **kwargs)
+    
+    def get_value(self, name):
+        return self._items[name]
 
     def to_xml(self) -> Element:
         """Convert the variable to XML node.
@@ -80,7 +96,7 @@ class EnumerationType(object):
         Returns
             xml.etree.ElementTree.Element: XML node
         """
-        element = Element(self.tag, self.__attrs)
-        for item in self._items:
-            element.append(item.to_xml())
-        return element
+        parent = super().to_xml()
+        for _, item in self._items.items():
+            parent.append(item.to_xml())
+        return parent

pythonfmu3/variables.py

@@ -32,6 +32,7 @@ class ModelVariable(ABC):
         description: Optional[str] = None,
         initial: Optional[Fmi3Initial] = None,
         variability: Optional[Fmi3Variability] = None,
+        declared_type: Optional[str] = None,
         getter: Any = None,
         setter: Any = None
     ):
@@ -46,6 +47,7 @@ class ModelVariable(ABC):
             "causality": causality,
             "variability": variability,
             "initial": initial,
+            "declaredType": declared_type,
             # 'canHandleMultipleSetPerTimeInstant': # Only for ME
         }
         self._extras = {}
@@ -81,6 +83,17 @@ class ModelVariable(ABC):
             raise RuntimeError("Value reference already set.")
         self.__attrs["valueReference"] = value
 
+    @property
+    def declared_type(self) -> str:
+        """str: declared type"""
+        return self.__attrs["declaredType"]
+
+    @declared_type.setter
+    def declared_type(self, value: str):
+        if self.__attrs["declaredType"] is not None:
+            raise RuntimeError("Declared type already set.")
+        self.__attrs["declaredType"] = value
+    
     @property
     def variability(self) -> Optional[Fmi3Variability]:
         """:obj:`Fmi3Variability` or None: Variable variability - None if not set"""
@@ -119,6 +132,16 @@ class ModelVariable(ABC):
                f"causality={self.causality}, " \
                f"variability={self.variability})"
 
+class Start(object):
+    def __init__(self, startValue):
+        self.value = startValue
+    
+    def to_xml(self) -> Element:
+        attrib = dict()
+        attrib["value"] = self.value
+        return Element("Start", attrib)
+
+
 class Dimension(object):
     def __init__(self, start: str = "", valueReference: str = ""):
         if start and valueReference and any((start, valueReference)):
@@ -131,7 +154,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:
@@ -145,10 +168,11 @@ class Dimension(object):
         return ele
 
 class Float64(ModelVariable):
-    def __init__(self, name: str, start: Optional[Any] = None, derivative: Optional[Any] = None, dimensions: List[Dimension] = [], **kwargs):
+    def __init__(self, name: str, start: Optional[Any] = None, derivative: Optional[Any] = None, dimensions: List[Dimension] = [], unit: Optional[str] = None, **kwargs):
         super().__init__(name, **kwargs)
         self.__attrs = {"start": start, "derivative": derivative}
         self._type = "Float64"
+        self._unit = unit
         if dimensions:
             check_numpy()
         self.__dimensions = dimensions
@@ -160,6 +184,14 @@ class Float64(ModelVariable):
     @start.setter
     def start(self, value: float):
         self.__attrs["start"] = value
+    
+    @property
+    def unit(self) -> Optional[Any]:
+        return self._unit
+
+    @unit.setter
+    def unit(self, value: str):
+        self._unit = value
 
     @property
     def derivative(self):
@@ -169,6 +201,7 @@ class Float64(ModelVariable):
     def dimensions(self) -> List[Dimension]:
         return self.__dimensions
 
+
     def to_xml(self) -> Element:
         attrib = dict()
         for key, value in self.__attrs.items():
@@ -181,6 +214,10 @@ class Float64(ModelVariable):
                 else:
                     output = f"{value:.16g}"
                 attrib[key] = output
+
+        if self.unit:
+            attrib["unit"] = self.unit
+
         self._extras = attrib
         parent = super().to_xml()
 
@@ -293,16 +330,17 @@ class Boolean(ModelVariable):
 class String(ModelVariable):
     def __init__(self, name: str, start: Optional[Any] = None, **kwargs):
         super().__init__(name, **kwargs)
-        self.__attrs = {"start": start}
+        self.__attrs = dict()
         self._type = "String"
+        self._start = Start(start)
 
     @property
     def start(self) -> Optional[Any]:
-        return self.__attrs["start"]
+        return self._start.value
 
     @start.setter
     def start(self, value: float):
-        self.__attrs["start"] = value
+        self._start.value = value
 
     def to_xml(self) -> Element:
         attrib = dict()
@@ -311,6 +349,9 @@ class String(ModelVariable):
                 attrib[key] = str(value)
         self._extras = attrib
         parent = super().to_xml()
+        
+        if self.start is not None:
+            parent.append(self._start.to_xml())
 
         return parent
     

{pythonfmu3-0.1.10.dist-info → pythonfmu3-0.1.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: pythonfmu3
-Version: 0.1.10
+Version: 0.1.16
 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
@@ -21,8 +21,8 @@ Classifier: Topic :: Scientific/Engineering
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: tests
-Requires-Dist: pytest ; extra == 'tests'
-Requires-Dist: fmpy ; extra == 'tests'
+Requires-Dist: pytest; extra == "tests"
+Requires-Dist: fmpy; extra == "tests"
 
 # PythonFMU3
 
@@ -40,13 +40,7 @@ This project is a fork of the original PythonFMU repository available at https:/
 
 ### Support:
 
-We currently support a basic FMU which follows the FMI3 standard. This includes support for:
-
-- Float64, Int32, UInt64, String, Boolean variables
-- Step Mode
-- Arrays, which requires the numpy package
-
-Please take a look at the examples bouncingBall.py and linearTransform.py for a demonstration of these features.
+Please take a look at the examples to see the supported features.
 
 ### Future
 
@@ -55,7 +49,6 @@ In no particular order, we plan to add support for:
 - Support more variable types from FMI3
 - Improve array support
 - Add event mode
-- Include FMI3 related testing
 
 ### How do I build an FMU from python code?
 
@@ -138,16 +131,18 @@ from pythonfmu3 import Fmi3Causality, Fmi3Slave, Boolean, Int32, Float64, String
 
 class PythonSlave(Fmi3Slave):
 
-    author = "John Doe"
-    description = "A simple description"
-
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
 
+        self.author = "John Doe"
+        self.description = "A simple description"
+
+        self.time = 0.0
         self.intOut = 1
         self.realOut = 3.0
         self.booleanVariable = True
         self.stringVariable = "Hello World!"
+        self.register_variable(Float64("time", causality=Fmi3Causality.independent))
         self.register_variable(Int32("intOut", causality=Fmi3Causality.output))
         self.register_variable(Float64("realOut", causality=Fmi3Causality.output))
         self.register_variable(Boolean("booleanVariable", causality=Fmi3Causality.local))

{pythonfmu3-0.1.10.dist-info → pythonfmu3-0.1.16.dist-info}/RECORD

@@ -1,52 +1,54 @@
-pythonfmu3/__init__.py,sha256=aTB9p2E_p6D6-KeUa1HGfzH88i_8Oin3JNApVD2D5HQ,375
+pythonfmu3/__init__.py,sha256=PT1R0LpSInyVdXGJbkWMTQym6_SEU7CqUkG7OH5j1f0,396
 pythonfmu3/__main__.py,sha256=gC1T8x2d02hhqshyNQGSS70SyCk-3I3t8zPqoRo2Xd8,1543
-pythonfmu3/_version.py,sha256=z0zCHFTcKSR0tJ6h5qrpNmRVP21QIPP8N0p7quCnnm0,23
+pythonfmu3/_version.py,sha256=yF88-8vL8keLe6gCTumymw0UoMkWkSrJnzLru4zBCLQ,23
 pythonfmu3/builder.py,sha256=YLTeLLpiFOkoDYwnJ55GEhb3ham0xxROMjMN6bvaw5Y,8784
 pythonfmu3/default_experiment.py,sha256=FJ0l0FpU7pT4Pox2RiA2y-Cb_e7DE2XlbWKySRYQaVk,293
 pythonfmu3/deploy.py,sha256=eqFWVxZUkJCLvmq1-GuMNjn2j0VCGoaXPhRWrCk2Vxg,3741
 pythonfmu3/enums.py,sha256=ZmC6vGeBTGt7HarPQ4uYV10ezPsvIxAHH1ypjNq7G3E,729
-pythonfmu3/fmi3slave.py,sha256=sJvODS7_adGYR4Ki4cBlmX-1LMxiK2iHrBKL0WqzDmI,15962
+pythonfmu3/fmi3slave.py,sha256=7rDp_5TCQnkFLV11UF55mKEvUDXbpZPfn8sOjYCNCSw,16569
 pythonfmu3/logmsg.py,sha256=0wn11GLwq0LLWqyC2ktLRjQFWlpj07wWliZ8rUHx1gg,359
-pythonfmu3/osutil.py,sha256=KMAoMf_BpqFQQUy3WzHnt9jiklkS1xy0syIbj7kNH6A,656
-pythonfmu3/type_definitions.py,sha256=gcwe5HueMBfOuHk6pkf6TNJHKfUtqga_DNbj0o13XKk,2219
-pythonfmu3/variables.py,sha256=sKVOnITuirzHIMAC2f9CrKlGX8-R-dGoteKS-QCv2nk,10838
+pythonfmu3/osutil.py,sha256=1qN6qudN4zCupZwc15pzp52WObkqi6jGy9a-MehNt9Q,656
+pythonfmu3/unit.py,sha256=SjOaywb5lVQbAO_iLjc_7Ly3nYrmAvIW2_hAGt12UFU,1475
+pythonfmu3/variable_types.py,sha256=Q0D4wlGi3i3zE5UsmGJEpNh7SV_W8mn_8p_WIkwrLQA,2881
+pythonfmu3/variables.py,sha256=hwYT6AfaSQIa1egVJrOxnDi5NEj1bk_VkQd9-hsoDII,11905
 pythonfmu3/pythonfmu-export/.clang-format,sha256=ApbsHWYwilCXJ1iBux4nqOjLkaqgbGLsVrc_U3hX7WI,944
 pythonfmu3/pythonfmu-export/CMakeLists.txt,sha256=p0-4Xh_sAaOI9AVb8lsUsMxJPc6bg9b_6CF6NJt5FHE,1847
 pythonfmu3/pythonfmu-export/build_unix.sh,sha256=I5RrF2O6y0hRG_SN4ExKN_CCFYaa2l-ngKzqmBXnHmA,73
 pythonfmu3/pythonfmu-export/build_win.sh,sha256=UzmAcWqFmwBu6mvYne2Dx3UK8iPwTtP4HpjICsjUaJA,97
 pythonfmu3/pythonfmu-export/src/CMakeLists.txt,sha256=RyjGhUUDhG_HEieCdt5WMfTR1snofOqigEKc83_zvfE,1104
-pythonfmu3/pythonfmu-export/src/cppfmu/cppfmu_common.hpp,sha256=k6TEU6J6fe6RJWxsvA4uA2W4BRQriPnkQX4GKdM-MgA,4465
+pythonfmu3/pythonfmu-export/src/cppfmu/cppfmu_common.hpp,sha256=cgrlZa5L-bbjZeVi0pmy4JKE5UJ2GszzuyOqTdRcBRQ,4353
 pythonfmu3/pythonfmu-export/src/cppfmu/cppfmu_cs.cpp,sha256=EsUIevwmCzX9hsui3i8x1crSnSOG8dEK15Zm1ZIavYQ,3843
 pythonfmu3/pythonfmu-export/src/cppfmu/cppfmu_cs.hpp,sha256=v4Fb8gOWk2tsUgnuQ2NBeqwc3EFQhWRxvDYHtL1C0zk,6144
-pythonfmu3/pythonfmu-export/src/cppfmu/fmi_functions.cpp,sha256=sTHQVUCH_dwIxRl6u1VRNkTb1MRUoVlQLGpTPh5WQdk,25505
+pythonfmu3/pythonfmu-export/src/cppfmu/fmi_functions.cpp,sha256=olF5Umz35uqXVMT_v9UMvwmvOJzbRbjuq1uOfnlvtUA,25539
 pythonfmu3/pythonfmu-export/src/fmi/fmi3FunctionTypes.h,sha256=Tk1WY0nAYBGiOAQ8zVbmqRAfdQttITWsLba7udhBwG4,30050
 pythonfmu3/pythonfmu-export/src/fmi/fmi3Functions.h,sha256=NsHuclp20wcuUInYf-91UXZbljTeu2cPXENqNEORdgU,16262
 pythonfmu3/pythonfmu-export/src/fmi/fmi3PlatformTypes.h,sha256=ZCQLJgSbRGrMsBiQ4auaYCY4J3Hck6g3t1iZp5NEguw,4251
-pythonfmu3/pythonfmu-export/src/pythonfmu/PySlaveInstance.cpp,sha256=uVGq0QcTySLjgTd3_fe-csPenT89DukCPL4u_j4rDew,22610
-pythonfmu3/pythonfmu-export/src/pythonfmu/PySlaveInstance.hpp,sha256=XvRaA0OvB9MRSxFUP64TvHsLEP4CSOn0WcfImegS2_8,3954
-pythonfmu3/pythonfmu-export/src/pythonfmu/PyState.hpp,sha256=PApY1VOpEJbzrnQjKB1-UoTKKCzaDbIGF-dZt6f3Uls,717
-pythonfmu3/resources/binaries/x86_64-linux/libpythonfmu-export.so,sha256=-xeuSKeqjB5_96yRhInnWCPh6kBXmlOHNeRzZZfOG9M,353232
-pythonfmu3/resources/binaries/x86_64-windows/pythonfmu-export.dll,sha256=itKDopGQbFf_7BJDOZSctnRsamjyx5sVslfrAWWnyFk,417280
+pythonfmu3/pythonfmu-export/src/pythonfmu/IPyState.hpp,sha256=GLiOjhKLDVEICersnqVwezwEshbxfdh_cyMxBJGFbu8,456
+pythonfmu3/pythonfmu-export/src/pythonfmu/PySlaveInstance.cpp,sha256=pzHSx3Cfq7Lt7dcvMR5na7tyOrTs0RsNglnrAcRc0cs,24333
+pythonfmu3/pythonfmu-export/src/pythonfmu/PySlaveInstance.hpp,sha256=Q8eulMAkv7YkfzCi2KSwxvYngv0I_nRbmfTJR9vT92M,4063
+pythonfmu3/pythonfmu-export/src/pythonfmu/PyState.hpp,sha256=CjFEIrZu8b1jxQAIgfI_o36hyItW_SdQ5VSkImf7JNs,2977
+pythonfmu3/resources/binaries/x86_64-linux/libpythonfmu-export.so,sha256=w89mM0c5nt_5RT1uYWtFFrM-qd40y7vdW-cmLbuo9Cc,365120
+pythonfmu3/resources/binaries/x86_64-windows/pythonfmu-export.dll,sha256=jjd6J1oOhFfExxYkoUClk4uakAmUc00HbZParm7iFXY,430592
 pythonfmu3/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pythonfmu3/tests/conftest.py,sha256=B6XxTnBdeF_tEJ3w2DlfPKUfvlk-oULgIhQtXkgOJIc,171
 pythonfmu3/tests/test_builder.py,sha256=StR9oNmF6dtuxxKtPFlncLQN-O7n97nvHm6EFH4Qn14,6252
 pythonfmu3/tests/test_deploy.py,sha256=JCDo-O93-izxrP9Q4K0njBcfZ-gAXYx9aZ4plgctz7k,1783
 pythonfmu3/tests/test_fmi3slave.py,sha256=1uwTdfiFZNmU0yzIdC30kAuu95xsZSTMA9CGk_Kdmm4,4304
-pythonfmu3/tests/test_integration.py,sha256=2ewA-Mai5qbC5ujyYDLo_Em1NzGsfrgaYiugDZH53ow,10562
+pythonfmu3/tests/test_integration.py,sha256=zA3iJ4rI2cKEE8mDsAmcVuwNWlJzhonV8Wxz92hzEac,10387
 pythonfmu3/tests/test_logger.py,sha256=OcHQhxUtNBPH-0zdmheC4I9OWz1yu48W8MYDshNVkf8,5765
-pythonfmu3/tests/test_multiple_fmus.py,sha256=NJC3aHu1PA4LlZjMmCfC3IKh-_IBu1h3QMkrKiDYFrY,3680
-pythonfmu3/tests/test_variables.py,sha256=ULSOUASU8PpRwDWO9MMNTv-u-fqhSqNGVJ28S2Q6M2k,9495
+pythonfmu3/tests/test_multiple_fmus.py,sha256=-sthCm2YUZiRkdfvpLQNgquPBForUKQ7HGqfFBdrRas,3942
+pythonfmu3/tests/test_variables.py,sha256=t4r2TBruf58uYwjkp3r-RcZS5TrsOaVT_mDuoiUTQtg,9598
 pythonfmu3/tests/utils.py,sha256=WusWSUGoBPenZL-FAKQlzaHN2aYXiznZM2fwCjoldwY,301
 pythonfmu3/tests/data/csvdemo.csv,sha256=TiTUyzHyjQNXM4eXI33oJipc7w9_PJ8aMejRmwc52Xw,256
 pythonfmu3/tests/data/hello.txt,sha256=wFNeS-K3n_2TKRMFQ2v4iTFOSj-uwF7P_Lt98xrZ5Ro,12
-pythonfmu3/tests/slaves/PythonSlaveWithException.py,sha256=SUSjrba1mZBT_2pOYNQi2fEv8Ns5QWDM5zYps__4NJM,479
+pythonfmu3/tests/slaves/PythonSlaveWithException.py,sha256=lTTMMnD5Cu09HzA8G2masKyf-ntEMfJ0a3M8btdYVLo,644
 pythonfmu3/tests/slaves/localmodule.py,sha256=-q5Lmh2I88MG7nLTscms0n5xhHLkUDed1IuQ5wj49lo,79
-pythonfmu3/tests/slaves/pythonslave.py,sha256=H75vLhqshSWWvMj2NQt6a_aQhA6BGSkBVJstjjVE0AU,2024
-pythonfmu3/tests/slaves/pythonslave_read_file.py,sha256=NIAmyZZGNAcnqf8R5jb1yFcQxj6iSMOAc13pY0GFtco,634
-pythonfmu3/tests/slaves/slavewithdep.py,sha256=4yqxa0vsOTLLvtaUQFkjfU9OcwjDUtuUe-qIjnD-jrw,647
-pythonfmu3-0.1.10.dist-info/LICENSE,sha256=24Cw_MPouLK-G_t8Hgjm59IS9BnPoL6SKkyuZ0xesXY,1155
-pythonfmu3-0.1.10.dist-info/METADATA,sha256=P0EXnuAfYYGxZMM0YIYUIX_SKWp5bNYXKrCPv0gkAz0,7597
-pythonfmu3-0.1.10.dist-info/WHEEL,sha256=5sUXSg9e4bi7lTLOHcm6QEYwO5TIF1TNbTSVFVjcJcc,92
-pythonfmu3-0.1.10.dist-info/entry_points.txt,sha256=GgkWYs0DKGHLcijMEYZGkhkHOK2RVUpjGwvl1fwyDwQ,60
-pythonfmu3-0.1.10.dist-info/top_level.txt,sha256=6ne7bh_cME1hepxCx1BG8N5QVhVAufrp7LLok6vq7nE,11
-pythonfmu3-0.1.10.dist-info/RECORD,,
+pythonfmu3/tests/slaves/pythonslave.py,sha256=uzrTQmfk0QBalxNTviGMZNph_YgVmcbxPqKgX5rSvXg,2172
+pythonfmu3/tests/slaves/pythonslave_read_file.py,sha256=t2sDaZSr2veD91gdqCO9W9CN-AN3TyXABXXfV9Rt0Xs,791
+pythonfmu3/tests/slaves/slavewithdep.py,sha256=hHDFB0dw8wkHiGzxeAVbz9O5LR6ghsFeONgRFdiK_t0,812
+pythonfmu3-0.1.16.dist-info/LICENSE,sha256=24Cw_MPouLK-G_t8Hgjm59IS9BnPoL6SKkyuZ0xesXY,1155
+pythonfmu3-0.1.16.dist-info/METADATA,sha256=fNhz4isDTQ1wlef8U-x5AYctr3bPGKRSqtSC8IunMhU,7442
+pythonfmu3-0.1.16.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+pythonfmu3-0.1.16.dist-info/entry_points.txt,sha256=GgkWYs0DKGHLcijMEYZGkhkHOK2RVUpjGwvl1fwyDwQ,60
+pythonfmu3-0.1.16.dist-info/top_level.txt,sha256=6ne7bh_cME1hepxCx1BG8N5QVhVAufrp7LLok6vq7nE,11
+pythonfmu3-0.1.16.dist-info/RECORD,,

{pythonfmu3-0.1.10.dist-info → pythonfmu3-0.1.16.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.1)
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any