From cda6d1c900a4bf28f8a5b4e9a2994ceaaf9fc336 Mon Sep 17 00:00:00 2001
From: syntron <syntron@web.de>
Date: Mon, 23 Jun 2025 09:51:50 +0200
Subject: [PATCH 01/17] [ModelicaSystem] add type hints for set*() functions
 and rename arguments

* fix some type hint issues in setInput()
* prepare for definition via dictionary replacing 'a=b' and '[a=b, c=d]' style
---
 OMPython/ModelicaSystem.py | 163 ++++++++++++++++++++++++-------------
 1 file changed, 106 insertions(+), 57 deletions(-)

diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py
index e9c247b3..2609afba 100644
--- a/OMPython/ModelicaSystem.py
+++ b/OMPython/ModelicaSystem.py
@@ -1001,46 +1001,79 @@ def _strip_space(name):
 
         raise ModelicaSystemError("Unhandled input for strip_space()")
 
-    def setMethodHelper(self, args1, args2, args3, args4=None):
+    def setMethodHelper(
+            self,
+            inputdata: str | list[str] | dict[str, str | int | float],
+            classdata: dict[str, Any],
+            datatype: str,
+            overwritedata: Optional[dict[str, str]] = None,
+    ) -> bool:
         """
         Helper function for setParameter(),setContinuous(),setSimulationOptions(),setLinearizationOption(),setOptimizationOption()
+
         args1 - string or list of string given by user
         args2 - dict() containing the values of different variables(eg:, parameter,continuous,simulation parameters)
         args3 - function name (eg; continuous, parameter, simulation, linearization,optimization)
         args4 - dict() which stores the new override variables list,
         """
-        def apply_single(args1):
-            args1 = self._strip_space(args1)
-            value = args1.split("=")
-            if value[0] in args2:
-                if args3 == "parameter" and self.isParameterChangeable(value[0], value[1]):
-                    args2[value[0]] = value[1]
-                    if args4 is not None:
-                        args4[value[0]] = value[1]
-                elif args3 != "parameter":
-                    args2[value[0]] = value[1]
-                    if args4 is not None:
-                        args4[value[0]] = value[1]
+
+        # TODO: cleanup / data handling / ...
+        #       (1) args1: Optional[str | list[str]] -> convert to dict
+        #       (2) work on dict! inputs: dict[str, str | int | float | ?numbers.number?]
+        #       (3) handle function
+        #       (4) use it also for other functions with such an input, i.e. 'key=value' | ['key=value']
+        #       (5) include setInputs()
+
+        def apply_single(key_val: str):
+            key_val_list = key_val.split("=")
+            if len(key_val_list) != 2:
+                raise ModelicaSystemError(f"Invalid key = value pair: {key_val}")
+
+            name = self._strip_space(key_val_list[0])
+            value = self._strip_space(key_val_list[1])
+
+            if name in classdata:
+                if datatype == "parameter" and not self.isParameterChangeable(name):
+                    logger.debug(f"It is not possible to set the parameter {repr(name)}. It seems to be "
+                                 "structural, final, protected, evaluated or has a non-constant binding. "
+                                 "Use sendExpression(...) and rebuild the model using buildModel() API; example: "
+                                 "sendExpression(\"setParameterValue("
+                                 f"{self.modelName}, {name}, {value if value is not None else '<?value?>'}"
+                                 ")\") ")
+                    return False
+
+                classdata[name] = value
+                if overwritedata is not None:
+                    overwritedata[name] = value
 
                 return True
 
             else:
                 raise ModelicaSystemError("Unhandled case in setMethodHelper.apply_single() - "
-                                          f"{repr(value[0])} is not a {repr(args3)} variable")
+                                          f"{repr(name)} is not a {repr(datatype)} variable")
 
         result = []
-        if isinstance(args1, str):
-            result = [apply_single(args1)]
+        if isinstance(inputdata, str):
+            result = [apply_single(inputdata)]
 
-        elif isinstance(args1, list):
+        elif isinstance(inputdata, list):
             result = []
-            args1 = self._strip_space(args1)
-            for var in args1:
+            inputdata = self._strip_space(inputdata)
+            for var in inputdata:
                 result.append(apply_single(var))
 
         return all(result)
 
-    def setContinuous(self, cvals):  # 13
+    def isParameterChangeable(
+            self,
+            name: str,
+    ):
+        q = self.getQuantities(name)
+        if q[0]["changeable"] == "false":
+            return False
+        return True
+
+    def setContinuous(self, cvals: str | list[str] | dict[str, str | int | float]) -> bool:
         """
         This method is used to set continuous values. It can be called:
         with a sequence of continuous name and assigning corresponding values as arguments as show in the example below:
@@ -1048,9 +1081,13 @@ def setContinuous(self, cvals):  # 13
         >>> setContinuous("Name=value")
         >>> setContinuous(["Name1=value1","Name2=value2"])
         """
-        return self.setMethodHelper(cvals, self.continuouslist, "continuous", self.overridevariables)
+        return self.setMethodHelper(
+            inputdata=cvals,
+            classdata=self.continuouslist,
+            datatype="continuous",
+            overwritedata=self.overridevariables)
 
-    def setParameters(self, pvals):  # 14
+    def setParameters(self, pvals: str | list[str] | dict[str, str | int | float]) -> bool:
         """
         This method is used to set parameter values. It can be called:
         with a sequence of parameter name and assigning corresponding value as arguments as show in the example below:
@@ -1058,19 +1095,13 @@ def setParameters(self, pvals):  # 14
         >>> setParameters("Name=value")
         >>> setParameters(["Name1=value1","Name2=value2"])
         """
-        return self.setMethodHelper(pvals, self.paramlist, "parameter", self.overridevariables)
-
-    def isParameterChangeable(self, name, value):
-        q = self.getQuantities(name)
-        if q[0]["changeable"] == "false":
-            logger.debug(f"setParameters() failed : It is not possible to set the following signal {repr(name)}. "
-                         "It seems to be structural, final, protected or evaluated or has a non-constant binding, "
-                         f"use sendExpression(\"setParameterValue({self.modelName}, {name}, {value})\") "
-                         "and rebuild the model using buildModel() API")
-            return False
-        return True
+        return self.setMethodHelper(
+            inputdata=pvals,
+            classdata=self.paramlist,
+            datatype="parameter",
+            overwritedata=self.overridevariables)
 
-    def setSimulationOptions(self, simOptions):  # 16
+    def setSimulationOptions(self, simOptions: str | list[str] | dict[str, str | int | float]) -> bool:
         """
         This method is used to set simulation options. It can be called:
         with a sequence of simulation options name and assigning corresponding values as arguments as show in the example below:
@@ -1078,9 +1109,13 @@ def setSimulationOptions(self, simOptions):  # 16
         >>> setSimulationOptions("Name=value")
         >>> setSimulationOptions(["Name1=value1","Name2=value2"])
         """
-        return self.setMethodHelper(simOptions, self.simulateOptions, "simulation-option", self.simoptionsoverride)
+        return self.setMethodHelper(
+            inputdata=simOptions,
+            classdata=self.simulateOptions,
+            datatype="simulation-option",
+            overwritedata=self.simoptionsoverride)
 
-    def setLinearizationOptions(self, linearizationOptions):  # 18
+    def setLinearizationOptions(self, linearizationOptions: str | list[str] | dict[str, str | int | float]) -> bool:
         """
         This method is used to set linearization options. It can be called:
         with a sequence of linearization options name and assigning corresponding value as arguments as show in the example below
@@ -1088,9 +1123,13 @@ def setLinearizationOptions(self, linearizationOptions):  # 18
         >>> setLinearizationOptions("Name=value")
         >>> setLinearizationOptions(["Name1=value1","Name2=value2"])
         """
-        return self.setMethodHelper(linearizationOptions, self.linearOptions, "Linearization-option", None)
+        return self.setMethodHelper(
+            inputdata=linearizationOptions,
+            classdata=self.linearOptions,
+            datatype="Linearization-option",
+            overwritedata=None)
 
-    def setOptimizationOptions(self, optimizationOptions):  # 17
+    def setOptimizationOptions(self, optimizationOptions: str | list[str] | dict[str, str | int | float]) -> bool:
         """
         This method is used to set optimization options. It can be called:
         with a sequence of optimization options name and assigning corresponding values as arguments as show in the example below:
@@ -1098,9 +1137,13 @@ def setOptimizationOptions(self, optimizationOptions):  # 17
         >>> setOptimizationOptions("Name=value")
         >>> setOptimizationOptions(["Name1=value1","Name2=value2"])
         """
-        return self.setMethodHelper(optimizationOptions, self.optimizeOptions, "optimization-option", None)
+        return self.setMethodHelper(
+            inputdata=optimizationOptions,
+            classdata=self.optimizeOptions,
+            datatype="optimization-option",
+            overwritedata=None)
 
-    def setInputs(self, name):  # 15
+    def setInputs(self, name: str | list[str] | dict[str, str | int | float]) -> bool:
         """
         This method is used to set input values. It can be called:
         with a sequence of input name and assigning corresponding values as arguments as show in the example below:
@@ -1109,34 +1152,40 @@ def setInputs(self, name):  # 15
         >>> setInputs(["Name1=value1","Name2=value2"])
         """
         if isinstance(name, str):
-            name = self._strip_space(name)
-            value = name.split("=")
-            if value[0] in self.inputlist:
-                tmpvalue = eval(value[1])
+            name1: str = name
+            name1 = name1.replace(" ", "")
+            value1 = name1.split("=")
+            if value1[0] in self.inputlist:
+                tmpvalue = eval(value1[1])
                 if isinstance(tmpvalue, (int, float)):
-                    self.inputlist[value[0]] = [(float(self.simulateOptions["startTime"]), float(value[1])),
-                                                (float(self.simulateOptions["stopTime"]), float(value[1]))]
+                    self.inputlist[value1[0]] = [(float(self.simulateOptions["startTime"]), float(value1[1])),
+                                                 (float(self.simulateOptions["stopTime"]), float(value1[1]))]
                 elif isinstance(tmpvalue, list):
                     self.checkValidInputs(tmpvalue)
-                    self.inputlist[value[0]] = tmpvalue
+                    self.inputlist[value1[0]] = tmpvalue
                 self.inputFlag = True
             else:
-                raise ModelicaSystemError(f"{value[0]} is not an input")
+                raise ModelicaSystemError(f"{value1[0]} is not an input")
         elif isinstance(name, list):
-            name = self._strip_space(name)
-            for var in name:
-                value = var.split("=")
-                if value[0] in self.inputlist:
-                    tmpvalue = eval(value[1])
+            name_list: list[str] = name
+            for name2 in name_list:
+                name2 = name2.replace(" ", "")
+                value2 = name2.split("=")
+                if value2[0] in self.inputlist:
+                    tmpvalue = eval(value2[1])
                     if isinstance(tmpvalue, (int, float)):
-                        self.inputlist[value[0]] = [(float(self.simulateOptions["startTime"]), float(value[1])),
-                                                    (float(self.simulateOptions["stopTime"]), float(value[1]))]
+                        self.inputlist[value2[0]] = [(float(self.simulateOptions["startTime"]), float(value2[1])),
+                                                     (float(self.simulateOptions["stopTime"]), float(value2[1]))]
                     elif isinstance(tmpvalue, list):
                         self.checkValidInputs(tmpvalue)
-                        self.inputlist[value[0]] = tmpvalue
+                        self.inputlist[value2[0]] = tmpvalue
                     self.inputFlag = True
                 else:
-                    raise ModelicaSystemError(f"{value[0]} is not an input!")
+                    raise ModelicaSystemError(f"{value2[0]} is not an input!")
+        elif isinstance(name, dict):
+            raise NotImplementedError("Must be defined!")
+
+        return True
 
     def checkValidInputs(self, name):
         if name != sorted(name, key=lambda x: x[0]):

From c21c58f67d95d2547dea178c58db73728bf7c250 Mon Sep 17 00:00:00 2001
From: syntron <syntron@web.de>
Date: Mon, 23 Jun 2025 10:38:58 +0200
Subject: [PATCH 02/17] [ModelicaSystem] add _prepare_inputdata()

---
 OMPython/ModelicaSystem.py | 44 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py
index 2609afba..a5503f42 100644
--- a/OMPython/ModelicaSystem.py
+++ b/OMPython/ModelicaSystem.py
@@ -1001,6 +1001,50 @@ def _strip_space(name):
 
         raise ModelicaSystemError("Unhandled input for strip_space()")
 
+    def _prepare_inputdata(
+            self,
+            rawinput: str | list[str] | dict[str, str | int | float],
+    ) -> dict[str, str]:
+        """
+        Convert raw input to a structured dictionary {'key1': 'value1', 'key2': 'value2'}.
+        """
+
+        def prepare_str(str_in: str) -> dict[str, str]:
+            str_in = str_in.replace(" ", "")
+            key_val_list: list[str] = str_in.split("=")
+            if len(key_val_list) != 2:
+                raise ModelicaSystemError(f"Invalid 'key=value' pair: {str_in}")
+
+            inputdata = {key_val_list[0]: key_val_list[1]}
+
+            return inputdata
+
+        if isinstance(rawinput, str):
+            warnings.warn(message="The definition of values to set should use a dictionary, "
+                                  "i.e. {'key1': 'val1', 'key2': 'val2', ...}. Please convert all cases which "
+                                  "use a string ('key=val') or list ['key1=val1', 'key2=val2', ...]",
+                          category=DeprecationWarning,
+                          stacklevel=3)
+            return prepare_str(rawinput)
+
+        if isinstance(rawinput, list):
+            warnings.warn(message="The definition of values to set should use a dictionary, "
+                                  "i.e. {'key1': 'val1', 'key2': 'val2', ...}. Please convert all cases which "
+                                  "use a string ('key=val') or list ['key1=val1', 'key2=val2', ...]",
+                          category=DeprecationWarning,
+                          stacklevel=3)
+
+            inputdata: dict[str, str] = {}
+            for item in rawinput:
+                inputdata |= prepare_str(item)
+
+            return inputdata
+
+        if isinstance(rawinput, dict):
+            inputdata = {key: str(val) for key, val in rawinput.items()}
+
+            return inputdata
+
     def setMethodHelper(
             self,
             inputdata: str | list[str] | dict[str, str | int | float],

From bf3a1a4997dc8dc5608f75e7b51d4c368538c392 Mon Sep 17 00:00:00 2001
From: syntron <syntron@web.de>
Date: Mon, 23 Jun 2025 10:39:55 +0200
Subject: [PATCH 03/17] [ModelicaSystem] update _set_method_helper()

* rename from setMethodHelper()
* use _prepare_inputdata()
* cleanup code to align with new input as dict[str, str]

* setInput() is a special case
---
 OMPython/ModelicaSystem.py | 161 +++++++++++++++++++------------------
 1 file changed, 81 insertions(+), 80 deletions(-)

diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py
index a5503f42..a6c9b970 100644
--- a/OMPython/ModelicaSystem.py
+++ b/OMPython/ModelicaSystem.py
@@ -992,17 +992,7 @@ def getSolutions(self, varList=None, resultfile=None):  # 12
         return np_res
 
     @staticmethod
-    def _strip_space(name):
-        if isinstance(name, str):
-            return name.replace(" ", "")
-
-        if isinstance(name, list):
-            return [x.replace(" ", "") for x in name]
-
-        raise ModelicaSystemError("Unhandled input for strip_space()")
-
     def _prepare_inputdata(
-            self,
             rawinput: str | list[str] | dict[str, str | int | float],
     ) -> dict[str, str]:
         """
@@ -1041,72 +1031,65 @@ def prepare_str(str_in: str) -> dict[str, str]:
             return inputdata
 
         if isinstance(rawinput, dict):
-            inputdata = {key: str(val) for key, val in rawinput.items()}
+            for key, val in rawinput.items():
+                str_val = str(val)
+                if ' ' in key or ' ' in str_val:
+                    raise ModelicaSystemError(f"Spaces not allowed in key/value pairs: {repr(key)} = {repr(val)}!")
+                inputdata[key] = str_val
 
             return inputdata
 
-    def setMethodHelper(
+    def _set_method_helper(
             self,
-            inputdata: str | list[str] | dict[str, str | int | float],
+            inputdata: dict[str, str],
             classdata: dict[str, Any],
             datatype: str,
             overwritedata: Optional[dict[str, str]] = None,
     ) -> bool:
         """
-        Helper function for setParameter(),setContinuous(),setSimulationOptions(),setLinearizationOption(),setOptimizationOption()
-
-        args1 - string or list of string given by user
-        args2 - dict() containing the values of different variables(eg:, parameter,continuous,simulation parameters)
-        args3 - function name (eg; continuous, parameter, simulation, linearization,optimization)
-        args4 - dict() which stores the new override variables list,
-        """
-
-        # TODO: cleanup / data handling / ...
-        #       (1) args1: Optional[str | list[str]] -> convert to dict
-        #       (2) work on dict! inputs: dict[str, str | int | float | ?numbers.number?]
-        #       (3) handle function
-        #       (4) use it also for other functions with such an input, i.e. 'key=value' | ['key=value']
-        #       (5) include setInputs()
-
-        def apply_single(key_val: str):
-            key_val_list = key_val.split("=")
-            if len(key_val_list) != 2:
-                raise ModelicaSystemError(f"Invalid key = value pair: {key_val}")
-
-            name = self._strip_space(key_val_list[0])
-            value = self._strip_space(key_val_list[1])
+        Helper function for:
+        * setParameter()
+        * setContinuous()
+        * setSimulationOptions()
+        * setLinearizationOption()
+        * setOptimizationOption()
+        * setInputs()
 
-            if name in classdata:
-                if datatype == "parameter" and not self.isParameterChangeable(name):
-                    logger.debug(f"It is not possible to set the parameter {repr(name)}. It seems to be "
+        Parameters
+        ----------
+        inputdata
+            string or list of string given by user
+        classdata
+            dict() containing the values of different variables (eg: parameter, continuous, simulation parameters)
+        datatype
+            type identifier (eg; continuous, parameter, simulation, linearization, optimization)
+        overwritedata
+            dict() which stores the new override variables list,
+        """
+
+        inputdata_status: dict[str, bool] = {}
+        for key, val in inputdata.items():
+            status = False
+            if key in classdata:
+                if datatype == "parameter" and not self.isParameterChangeable(key):
+                    logger.debug(f"It is not possible to set the parameter {repr(key)}. It seems to be "
                                  "structural, final, protected, evaluated or has a non-constant binding. "
                                  "Use sendExpression(...) and rebuild the model using buildModel() API; example: "
                                  "sendExpression(\"setParameterValue("
-                                 f"{self.modelName}, {name}, {value if value is not None else '<?value?>'}"
+                                 f"{self.modelName}, {key}, {val if val is not None else '<?value?>'}"
                                  ")\") ")
-                    return False
-
-                classdata[name] = value
-                if overwritedata is not None:
-                    overwritedata[name] = value
-
-                return True
-
+                else:
+                    classdata[key] = val
+                    if overwritedata is not None:
+                        overwritedata[key] = val
+                    status = True
             else:
                 raise ModelicaSystemError("Unhandled case in setMethodHelper.apply_single() - "
-                                          f"{repr(name)} is not a {repr(datatype)} variable")
-
-        result = []
-        if isinstance(inputdata, str):
-            result = [apply_single(inputdata)]
+                                          f"{repr(key)} is not a {repr(datatype)} variable")
 
-        elif isinstance(inputdata, list):
-            result = []
-            inputdata = self._strip_space(inputdata)
-            for var in inputdata:
-                result.append(apply_single(var))
+            inputdata_status[key] = status
 
-        return all(result)
+        return all(inputdata_status.values())
 
     def isParameterChangeable(
             self,
@@ -1122,11 +1105,14 @@ def setContinuous(self, cvals: str | list[str] | dict[str, str | int | float]) -
         This method is used to set continuous values. It can be called:
         with a sequence of continuous name and assigning corresponding values as arguments as show in the example below:
         usage
-        >>> setContinuous("Name=value")
-        >>> setContinuous(["Name1=value1","Name2=value2"])
+        >>> setContinuous("Name=value")  # depreciated
+        >>> setContinuous(["Name1=value1","Name2=value2"])  # depreciated
+        >>> setContinuous(cvals={"Name1": "value1", "Name2": "value2"})
         """
-        return self.setMethodHelper(
-            inputdata=cvals,
+        inputdata = self._prepare_inputdata(rawinput=cvals)
+
+        return self._set_method_helper(
+            inputdata=inputdata,
             classdata=self.continuouslist,
             datatype="continuous",
             overwritedata=self.overridevariables)
@@ -1136,11 +1122,14 @@ def setParameters(self, pvals: str | list[str] | dict[str, str | int | float]) -
         This method is used to set parameter values. It can be called:
         with a sequence of parameter name and assigning corresponding value as arguments as show in the example below:
         usage
-        >>> setParameters("Name=value")
-        >>> setParameters(["Name1=value1","Name2=value2"])
+        >>> setParameters("Name=value")  # depreciated
+        >>> setParameters(["Name1=value1","Name2=value2"])  # depreciated
+        >>> setParameters(pvals={"Name1": "value1", "Name2": "value2"})
         """
-        return self.setMethodHelper(
-            inputdata=pvals,
+        inputdata = self._prepare_inputdata(rawinput=pvals)
+
+        return self._set_method_helper(
+            inputdata=inputdata,
             classdata=self.paramlist,
             datatype="parameter",
             overwritedata=self.overridevariables)
@@ -1150,11 +1139,14 @@ def setSimulationOptions(self, simOptions: str | list[str] | dict[str, str | int
         This method is used to set simulation options. It can be called:
         with a sequence of simulation options name and assigning corresponding values as arguments as show in the example below:
         usage
-        >>> setSimulationOptions("Name=value")
-        >>> setSimulationOptions(["Name1=value1","Name2=value2"])
+        >>> setSimulationOptions("Name=value")  # depreciated
+        >>> setSimulationOptions(["Name1=value1","Name2=value2"])  # depreciated
+        >>> setSimulationOptions(simOptions={"Name1": "value1", "Name2": "value2"})
         """
-        return self.setMethodHelper(
-            inputdata=simOptions,
+        inputdata = self._prepare_inputdata(rawinput=simOptions)
+
+        return self._set_method_helper(
+            inputdata=inputdata,
             classdata=self.simulateOptions,
             datatype="simulation-option",
             overwritedata=self.simoptionsoverride)
@@ -1164,11 +1156,14 @@ def setLinearizationOptions(self, linearizationOptions: str | list[str] | dict[s
         This method is used to set linearization options. It can be called:
         with a sequence of linearization options name and assigning corresponding value as arguments as show in the example below
         usage
-        >>> setLinearizationOptions("Name=value")
-        >>> setLinearizationOptions(["Name1=value1","Name2=value2"])
+        >>> setLinearizationOptions("Name=value")  # depreciated
+        >>> setLinearizationOptions(["Name1=value1","Name2=value2"])  # depreciated
+        >>> setLinearizationOptions(linearizationOtions={"Name1": "value1", "Name2": "value2"})
         """
-        return self.setMethodHelper(
-            inputdata=linearizationOptions,
+        inputdata = self._prepare_inputdata(rawinput=linearizationOptions)
+
+        return self._set_method_helper(
+            inputdata=inputdata,
             classdata=self.linearOptions,
             datatype="Linearization-option",
             overwritedata=None)
@@ -1178,11 +1173,14 @@ def setOptimizationOptions(self, optimizationOptions: str | list[str] | dict[str
         This method is used to set optimization options. It can be called:
         with a sequence of optimization options name and assigning corresponding values as arguments as show in the example below:
         usage
-        >>> setOptimizationOptions("Name=value")
-        >>> setOptimizationOptions(["Name1=value1","Name2=value2"])
+        >>> setOptimizationOptions("Name=value")  # depreciated
+        >>> setOptimizationOptions(["Name1=value1","Name2=value2"])  # depreciated
+        >>> setOptimizationOptions(optimizationOptions={"Name1": "value1", "Name2": "value2"})
         """
-        return self.setMethodHelper(
-            inputdata=optimizationOptions,
+        inputdata = self._prepare_inputdata(rawinput=optimizationOptions)
+
+        return self._set_method_helper(
+            inputdata=inputdata,
             classdata=self.optimizeOptions,
             datatype="optimization-option",
             overwritedata=None)
@@ -1192,9 +1190,12 @@ def setInputs(self, name: str | list[str] | dict[str, str | int | float]) -> boo
         This method is used to set input values. It can be called:
         with a sequence of input name and assigning corresponding values as arguments as show in the example below:
         usage
-        >>> setInputs("Name=value")
-        >>> setInputs(["Name1=value1","Name2=value2"])
+        >>> setInputs("Name=value")  # depreciated
+        >>> setInputs(["Name1=value1","Name2=value2"])  # depreciated
+        >>> setInputs(name={"Name1": "value1", "Name2": "value2"})
         """
+        # inputdata = self._prepare_inputdata(rawinput=name)
+
         if isinstance(name, str):
             name1: str = name
             name1 = name1.replace(" ", "")

From 0301043fdde223d0c17bd78dd494b320210cf274 Mon Sep 17 00:00:00 2001
From: syntron <syntron@web.de>
Date: Mon, 23 Jun 2025 16:15:29 +0200
Subject: [PATCH 04/17] [ModelicaSystem] improve definition of
 _prepare_inputdata()

---
 OMPython/ModelicaSystem.py | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py
index a6c9b970..f22cbf9e 100644
--- a/OMPython/ModelicaSystem.py
+++ b/OMPython/ModelicaSystem.py
@@ -1005,9 +1005,11 @@ def prepare_str(str_in: str) -> dict[str, str]:
             if len(key_val_list) != 2:
                 raise ModelicaSystemError(f"Invalid 'key=value' pair: {str_in}")
 
-            inputdata = {key_val_list[0]: key_val_list[1]}
+            input_data_from_str: dict[str, str] = {key_val_list[0]: key_val_list[1]}
 
-            return inputdata
+            return input_data_from_str
+
+        input_data: dict[str, str] = {}
 
         if isinstance(rawinput, str):
             warnings.warn(message="The definition of values to set should use a dictionary, "
@@ -1024,20 +1026,21 @@ def prepare_str(str_in: str) -> dict[str, str]:
                           category=DeprecationWarning,
                           stacklevel=3)
 
-            inputdata: dict[str, str] = {}
             for item in rawinput:
-                inputdata |= prepare_str(item)
+                input_data |= prepare_str(item)
 
-            return inputdata
+            return input_data
 
         if isinstance(rawinput, dict):
             for key, val in rawinput.items():
                 str_val = str(val)
                 if ' ' in key or ' ' in str_val:
                     raise ModelicaSystemError(f"Spaces not allowed in key/value pairs: {repr(key)} = {repr(val)}!")
-                inputdata[key] = str_val
+                input_data[key] = str_val
+
+            return input_data
 
-            return inputdata
+        raise ModelicaSystemError(f"Invalid type of input: {type(rawinput)}")
 
     def _set_method_helper(
             self,

From 341e429c74a04c8b5e0cdf10e51a51044c1d177a Mon Sep 17 00:00:00 2001
From: syntron <syntron@web.de>
Date: Mon, 23 Jun 2025 16:16:02 +0200
Subject: [PATCH 05/17] [ModelicaSystem] rename _prepare_inputdata() =>
 _prepare_input_data()

---
 OMPython/ModelicaSystem.py | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py
index f22cbf9e..8234618e 100644
--- a/OMPython/ModelicaSystem.py
+++ b/OMPython/ModelicaSystem.py
@@ -992,8 +992,8 @@ def getSolutions(self, varList=None, resultfile=None):  # 12
         return np_res
 
     @staticmethod
-    def _prepare_inputdata(
-            rawinput: str | list[str] | dict[str, str | int | float],
+    def _prepare_input_data(
+            raw_input: str | list[str] | dict[str, str | int | float],
     ) -> dict[str, str]:
         """
         Convert raw input to a structured dictionary {'key1': 'value1', 'key2': 'value2'}.
@@ -1011,28 +1011,28 @@ def prepare_str(str_in: str) -> dict[str, str]:
 
         input_data: dict[str, str] = {}
 
-        if isinstance(rawinput, str):
+        if isinstance(raw_input, str):
             warnings.warn(message="The definition of values to set should use a dictionary, "
                                   "i.e. {'key1': 'val1', 'key2': 'val2', ...}. Please convert all cases which "
                                   "use a string ('key=val') or list ['key1=val1', 'key2=val2', ...]",
                           category=DeprecationWarning,
                           stacklevel=3)
-            return prepare_str(rawinput)
+            return prepare_str(raw_input)
 
-        if isinstance(rawinput, list):
+        if isinstance(raw_input, list):
             warnings.warn(message="The definition of values to set should use a dictionary, "
                                   "i.e. {'key1': 'val1', 'key2': 'val2', ...}. Please convert all cases which "
                                   "use a string ('key=val') or list ['key1=val1', 'key2=val2', ...]",
                           category=DeprecationWarning,
                           stacklevel=3)
 
-            for item in rawinput:
+            for item in raw_input:
                 input_data |= prepare_str(item)
 
             return input_data
 
-        if isinstance(rawinput, dict):
-            for key, val in rawinput.items():
+        if isinstance(raw_input, dict):
+            for key, val in raw_input.items():
                 str_val = str(val)
                 if ' ' in key or ' ' in str_val:
                     raise ModelicaSystemError(f"Spaces not allowed in key/value pairs: {repr(key)} = {repr(val)}!")
@@ -1040,7 +1040,7 @@ def prepare_str(str_in: str) -> dict[str, str]:
 
             return input_data
 
-        raise ModelicaSystemError(f"Invalid type of input: {type(rawinput)}")
+        raise ModelicaSystemError(f"Invalid type of input: {type(raw_input)}")
 
     def _set_method_helper(
             self,
@@ -1112,7 +1112,7 @@ def setContinuous(self, cvals: str | list[str] | dict[str, str | int | float]) -
         >>> setContinuous(["Name1=value1","Name2=value2"])  # depreciated
         >>> setContinuous(cvals={"Name1": "value1", "Name2": "value2"})
         """
-        inputdata = self._prepare_inputdata(rawinput=cvals)
+        inputdata = self._prepare_input_data(raw_input=cvals)
 
         return self._set_method_helper(
             inputdata=inputdata,
@@ -1129,7 +1129,7 @@ def setParameters(self, pvals: str | list[str] | dict[str, str | int | float]) -
         >>> setParameters(["Name1=value1","Name2=value2"])  # depreciated
         >>> setParameters(pvals={"Name1": "value1", "Name2": "value2"})
         """
-        inputdata = self._prepare_inputdata(rawinput=pvals)
+        inputdata = self._prepare_input_data(raw_input=pvals)
 
         return self._set_method_helper(
             inputdata=inputdata,
@@ -1146,7 +1146,7 @@ def setSimulationOptions(self, simOptions: str | list[str] | dict[str, str | int
         >>> setSimulationOptions(["Name1=value1","Name2=value2"])  # depreciated
         >>> setSimulationOptions(simOptions={"Name1": "value1", "Name2": "value2"})
         """
-        inputdata = self._prepare_inputdata(rawinput=simOptions)
+        inputdata = self._prepare_input_data(raw_input=simOptions)
 
         return self._set_method_helper(
             inputdata=inputdata,
@@ -1163,7 +1163,7 @@ def setLinearizationOptions(self, linearizationOptions: str | list[str] | dict[s
         >>> setLinearizationOptions(["Name1=value1","Name2=value2"])  # depreciated
         >>> setLinearizationOptions(linearizationOtions={"Name1": "value1", "Name2": "value2"})
         """
-        inputdata = self._prepare_inputdata(rawinput=linearizationOptions)
+        inputdata = self._prepare_input_data(raw_input=linearizationOptions)
 
         return self._set_method_helper(
             inputdata=inputdata,
@@ -1180,7 +1180,7 @@ def setOptimizationOptions(self, optimizationOptions: str | list[str] | dict[str
         >>> setOptimizationOptions(["Name1=value1","Name2=value2"])  # depreciated
         >>> setOptimizationOptions(optimizationOptions={"Name1": "value1", "Name2": "value2"})
         """
-        inputdata = self._prepare_inputdata(rawinput=optimizationOptions)
+        inputdata = self._prepare_input_data(raw_input=optimizationOptions)
 
         return self._set_method_helper(
             inputdata=inputdata,
@@ -1197,7 +1197,7 @@ def setInputs(self, name: str | list[str] | dict[str, str | int | float]) -> boo
         >>> setInputs(["Name1=value1","Name2=value2"])  # depreciated
         >>> setInputs(name={"Name1": "value1", "Name2": "value2"})
         """
-        # inputdata = self._prepare_inputdata(rawinput=name)
+        # inputdata = self._prepare_input_data(raw_input=name)
 
         if isinstance(name, str):
             name1: str = name

From 1cbd1f72d770328b74d387da27a90feee1a1c468 Mon Sep 17 00:00:00 2001
From: syntron <syntron@web.de>
Date: Mon, 23 Jun 2025 16:33:58 +0200
Subject: [PATCH 06/17] [ModelicaSystem] update setInput()

* replace eval() with ast.literal_eval() as a saver version
* use _prepare_input_data()
* simplify code
---
 OMPython/ModelicaSystem.py | 73 ++++++++++++++------------------------
 1 file changed, 27 insertions(+), 46 deletions(-)

diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py
index 8234618e..ca0a8cdd 100644
--- a/OMPython/ModelicaSystem.py
+++ b/OMPython/ModelicaSystem.py
@@ -32,6 +32,7 @@
  CONDITIONS OF OSMC-PL.
 """
 
+import ast
 import csv
 from dataclasses import dataclass
 import importlib
@@ -1197,57 +1198,37 @@ def setInputs(self, name: str | list[str] | dict[str, str | int | float]) -> boo
         >>> setInputs(["Name1=value1","Name2=value2"])  # depreciated
         >>> setInputs(name={"Name1": "value1", "Name2": "value2"})
         """
-        # inputdata = self._prepare_input_data(raw_input=name)
-
-        if isinstance(name, str):
-            name1: str = name
-            name1 = name1.replace(" ", "")
-            value1 = name1.split("=")
-            if value1[0] in self.inputlist:
-                tmpvalue = eval(value1[1])
-                if isinstance(tmpvalue, (int, float)):
-                    self.inputlist[value1[0]] = [(float(self.simulateOptions["startTime"]), float(value1[1])),
-                                                 (float(self.simulateOptions["stopTime"]), float(value1[1]))]
-                elif isinstance(tmpvalue, list):
-                    self.checkValidInputs(tmpvalue)
-                    self.inputlist[value1[0]] = tmpvalue
+        inputdata = self._prepare_input_data(raw_input=name)
+
+        for key, val in inputdata.items():
+            if key in self.inputlist:
+                val_evaluated = ast.literal_eval(val)
+                if isinstance(val_evaluated, (int, float)):
+                    self.inputlist[key] = [(float(self.simulateOptions["startTime"]), float(val)),
+                                           (float(self.simulateOptions["stopTime"]), float(val))]
+                elif isinstance(val_evaluated, list):
+                    if not all([isinstance(item, tuple) for item in val_evaluated]):
+                        raise ModelicaSystemError("Value for setInput() must be in tuple format; "
+                                                  f"got {repr(val_evaluated)}")
+                    if val_evaluated != sorted(val_evaluated, key=lambda x: x[0]):
+                        raise ModelicaSystemError("Time value should be in increasing order; "
+                                                  f"got {repr(val_evaluated)}")
+
+                    for item in val_evaluated:
+                        if item[0] < float(self.simulateOptions["startTime"]):
+                            raise ModelicaSystemError(f"Time value in {repr(item)} of {repr(val_evaluated)} is less "
+                                                      "than the simulation start time")
+                        if len(item) != 2:
+                            raise ModelicaSystemError(f"Value {repr(item)} of {repr(val_evaluated)} "
+                                                      "is in incorrect format!")
+
+                    self.inputlist[key] = val_evaluated
                 self.inputFlag = True
             else:
-                raise ModelicaSystemError(f"{value1[0]} is not an input")
-        elif isinstance(name, list):
-            name_list: list[str] = name
-            for name2 in name_list:
-                name2 = name2.replace(" ", "")
-                value2 = name2.split("=")
-                if value2[0] in self.inputlist:
-                    tmpvalue = eval(value2[1])
-                    if isinstance(tmpvalue, (int, float)):
-                        self.inputlist[value2[0]] = [(float(self.simulateOptions["startTime"]), float(value2[1])),
-                                                     (float(self.simulateOptions["stopTime"]), float(value2[1]))]
-                    elif isinstance(tmpvalue, list):
-                        self.checkValidInputs(tmpvalue)
-                        self.inputlist[value2[0]] = tmpvalue
-                    self.inputFlag = True
-                else:
-                    raise ModelicaSystemError(f"{value2[0]} is not an input!")
-        elif isinstance(name, dict):
-            raise NotImplementedError("Must be defined!")
+                raise ModelicaSystemError(f"{key} is not an input")
 
         return True
 
-    def checkValidInputs(self, name):
-        if name != sorted(name, key=lambda x: x[0]):
-            raise ModelicaSystemError('Time value should be in increasing order')
-        for l in name:
-            if isinstance(l, tuple):
-                # if l[0] < float(self.simValuesList[0]):
-                if l[0] < float(self.simulateOptions["startTime"]):
-                    raise ModelicaSystemError('Input time value is less than simulation startTime')
-                if len(l) != 2:
-                    raise ModelicaSystemError(f'Value for {l} is in incorrect format!')
-            else:
-                raise ModelicaSystemError('Error!!! Value must be in tuple format')
-
     def createCSVData(self) -> pathlib.Path:
         start_time: float = float(self.simulateOptions["startTime"])
         stop_time: float = float(self.simulateOptions["stopTime"])

From 2c87f4ed13cf480b8193611e18a0868d48cc4367 Mon Sep 17 00:00:00 2001
From: syntron <syntron@web.de>
Date: Mon, 23 Jun 2025 16:49:52 +0200
Subject: [PATCH 07/17] update tests - use new dict based input for set*()
 methods

---
 tests/test_ModelicaSystem.py | 20 ++++++++++----------
 tests/test_linearization.py  |  2 +-
 tests/test_optimization.py   |  8 +++++---
 3 files changed, 16 insertions(+), 14 deletions(-)

diff --git a/tests/test_ModelicaSystem.py b/tests/test_ModelicaSystem.py
index 156dde03..9749e5f1 100644
--- a/tests/test_ModelicaSystem.py
+++ b/tests/test_ModelicaSystem.py
@@ -35,8 +35,8 @@ def test_setParameters():
     mod = OMPython.ModelicaSystem(model_path + "BouncingBall.mo", "BouncingBall")
 
     # method 1
-    mod.setParameters("e=1.234")
-    mod.setParameters("g=321.0")
+    mod.setParameters(pvals={"e": 1.234})
+    mod.setParameters(pvals={"g": 321.0})
     assert mod.getParameters("e") == ["1.234"]
     assert mod.getParameters("g") == ["321.0"]
     assert mod.getParameters() == {
@@ -47,7 +47,7 @@ def test_setParameters():
         mod.getParameters("thisParameterDoesNotExist")
 
     # method 2
-    mod.setParameters(["e=21.3", "g=0.12"])
+    mod.setParameters(pvals={"e": 21.3, "g": 0.12})
     assert mod.getParameters() == {
         "e": "21.3",
         "g": "0.12",
@@ -64,8 +64,8 @@ def test_setSimulationOptions():
     mod = OMPython.ModelicaSystem(fileName=model_path + "BouncingBall.mo", modelName="BouncingBall")
 
     # method 1
-    mod.setSimulationOptions("stopTime=1.234")
-    mod.setSimulationOptions("tolerance=1.1e-08")
+    mod.setSimulationOptions(simOptions={"stopTime": 1.234})
+    mod.setSimulationOptions(simOptions={"tolerance": 1.1e-08})
     assert mod.getSimulationOptions("stopTime") == ["1.234"]
     assert mod.getSimulationOptions("tolerance") == ["1.1e-08"]
     assert mod.getSimulationOptions(["tolerance", "stopTime"]) == ["1.1e-08", "1.234"]
@@ -77,7 +77,7 @@ def test_setSimulationOptions():
         mod.getSimulationOptions("thisOptionDoesNotExist")
 
     # method 2
-    mod.setSimulationOptions(["stopTime=2.1", "tolerance=1.2e-08"])
+    mod.setSimulationOptions(simOptions={"stopTime": 2.1, "tolerance": "1.2e-08"})
     d = mod.getSimulationOptions()
     assert d["stopTime"] == "2.1"
     assert d["tolerance"] == "1.2e-08"
@@ -119,7 +119,7 @@ def test_getSolutions(model_firstorder):
     a = -1
     tau = -1 / a
     stopTime = 5*tau
-    mod.setSimulationOptions([f"stopTime={stopTime}", "stepSize=0.1", "tolerance=1e-8"])
+    mod.setSimulationOptions(simOptions={"stopTime": stopTime, "stepSize": 0.1, "tolerance": 1e-8})
     mod.simulate()
 
     x = mod.getSolutions("x")
@@ -298,7 +298,7 @@ def test_getters(tmp_path):
     x0 = 1.0
     x_analytical = -b/a + (x0 + b/a) * np.exp(a * stopTime)
     dx_analytical = (x0 + b/a) * a * np.exp(a * stopTime)
-    mod.setSimulationOptions(f"stopTime={stopTime}")
+    mod.setSimulationOptions(simOptions={"stopTime": stopTime})
     mod.simulate()
 
     # getOutputs after simulate()
@@ -327,7 +327,7 @@ def test_getters(tmp_path):
         mod.getContinuous("a")  # a is a parameter
 
     with pytest.raises(OMPython.ModelicaSystemError):
-        mod.setSimulationOptions("thisOptionDoesNotExist=3")
+        mod.setSimulationOptions(simOptions={"thisOptionDoesNotExist": 3})
 
 
 def test_simulate_inputs(tmp_path):
@@ -345,7 +345,7 @@ def test_simulate_inputs(tmp_path):
 """)
     mod = OMPython.ModelicaSystem(fileName=model_file.as_posix(), modelName="M_input")
 
-    mod.setSimulationOptions("stopTime=1.0")
+    mod.setSimulationOptions(simOptions={"stopTime": 1.0})
 
     # integrate zero (no setInputs call) - it should default to None -> 0
     assert mod.getInputs() == {
diff --git a/tests/test_linearization.py b/tests/test_linearization.py
index 2c79190c..baec6202 100644
--- a/tests/test_linearization.py
+++ b/tests/test_linearization.py
@@ -62,7 +62,7 @@ def test_getters(tmp_path):
     assert "startTime" in d
     assert "stopTime" in d
     assert mod.getLinearizationOptions(["stopTime", "startTime"]) == [d["stopTime"], d["startTime"]]
-    mod.setLinearizationOptions("stopTime=0.02")
+    mod.setLinearizationOptions(linearizationOptions={"stopTime": 0.02})
     assert mod.getLinearizationOptions("stopTime") == ["0.02"]
 
     mod.setInputs(["u1=10", "u2=0"])
diff --git a/tests/test_optimization.py b/tests/test_optimization.py
index aa74df79..b4164397 100644
--- a/tests/test_optimization.py
+++ b/tests/test_optimization.py
@@ -35,13 +35,15 @@ def test_optimization_example(tmp_path):
 
     mod = OMPython.ModelicaSystem(fileName=model_file.as_posix(), modelName="BangBang2021")
 
-    mod.setOptimizationOptions(["numberOfIntervals=16", "stopTime=1",
-                                "stepSize=0.001", "tolerance=1e-8"])
+    mod.setOptimizationOptions(optimizationOptions={"numberOfIntervals": 16,
+                                                    "stopTime": 1,
+                                                    "stepSize": 0.001,
+                                                    "tolerance": 1e-8})
 
     # test the getter
     assert mod.getOptimizationOptions()["stopTime"] == "1"
     assert mod.getOptimizationOptions("stopTime") == ["1"]
-    assert mod.getOptimizationOptions(["tolerance", "stopTime"]) == ["1e-8", "1"]
+    assert mod.getOptimizationOptions(["tolerance", "stopTime"]) == ["1e-08", "1"]
 
     r = mod.optimize()
     # it is necessary to specify resultfile, otherwise it wouldn't find it.

From c498498e0d3c5a8567a50cf9ba28c90b0195ea85 Mon Sep 17 00:00:00 2001
From: syntron <syntron@web.de>
Date: Mon, 23 Jun 2025 17:02:05 +0200
Subject: [PATCH 08/17] [ModelicaSystem] add type hint for return value of
 isParameterChangeable()

---
 OMPython/ModelicaSystem.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py
index ca0a8cdd..4c98c01a 100644
--- a/OMPython/ModelicaSystem.py
+++ b/OMPython/ModelicaSystem.py
@@ -1098,7 +1098,7 @@ def _set_method_helper(
     def isParameterChangeable(
             self,
             name: str,
-    ):
+    ) -> bool:
         q = self.getQuantities(name)
         if q[0]["changeable"] == "false":
             return False

From 3b0c9d9e5b336c4caa5e980b6b2158a4d2aa52c8 Mon Sep 17 00:00:00 2001
From: syntron <syntron@web.de>
Date: Mon, 23 Jun 2025 17:09:46 +0200
Subject: [PATCH 09/17] [ModelicaSystem] fix type hint for
 _prepare_input_data() - use dict[str, Any]

---
 OMPython/ModelicaSystem.py | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py
index 4c98c01a..ee3f73d1 100644
--- a/OMPython/ModelicaSystem.py
+++ b/OMPython/ModelicaSystem.py
@@ -994,7 +994,7 @@ def getSolutions(self, varList=None, resultfile=None):  # 12
 
     @staticmethod
     def _prepare_input_data(
-            raw_input: str | list[str] | dict[str, str | int | float],
+            raw_input: str | list[str] | dict[str, Any],
     ) -> dict[str, str]:
         """
         Convert raw input to a structured dictionary {'key1': 'value1', 'key2': 'value2'}.
@@ -1104,7 +1104,7 @@ def isParameterChangeable(
             return False
         return True
 
-    def setContinuous(self, cvals: str | list[str] | dict[str, str | int | float]) -> bool:
+    def setContinuous(self, cvals: str | list[str] | dict[str, Any]) -> bool:
         """
         This method is used to set continuous values. It can be called:
         with a sequence of continuous name and assigning corresponding values as arguments as show in the example below:
@@ -1121,7 +1121,7 @@ def setContinuous(self, cvals: str | list[str] | dict[str, str | int | float]) -
             datatype="continuous",
             overwritedata=self.overridevariables)
 
-    def setParameters(self, pvals: str | list[str] | dict[str, str | int | float]) -> bool:
+    def setParameters(self, pvals: str | list[str] | dict[str, Any]) -> bool:
         """
         This method is used to set parameter values. It can be called:
         with a sequence of parameter name and assigning corresponding value as arguments as show in the example below:
@@ -1138,7 +1138,7 @@ def setParameters(self, pvals: str | list[str] | dict[str, str | int | float]) -
             datatype="parameter",
             overwritedata=self.overridevariables)
 
-    def setSimulationOptions(self, simOptions: str | list[str] | dict[str, str | int | float]) -> bool:
+    def setSimulationOptions(self, simOptions: str | list[str] | dict[str, Any]) -> bool:
         """
         This method is used to set simulation options. It can be called:
         with a sequence of simulation options name and assigning corresponding values as arguments as show in the example below:
@@ -1155,7 +1155,7 @@ def setSimulationOptions(self, simOptions: str | list[str] | dict[str, str | int
             datatype="simulation-option",
             overwritedata=self.simoptionsoverride)
 
-    def setLinearizationOptions(self, linearizationOptions: str | list[str] | dict[str, str | int | float]) -> bool:
+    def setLinearizationOptions(self, linearizationOptions: str | list[str] | dict[str, Any]) -> bool:
         """
         This method is used to set linearization options. It can be called:
         with a sequence of linearization options name and assigning corresponding value as arguments as show in the example below
@@ -1172,7 +1172,7 @@ def setLinearizationOptions(self, linearizationOptions: str | list[str] | dict[s
             datatype="Linearization-option",
             overwritedata=None)
 
-    def setOptimizationOptions(self, optimizationOptions: str | list[str] | dict[str, str | int | float]) -> bool:
+    def setOptimizationOptions(self, optimizationOptions: str | list[str] | dict[str, Any]) -> bool:
         """
         This method is used to set optimization options. It can be called:
         with a sequence of optimization options name and assigning corresponding values as arguments as show in the example below:
@@ -1189,7 +1189,7 @@ def setOptimizationOptions(self, optimizationOptions: str | list[str] | dict[str
             datatype="optimization-option",
             overwritedata=None)
 
-    def setInputs(self, name: str | list[str] | dict[str, str | int | float]) -> bool:
+    def setInputs(self, name: str | list[str] | dict[str, Any]) -> bool:
         """
         This method is used to set input values. It can be called:
         with a sequence of input name and assigning corresponding values as arguments as show in the example below:

From 241615dd823f9ec9bc7000fbe8b11bf97434d427 Mon Sep 17 00:00:00 2001
From: syntron <syntron@web.de>
Date: Mon, 23 Jun 2025 17:14:54 +0200
Subject: [PATCH 10/17] [ModelicaSystem] setInput() - handly input data as list
 of tuples

This method is used to set input values. It can be called with a sequence of input name and assigning
corresponding values as arguments as show in the example below. Compared to other set*() methods this is a
special case as value could be a list of tuples - these are converted to a string in _prepare_input_data()
and restored here via ast.literal_eval().
---
 OMPython/ModelicaSystem.py | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py
index ee3f73d1..5f01d814 100644
--- a/OMPython/ModelicaSystem.py
+++ b/OMPython/ModelicaSystem.py
@@ -1034,7 +1034,9 @@ def prepare_str(str_in: str) -> dict[str, str]:
 
         if isinstance(raw_input, dict):
             for key, val in raw_input.items():
-                str_val = str(val)
+                # convert all values to strings to align it on one type: dict[str, str]
+                # spaces have to be removed as setInput() could take list of tuples as input and spaces would
+                str_val = str(val).replace(' ', '')
                 if ' ' in key or ' ' in str_val:
                     raise ModelicaSystemError(f"Spaces not allowed in key/value pairs: {repr(key)} = {repr(val)}!")
                 input_data[key] = str_val
@@ -1191,9 +1193,11 @@ def setOptimizationOptions(self, optimizationOptions: str | list[str] | dict[str
 
     def setInputs(self, name: str | list[str] | dict[str, Any]) -> bool:
         """
-        This method is used to set input values. It can be called:
-        with a sequence of input name and assigning corresponding values as arguments as show in the example below:
-        usage
+        This method is used to set input values. It can be called with a sequence of input name and assigning
+        corresponding values as arguments as show in the example below. Compared to other set*() methods this is a
+        special case as value could be a list of tuples - these are converted to a string in _prepare_input_data()
+        and restored here via ast.literal_eval().
+
         >>> setInputs("Name=value")  # depreciated
         >>> setInputs(["Name1=value1","Name2=value2"])  # depreciated
         >>> setInputs(name={"Name1": "value1", "Name2": "value2"})
@@ -1202,7 +1206,11 @@ def setInputs(self, name: str | list[str] | dict[str, Any]) -> bool:
 
         for key, val in inputdata.items():
             if key in self.inputlist:
+                if not isinstance(val, str):
+                    raise ModelicaSystemError(f"Invalid data in input for {repr(key)}: {repr(val)}")
+
                 val_evaluated = ast.literal_eval(val)
+
                 if isinstance(val_evaluated, (int, float)):
                     self.inputlist[key] = [(float(self.simulateOptions["startTime"]), float(val)),
                                            (float(self.simulateOptions["stopTime"]), float(val))]

From f8c742bf590bf351ebf61fd852f1211d6beae188 Mon Sep 17 00:00:00 2001
From: syntron <syntron@web.de>
Date: Mon, 23 Jun 2025 17:15:43 +0200
Subject: [PATCH 11/17] update tests - use new dict based input for setInput()
 method

---
 tests/test_ModelicaSystem.py | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/tests/test_ModelicaSystem.py b/tests/test_ModelicaSystem.py
index 9749e5f1..ef1dccf8 100644
--- a/tests/test_ModelicaSystem.py
+++ b/tests/test_ModelicaSystem.py
@@ -357,7 +357,7 @@ def test_simulate_inputs(tmp_path):
     assert np.isclose(y[-1], 0.0)
 
     # integrate a constant
-    mod.setInputs("u1=2.5")
+    mod.setInputs(name={"u1": 2.5})
     assert mod.getInputs() == {
         "u1": [
             (0.0, 2.5),
@@ -370,7 +370,7 @@ def test_simulate_inputs(tmp_path):
     assert np.isclose(y[-1], 2.5)
 
     # now let's integrate the sum of two ramps
-    mod.setInputs("u1=[(0.0, 0.0), (0.5, 2), (1.0, 0)]")
+    mod.setInputs(name={"u1": [(0.0, 0.0), (0.5, 2), (1.0, 0)]})
     assert mod.getInputs("u1") == [[
         (0.0, 0.0),
         (0.5, 2.0),
@@ -383,19 +383,17 @@ def test_simulate_inputs(tmp_path):
     # let's try some edge cases
     # unmatched startTime
     with pytest.raises(OMPython.ModelicaSystemError):
-        mod.setInputs("u1=[(-0.5, 0.0), (1.0, 1)]")
+        mod.setInputs(name={"u1": [(-0.5, 0.0), (1.0, 1)]})
         mod.simulate()
     # unmatched stopTime
     with pytest.raises(OMPython.ModelicaSystemError):
-        mod.setInputs("u1=[(0.0, 0.0), (0.5, 1)]")
+        mod.setInputs(name={"u1": [(0.0, 0.0), (0.5, 1)]})
         mod.simulate()
 
     # Let's use both inputs, but each one with different number of of
     # samples. This has an effect when generating the csv file.
-    mod.setInputs([
-        "u1=[(0.0, 0), (1.0, 1)]",
-        "u2=[(0.0, 0), (0.25, 0.5), (0.5, 1.0), (1.0, 0)]",
-    ])
+    mod.setInputs(name={"u1": [(0.0, 0), (1.0, 1)],
+                        "u2": [(0.0, 0), (0.25, 0.5), (0.5, 1.0), (1.0, 0)]})
     mod.simulate()
     assert pathlib.Path(mod.csvFile).read_text() == """time,u1,u2,end
 0.0,0.0,0.0,0

From 9ec7edd491da710a264ea3d5a12dc07fc3563802 Mon Sep 17 00:00:00 2001
From: syntron <syntron@web.de>
Date: Tue, 24 Jun 2025 21:31:29 +0200
Subject: [PATCH 12/17] [test_linearization] fix setInput() call

---
 tests/test_linearization.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/test_linearization.py b/tests/test_linearization.py
index baec6202..6af565c6 100644
--- a/tests/test_linearization.py
+++ b/tests/test_linearization.py
@@ -65,7 +65,7 @@ def test_getters(tmp_path):
     mod.setLinearizationOptions(linearizationOptions={"stopTime": 0.02})
     assert mod.getLinearizationOptions("stopTime") == ["0.02"]
 
-    mod.setInputs(["u1=10", "u2=0"])
+    mod.setInputs(name={"u1": 10, "u2": 0})
     [A, B, C, D] = mod.linearize()
     g = float(mod.getParameters("g")[0])
     l = float(mod.getParameters("l")[0])

From 36ca683ce3ae94dec4ea634c8c8850ccf1924db5 Mon Sep 17 00:00:00 2001
From: syntron <syntron@web.de>
Date: Thu, 26 Jun 2025 20:34:19 +0200
Subject: [PATCH 13/17] [ModelicaSystem] simplify _set_method_helper()

---
 OMPython/ModelicaSystem.py | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py
index 5f01d814..ae332831 100644
--- a/OMPython/ModelicaSystem.py
+++ b/OMPython/ModelicaSystem.py
@@ -1075,24 +1075,24 @@ def _set_method_helper(
 
         inputdata_status: dict[str, bool] = {}
         for key, val in inputdata.items():
-            status = False
-            if key in classdata:
-                if datatype == "parameter" and not self.isParameterChangeable(key):
-                    logger.debug(f"It is not possible to set the parameter {repr(key)}. It seems to be "
-                                 "structural, final, protected, evaluated or has a non-constant binding. "
-                                 "Use sendExpression(...) and rebuild the model using buildModel() API; example: "
-                                 "sendExpression(\"setParameterValue("
-                                 f"{self.modelName}, {key}, {val if val is not None else '<?value?>'}"
-                                 ")\") ")
-                else:
-                    classdata[key] = val
-                    if overwritedata is not None:
-                        overwritedata[key] = val
-                    status = True
-            else:
+            if key not in classdata:
                 raise ModelicaSystemError("Unhandled case in setMethodHelper.apply_single() - "
                                           f"{repr(key)} is not a {repr(datatype)} variable")
 
+            status = False
+            if datatype == "parameter" and not self.isParameterChangeable(key):
+                logger.debug(f"It is not possible to set the parameter {repr(key)}. It seems to be "
+                             "structural, final, protected, evaluated or has a non-constant binding. "
+                             "Use sendExpression(...) and rebuild the model using buildModel() API; example: "
+                             "sendExpression(\"setParameterValue("
+                             f"{self.modelName}, {key}, {val if val is not None else '<?value?>'}"
+                             ")\") ")
+            else:
+                classdata[key] = val
+                if overwritedata is not None:
+                    overwritedata[key] = val
+                status = True
+
             inputdata_status[key] = status
 
         return all(inputdata_status.values())

From 817f20dc91992b6368c4fdfcfd8addbc021594b3 Mon Sep 17 00:00:00 2001
From: syntron <syntron@web.de>
Date: Thu, 26 Jun 2025 21:14:55 +0200
Subject: [PATCH 14/17] [ModelicaSystem] improve setInputs() - reduce spaces /
 cleanup

---
 OMPython/ModelicaSystem.py | 59 ++++++++++++++++++++------------------
 1 file changed, 31 insertions(+), 28 deletions(-)

diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py
index ae332831..34d479bd 100644
--- a/OMPython/ModelicaSystem.py
+++ b/OMPython/ModelicaSystem.py
@@ -1205,36 +1205,39 @@ def setInputs(self, name: str | list[str] | dict[str, Any]) -> bool:
         inputdata = self._prepare_input_data(raw_input=name)
 
         for key, val in inputdata.items():
-            if key in self.inputlist:
-                if not isinstance(val, str):
-                    raise ModelicaSystemError(f"Invalid data in input for {repr(key)}: {repr(val)}")
-
-                val_evaluated = ast.literal_eval(val)
-
-                if isinstance(val_evaluated, (int, float)):
-                    self.inputlist[key] = [(float(self.simulateOptions["startTime"]), float(val)),
-                                           (float(self.simulateOptions["stopTime"]), float(val))]
-                elif isinstance(val_evaluated, list):
-                    if not all([isinstance(item, tuple) for item in val_evaluated]):
-                        raise ModelicaSystemError("Value for setInput() must be in tuple format; "
-                                                  f"got {repr(val_evaluated)}")
-                    if val_evaluated != sorted(val_evaluated, key=lambda x: x[0]):
-                        raise ModelicaSystemError("Time value should be in increasing order; "
-                                                  f"got {repr(val_evaluated)}")
-
-                    for item in val_evaluated:
-                        if item[0] < float(self.simulateOptions["startTime"]):
-                            raise ModelicaSystemError(f"Time value in {repr(item)} of {repr(val_evaluated)} is less "
-                                                      "than the simulation start time")
-                        if len(item) != 2:
-                            raise ModelicaSystemError(f"Value {repr(item)} of {repr(val_evaluated)} "
-                                                      "is in incorrect format!")
-
-                    self.inputlist[key] = val_evaluated
-                self.inputFlag = True
-            else:
+            if key not in self.inputlist:
                 raise ModelicaSystemError(f"{key} is not an input")
 
+            if not isinstance(val, str):
+                raise ModelicaSystemError(f"Invalid data in input for {repr(key)}: {repr(val)}")
+
+            val_evaluated = ast.literal_eval(val)
+
+            if isinstance(val_evaluated, (int, float)):
+                self.inputlist[key] = [(float(self.simulateOptions["startTime"]), float(val)),
+                                       (float(self.simulateOptions["stopTime"]), float(val))]
+            elif isinstance(val_evaluated, list):
+                if not all([isinstance(item, tuple) for item in val_evaluated]):
+                    raise ModelicaSystemError("Value for setInput() must be in tuple format; "
+                                              f"got {repr(val_evaluated)}")
+                if val_evaluated != sorted(val_evaluated, key=lambda x: x[0]):
+                    raise ModelicaSystemError("Time value should be in increasing order; "
+                                              f"got {repr(val_evaluated)}")
+
+                for item in val_evaluated:
+                    if item[0] < float(self.simulateOptions["startTime"]):
+                        raise ModelicaSystemError(f"Time value in {repr(item)} of {repr(val_evaluated)} is less "
+                                                  "than the simulation start time")
+                    if len(item) != 2:
+                        raise ModelicaSystemError(f"Value {repr(item)} of {repr(val_evaluated)} "
+                                                  "is in incorrect format!")
+
+                self.inputlist[key] = val_evaluated
+            else:
+                raise ModelicaSystemError(f"Data cannot be evaluated for {repr(key)}: {repr(val)}")
+
+            self.inputFlag = True
+
         return True
 
     def createCSVData(self) -> pathlib.Path:

From d8c2d71a302ae1b4cedefd3a799ad10183c9c577 Mon Sep 17 00:00:00 2001
From: syntron <syntron@web.de>
Date: Tue, 17 Jun 2025 08:47:13 +0200
Subject: [PATCH 15/17] [OMCSessionZMQ] remove depreciated function execute()

---
 OMPython/OMCSession.py | 7 -------
 tests/test_ZMQ.py      | 4 +---
 2 files changed, 1 insertion(+), 10 deletions(-)

diff --git a/OMPython/OMCSession.py b/OMPython/OMCSession.py
index ac99dc05..66038d47 100644
--- a/OMPython/OMCSession.py
+++ b/OMPython/OMCSession.py
@@ -50,7 +50,6 @@
 import time
 from typing import Any, Optional, Tuple
 import uuid
-import warnings
 import zmq
 
 # TODO: replace this with the new parser
@@ -322,12 +321,6 @@ def __del__(self):
 
         self.omc_zmq = None
 
-    def execute(self, command: str):
-        warnings.warn("This function is depreciated and will be removed in future versions; "
-                      "please use sendExpression() instead", DeprecationWarning, stacklevel=2)
-
-        return self.sendExpression(command, parsed=False)
-
     def sendExpression(self, command: str, parsed: bool = True) -> Any:
         if self.omc_zmq is None:
             raise OMCSessionException("No OMC running. Create a new instance of OMCSessionZMQ!")
diff --git a/tests/test_ZMQ.py b/tests/test_ZMQ.py
index 30bf78e7..0ae91b29 100644
--- a/tests/test_ZMQ.py
+++ b/tests/test_ZMQ.py
@@ -36,9 +36,7 @@ def test_Simulate(om, model_time_str):
     assert om.sendExpression('res.resultFile')
 
 
-def test_execute(om):
-    with pytest.deprecated_call():
-        assert om.execute('"HelloWorld!"') == '"HelloWorld!"\n'
+def test_sendExpression(om):
     assert om.sendExpression('"HelloWorld!"', parsed=False) == '"HelloWorld!"\n'
     assert om.sendExpression('"HelloWorld!"', parsed=True) == 'HelloWorld!'
 

From f7c04b51e3f4a982086ce07723f588c10d23c02d Mon Sep 17 00:00:00 2001
From: syntron <syntron@web.de>
Date: Tue, 17 Jun 2025 08:48:59 +0200
Subject: [PATCH 16/17] [ModelicaSystemCmd] remove depreciated simflags

---
 OMPython/ModelicaSystem.py      | 81 ++++++---------------------------
 tests/test_ModelicaSystemCmd.py |  7 ++-
 2 files changed, 18 insertions(+), 70 deletions(-)

diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py
index e9c247b3..423170c9 100644
--- a/OMPython/ModelicaSystem.py
+++ b/OMPython/ModelicaSystem.py
@@ -45,8 +45,7 @@
 import subprocess
 import tempfile
 import textwrap
-from typing import Optional, Any
-import warnings
+from typing import Any, Optional
 import xml.etree.ElementTree as ET
 
 from OMPython.OMCSession import OMCSessionException, OMCSessionZMQ
@@ -275,52 +274,6 @@ def run(self) -> int:
 
         return returncode
 
-    @staticmethod
-    def parse_simflags(simflags: str) -> dict[str, Optional[str | dict[str, str]]]:
-        """
-        Parse a simflag definition; this is depreciated!
-
-        The return data can be used as input for self.args_set().
-
-        Parameters
-        ----------
-        simflags : str
-
-        Returns
-        -------
-            dict
-        """
-        warnings.warn("The argument 'simflags' is depreciated and will be removed in future versions; "
-                      "please use 'simargs' instead", DeprecationWarning, stacklevel=2)
-
-        simargs: dict[str, Optional[str | dict[str, str]]] = {}
-
-        args = [s for s in simflags.split(' ') if s]
-        for arg in args:
-            if arg[0] != '-':
-                raise ModelicaSystemError(f"Invalid simulation flag: {arg}")
-            arg = arg[1:]
-            parts = arg.split('=')
-            if len(parts) == 1:
-                simargs[parts[0]] = None
-            elif parts[0] == 'override':
-                override = '='.join(parts[1:])
-
-                override_dict = {}
-                for item in override.split(','):
-                    kv = item.split('=')
-                    if not 0 < len(kv) < 3:
-                        raise ModelicaSystemError(f"Invalid value for '-override': {override}")
-                    if kv[0]:
-                        try:
-                            override_dict[kv[0]] = kv[1]
-                        except (KeyError, IndexError) as ex:
-                            raise ModelicaSystemError(f"Invalid value for '-override': {override}") from ex
-
-                simargs[parts[0]] = override_dict
-
-        return simargs
-
 
 class ModelicaSystem:
     def __init__(
@@ -867,9 +820,12 @@ def getOptimizationOptions(self, names=None):  # 10
 
         raise ModelicaSystemError("Unhandled input for getOptimizationOptions()")
 
-    def simulate(self, resultfile: Optional[str] = None, simflags: Optional[str] = None,
-                 simargs: Optional[dict[str, Optional[str | dict[str, str]]]] = None,
-                 timeout: Optional[int] = None):  # 11
+    def simulate(
+            self,
+            resultfile: Optional[str] = None,
+            simargs: Optional[dict[str, Optional[str | dict[str, str]]]] = None,
+            timeout: Optional[int] = None
+    ):  # 11
         """
         This method simulates model according to the simulation options.
         usage
@@ -891,11 +847,7 @@ def simulate(self, resultfile: Optional[str] = None, simflags: Optional[str] = N
         # always define the resultfile to use
         om_cmd.arg_set(key="r", val=self.resultfile.as_posix())
 
-        # allow runtime simulation flags from user input
-        if simflags is not None:
-            om_cmd.args_set(args=om_cmd.parse_simflags(simflags=simflags))
-
-        if simargs:
+        if simargs is not None:
             om_cmd.args_set(args=simargs)
 
         overrideFile = self.tempdir / f"{self.modelName}_override.txt"
@@ -1258,15 +1210,16 @@ def optimize(self):  # 21
 
         return optimizeResult
 
-    def linearize(self, lintime: Optional[float] = None, simflags: Optional[str] = None,
-                  simargs: Optional[dict[str, Optional[str | dict[str, str]]]] = None,
-                  timeout: Optional[int] = None) -> LinearizationResult:
+    def linearize(
+            self,
+            lintime: Optional[float] = None,
+            simargs: Optional[dict[str, Optional[str | dict[str, str]]]] = None,
+            timeout: Optional[int] = None,
+    ) -> LinearizationResult:
         """Linearize the model according to linearOptions.
 
         Args:
             lintime: Override linearOptions["stopTime"] value.
-            simflags: A string of extra command line flags for the model
-              binary. - depreciated in favor of simargs
             simargs: A dict with command line flags and possible options; example: "simargs={'csvInput': 'a.csv'}"
             timeout: Possible timeout for the execution of OM.
 
@@ -1319,11 +1272,7 @@ def load_module_from_path(module_name, file_path):
 
         om_cmd.arg_set(key="l", val=str(lintime or self.linearOptions["stopTime"]))
 
-        # allow runtime simulation flags from user input
-        if simflags is not None:
-            om_cmd.args_set(args=om_cmd.parse_simflags(simflags=simflags))
-
-        if simargs:
+        if simargs is not None:
             om_cmd.args_set(args=simargs)
 
         returncode = om_cmd.run()
diff --git a/tests/test_ModelicaSystemCmd.py b/tests/test_ModelicaSystemCmd.py
index 420193df..8c99550d 100644
--- a/tests/test_ModelicaSystemCmd.py
+++ b/tests/test_ModelicaSystemCmd.py
@@ -23,11 +23,10 @@ def test_simflags(model_firstorder):
         "noRestart": None,
         "override": {'b': 2}
     })
-    with pytest.deprecated_call():
-        mscmd.args_set(args=mscmd.parse_simflags(simflags="-noEventEmit -noRestart -override=a=1,x=3"))
 
     assert mscmd.get_cmd() == [
         mscmd.get_exe().as_posix(),
-        '-noEventEmit', '-noRestart',
-        '-override=b=2,a=1,x=3'
+        '-noEventEmit',
+        '-noRestart',
+        '-override=b=2'
     ]

From 144fa10b22b16d99093094240802df5dbdda1e1d Mon Sep 17 00:00:00 2001
From: syntron <syntron@web.de>
Date: Mon, 23 Jun 2025 20:02:01 +0200
Subject: [PATCH 17/17] [ModelicaSystem] remove obsolete inputs for set*()
 methods

---
 OMPython/ModelicaSystem.py | 57 +++++---------------------------------
 1 file changed, 7 insertions(+), 50 deletions(-)

diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py
index c88aa31f..6e53954f 100644
--- a/OMPython/ModelicaSystem.py
+++ b/OMPython/ModelicaSystem.py
@@ -946,44 +946,13 @@ def getSolutions(self, varList=None, resultfile=None):  # 12
 
     @staticmethod
     def _prepare_input_data(
-            raw_input: str | list[str] | dict[str, Any],
+            raw_input: dict[str, Any],
     ) -> dict[str, str]:
         """
         Convert raw input to a structured dictionary {'key1': 'value1', 'key2': 'value2'}.
         """
 
-        def prepare_str(str_in: str) -> dict[str, str]:
-            str_in = str_in.replace(" ", "")
-            key_val_list: list[str] = str_in.split("=")
-            if len(key_val_list) != 2:
-                raise ModelicaSystemError(f"Invalid 'key=value' pair: {str_in}")
-
-            input_data_from_str: dict[str, str] = {key_val_list[0]: key_val_list[1]}
-
-            return input_data_from_str
-
         input_data: dict[str, str] = {}
-
-        if isinstance(raw_input, str):
-            warnings.warn(message="The definition of values to set should use a dictionary, "
-                                  "i.e. {'key1': 'val1', 'key2': 'val2', ...}. Please convert all cases which "
-                                  "use a string ('key=val') or list ['key1=val1', 'key2=val2', ...]",
-                          category=DeprecationWarning,
-                          stacklevel=3)
-            return prepare_str(raw_input)
-
-        if isinstance(raw_input, list):
-            warnings.warn(message="The definition of values to set should use a dictionary, "
-                                  "i.e. {'key1': 'val1', 'key2': 'val2', ...}. Please convert all cases which "
-                                  "use a string ('key=val') or list ['key1=val1', 'key2=val2', ...]",
-                          category=DeprecationWarning,
-                          stacklevel=3)
-
-            for item in raw_input:
-                input_data |= prepare_str(item)
-
-            return input_data
-
         if isinstance(raw_input, dict):
             for key, val in raw_input.items():
                 # convert all values to strings to align it on one type: dict[str, str]
@@ -1058,13 +1027,11 @@ def isParameterChangeable(
             return False
         return True
 
-    def setContinuous(self, cvals: str | list[str] | dict[str, Any]) -> bool:
+    def setContinuous(self, cvals: dict[str, Any]) -> bool:
         """
         This method is used to set continuous values. It can be called:
         with a sequence of continuous name and assigning corresponding values as arguments as show in the example below:
         usage
-        >>> setContinuous("Name=value")  # depreciated
-        >>> setContinuous(["Name1=value1","Name2=value2"])  # depreciated
         >>> setContinuous(cvals={"Name1": "value1", "Name2": "value2"})
         """
         inputdata = self._prepare_input_data(raw_input=cvals)
@@ -1075,13 +1042,11 @@ def setContinuous(self, cvals: str | list[str] | dict[str, Any]) -> bool:
             datatype="continuous",
             overwritedata=self.overridevariables)
 
-    def setParameters(self, pvals: str | list[str] | dict[str, Any]) -> bool:
+    def setParameters(self, pvals: dict[str, Any]) -> bool:
         """
         This method is used to set parameter values. It can be called:
         with a sequence of parameter name and assigning corresponding value as arguments as show in the example below:
         usage
-        >>> setParameters("Name=value")  # depreciated
-        >>> setParameters(["Name1=value1","Name2=value2"])  # depreciated
         >>> setParameters(pvals={"Name1": "value1", "Name2": "value2"})
         """
         inputdata = self._prepare_input_data(raw_input=pvals)
@@ -1092,13 +1057,11 @@ def setParameters(self, pvals: str | list[str] | dict[str, Any]) -> bool:
             datatype="parameter",
             overwritedata=self.overridevariables)
 
-    def setSimulationOptions(self, simOptions: str | list[str] | dict[str, Any]) -> bool:
+    def setSimulationOptions(self, simOptions: dict[str, Any]) -> bool:
         """
         This method is used to set simulation options. It can be called:
         with a sequence of simulation options name and assigning corresponding values as arguments as show in the example below:
         usage
-        >>> setSimulationOptions("Name=value")  # depreciated
-        >>> setSimulationOptions(["Name1=value1","Name2=value2"])  # depreciated
         >>> setSimulationOptions(simOptions={"Name1": "value1", "Name2": "value2"})
         """
         inputdata = self._prepare_input_data(raw_input=simOptions)
@@ -1109,13 +1072,11 @@ def setSimulationOptions(self, simOptions: str | list[str] | dict[str, Any]) ->
             datatype="simulation-option",
             overwritedata=self.simoptionsoverride)
 
-    def setLinearizationOptions(self, linearizationOptions: str | list[str] | dict[str, Any]) -> bool:
+    def setLinearizationOptions(self, linearizationOptions: dict[str, Any]) -> bool:
         """
         This method is used to set linearization options. It can be called:
         with a sequence of linearization options name and assigning corresponding value as arguments as show in the example below
         usage
-        >>> setLinearizationOptions("Name=value")  # depreciated
-        >>> setLinearizationOptions(["Name1=value1","Name2=value2"])  # depreciated
         >>> setLinearizationOptions(linearizationOtions={"Name1": "value1", "Name2": "value2"})
         """
         inputdata = self._prepare_input_data(raw_input=linearizationOptions)
@@ -1126,13 +1087,11 @@ def setLinearizationOptions(self, linearizationOptions: str | list[str] | dict[s
             datatype="Linearization-option",
             overwritedata=None)
 
-    def setOptimizationOptions(self, optimizationOptions: str | list[str] | dict[str, Any]) -> bool:
+    def setOptimizationOptions(self, optimizationOptions: dict[str, Any]) -> bool:
         """
         This method is used to set optimization options. It can be called:
         with a sequence of optimization options name and assigning corresponding values as arguments as show in the example below:
         usage
-        >>> setOptimizationOptions("Name=value")  # depreciated
-        >>> setOptimizationOptions(["Name1=value1","Name2=value2"])  # depreciated
         >>> setOptimizationOptions(optimizationOptions={"Name1": "value1", "Name2": "value2"})
         """
         inputdata = self._prepare_input_data(raw_input=optimizationOptions)
@@ -1143,15 +1102,13 @@ def setOptimizationOptions(self, optimizationOptions: str | list[str] | dict[str
             datatype="optimization-option",
             overwritedata=None)
 
-    def setInputs(self, name: str | list[str] | dict[str, Any]) -> bool:
+    def setInputs(self, name: dict[str, Any]) -> bool:
         """
         This method is used to set input values. It can be called with a sequence of input name and assigning
         corresponding values as arguments as show in the example below. Compared to other set*() methods this is a
         special case as value could be a list of tuples - these are converted to a string in _prepare_input_data()
         and restored here via ast.literal_eval().
 
-        >>> setInputs("Name=value")  # depreciated
-        >>> setInputs(["Name1=value1","Name2=value2"])  # depreciated
         >>> setInputs(name={"Name1": "value1", "Name2": "value2"})
         """
         inputdata = self._prepare_input_data(raw_input=name)