pythonfmu3 0.2.2.2__py3-none-any.whl → 0.2.4__py3-none-any.whl

pythonfmu3/pythonfmu-export/src/pythonfmu/PySlaveInstance.hpp

@@ -1,111 +1,111 @@
-
-#ifndef PYTHONFMU_SLAVEINSTANCE_HPP
-#define PYTHONFMU_SLAVEINSTANCE_HPP
-
-#include "cppfmu/cppfmu_cs.hpp"
-#include "pythonfmu/IPyState.hpp"
-
-#include <Python.h>
-#include <string>
-#include <vector>
-
-namespace pythonfmu
-{
-
-class PySlaveInstance : public cppfmu::SlaveInstance
-{
-
-public:
-    PySlaveInstance(std::string instanceName, std::string resources, const cppfmu::Logger& logger, bool visible, std::shared_ptr<IPyState> pyState);
-
-    void initialize(PyGILState_STATE gilState);
-
-    void SetupExperiment(cppfmu::FMIBoolean toleranceDefined, cppfmu::FMIFloat64 tolerance, cppfmu::FMIFloat64 tStart, cppfmu::FMIBoolean stopTimeDefined, cppfmu::FMIFloat64 tStop) override;
-    void EnterInitializationMode() override;
-    void ExitInitializationMode() override;
-    void Terminate() override;
-    void Reset() override;
-    cppfmu::FMIStatus DoStep(cppfmu::FMIFloat64 currentCommunicationPoint,
-        cppfmu::FMIFloat64 communicationStepSize,
-        cppfmu::FMIBoolean newStep,
-        cppfmu::FMIBoolean* eventHandlingNeeded,
-        cppfmu::FMIBoolean* terminateSimulation,
-        cppfmu::FMIBoolean* earlyReturn,
-        cppfmu::FMIFloat64& endOfStep) override;
-
-    void SetFloat64(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIFloat64* value, std::size_t nValues) override;
-    void SetInt32(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIInt32* value) override;
-    void SetInt64(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIInt64* value) override;
-    void SetUInt64(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIUInt64* value) override;
-    void SetBoolean(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIBoolean* value) override;
-    void SetString(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIString const* value) override;
-
-    void GetFloat64(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIFloat64* value, std::size_t nValues) const override;
-    void GetInt32(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIInt32* value) const override;
-    void GetInt64(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIInt64* value) const override;
-    void GetUInt64(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIUInt64* value) const override;
-    void GetBoolean(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIBoolean* value) const override;
-    void GetString(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIString* value) const override;
-
-    void GetFMUstate(fmi3FMUState& State) override;
-    void SetFMUstate(const fmi3FMUState& State) override;
-    void FreeFMUstate(fmi3FMUState& State) override;
-
-    size_t SerializedFMUstateSize(const fmi3FMUState& State) override;
-    void SerializeFMUstate(const fmi3FMUState& State, fmi3Byte bytes[], size_t size) override;
-    void DeSerializeFMUstate(const fmi3Byte bytes[], size_t size, fmi3FMUState& State) override;
-
-    void clearLogBuffer() const;
-
-    ~PySlaveInstance() override;
-
-private:
-    std::shared_ptr<IPyState> pyState_;
-    PyObject* pClass_;
-    PyObject* pInstance_{};
-    PyObject* pMessages_{};
-
-    const bool visible_;
-    const std::string instanceName_;
-    const std::string resources_;
-    const cppfmu::Logger& logger_;
-
-    mutable std::vector<PyObject*> strBuffer;
-    mutable std::vector<PyObject*> logStrBuffer;
-
-    void handle_py_exception(const std::string& what, PyGILState_STATE gilState) const;
-
-    inline void clearStrBuffer() const
-    {
-        if (!strBuffer.empty()) {
-            for (auto obj : strBuffer) {
-                Py_DECREF(obj);
-            }
-            strBuffer.clear();
-        }
-    }
-
-    inline void clearLogStrBuffer() const
-    {
-        if (!logStrBuffer.empty()) {
-            for (auto obj : logStrBuffer) {
-                Py_DECREF(obj);
-            }
-            logStrBuffer.clear();
-        }
-    }
-
-    inline void cleanPyObject() const
-    {
-        clearLogBuffer();
-        clearLogStrBuffer();
-        clearStrBuffer();
-        Py_XDECREF(pClass_);
-        Py_XDECREF(pInstance_);
-        Py_XDECREF(pMessages_);
-    }
-};
-
-} // namespace pythonfmu
-
-#endif
+
+#ifndef PYTHONFMU_SLAVEINSTANCE_HPP
+#define PYTHONFMU_SLAVEINSTANCE_HPP
+
+#include "cppfmu/cppfmu_cs.hpp"
+#include "pythonfmu/IPyState.hpp"
+
+#include <Python.h>
+#include <string>
+#include <vector>
+
+namespace pythonfmu
+{
+
+class PySlaveInstance : public cppfmu::SlaveInstance
+{
+
+public:
+    PySlaveInstance(std::string instanceName, std::string resources, const cppfmu::Logger& logger, bool visible, std::shared_ptr<IPyState> pyState);
+
+    void initialize(PyGILState_STATE gilState);
+
+    void SetupExperiment(cppfmu::FMIBoolean toleranceDefined, cppfmu::FMIFloat64 tolerance, cppfmu::FMIFloat64 tStart, cppfmu::FMIBoolean stopTimeDefined, cppfmu::FMIFloat64 tStop) override;
+    void EnterInitializationMode() override;
+    void ExitInitializationMode() override;
+    void Terminate() override;
+    void Reset() override;
+    cppfmu::FMIStatus DoStep(cppfmu::FMIFloat64 currentCommunicationPoint,
+        cppfmu::FMIFloat64 communicationStepSize,
+        cppfmu::FMIBoolean newStep,
+        cppfmu::FMIBoolean* eventHandlingNeeded,
+        cppfmu::FMIBoolean* terminateSimulation,
+        cppfmu::FMIBoolean* earlyReturn,
+        cppfmu::FMIFloat64& endOfStep) override;
+
+    void SetFloat64(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIFloat64* value, std::size_t nValues) override;
+    void SetInt32(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIInt32* value) override;
+    void SetInt64(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIInt64* value) override;
+    void SetUInt64(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIUInt64* value) override;
+    void SetBoolean(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIBoolean* value) override;
+    void SetString(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIString const* value) override;
+
+    void GetFloat64(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIFloat64* value, std::size_t nValues) const override;
+    void GetInt32(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIInt32* value) const override;
+    void GetInt64(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIInt64* value) const override;
+    void GetUInt64(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIUInt64* value) const override;
+    void GetBoolean(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIBoolean* value) const override;
+    void GetString(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIString* value) const override;
+
+    void GetFMUstate(fmi3FMUState& State) override;
+    void SetFMUstate(const fmi3FMUState& State) override;
+    void FreeFMUstate(fmi3FMUState& State) override;
+
+    size_t SerializedFMUstateSize(const fmi3FMUState& State) override;
+    void SerializeFMUstate(const fmi3FMUState& State, fmi3Byte bytes[], size_t size) override;
+    void DeSerializeFMUstate(const fmi3Byte bytes[], size_t size, fmi3FMUState& State) override;
+
+    void clearLogBuffer() const;
+
+    ~PySlaveInstance() override;
+
+private:
+    std::shared_ptr<IPyState> pyState_;
+    PyObject* pClass_;
+    PyObject* pInstance_{};
+    PyObject* pMessages_{};
+
+    const bool visible_;
+    const std::string instanceName_;
+    const std::string resources_;
+    const cppfmu::Logger& logger_;
+
+    mutable std::vector<PyObject*> strBuffer;
+    mutable std::vector<PyObject*> logStrBuffer;
+
+    void handle_py_exception(const std::string& what, PyGILState_STATE gilState) const;
+
+    inline void clearStrBuffer() const
+    {
+        if (!strBuffer.empty()) {
+            for (auto obj : strBuffer) {
+                Py_DECREF(obj);
+            }
+            strBuffer.clear();
+        }
+    }
+
+    inline void clearLogStrBuffer() const
+    {
+        if (!logStrBuffer.empty()) {
+            for (auto obj : logStrBuffer) {
+                Py_DECREF(obj);
+            }
+            logStrBuffer.clear();
+        }
+    }
+
+    inline void cleanPyObject() const
+    {
+        clearLogBuffer();
+        clearLogStrBuffer();
+        clearStrBuffer();
+        Py_XDECREF(pClass_);
+        Py_XDECREF(pInstance_);
+        Py_XDECREF(pMessages_);
+    }
+};
+
+} // namespace pythonfmu
+
+#endif

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

@@ -1,85 +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
-
+
+#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/tests/conftest.py

@@ -1,6 +1,6 @@
-import pytest
-
-def pytest_configure(config):  
-    config.addinivalue_line(  
-        "markers", "requirements(pkg): mark test as requiring the specified package"  
+import pytest
+
+def pytest_configure(config):  
+    config.addinivalue_line(  
+        "markers", "requirements(pkg): mark test as requiring the specified package"  
     ) 

pythonfmu3/tests/data/csvdemo.csv

@@ -1,7 +1,7 @@
-t, default_Float64, submodel.int [1 INTEGER], real[1][REAL], bool[BOOLEAN], string [STRING]
-0.0, -1, 1, 2.0, true,"1"
-0.1,-1, 2, 4.0, false, "2"
-0.2, -1, 3, 8.0, true, "3"
-0.3, -1, 4, 16.0,false, "4"
-0.4, -1, 5, 32.0, true, "5"
-0.5, -1,6, 64.0, false, "6"
+t, default_Float64, submodel.int [1 INTEGER], real[1][REAL], bool[BOOLEAN], string [STRING]
+0.0, -1, 1, 2.0, true,"1"
+0.1,-1, 2, 4.0, false, "2"
+0.2, -1, 3, 8.0, true, "3"
+0.3, -1, 4, 16.0,false, "4"
+0.4, -1, 5, 32.0, true, "5"
+0.5, -1,6, 64.0, false, "6"

pythonfmu3/tests/slaves/PythonSlaveWithException.py

@@ -1,18 +1,18 @@
-from pythonfmu3.fmi3slave import Fmi3Slave, Fmi3Causality, Float64, Fmi3Variability
-
-
-class PythonSlaveWithException(Fmi3Slave):
-
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-
-        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))
-
-    def do_step(self, current_time, step_size):
-        raise RuntimeError()
+from pythonfmu3.fmi3slave import Fmi3Slave, Fmi3Causality, Float64, Fmi3Variability
+
+
+class PythonSlaveWithException(Fmi3Slave):
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        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))
+
+    def do_step(self, current_time, step_size):
+        raise RuntimeError()

pythonfmu3/tests/slaves/localmodule.py

@@ -1,8 +1,8 @@
-
-
-def get_amplitude():
-    return 5.
-
-
-def get_time_constant():
-    return 0.1
+
+
+def get_amplitude():
+    return 5.
+
+
+def get_time_constant():
+    return 0.1

pythonfmu3/tests/slaves/pythonslave.py

@@ -1,52 +1,52 @@
-from pythonfmu3.fmi3slave import Fmi3Slave, Fmi3Causality, Fmi3Variability, Int32, Float64, Boolean, String
-
-
-class Container:
-    pass
-
-
-class PythonSlave(Fmi3Slave):
-
-    author = "John Doe"
-    description = "A simple description"
-
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-
-        self.intParam = 42
-        self.intOut = 23
-        self.realOut = 3.0
-        self.booleanVariable = True
-        self.stringVariable = "Hello World!"
-        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))
-        self.register_variable(
-            Boolean("booleanParameter", causality=Fmi3Causality.parameter, variability=Fmi3Variability.tunable))
-        self.register_variable(
-            String("stringParameter", causality=Fmi3Causality.parameter, variability=Fmi3Variability.tunable))
-
-        self.register_variable(Int32("intOut", causality=Fmi3Causality.output))
-        self.register_variable(Float64("realOut", causality=Fmi3Causality.output))
-        self.register_variable(Boolean("booleanVariable", causality=Fmi3Causality.local))
-        self.register_variable(String("stringVariable", causality=Fmi3Causality.local))
-
-        self.container = Container()
-        self.container.someReal = 99.0
-        self.container.subContainer = sub = Container()
-        sub.someInteger = -15
-        self.register_variable(
-            Float64("container.someReal", causality=Fmi3Causality.parameter, variability=Fmi3Variability.tunable))
-        self.register_variable(
-            Int32("container.subContainer.someInteger", causality=Fmi3Causality.parameter,
-                    variability=Fmi3Variability.tunable))
-
-    def do_step(self, current_time, step_size):
-        self.realOut = current_time + step_size
-        return True
+from pythonfmu3.fmi3slave import Fmi3Slave, Fmi3Causality, Fmi3Variability, Int32, Float64, Boolean, String
+
+
+class Container:
+    pass
+
+
+class PythonSlave(Fmi3Slave):
+
+    author = "John Doe"
+    description = "A simple description"
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        self.intParam = 42
+        self.intOut = 23
+        self.realOut = 3.0
+        self.booleanVariable = True
+        self.stringVariable = "Hello World!"
+        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))
+        self.register_variable(
+            Boolean("booleanParameter", causality=Fmi3Causality.parameter, variability=Fmi3Variability.tunable))
+        self.register_variable(
+            String("stringParameter", causality=Fmi3Causality.parameter, variability=Fmi3Variability.tunable))
+
+        self.register_variable(Int32("intOut", causality=Fmi3Causality.output))
+        self.register_variable(Float64("realOut", causality=Fmi3Causality.output))
+        self.register_variable(Boolean("booleanVariable", causality=Fmi3Causality.local))
+        self.register_variable(String("stringVariable", causality=Fmi3Causality.local))
+
+        self.container = Container()
+        self.container.someReal = 99.0
+        self.container.subContainer = sub = Container()
+        sub.someInteger = -15
+        self.register_variable(
+            Float64("container.someReal", causality=Fmi3Causality.parameter, variability=Fmi3Variability.tunable))
+        self.register_variable(
+            Int32("container.subContainer.someInteger", causality=Fmi3Causality.parameter,
+                    variability=Fmi3Variability.tunable))
+
+    def do_step(self, current_time, step_size):
+        self.realOut = current_time + step_size
+        return True

pythonfmu3/tests/slaves/pythonslave_read_file.py

@@ -1,23 +1,23 @@
-from pythonfmu3.fmi3slave import Fmi3Slave, Fmi3Causality, Fmi3Variability, String, DefaultExperiment, Float64
-
-
-class PythonSlaveReadFile(Fmi3Slave):
-
-    default_experiment = DefaultExperiment(start_time=0)
-
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-
-        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,
-                   variability=Fmi3Variability.constant))
-
-    def do_step(self, current_time, step_size):
-        return True
+from pythonfmu3.fmi3slave import Fmi3Slave, Fmi3Causality, Fmi3Variability, String, DefaultExperiment, Float64
+
+
+class PythonSlaveReadFile(Fmi3Slave):
+
+    default_experiment = DefaultExperiment(start_time=0)
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        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,
+                   variability=Fmi3Variability.constant))
+
+    def do_step(self, current_time, step_size):
+        return True