[ModelicaSystem] update setInput()

* replace eval() with ast.literal_eval() as a saver version
* use _prepare_input_data()
* simplify code

Author: syntron

OMPython/ModelicaSystem.py

@@ -32,6 +32,7 @@
  CONDITIONS OF OSMC-PL.
 """
 
+import ast
 import csv
 from dataclasses import dataclass
 import importlib
@@ -1337,62 +1338,38 @@ def setInputs(
         >>> 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._inputs[value1[0]] = tmpvalue
+        inputdata = self._prepare_input_data(raw_input=name)
+
+        for key, val in inputdata.items():
+            if key in self._inputs:
+                val_evaluated = ast.literal_eval(val)
+                if isinstance(val_evaluated, (int, float)):
+                    self._inputs[key] = [(float(self._simulate_options["startTime"]), float(val)),
+                                         (float(self._simulate_options["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._simulate_options["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._inputs[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._inputs[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._simulate_options["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, csvfile: Optional[pathlib.Path] = None) -> pathlib.Path:
-        """
-        Create a csv file with inputs for the simulation/optimization of the model. If csvfile is provided as argument,
-        this file is used; else a generic file name is created.
-        """
+    def _createCSVData(self) -> pathlib.Path:
         start_time: float = float(self._simulate_options["startTime"])
         stop_time: float = float(self._simulate_options["stopTime"])