[ModelicaSystem] remove obsolete inputs for set*() methods

Author: syntron

OMPython/ModelicaSystem.py

@@ -930,44 +930,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]
@@ -1042,13 +1011,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)
@@ -1059,13 +1026,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)
@@ -1076,13 +1041,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)
@@ -1093,13 +1056,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)
@@ -1110,13 +1071,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)
@@ -1127,15 +1086,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)