Merge branch 'parser' of https://github.com/syntron/OMPython into parser

Author: adeas31

OMPython/ModelicaSystem.py

@@ -320,8 +320,9 @@ def _run_cmd(self, cmd: list):
                 raise ModelicaSystemError(f"Error running command {cmd}: {stderr}")
             if self._verbose and stdout:
                 logger.info("OM output for command %s:\n%s", cmd, stdout)
-            p.wait()
-            p.terminate()
+            # check process returncode, some errors don't print to stderr
+            if p.wait():
+                raise ModelicaSystemError(f"Error running command {cmd}: nonzero returncode")
         except Exception as e:
             raise ModelicaSystemError(f"Exception {type(e)} running command {cmd}: {e}")
 
@@ -395,19 +396,11 @@ def xmlparse(self):
             scalar["changeable"] = sv.get('isValueChangeable')
             scalar["aliasvariable"] = sv.get('aliasVariable')
             ch = list(sv)
-            start = None
-            min = None
-            max = None
-            unit = None
             for att in ch:
-                start = att.get('start')
-                min = att.get('min')
-                max = att.get('max')
-                unit = att.get('unit')
-            scalar["start"] = start
-            scalar["min"] = min
-            scalar["max"] = max
-            scalar["unit"] = unit
+                scalar["start"] = att.get('start')
+                scalar["min"] = att.get('min')
+                scalar["max"] = att.get('max')
+                scalar["unit"] = att.get('unit')
 
             if scalar["variability"] == "parameter":
                 if scalar["name"] in self.overridevariables:
@@ -438,6 +431,8 @@ def getQuantities(self, names=None):  # 3
         elif isinstance(names, list):
             return [x for y in names for x in self.quantitiesList if x["name"] == y]
 
+        raise ModelicaSystemError("Unhandled input for getQuantities()")
+
     def getContinuous(self, names=None):  # 4
         """
         This method returns dict. The key is continuous names and value is corresponding continuous value.
@@ -482,6 +477,8 @@ def getContinuous(self, names=None):  # 4
                         raise ModelicaSystemError(f"OM error: {i} is not continuous")
                 return valuelist
 
+        raise ModelicaSystemError("Unhandled input for getContinous()")
+
     def getParameters(self, names: Optional[str | list[str]] = None) -> dict[str, str] | list[str]:  # 5
         """Get parameter values.
 
@@ -509,7 +506,9 @@ def getParameters(self, names: Optional[str | list[str]] = None) -> dict[str, st
         elif isinstance(names, str):
             return [self.paramlist.get(names, "NotExist")]
         elif isinstance(names, list):
-            return ([self.paramlist.get(x, "NotExist") for x in names])
+            return [self.paramlist.get(x, "NotExist") for x in names]
+
+        raise ModelicaSystemError("Unhandled input for getParameters()")
 
     def getInputs(self, names: Optional[str | list[str]] = None) -> dict | list:  # 6
         """Get input values.
@@ -543,7 +542,9 @@ def getInputs(self, names: Optional[str | list[str]] = None) -> dict | list:  #
         elif isinstance(names, str):
             return [self.inputlist.get(names, "NotExist")]
         elif isinstance(names, list):
-            return ([self.inputlist.get(x, "NotExist") for x in names])
+            return [self.inputlist.get(x, "NotExist") for x in names]
+
+        raise ModelicaSystemError("Unhandled input for getInputs()")
 
     def getOutputs(self, names: Optional[str | list[str]] = None):  # 7
         """Get output values.
@@ -588,7 +589,7 @@ def getOutputs(self, names: Optional[str | list[str]] = None):  # 7
             elif isinstance(names, str):
                 return [self.outputlist.get(names, "NotExist")]
             else:
-                return ([self.outputlist.get(x, "NotExist") for x in names])
+                return [self.outputlist.get(x, "NotExist") for x in names]
         else:
             if names is None:
                 for i in self.outputlist:
@@ -601,7 +602,7 @@ def getOutputs(self, names: Optional[str | list[str]] = None):  # 7
                     self.outputlist[names] = value[0][-1]
                     return [self.outputlist.get(names)]
                 else:
-                    return (names, " is not Output")
+                    return names, " is not Output"
             elif isinstance(names, list):
                 valuelist = []
                 for i in names:
@@ -610,9 +611,11 @@ def getOutputs(self, names: Optional[str | list[str]] = None):  # 7
                         self.outputlist[i] = value[0][-1]
                         valuelist.append(value[0][-1])
                     else:
-                        return (i, "is not Output")
+                        return i, "is not Output"
                 return valuelist
 
+        raise ModelicaSystemError("Unhandled input for getOutputs()")
+
     def getSimulationOptions(self, names=None):  # 8
         """
         This method returns dict. The key is simulation option names and value is corresponding simulation option value.
@@ -627,7 +630,9 @@ def getSimulationOptions(self, names=None):  # 8
         elif isinstance(names, str):
             return [self.simulateOptions.get(names, "NotExist")]
         elif isinstance(names, list):
-            return ([self.simulateOptions.get(x, "NotExist") for x in names])
+            return [self.simulateOptions.get(x, "NotExist") for x in names]
+
+        raise ModelicaSystemError("Unhandled input for getSimulationOptions()")
 
     def getLinearizationOptions(self, names=None):  # 9
         """
@@ -643,7 +648,9 @@ def getLinearizationOptions(self, names=None):  # 9
         elif isinstance(names, str):
             return [self.linearOptions.get(names, "NotExist")]
         elif isinstance(names, list):
-            return ([self.linearOptions.get(x, "NotExist") for x in names])
+            return [self.linearOptions.get(x, "NotExist") for x in names]
+
+        raise ModelicaSystemError("Unhandled input for getLinearizationOptions()")
 
     def getOptimizationOptions(self, names=None):  # 10
         """
@@ -657,7 +664,9 @@ def getOptimizationOptions(self, names=None):  # 10
         elif isinstance(names, str):
             return [self.optimizeOptions.get(names, "NotExist")]
         elif isinstance(names, list):
-            return ([self.optimizeOptions.get(x, "NotExist") for x in names])
+            return [self.optimizeOptions.get(x, "NotExist") for x in names]
+
+        raise ModelicaSystemError("Unhandled input for getOptimizationOptions()")
 
     def get_exe_file(self) -> pathlib.Path:
         """Get path to model executable."""
@@ -728,7 +737,7 @@ def simulate(self, resultfile=None, simflags=None):  # 11
             raise Exception(f"Error: Application file path not found: {exe_file}")
 
         cmd = exe_file.as_posix() + override + csvinput + r + simflags
-        cmd = cmd.split(" ")
+        cmd = [s for s in cmd.split(' ') if s]
         self._run_cmd(cmd=cmd)
         self.simulationFlag = True
 
@@ -752,41 +761,40 @@ def getSolutions(self, varList=None, resultfile=None):  # 12
 
         # check for result file exits
         if not os.path.exists(resFile):
-            errstr = f"Error: Result file does not exist {resFile}"
-            self._raise_error(errstr=errstr)
-            return
+            raise ModelicaSystemError(f"Result file does not exist {resFile}")
         resultVars = self.sendExpression(f'readSimulationResultVars("{resFile}")')
         self.sendExpression("closeSimulationResultFile()")
         if varList is None:
             return resultVars
         elif isinstance(varList, str):
             if varList not in resultVars and varList != "time":
-                self._raise_error(errstr=f'!!! {varList} does not exist')
-                return
+                raise ModelicaSystemError(f"Requested data {repr(varList)} does not exist")
             res = self.sendExpression(f'readSimulationResult("{resFile}", {{{varList}}})')
             npRes = np.array(res)
             self.sendExpression("closeSimulationResultFile()")
             return npRes
         elif isinstance(varList, list):
-            # varList, = varList
-            for v in varList:
-                if v == "time":
+            for var in varList:
+                if var == "time":
                     continue
-                if v not in resultVars:
-                    self._raise_error(errstr=f'!!! {v} does not exist')
-                    return
+                if var not in resultVars:
+                    raise ModelicaSystemError(f"Requested data {repr(var)} does not exist")
             variables = ",".join(varList)
             res = self.sendExpression(f'readSimulationResult("{resFile}",{{{variables}}})')
             npRes = np.array(res)
             self.sendExpression("closeSimulationResultFile()")
             return npRes
 
+        raise ModelicaSystemError("Unhandled input for getSolutions()")
+
     def strip_space(self, name):
         if isinstance(name, str):
             return name.replace(" ", "")
         elif isinstance(name, list):
             return [x.replace(" ", "") for x in name]
 
+        raise ModelicaSystemError("Unhandled input for strip_space()")
+
     def setMethodHelper(self, args1, args2, args3, args4=None):
         """
         Helper function for setParameter(),setContinuous(),setSimulationOptions(),setLinearizationOption(),setOptimizationOption()
@@ -811,7 +819,8 @@ def apply_single(args1):
                 return True
 
             else:
-                self._raise_error(errstr=f'"{value[0]}" is not a {args3} variable')
+                raise ModelicaSystemError("Unhandled case in setMethodHelper.apply_single() - "
+                                          f"{repr(value[0])} is not a {repr(args3)} variable")
 
         result = []
         if isinstance(args1, str):
@@ -847,7 +856,7 @@ def setParameters(self, pvals):  # 14
 
     def isParameterChangeable(self, name, value):
         q = self.getQuantities(name)
-        if (q[0]["changeable"] == "false"):
+        if q[0]["changeable"] == "false":
             if self._verbose:
                 logger.info("setParameters() failed : It is not possible to set "
                             f'the following signal "{name}", It seems to be structural, final, '
@@ -916,10 +925,10 @@ def setInputs(self, name):  # 15
                 value = var.split("=")
                 if value[0] in self.inputlist:
                     tmpvalue = eval(value[1])
-                    if (isinstance(tmpvalue, int) or isinstance(tmpvalue, float)):
+                    if isinstance(tmpvalue, int) or isinstance(tmpvalue, float):
                         self.inputlist[value[0]] = [(float(self.simulateOptions["startTime"]), float(value[1])),
                                                     (float(self.simulateOptions["stopTime"]), float(value[1]))]
-                    elif (isinstance(tmpvalue, list)):
+                    elif isinstance(tmpvalue, list):
                         self.checkValidInputs(tmpvalue)
                         self.inputlist[value[0]] = tmpvalue
                     self.inputFlag = True
@@ -1106,7 +1115,7 @@ def linearize(self, lintime: Optional[float] = None, simflags: Optional[str] = N
             raise Exception(f"Error: Application file path not found: {exe_file}")
         else:
             cmd = exe_file.as_posix() + linruntime + override + csvinput + simflags
-            cmd = cmd.split(' ')
+            cmd = [s for s in cmd.split(' ') if s]
             self._run_cmd(cmd=cmd)
 
         # code to get the matrix and linear inputs, outputs and states

OMPython/OMCSession.py

@@ -253,17 +253,15 @@ def getComponentModifierNames(self, className, componentName):
         return self.ask('getComponentModifierNames', f'{className}, {componentName}')
 
     def getComponentModifierValue(self, className, componentName):
-        result = self._ask_with_fallback(question='getComponentModifierValue',
-                                         opt=f'{className}, {componentName}')
-        return result[2:]
+        return self._ask_with_fallback(question='getComponentModifierValue',
+                                       opt=f'{className}, {componentName}')
 
     def getExtendsModifierNames(self, className, componentName):
         return self.ask('getExtendsModifierNames', f'{className}, {componentName}')
 
     def getExtendsModifierValue(self, className, extendsName, modifierName):
-        result = self._ask_with_fallback(question='getExtendsModifierValue',
-                                         opt=f'{className}, {extendsName}, {modifierName}')
-        return result[2:]
+        return self._ask_with_fallback(question='getExtendsModifierValue',
+                                       opt=f'{className}, {extendsName}, {modifierName}')
 
     def getNthComponentModification(self, className, comp_id):
         # FIXME: OMPython exception Results KeyError exception

OMPython/__init__.py

@@ -36,27 +36,9 @@
  CONDITIONS OF OSMC-PL.
 """
 
-import logging
-
 from OMPython.OMCSession import OMCSessionBase, OMCSessionZMQ
 from OMPython.ModelicaSystem import ModelicaSystem, ModelicaSystemError, LinearizationResult
 
-# Logger Defined
-logger = logging.getLogger('OMPython')
-logger.setLevel(logging.DEBUG)
-# create console handler with a higher log level
-logger_console_handler = logging.StreamHandler()
-logger_console_handler.setLevel(logging.INFO)
-
-# create formatter and add it to the handlers
-logger_formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-logger_console_handler.setFormatter(logger_formatter)
-
-# add the handlers to the logger
-logger.addHandler(logger_console_handler)
-logger.setLevel(logging.WARNING)
-
-
 # global names imported if import 'from OMPython import *' is used
 __all__ = [
     'ModelicaSystem',