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

pythonfmu3/__init__.py

@@ -1,7 +1,9 @@
 from ._version import __version__
 from .builder import FmuBuilder
+from .cosimulation import CoSimulation
+from .modelexchange import ModelExchange
 from .enums import Fmi3Causality, Fmi3Initial, Fmi3Status, Fmi3Variability
-from .fmi3slave import Fmi3Slave, Fmi3StepResult
+from .fmi3slave import Fmi3Slave, Fmi3SlaveBase, Fmi3StepResult
 from .variables import Boolean, Enumeration, Int32, Int64, UInt64, Float64, String, Dimension
 from .default_experiment import DefaultExperiment
 from .variable_types import Float64Type, EnumerationType

pythonfmu3/_version.py

@@ -1 +1 @@
-__version__ = "0.2.4"
+__version__ = "0.3.0"

pythonfmu3/builder.py

@@ -13,7 +13,7 @@ from typing import Iterable, Optional, Tuple, Union
 from xml.dom.minidom import parseString
 from xml.etree.ElementTree import Element, SubElement, tostring
 from .osutil import get_lib_extension, get_platform
-from .fmi3slave import FMI3_MODEL_OPTIONS, Fmi3Slave
+from .fmi3slave import FMI3_MODEL_OPTIONS, Fmi3Slave, Fmi3SlaveBase
 
 FilePath = Union[str, Path]
 HERE = Path(__file__).parent
@@ -24,7 +24,7 @@ logger = logging.getLogger(__name__)
 def get_class_name(file_name: Path) -> str:
     with open(str(file_name), 'r') as file:
         data = file.read()
-        return re.search(r'class (\w+)\(\s*Fmi3Slave\s*\)\s*:', data).group(1)
+        return re.search(r'class (\w+)\(([^)]*\bFmi3Slave(?:Base)?\b[^)]*)\)\s*:', data).group(1)
 
 
 def get_model_description(filepath: Path, module_name: str) -> Tuple[str, Element]:
@@ -50,9 +50,9 @@ def get_model_description(filepath: Path, module_name: str) -> Tuple[str, Elemen
     finally:
         sys.path.remove(str(filepath.parent))  # remove inserted temporary path
 
-    if not isinstance(instance, Fmi3Slave):
+    if not isinstance(instance, Fmi3SlaveBase):
         raise TypeError(
-            f"The provided class '{class_name}' does not inherit from {Fmi3Slave.__qualname__}"
+            f"The provided class '{class_name}' does not inherit from {Fmi3SlaveBase.__qualname__}"
         )
     # Produce the xml
     return instance.modelName, instance.to_xml()
@@ -138,9 +138,16 @@ class FmuBuilder:
 
             type_node = xml.find("CoSimulation")
             option_names = [opt.name for opt in FMI3_MODEL_OPTIONS]
-            for option, value in options.items():
-                if option in option_names:
-                    type_node.set(option, str(value).lower())
+            if type_node:
+                for option, value in options.items():
+                    if option in option_names:
+                        type_node.set(option, str(value).lower())
+
+            type_node = xml.find("ModelExchange")
+            if type_node:
+                for option, value in options.items():
+                    if option in option_names:
+                        type_node.set(option, str(value).lower())
 
             with zipfile.ZipFile(dest_file, "w") as zip_fmu:
 

pythonfmu3/cosimulation.py

@@ -0,0 +1,8 @@
+from abc import ABC, abstractmethod
+
+# co-simulation mixin
+class CoSimulation(ABC):
+
+    @abstractmethod
+    def do_step(self, current_time: float, step_size: float):
+        pass

pythonfmu3/fmi3slave.py

@@ -11,6 +11,8 @@ from xml.etree.ElementTree import Element, SubElement
 
 from .logmsg import LogMsg
 from .default_experiment import DefaultExperiment
+from .cosimulation import CoSimulation
+from .modelexchange import ModelExchange
 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
@@ -33,7 +35,8 @@ class Fmi3StepResult(NamedTuple):
     terminateSimulation: bool = False
     earlyReturn: bool = False
 
-class Fmi3Slave(ABC):
+
+class Fmi3SlaveBase(object):
     """Abstract facade class to execute Python through FMI standard."""
 
     # Dictionary of (category, description) entries
@@ -104,8 +107,18 @@ class Fmi3Slave(ABC):
             options[option.name] = str(value).lower()
         options["modelIdentifier"] = self.modelName
         options["canNotUseMemoryManagementFunctions"] = "true"
-
-        SubElement(root, "CoSimulation", attrib=options)
+        
+        options_me = dict()
+        options_me["canGetAndSetFMUState"] = "true"
+        options_me["modelIdentifier"] = self.modelName
+        options_me["needsCompletedIntegratorStep"] = "false"
+
+        # check if we have cosim mixin or model exchange mixin
+        if isinstance(self, ModelExchange):
+            SubElement(root, "ModelExchange", attrib=options_me)
+        
+        if isinstance(self, CoSimulation):
+            SubElement(root, "CoSimulation", attrib=options)
 
         if self.units:
             unit_defs = SubElement(root, "UnitDefinitions")
@@ -239,7 +252,6 @@ class Fmi3Slave(ABC):
     def exit_initialization_mode(self):
         pass
 
-    @abstractmethod
     def do_step(self, current_time: float, step_size: float) -> Fmi3StepResult:
         pass
 
@@ -404,6 +416,50 @@ class Fmi3Slave(ABC):
                 if v.setter is not None:
                     v.setter(value)
 
+    def set_continuous_states(self, values: List[float]):
+        offset = 0
+        continuous_state_derivatives = list(
+            filter(lambda v: v.variability == Fmi3Variability.continuous and (isinstance(v, Float64) and v.derivative is not None), self.vars.values())
+        )
+
+        vrs = [v.derivative for v in continuous_state_derivatives]
+        
+        for vr in vrs:
+            var = self.vars[vr]
+            size = var.size(self.vars)
+            if size > 1:
+                var.setter(values[offset:offset+size])
+            else:
+                var.setter(values[offset])
+            offset += size
+        
+    def get_continuous_states(self) -> List[float]:
+        offset = 0
+        continuous_state_derivatives = list(
+            filter(lambda v: v.variability == Fmi3Variability.continuous and (isinstance(v, Float64) and v.derivative is not None), self.vars.values())
+        )
+
+        vrs = [v.derivative for v in continuous_state_derivatives]
+        
+        refs = list()
+        for vr in vrs:
+            var = self.vars[vr]
+            if len(var.dimensions) == 0:
+                refs.append(float(var.getter()))
+            else:
+                refs.extend(var.getter())
+                
+        return refs
+    
+    def get_number_of_continuous_states(self) -> int:
+        continuous_state_derivatives = list(
+            filter(lambda v: v.variability == Fmi3Variability.continuous and (isinstance(v, Float64) and v.derivative is not None), self.vars.values())
+        )
+        return len(continuous_state_derivatives)
+    
+    def set_time(self, time: float):
+        self.time = time
+
     @staticmethod
     def _fmu_state_to_bytes(state: Dict[str, Any]) -> bytes:
         return json.dumps(state).encode("utf-8")
@@ -436,3 +492,6 @@ class Fmi3Slave(ABC):
                 category = "logAll"
         log_msg = LogMsg(status, category, msg, debug)
         self.log_queue.append(log_msg)
+
+class Fmi3Slave(Fmi3SlaveBase, CoSimulation):
+    pass

pythonfmu3/modelexchange.py

@@ -0,0 +1,23 @@
+from abc import ABC, ABCMeta, abstractmethod
+
+class RequireTimeMeta(ABCMeta):
+    def __init__(cls, name, bases, namespace):
+        super().__init__(name, bases, namespace)
+        orig_init = cls.__init__
+        def new_init(self, *args, **kwargs):
+            orig_init(self, *args, **kwargs)
+            if not hasattr(self, 'time'):
+                raise AttributeError(f"{cls.__name__} must define 'self.time' in __init__")
+        cls.__init__ = new_init
+
+
+# model exchange mixin
+class ModelExchange(ABC, metaclass=RequireTimeMeta):
+    """
+    Classes derived from ModelExchange must define a 'self.time' member variable.
+    """
+    
+    @abstractmethod
+    def get_continuous_state_derivatives(self):
+        """Return the continuous state derivatives of the model."""
+        pass

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

@@ -133,6 +133,23 @@ public:
         FMIBoolean* earlyReturn,
         FMIFloat64& endOfStep) = 0;
 
+    // Model Exchange methods
+    virtual void GetContinuousStates(cppfmu::FMIFloat64* continuousStates, std::size_t nStates) const = 0;
+    virtual void GetContinuousStateDerivatives(cppfmu::FMIFloat64* derivatives, std::size_t nStates) const = 0;
+    virtual void GetNominalsOfContinuousStates(cppfmu::FMIFloat64* nominalContinuousStates, std::size_t nStates) const = 0;
+    virtual void SetContinuousStates(const cppfmu::FMIFloat64* continuousStates, std::size_t nStates) = 0;
+    virtual void SetTime(cppfmu::FMIFloat64 time) = 0;
+    virtual void GetNumberOfContinuousStates(std::size_t& nStates) const = 0;
+    virtual void GetNumberOfEventIndicators(std::size_t& nEventIndicators) const = 0;
+    virtual void UpdateDiscreteStates(
+        cppfmu::FMIBoolean* discreteStatesNeedUpdate,
+        cppfmu::FMIBoolean* terminateSimulation,
+        cppfmu::FMIBoolean* nominalContinuousStatesChanged,
+        cppfmu::FMIBoolean* valuesOfContinuousStatesChanged,
+        cppfmu::FMIBoolean* nextEventTimeDefined,
+        cppfmu::FMIFloat64* nextEventTime) = 0;
+    
+
     virtual void GetFMUstate(fmi3FMUState& state) = 0;
     virtual void SetFMUstate(const fmi3FMUState& state) = 0;
     virtual void FreeFMUstate(fmi3FMUState& state) = 0;

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

@@ -110,10 +110,16 @@ fmi3Instance fmi3InstantiateCoSimulation(
             component->logger);
         return component;
     } catch (const cppfmu::FatalError& e) {
-        // functions->logger(nullptr, instanceName, fmi3Fatal, "", e.what());
+        if (logMessage)
+        {
+            logMessage(environment, fmi3Fatal, "", e.what());
+        }
         return nullptr;
     } catch (const std::exception& e) {
-        // functions->logger(nullptr, instanceName, fmi3Error, "", e.what());
+        if (logMessage)
+        {
+            logMessage(environment, fmi3Error, "", e.what());
+        }
         return nullptr;
     }
 }
@@ -124,10 +130,38 @@ fmi3Instance fmi3InstantiateModelExchange(
     fmi3String                 resourcePath,
     fmi3Boolean                visible,
     fmi3Boolean                loggingOn,
-    fmi3InstanceEnvironment    instanceEnvironment,
+    fmi3InstanceEnvironment    environment,
     fmi3LogMessageCallback     logMessage)
 {
-    throw std::logic_error("Unsupported FMU instance type requested (only co-simulation is supported)");
+    try {
+        auto component = new Component(
+            environment,
+            logMessage,
+            loggingOn);
+        component->slave = CppfmuInstantiateSlave(
+            instanceName,
+            instantiationToken,
+            resourcePath,
+            "application/x-fmu-sharedlibrary",
+            0.0,
+            visible,
+            cppfmu::FMIFalse,
+            component->logger);
+        return component;
+    } catch (const cppfmu::FatalError& e) {
+        if (logMessage)
+        {
+            logMessage(environment, fmi3Fatal, "", e.what());
+        }
+        return nullptr;
+    } catch (const std::exception& e) {
+        if (logMessage)
+        {
+            logMessage(environment, fmi3Error, "", e.what());
+        }
+        return nullptr;
+    }
+
 }
 
 fmi3Instance fmi3InstantiateScheduledExecution(
@@ -512,6 +546,183 @@ fmi3Status fmi3SetString(
     }
 }
 
+fmi3Status fmi3GetContinuousStates(
+    fmi3Instance c,
+    fmi3Float64 continuousStates[],
+    size_t nStates)
+{
+    auto component = reinterpret_cast<Component*>(c);
+    try {
+        component->slave->GetContinuousStates(continuousStates, nStates);
+        return fmi3OK;  
+    } catch (const cppfmu::FatalError& e) {
+        component->logger.Log(fmi3Fatal, "", e.what());
+        return fmi3Fatal;
+    } catch (const std::exception& e) {
+        component->logger.Log(fmi3Error, "", e.what());
+        return fmi3Error;
+    }
+}
+
+fmi3Status fmi3GetContinuousStateDerivatives(
+    fmi3Instance c,
+    fmi3Float64 derivatives[],
+    size_t nStates)
+{
+    auto component = reinterpret_cast<Component*>(c);
+    try {
+        component->slave->GetContinuousStateDerivatives(derivatives, nStates);
+        return fmi3OK;
+    } catch (const cppfmu::FatalError& e) {
+        component->logger.Log(fmi3Fatal, "", e.what());
+        return fmi3Fatal;
+    } catch (const std::exception& e) {
+        component->logger.Log(fmi3Error, "", e.what());
+        return fmi3Error;
+    }
+}
+
+fmi3Status fmi3SetTime(
+    fmi3Instance c,
+    fmi3Float64 time)
+{
+    auto component = reinterpret_cast<Component*>(c);
+    try {
+        component->slave->SetTime(time);
+        return fmi3OK;
+    } catch (const cppfmu::FatalError& e) {
+        component->logger.Log(fmi3Fatal, "", e.what());
+        return fmi3Fatal;
+    } catch (const std::exception& e) {
+        component->logger.Log(fmi3Error, "", e.what());
+        return fmi3Error;
+    }
+}
+
+fmi3Status fmi3SetContinuousStates(
+    fmi3Instance c,
+    const fmi3Float64 continuousStates[],
+    size_t nStates)
+{
+    auto component = reinterpret_cast<Component*>(c);
+    try {
+        component->slave->SetContinuousStates(continuousStates, nStates);
+        return fmi3OK;
+    } catch (const cppfmu::FatalError& e) {
+        component->logger.Log(fmi3Fatal, "", e.what());
+        return fmi3Fatal;
+    } catch (const std::exception& e) {
+        component->logger.Log(fmi3Error, "", e.what());
+        return fmi3Error;
+    }
+}
+
+fmi3Status fmi3GetEventIndicators(
+    fmi3Instance c,
+    fmi3Float64 eventIndicators[],
+    size_t nEventIndicators)
+{
+    return fmi3OK;
+}
+
+fmi3Status fmi3GetNominalsOfContinuousStates(
+    fmi3Instance c,
+    fmi3Float64 nominalContinuousStates[],
+    size_t nStates)
+{
+    const auto component = reinterpret_cast<Component*>(c);
+    try {
+        component->slave->GetNominalsOfContinuousStates(nominalContinuousStates, nStates);
+        return fmi3OK;  
+    } catch (const cppfmu::FatalError& e) {
+        component->logger.Log(fmi3Fatal, "", e.what());
+        return fmi3Fatal;
+    } catch (const std::exception& e) {
+        component->logger.Log(fmi3Error, "", e.what());
+        return fmi3Error;
+    }
+}
+
+fmi3Status fmi3GetNumberOfContinuousStates(
+    fmi3Instance c, 
+    std::size_t * nContinuousStates)
+{
+    const auto component = reinterpret_cast<Component*>(c);
+    try {
+        component->slave->GetNumberOfContinuousStates(*nContinuousStates);
+        return fmi3OK;
+    } catch (const cppfmu::FatalError& e) {
+        component->logger.Log(fmi3Fatal, "", e.what());
+        return fmi3Fatal;
+    } catch (const std::exception& e) {
+        component->logger.Log(fmi3Error, "", e.what());
+        return fmi3Error;
+    }
+}
+
+fmi3Status fmi3GetNumberOfEventIndicators(
+    fmi3Instance c, 
+    std::size_t * nEventIndicators)
+{
+    const auto component = reinterpret_cast<Component*>(c);
+    try {
+        component->slave->GetNumberOfEventIndicators(*nEventIndicators);
+        return fmi3OK;
+    } catch (const cppfmu::FatalError& e) {
+        component->logger.Log(fmi3Fatal, "", e.what());
+        return fmi3Fatal;
+    } catch (const std::exception& e) {
+        component->logger.Log(fmi3Error, "", e.what());
+        return fmi3Error;
+    }
+}
+
+
+fmi3Status fmi3UpdateDiscreteStates(fmi3Instance c,
+    fmi3Boolean* discreteStatesNeedUpdate,
+    fmi3Boolean* terminateSimulation,
+    fmi3Boolean* nominalContinuousStatesChanged,
+    fmi3Boolean* valuesOfContinuousStatesChanged,
+    fmi3Boolean* nextEventTimeDefined,
+    fmi3Float64* nextEventTime)
+{
+    const auto component = reinterpret_cast<Component*>(c);
+    try {
+        component->slave->UpdateDiscreteStates(
+            discreteStatesNeedUpdate,
+            terminateSimulation,
+            nominalContinuousStatesChanged,
+            valuesOfContinuousStatesChanged,
+            nextEventTimeDefined,
+            nextEventTime);
+        return fmi3OK;
+    } catch (const cppfmu::FatalError& e) {
+        component->logger.Log(fmi3Fatal, "", e.what());
+        return fmi3Fatal;
+    } catch (const std::exception& e) {
+        component->logger.Log(fmi3Error, "", e.what());
+        return fmi3Error;
+    }
+}
+
+fmi3Status fmi3EnterContinuousTimeMode(fmi3Instance c)
+{
+    return fmi3OK;
+}
+
+fmi3Status fmi3CompletedIntegratorStep(
+    fmi3Instance c,
+    fmi3Boolean noSetFMUStatePriorToCurrentPoint,
+    fmi3Boolean* enterEventMode,
+    fmi3Boolean* terminateSimulation)
+{
+    *enterEventMode = false;
+    *terminateSimulation = false;
+    
+    return fmi3OK;
+}
+
+
 
 fmi3Status fmi3GetFMUState(
     fmi3Instance c,
@@ -850,15 +1061,6 @@ fmi3EvaluateDiscreteStates(fmi3Instance instance)
   NOT_IMPLEMENTED;
 }
 
-fmi3Status
-fmi3UpdateDiscreteStates(fmi3Instance instance, fmi3Boolean* discreteStatesNeedUpdate,
-    fmi3Boolean* terminateSimulation,
-    fmi3Boolean* nominalsOfContinuousStatesChanged,
-    fmi3Boolean* valuesOfContinuousStatesChanged,
-    fmi3Boolean* nextEventTimeDefined, fmi3Float64* nextEventTime)
-{
-  NOT_IMPLEMENTED;
-}
 
 fmi3Status fmi3ActivateModelPartition(fmi3Instance instance, fmi3ValueReference clockReference,
     fmi3Float64 activationTime)
@@ -866,72 +1068,3 @@ fmi3Status fmi3ActivateModelPartition(fmi3Instance instance, fmi3ValueReference
   NOT_IMPLEMENTED;
 }
 
-
-// model exchange functions
-fmi3Status
-fmi3EnterContinuousTimeMode(fmi3Instance instance)
-{
-    NOT_IMPLEMENTED;
-}
-
-fmi3Status
-fmi3CompletedIntegratorStep(fmi3Instance instance, fmi3Boolean noSetFMUStatePriorToCurrentPoint,
-                            fmi3Boolean* enterEventMode, fmi3Boolean* terminateSimulation)
-{
-    NOT_IMPLEMENTED;
-}
-
-/* Providing independent variables and re-initialization of caching */
-fmi3Status
-fmi3SetTime(fmi3Instance instance, fmi3Float64 time)
-{
-    NOT_IMPLEMENTED;
-}
-
-fmi3Status
-fmi3SetContinuousStates(fmi3Instance instance, const fmi3Float64 continuousStates[],
-    size_t nContinuousStates)
-{
-    NOT_IMPLEMENTED;
-}
-
-/* Evaluation of the model equations */
-fmi3Status
-fmi3GetContinuousStateDerivatives(fmi3Instance instance, fmi3Float64 derivatives[],
-    size_t nContinuousStates)
-{
-    NOT_IMPLEMENTED;
-}
-
-fmi3Status
-fmi3GetEventIndicators(fmi3Instance instance, fmi3Float64 eventIndicators[],
-    size_t nEventIndicators)
-{
-    NOT_IMPLEMENTED;
-}
-
-fmi3Status
-fmi3GetContinuousStates(fmi3Instance instance, fmi3Float64 continuousStates[],
-    size_t nContinuousStates)
-{
-    NOT_IMPLEMENTED;
-}
-
-fmi3Status
-fmi3GetNominalsOfContinuousStates(fmi3Instance instance, fmi3Float64 nominals[],
-    size_t nContinuousStates)
-{
-    NOT_IMPLEMENTED;
-}
-
-fmi3Status
-fmi3GetNumberOfEventIndicators(fmi3Instance instance, size_t* nEventIndicators)
-{
-    NOT_IMPLEMENTED;
-}
-
-fmi3Status
-fmi3GetNumberOfContinuousStates(fmi3Instance instance, size_t* nContinuousStates)
-{
-    NOT_IMPLEMENTED;
-}

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

@@ -28,7 +28,7 @@ inline std::string findClassName(const std::string& fileName)
 {
     std::string line;
     std::ifstream infile(fileName);
-    std::string regexStr(R"(^class (\w+)\(\s*Fmi3Slave\s*\)\s*:)");
+    std::string regexStr(R"(^class (\w+)\(([^)]*\bFmi3Slave(?:Base)?\b[^)]*)\)\s*:)");
     while (getline(infile, line)) {
         std::smatch m;
         std::regex re(regexStr);
@@ -80,7 +80,7 @@ PySlaveInstance::PySlaveInstance(std::string instanceName, std::string resources
         std::string className = findClassName(resources_ + "/" + moduleName + ".py");
         if (className.empty()) {
             cleanPyObject();
-            throw cppfmu::FatalError("Unable to find class extending Fmi3Slave!");
+            throw cppfmu::FatalError("Unable to find class extending Fmi3SlaveBase!");
         }
 
         PyObject* pyClassName = Py_BuildValue("s", className.c_str());
@@ -530,6 +530,109 @@ void PySlaveInstance::GetString(const cppfmu::FMIValueReference* vr, std::size_t
     });
 }
 
+void PySlaveInstance::GetContinuousStates(cppfmu::FMIFloat64* continuousStates, std::size_t nStates) const
+{
+    py_safe_run([this, &continuousStates, nStates](PyGILState_STATE gilState) {
+        auto f = PyObject_CallMethod(pInstance_, "get_continuous_states", nullptr);
+        if (f == nullptr) {
+            handle_py_exception("[get_continuous_states] PyObject_CallMethod", gilState);
+        }
+        // Assuming f is a list of floats
+        for (std::size_t i = 0; i < nStates; i++) {
+            PyObject* item = PyList_GetItem(f, i);
+            continuousStates[i] = static_cast<cppfmu::FMIFloat64>(PyFloat_AsDouble(item));
+        }
+        clearLogBuffer();
+    });
+}
+
+void PySlaveInstance::GetContinuousStateDerivatives(cppfmu::FMIFloat64* continuousStateDerivatives, std::size_t nStates) const
+{
+    py_safe_run([this, &continuousStateDerivatives, nStates](PyGILState_STATE gilState) {
+        auto f = PyObject_CallMethod(pInstance_, "get_continuous_state_derivatives", nullptr);
+        if (f == nullptr) {
+            handle_py_exception("[get_continuous_state_derivatives] PyObject_CallMethod", gilState);
+        }
+        // Assuming f is a list of floats
+        for (std::size_t i = 0; i < nStates; i++) {
+            PyObject* item = PyList_GetItem(f, i);
+            continuousStateDerivatives[i] = static_cast<cppfmu::FMIFloat64>(PyFloat_AsDouble(item));
+        }
+        clearLogBuffer();
+    });
+}
+
+void PySlaveInstance::GetNominalsOfContinuousStates(cppfmu::FMIFloat64* nominalsOfContinuousStates, std::size_t nStates) const
+{
+    for (size_t i = 0u; i < nStates; i++) {
+        nominalsOfContinuousStates[i] = 1.0;
+    }
+}
+
+void PySlaveInstance::SetContinuousStates(const cppfmu::FMIFloat64* continuousStates, std::size_t nStates)
+{
+    py_safe_run([this, &continuousStates, nStates](PyGILState_STATE gilState) {
+        PyObject* refs = PyList_New(nStates);
+        for (int i = 0; i < nStates; i++) {
+            PyList_SetItem(refs, i, Py_BuildValue("d", continuousStates[i]));
+        }
+
+        auto f = PyObject_CallMethod(pInstance_, "set_continuous_states", "(O)", refs);
+        Py_DECREF(refs);
+        if (f == nullptr) {
+            handle_py_exception("[setContinuousStates] PyObject_CallMethod", gilState);
+        }
+        Py_DECREF(f);
+        clearLogBuffer();
+    });
+}
+
+void PySlaveInstance::GetNumberOfContinuousStates(std::size_t& nStates) const
+{
+    py_safe_run([this, &nStates](PyGILState_STATE gilState) {
+        auto f = PyObject_CallMethod(pInstance_, "get_number_of_continuous_states", nullptr);
+        if (f == nullptr) {
+            handle_py_exception("[getNumberOfContinuousStates] PyObject_CallMethod", gilState);
+        }
+        nStates = static_cast<std::size_t>(PyLong_AsLong(f));
+        Py_DECREF(f);
+        clearLogBuffer();
+    });
+}
+
+void PySlaveInstance::GetNumberOfEventIndicators(std::size_t& nIndicators) const
+{
+   nIndicators= 0u;
+}
+
+void PySlaveInstance::SetTime(cppfmu::FMIFloat64 time)
+{
+    py_safe_run([this, time](PyGILState_STATE gilState) {
+        auto f = PyObject_CallMethod(pInstance_, "set_time", "(d)", time);
+        if (f == nullptr) {
+            handle_py_exception("[setTime] PyObject_CallMethod", gilState);
+        }
+        Py_DECREF(f);
+        clearLogBuffer();
+    });
+}
+
+void PySlaveInstance::UpdateDiscreteStates(
+    cppfmu::FMIBoolean* discreteStatesNeedUpdate,
+    cppfmu::FMIBoolean* terminateSimulation,
+    cppfmu::FMIBoolean* nominalContinuousStatesChanged,
+    cppfmu::FMIBoolean* valuesOfContinuousStatesChanged,
+    cppfmu::FMIBoolean* nextEventTimeDefined,
+    cppfmu::FMIFloat64* nextEventTime)
+{
+    *discreteStatesNeedUpdate = false;
+    *terminateSimulation = false;
+    *nominalContinuousStatesChanged = false;
+    *valuesOfContinuousStatesChanged = false;
+    *nextEventTimeDefined = false;
+    *nextEventTime = 0.0;
+}
+
 void PySlaveInstance::GetFMUstate(fmi3FMUState& state)
 {
     py_safe_run([this, &state](PyGILState_STATE gilState) {

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

@@ -50,6 +50,23 @@ public:
     void GetFMUstate(fmi3FMUState& State) override;
     void SetFMUstate(const fmi3FMUState& State) override;
     void FreeFMUstate(fmi3FMUState& State) override;
+    
+    // Model Exchange methods
+    void GetContinuousStates(cppfmu::FMIFloat64* continuousStates, std::size_t nStates) const override;
+    void GetNumberOfContinuousStates(std::size_t& nStates) const override;
+    void GetNumberOfEventIndicators(std::size_t& nEventIndicators) const override;
+    void GetContinuousStateDerivatives(cppfmu::FMIFloat64* derivatives, std::size_t nStates) const override;
+    void GetNominalsOfContinuousStates(cppfmu::FMIFloat64* nominalContinuousStates, std::size_t nStates) const override;
+    void SetContinuousStates(const cppfmu::FMIFloat64* continuousStates, std::size_t nStates) override;
+    void SetTime(cppfmu::FMIFloat64 time) override;
+    void UpdateDiscreteStates(
+        cppfmu::FMIBoolean* discreteStatesNeedUpdate,
+        cppfmu::FMIBoolean* terminateSimulation,
+        cppfmu::FMIBoolean* nominalContinuousStatesChanged,
+        cppfmu::FMIBoolean* valuesOfContinuousStatesChanged,
+        cppfmu::FMIBoolean* nextEventTimeDefined,
+        cppfmu::FMIFloat64* nextEventTime) override;
+
 
     size_t SerializedFMUstateSize(const fmi3FMUState& State) override;
     void SerializeFMUstate(const fmi3FMUState& State, fmi3Byte bytes[], size_t size) override;

pythonfmu3/tests/slaves/pythonslaveMX.py

@@ -0,0 +1,27 @@
+from pythonfmu3 import Fmi3Causality, ModelExchange, Fmi3Variability, Fmi3SlaveBase, Fmi3Status, Float64, Fmi3Initial, Unit, Float64Type, Fmi3StepResult
+
+from typing import List
+
+class Dahlquist(Fmi3SlaveBase, ModelExchange):
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        self.author = "Stephen Smith"
+        self.description = "Dahlquist's test problem for model exchange FMUs"
+
+        self.time = 0.0
+        self.k = 1.0
+        self.x = 1.0
+        self.derx = 0.0
+
+        self.register_variable(Float64("time", causality=Fmi3Causality.independent, variability=Fmi3Variability.continuous))
+        self.register_variable(Float64("x", causality=Fmi3Causality.output, start=1, variability=Fmi3Variability.continuous, initial=Fmi3Initial.exact))
+        self.register_variable(Float64("derx", causality=Fmi3Causality.local, variability=Fmi3Variability.continuous, derivative=1))
+        self.register_variable(Float64("k", causality=Fmi3Causality.parameter, variability=Fmi3Variability.fixed))
+
+
+    def get_continuous_state_derivatives(self) -> List[float]:
+        self.derx = -self.k * self.x
+        return [self.derx]
+       

pythonfmu3/tests/slaves/pythonslaveMXCS.py

@@ -0,0 +1,32 @@
+from pythonfmu3 import Fmi3Causality, CoSimulation, ModelExchange, Fmi3Variability, Fmi3SlaveBase, Fmi3Status, Float64, Fmi3Initial, Unit, Float64Type, Fmi3StepResult
+
+from typing import List
+
+class Dahlquist(Fmi3SlaveBase, ModelExchange, CoSimulation):
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        self.author = "Stephen Smith"
+        self.description = "Dahlquist's test problem for model exchange FMUs"
+
+        self.time = 0.0
+        self.k = 1.0
+        self.x = 1.0
+        self.derx = 0.0
+
+        self.register_variable(Float64("time", causality=Fmi3Causality.independent, variability=Fmi3Variability.continuous))
+        self.register_variable(Float64("x", causality=Fmi3Causality.output, start=1, variability=Fmi3Variability.continuous, initial=Fmi3Initial.exact))
+        self.register_variable(Float64("derx", causality=Fmi3Causality.local, variability=Fmi3Variability.continuous, derivative=1))
+        self.register_variable(Float64("k", causality=Fmi3Causality.parameter, variability=Fmi3Variability.fixed))
+
+
+    def get_continuous_state_derivatives(self) -> List[float]:
+        self.derx = -self.k * self.x
+        return [self.derx]
+       
+    def do_step(self, current_time: float, step_size: float) -> Fmi3StepResult:
+        self.time = current_time + step_size
+        self.derx = -self.k * self.x
+        self.x += self.derx * step_size
+        return True

pythonfmu3/tests/test_fmi3slave.py

@@ -1,6 +1,6 @@
 import pytest
 
-from pythonfmu3 import Fmi3Slave
+from pythonfmu3 import Fmi3Slave, ModelExchange
 from pythonfmu3 import __version__ as VERSION
 
 from .utils import FMI2PY, PY2FMI
@@ -150,3 +150,18 @@ def test_Fmi3Slave_customized_log_categories(new_categories):
             assert categories.find(f"Category[@name='{category}'][@description='{description}']") is not None
     else:
         assert categories is None
+
+
+def test_Fmi3Slave_model_exchange():
+    class Slave(Fmi3Slave, ModelExchange):
+
+        def get_continuous_state_derivatives(self, vals):
+            return []
+    
+    slave = Slave(instance_name="instance")
+    xml = slave.to_xml()
+
+    categories = xml.find("ModelExchange")
+    
+    assert categories is not None, "ModelExchange category should be present in the XML"
+

pythonfmu3/tests/test_integration.py

@@ -1,5 +1,6 @@
 import math
 from pathlib import Path
+import ctypes
 
 import pytest
 
@@ -30,6 +31,66 @@ def test_integration_demo(tmp_path):
     assert res["realOut"][-1] == pytest.approx(res["time"][-1], rel=1e-7)
 
 
+@pytest.mark.integration
+def test_integration_demo_MX(tmp_path):
+    script_file = Path(__file__).parent / "slaves/pythonslaveMX.py"
+    fmu = FmuBuilder.build_FMU(script_file, dest=tmp_path, needsExecutionTool="false")
+    assert fmu.exists()
+    res = fmpy.simulate_fmu(str(fmu), stop_time=0.5)
+
+
+@pytest.mark.integration
+def test_integration_solve_MX(tmp_path):
+    script_file = Path(__file__).parent / "slaves/pythonslaveMX.py"
+    fmu = FmuBuilder.build_FMU(script_file, dest=tmp_path, needsExecutionTool="false")
+    assert fmu.exists()
+
+    md = fmpy.read_model_description(str(fmu))
+    unzipdir = fmpy.extract(str(fmu))
+    model = fmpy.fmi3.FMU3Model(guid=md.guid,
+                                unzipDirectory=unzipdir,
+                                modelIdentifier=md.modelExchange.modelIdentifier,
+                                instanceName="instance"
+                                )
+    model.instantiate()
+    model.enterInitializationMode()
+    model.exitInitializationMode()
+    
+    # forward euler
+    t = 0.0
+    step_size = 0.1
+    
+    values = (ctypes.c_double * 1)(0.0)
+    states = (ctypes.c_double *1)(0.0)
+
+    model.getContinuousStateDerivatives(values, 1)
+    model.getContinuousStates(states, 1)
+    
+    assert values[0] == pytest.approx(-1.0, rel=1e-7)
+
+    der = values[0]
+    new_state = states[0] + der * step_size
+
+    model.setContinuousStates((ctypes.c_double * 1)(new_state), 1)
+    model.setTime(t + step_size)
+    
+    model.getContinuousStates(states, 1)
+    
+    assert states[0] == pytest.approx(new_state, rel=1e-7)
+
+@pytest.mark.integration
+def test_integration_demo_CS_MX(tmp_path):
+    script_file = Path(__file__).parent / "slaves/pythonslaveMXCS.py"
+    fmu = FmuBuilder.build_FMU(script_file, dest=tmp_path, needsExecutionTool="false")
+    assert fmu.exists()
+    res = fmpy.simulate_fmu(str(fmu), stop_time=0.5, fmi_type="ModelExchange")
+    
+    res1 = fmpy.simulate_fmu(str(fmu), stop_time=0.5, fmi_type="CoSimulation")
+    
+    assert res[-1][0] == pytest.approx(res1[-1][0], rel=1e-7)
+    assert res[-1][1] == pytest.approx(res1[-1][1], rel=0.1)
+
+
 @pytest.mark.integration
 def test_integration_reset(tmp_path):
     script_file = Path(__file__).parent / "slaves/pythonslave.py"

{pythonfmu3-0.2.4.dist-info → pythonfmu3-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythonfmu3
-Version: 0.2.4
+Version: 0.3.0
 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
@@ -27,7 +27,7 @@ Dynamic: license-file
 
 # PythonFMU3
 
-> A lightweight framework that enables the packaging of Python 3 code as co-simulation FMUs (following FMI version 3.0).
+> A lightweight framework that enables the packaging of Python 3 code as FMUs (following FMI version 3.0).
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![contributions welcome](https://img.shields.io/badge/contributions-welcome-brightgreen.svg?style=flat)](https://github.com/StephenSmith25/PythonFMU3/issues)
@@ -42,14 +42,16 @@ This project is a fork of the original PythonFMU repository available at https:/
 ### Support:
 
 Please take a look at the examples to see the supported features.
+We currently support both the Model exchange and Cosimulation Interfaces.
 
-### Future
+For both interfaces event mode is not supported.
 
-In no particular order, we plan to add support for:
+We currently do not support the following methods (beyond a default, trivial implementation)
 
-- Support more variable types from FMI3
-- Improve array support
-- Add event mode
+- fmi3UpdateDiscreteStates
+- fmi3GetNumberOfEventindicators
+- fmi3GetNominalsOfContinuousStates
+- fmi3EvaluateDiscreteStates
 
 ### How do I build an FMU from python code?
 
@@ -123,7 +125,7 @@ optional arguments:
                         Requirements or environment file.
 ```
 
-### Example:
+### Cosimulation Example:
 
 #### Write the script
 
@@ -169,3 +171,54 @@ pythonfmu3 build -f pythonslave.py myproject
 In this example a python class named `PythonSlave` that extends `Fmi3Slave` is declared in a file named `pythonslave.py`,
 where `myproject` is an optional folder containing additional project files required by the python script.
 Project folders such as this will be recursively copied into the FMU. Multiple project files/folders may be added.
+
+
+### Model Exchange Example
+
+To create a model exchange FMU you must inherit from `Fmi3SlaveBase` and one of (or both) mixin classes `ModelExchange` or `CoSimulation`.
+
+#### Write the script
+
+```python
+
+from pythonfmu3 import Fmi3Causality, Fmi3SlaveBase, Float64, ModelExchange
+
+
+class PythonSlaveMX(Fmi3SlaveBase, ModelExchange):
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        self.author = "John Doe"
+        self.description = "A simple description"
+
+        self.time = 0.0
+        self.mu = 1.0
+        self.x0 = 2
+        self.x1 = 0
+        self.derx0 = 0.0
+        self.derx1 = 0.0
+
+        self.register_variable(Float64("time", causality=Fmi3Causality.independent, variability=Fmi3Variability.continuous))
+        self.register_variable(Float64("x0", causality=Fmi3Causality.output, start=2, variability=Fmi3Variability.continuous, initial=Fmi3Initial.exact))
+        self.register_variable(Float64("x1", causality=Fmi3Causality.output, start=0, variability=Fmi3Variability.continuous, initial=Fmi3Initial.exact))
+        self.register_variable(Float64("derx0", causality=Fmi3Causality.local, variability=Fmi3Variability.continuous, derivative=1))
+        self.register_variable(Float64("derx1", causality=Fmi3Causality.local, variability=Fmi3Variability.continuous, derivative=2))
+        self.register_variable(Float64("mu", causality=Fmi3Causality.parameter, variability=Fmi3Variability.fixed))
+
+
+    def get_continuous_state_derivatives(self) -> List[float]:
+        self.derx0 = self.x1
+        self.derx1 = self.mu * ((1 - self.x0**2) * self.x1) - self.x0
+        return [self.derx0, self.derx1]
+        
+
+```
+
+Note: There is a hard requirement that we have a `self.time` member in the derived class.
+
+#### Create the FMU
+
+```
+pythonfmu3 build -f pythonslaveMX.py
+```

{pythonfmu3-0.2.4.dist-info → pythonfmu3-0.3.0.dist-info}/RECORD

@@ -1,12 +1,14 @@
-pythonfmu3/__init__.py,sha256=oN-2oXyCFwq0gvL2IEf5QvwIXBXZgsSBwAJw7LZ9vzc,424
+pythonfmu3/__init__.py,sha256=ZftV413VIf6iwjwRkjR0on_r3ufKIwMkp25TBN9APhY,519
 pythonfmu3/__main__.py,sha256=gC1T8x2d02hhqshyNQGSS70SyCk-3I3t8zPqoRo2Xd8,1543
-pythonfmu3/_version.py,sha256=SBl2EPFW-ltPvQ7vbVWItyAsz3aKYIpjO7vcfr84GkU,22
-pythonfmu3/builder.py,sha256=d_nTRWKohZrZsMbTmxiYJzszzVBp-CRisV_y_OVyW6U,9779
+pythonfmu3/_version.py,sha256=VrXpHDu3erkzwl_WXrqINBm9xWkcyUy53IQOj042dOs,22
+pythonfmu3/builder.py,sha256=w7c9ZFv1Udz99cb7rj2NpD0CgrcHRu1SR_axm0ew__Y,10103
+pythonfmu3/cosimulation.py,sha256=EZ5pa_5hy1AwoaZRzZqNz_IX8kjxoFM9sPgeqrUiRuw,179
 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=M5zZbsdM8fv8NPfMp9ljyrLcqzE5RSvM3iFz5qyxnN0,16770
+pythonfmu3/fmi3slave.py,sha256=5myd4EzlkLdeyNXGYDddrORFUCiKJnzBtmcoHJtmfA4,18960
 pythonfmu3/logmsg.py,sha256=0wn11GLwq0LLWqyC2ktLRjQFWlpj07wWliZ8rUHx1gg,359
+pythonfmu3/modelexchange.py,sha256=riF9YkiAY1WN27jhYnUOHwwkajrFUR6Yu6038ClxYho,792
 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
@@ -18,23 +20,23 @@ pythonfmu3/pythonfmu-export/build_win.sh,sha256=UzmAcWqFmwBu6mvYne2Dx3UK8iPwTtP4
 pythonfmu3/pythonfmu-export/src/CMakeLists.txt,sha256=fOVlV7hy9c0wx_Qp4K51tQaQ5xy9lL4qtyGl15ZXfGs,1208
 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=UmqAVAVE1KHNHMC8mIh8gIHRJ_aQk0Ma139TU6Kvv4o,6264
-pythonfmu3/pythonfmu-export/src/cppfmu/fmi_functions.cpp,sha256=FL8TveY4TNAbtrgzElC4WliY8C1vOfvtd5Sh2CcVFgc,25610
+pythonfmu3/pythonfmu-export/src/cppfmu/cppfmu_cs.hpp,sha256=yI_iktqM2vh2OQXj5Ul6WNsRO591QPXWefSPfXXzXFg,7330
+pythonfmu3/pythonfmu-export/src/cppfmu/fmi_functions.cpp,sha256=_vZcoG4EzeIjSqY28JtTwJBMZiGepruAg1r8nbp1_BU,29606
 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/IPyState.hpp,sha256=GLiOjhKLDVEICersnqVwezwEshbxfdh_cyMxBJGFbu8,456
-pythonfmu3/pythonfmu-export/src/pythonfmu/PySlaveInstance.cpp,sha256=WShZMdZExWWG86kFPh89mATYK4tVn38JdHV6c-fZ0_A,25411
-pythonfmu3/pythonfmu-export/src/pythonfmu/PySlaveInstance.hpp,sha256=T-epGp68SjhDv-JupxUe2ZgnV8unU4htc-PUBokjWm4,4239
+pythonfmu3/pythonfmu-export/src/pythonfmu/PySlaveInstance.cpp,sha256=wwsp1N2tuCxdZzA6tbgcqI-wXPLnjXnQn3Tkdmxfxyo,29284
+pythonfmu3/pythonfmu-export/src/pythonfmu/PySlaveInstance.hpp,sha256=mMNKbzP0pZYMJQbqwa_dybPAQtTslElRvoAqaRf6_ww,5281
 pythonfmu3/pythonfmu-export/src/pythonfmu/PyState.hpp,sha256=CjFEIrZu8b1jxQAIgfI_o36hyItW_SdQ5VSkImf7JNs,2977
-pythonfmu3/resources/binaries/x86_64-linux/libpythonfmu-export.so,sha256=WPL5ubqKQvfH8SOe_kTVoUQjFRRr1l4HnhPM-g1VGO0,342520
-pythonfmu3/resources/binaries/x86_64-windows/pythonfmu-export.dll,sha256=68J_TpfzniY8g9LZyzuFqMAWgrb1JBL_qBQvlKe6ixg,414720
+pythonfmu3/resources/binaries/x86_64-linux/libpythonfmu-export.so,sha256=hKu5soPg6GEieC-H5_Tnd9PIRmU_PazfWOX3Y9mAmdY,356232
+pythonfmu3/resources/binaries/x86_64-windows/pythonfmu-export.dll,sha256=iNB6sT7BEg2B2Cy2Mvhi6hHfQ5ctyHnr96Qix9iRBF0,421376
 pythonfmu3/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pythonfmu3/tests/conftest.py,sha256=B6XxTnBdeF_tEJ3w2DlfPKUfvlk-oULgIhQtXkgOJIc,171
 pythonfmu3/tests/test_builder.py,sha256=GrD4ziin3RLOe_36rBQCMnKrSkhc3IqnxE1a6kCFPok,6842
 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=zA3iJ4rI2cKEE8mDsAmcVuwNWlJzhonV8Wxz92hzEac,10387
+pythonfmu3/tests/test_fmi3slave.py,sha256=7nPT5UPQdJu7T3SSQggIi2ZL_hEgs5iEX3KNc-UYX-c,4695
+pythonfmu3/tests/test_integration.py,sha256=34rus-OU9S5FlAVAfpZyoHrXoziG14d4_yw4Wdt5uVU,12513
 pythonfmu3/tests/test_logger.py,sha256=OcHQhxUtNBPH-0zdmheC4I9OWz1yu48W8MYDshNVkf8,5765
 pythonfmu3/tests/test_multiple_fmus.py,sha256=-sthCm2YUZiRkdfvpLQNgquPBForUKQ7HGqfFBdrRas,3942
 pythonfmu3/tests/test_variables.py,sha256=FL7eUCXH4RmH0rK0k6qXDnyDzthW_wAWJBHEmC-u8SI,10384
@@ -44,11 +46,13 @@ pythonfmu3/tests/data/hello.txt,sha256=wFNeS-K3n_2TKRMFQ2v4iTFOSj-uwF7P_Lt98xrZ5
 pythonfmu3/tests/slaves/PythonSlaveWithException.py,sha256=lTTMMnD5Cu09HzA8G2masKyf-ntEMfJ0a3M8btdYVLo,644
 pythonfmu3/tests/slaves/localmodule.py,sha256=-q5Lmh2I88MG7nLTscms0n5xhHLkUDed1IuQ5wj49lo,79
 pythonfmu3/tests/slaves/pythonslave.py,sha256=uzrTQmfk0QBalxNTviGMZNph_YgVmcbxPqKgX5rSvXg,2172
+pythonfmu3/tests/slaves/pythonslaveMX.py,sha256=rmtiKWj-7DNCEGKAzCoS-6ybkWKabYMhatpn14r7UpA,1167
+pythonfmu3/tests/slaves/pythonslaveMXCS.py,sha256=P1aKY92obd-y9VGwDRin9fwmnAlSmdHguFW8E5-LU4I,1417
 pythonfmu3/tests/slaves/pythonslave_read_file.py,sha256=t2sDaZSr2veD91gdqCO9W9CN-AN3TyXABXXfV9Rt0Xs,791
 pythonfmu3/tests/slaves/slavewithdep.py,sha256=hHDFB0dw8wkHiGzxeAVbz9O5LR6ghsFeONgRFdiK_t0,812
-pythonfmu3-0.2.4.dist-info/licenses/LICENSE,sha256=RL2018BU2DKcTi8Eb4ODF-XF3wnr7SDKvMP5S49x4rQ,1188
-pythonfmu3-0.2.4.dist-info/METADATA,sha256=HlzLHalSOQL7t06N0Gzr-tcUqvEVgFQQB8R1TQlSR7A,7607
-pythonfmu3-0.2.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pythonfmu3-0.2.4.dist-info/entry_points.txt,sha256=GgkWYs0DKGHLcijMEYZGkhkHOK2RVUpjGwvl1fwyDwQ,60
-pythonfmu3-0.2.4.dist-info/top_level.txt,sha256=6ne7bh_cME1hepxCx1BG8N5QVhVAufrp7LLok6vq7nE,11
-pythonfmu3-0.2.4.dist-info/RECORD,,
+pythonfmu3-0.3.0.dist-info/licenses/LICENSE,sha256=RL2018BU2DKcTi8Eb4ODF-XF3wnr7SDKvMP5S49x4rQ,1188
+pythonfmu3-0.3.0.dist-info/METADATA,sha256=MfS9nNJe_1MHA7fs7mlu92rsPd6bbXpKM-oTIjGU8q4,9621
+pythonfmu3-0.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pythonfmu3-0.3.0.dist-info/entry_points.txt,sha256=GgkWYs0DKGHLcijMEYZGkhkHOK2RVUpjGwvl1fwyDwQ,60
+pythonfmu3-0.3.0.dist-info/top_level.txt,sha256=6ne7bh_cME1hepxCx1BG8N5QVhVAufrp7LLok6vq7nE,11
+pythonfmu3-0.3.0.dist-info/RECORD,,