"""

def __init__(self, pid):

self.pid = pid

self.process = psutil.Process(pid)

self.returncode = 0

def poll(self):

return None if self.process.is_running() else True

def kill(self):

return os.kill(self.pid, signal.SIGKILL)

def wait(self, timeout):

try:

self.process.wait(timeout=timeout)

except psutil.TimeoutExpired:

"""

def __init__(self, session: OMCSessionZMQ, readonly: bool = False):

if not isinstance(session, OMCSessionZMQ):

raise OMCSessionException("Invalid session definition!")

self._session = session

self._readonly = readonly

self._omc_cache: dict[tuple[str, bool], Any] = {}

def _ask(self, question: str, opt: Optional[list[str]] = None, parsed: bool = True):

if opt is None:

expression = question

elif isinstance(opt, list):

expression = f"{question}({','.join([str(x) for x in opt])})"

else:

raise OMCSessionException(f"Invalid definition of options for {repr(question)}: {repr(opt)}")

p = (expression, parsed)

if self._readonly and question != 'getErrorString':

# can use cache if readonly

if p in self._omc_cache:

return self._omc_cache[p]

try:

res = self._session.sendExpression(expression, parsed=parsed)

except OMCSessionException as ex:

raise OMCSessionException(f"OMC _ask() failed: {expression} (parsed={parsed})") from ex

# save response

self._omc_cache[p] = res

return res

# TODO: Open Modelica Compiler API functions. Would be nice to generate these.

def loadFile(self, filename):

return self._ask(question='loadFile', opt=[f'"{filename}"'])

def loadModel(self, className):

return self._ask(question='loadModel', opt=[className])

def isModel(self, className):

return self._ask(question='isModel', opt=[className])

def isPackage(self, className):

return self._ask(question='isPackage', opt=[className])

def isPrimitive(self, className):

return self._ask(question='isPrimitive', opt=[className])

def isConnector(self, className):

return self._ask(question='isConnector', opt=[className])

def isRecord(self, className):

return self._ask(question='isRecord', opt=[className])

def isBlock(self, className):

return self._ask(question='isBlock', opt=[className])

def isType(self, className):

return self._ask(question='isType', opt=[className])

def isFunction(self, className):

return self._ask(question='isFunction', opt=[className])

def isClass(self, className):

return self._ask(question='isClass', opt=[className])

def isParameter(self, className):

return self._ask(question='isParameter', opt=[className])

def isConstant(self, className):

return self._ask(question='isConstant', opt=[className])

def isProtected(self, className):

return self._ask(question='isProtected', opt=[className])

def getPackages(self, className="AllLoadedClasses"):

return self._ask(question='getPackages', opt=[className])

def getClassRestriction(self, className):

return self._ask(question='getClassRestriction', opt=[className])

def getDerivedClassModifierNames(self, className):

return self._ask(question='getDerivedClassModifierNames', opt=[className])

def getDerivedClassModifierValue(self, className, modifierName):

return self._ask(question='getDerivedClassModifierValue', opt=[className, modifierName])

def typeNameStrings(self, className):

return self._ask(question='typeNameStrings', opt=[className])

def getComponents(self, className):

return self._ask(question='getComponents', opt=[className])

def getClassComment(self, className):

try:

return self._ask(question='getClassComment', opt=[className])

except pyparsing.ParseException as ex:

logger.warning("Method 'getClassComment(%s)' failed; OMTypedParser error: %s",

className, ex.msg)

return 'No description available'

except OMCSessionException:

raise

def getNthComponent(self, className, comp_id):

""" returns with (type, name, description) """

return self._ask(question='getNthComponent', opt=[className, comp_id])

def getNthComponentAnnotation(self, className, comp_id):

return self._ask(question='getNthComponentAnnotation', opt=[className, comp_id])

def getImportCount(self, className):

return self._ask(question='getImportCount', opt=[className])

def getNthImport(self, className, importNumber):

# [Path, id, kind]

return self._ask(question='getNthImport', opt=[className, importNumber])

def getInheritanceCount(self, className):

return self._ask(question='getInheritanceCount', opt=[className])

def getNthInheritedClass(self, className, inheritanceDepth):

return self._ask(question='getNthInheritedClass', opt=[className, inheritanceDepth])

def getParameterNames(self, className):

try:

return self._ask(question='getParameterNames', opt=[className])

except KeyError as ex:

logger.warning('OMPython error: %s', ex)

# FIXME: OMC returns with a different structure for empty parameter set

return []

except OMCSessionException:

raise

def getParameterValue(self, className, parameterName):

try:

return self._ask(question='getParameterValue', opt=[className, parameterName])

except pyparsing.ParseException as ex:

logger.warning("Method 'getParameterValue(%s, %s)' failed; OMTypedParser error: %s",

className, parameterName, ex.msg)

return ""

except OMCSessionException:

raise

def getComponentModifierNames(self, className, componentName):

return self._ask(question='getComponentModifierNames', opt=[className, componentName])

def getComponentModifierValue(self, className, componentName):

return self._ask(question='getComponentModifierValue', opt=[className, componentName])

def getExtendsModifierNames(self, className, componentName):

return self._ask(question='getExtendsModifierNames', opt=[className, componentName])

def getExtendsModifierValue(self, className, extendsName, modifierName):

return self._ask(question='getExtendsModifierValue', opt=[className, extendsName, modifierName])

def getNthComponentModification(self, className, comp_id):

# FIXME: OMPython exception Results KeyError exception

# get {$Code(....)} field

# \{\$Code\((\S*\s*)*\)\}

value = self._ask(question='getNthComponentModification', opt=[className, comp_id], parsed=False)

value = value.replace("{$Code(", "")

return value[:-3]

# return self.re_Code.findall(value)

# function getClassNames

# input TypeName class_ = $Code(AllLoadedClasses);

# input Boolean recursive = false;

# input Boolean qualified = false;

# input Boolean sort = false;

# input Boolean builtin = false "List also builtin classes if true";

# input Boolean showProtected = false "List also protected classes if true";

# output TypeName classNames[:];

# end getClassNames;

def getClassNames(self, className=None, recursive=False, qualified=False, sort=False, builtin=False,

showProtected=False):

opt = [className] if className else [] + [f'recursive={str(recursive).lower()}',

f'qualified={str(qualified).lower()}',

f'sort={str(sort).lower()}',

f'builtin={str(builtin).lower()}',

f'showProtected={str(showProtected).lower()}']

"""

def __init__(self, *path, session: OMCSession) -> None:

super().__init__(*path)

self._session = session

def with_segments(self, *pathsegments):

"""

return type(self)(*pathsegments, session=self._session)

def is_file(self, *, follow_symlinks=True) -> bool:

"""

return self._session.sendExpression(f'regularFileExists("{self.as_posix()}")')

def is_dir(self, *, follow_symlinks=True) -> bool:

"""

return self._session.sendExpression(f'directoryExists("{self.as_posix()}")')

def is_absolute(self):

"""

if isinstance(self._session, OMCSessionLocal) and platform.system() == 'Windows':

return pathlib.PureWindowsPath(self.as_posix()).is_absolute()

return super().is_absolute()

def read_text(self, encoding=None, errors=None, newline=None) -> str:

"""

return self._session.sendExpression(f'readFile("{self.as_posix()}")')

def write_text(self, data: str, encoding=None, errors=None, newline=None):

"""

if not isinstance(data, str):

raise TypeError(f"data must be str, not {data.__class__.__name__}")

data_omc = self._session.escape_str(data)

self._session.sendExpression(f'writeFile("{self.as_posix()}", "{data_omc}", false);')

return len(data)

def mkdir(self, mode=0o777, parents=False, exist_ok=False):

"""

if self.is_dir() and not exist_ok:

raise FileExistsError(f"Directory {self.as_posix()} already exists!")

return self._session.sendExpression(f'mkdir("{self.as_posix()}")')

def cwd(self):

"""

cwd_str = self._session.sendExpression('cd()')

return OMCPath(cwd_str, session=self._session)

def unlink(self, missing_ok: bool = False) -> None:

"""

res = self._session.sendExpression(f'deleteFile("{self.as_posix()}")')

if not res and not missing_ok:

raise FileNotFoundError(f"Cannot delete file {self.as_posix()} - it does not exists!")

def resolve(self, strict: bool = False):

"""

if strict and not (self.is_file() or self.is_dir()):

raise OMCSessionException(f"Path {self.as_posix()} does not exist!")

if self.is_file():

pathstr_resolved = self._omc_resolve(self.parent.as_posix())

omcpath_resolved = self._session.omcpath(pathstr_resolved) / self.name

elif self.is_dir():

pathstr_resolved = self._omc_resolve(self.as_posix())

omcpath_resolved = self._session.omcpath(pathstr_resolved)

else:

raise OMCSessionException(f"Path {self.as_posix()} is neither a file nor a directory!")

if not omcpath_resolved.is_file() and not omcpath_resolved.is_dir():

raise OMCSessionException(f"OMCPath resolve failed for {self.as_posix()} - path does not exist!")

return omcpath_resolved

def _omc_resolve(self, pathstr: str) -> str:

"""

expression = ('omcpath_cwd := cd(); '

f'omcpath_check := cd("{pathstr}"); ' # check requested pathstring

'cd(omcpath_cwd)')

try:

result = self._session.sendExpression(command=expression, parsed=False)

result_parts = result.split('\n')

pathstr_resolved = result_parts[1]

pathstr_resolved = pathstr_resolved[1:-1] # remove quotes

except OMCSessionException as ex:

raise OMCSessionException(f"OMCPath resolve failed for {pathstr}!") from ex

return pathstr_resolved

def absolute(self):

"""

return self.resolve(strict=True)

def exists(self, follow_symlinks=True) -> bool:

"""

return self.is_file() or self.is_dir()

def size(self) -> int:

"""

if not self.is_file():

raise OMCSessionException(f"Path {self.as_posix()} is not a file!")

res = self._session.sendExpression(f'stat("{self.as_posix()}")')

if res[0]:

return int(res[1])

raise OMCSessionException(f"Error reading file size for path {self.as_posix()}!")

def stat(self):

"""

raise NotImplementedError("The function stat() cannot be implemented using OMC; "

"""

# modified copy of pathlib.Path.__new__() definition

def __new__(cls, *args, **kwargs):

logger.warning("Python < 3.12 - using a version of class OMCPath "

"based on pathlib.Path for local usage only.")

if cls is OMCPathCompatibility:

cls = OMCPathCompatibilityWindows if os.name == 'nt' else OMCPathCompatibilityPosix

self = cls._from_parts(args)

if not self._flavour.is_supported:

raise NotImplementedError(f"cannot instantiate {cls.__name__} on your system")

return self

def size(self) -> int:

"""

"""

# cmd_path is the expected working directory

cmd_path: str

cmd_model_name: str

# command line arguments for the model executable

cmd_args: list[str]

# result file with the simulation output

cmd_result_path: str

# command prefix data (as list of strings); needed for docker or WSL

cmd_prefix: Optional[list[str]] = None

# cmd_model_executable is build out of cmd_path and cmd_model_name; this is mainly needed on Windows (add *.exe)

cmd_model_executable: Optional[str] = None

# additional library search path; this is mainly needed if OMCProcessLocal is run on Windows

cmd_library_path: Optional[str] = None

# command timeout

cmd_timeout: Optional[float] = 10.0

# working directory to be used on the *local* system

cmd_cwd_local: Optional[str] = None

def get_cmd(self) -> list[str]:

"""

if self.cmd_model_executable is None:

raise OMCSessionException("No model file defined for the model executable!")

cmdl = [] if self.cmd_prefix is None else self.cmd_prefix

cmdl += [self.cmd_model_executable] + self.cmd_args

"""

def __init__(

self,

timeout: float = 10.00,

omhome: Optional[str] = None,

omc_process: Optional[OMCSession] = None,

) -> None:

"""

warnings.warn(message="The class OMCSessionZMQ is depreciated and will be removed in future versions; "

"please use OMCProcess* classes instead!",

category=DeprecationWarning,

stacklevel=2)

if omc_process is None:

omc_process = OMCSessionLocal(omhome=omhome, timeout=timeout)

elif not isinstance(omc_process, OMCSession):

raise OMCSessionException("Invalid definition of the OMC process!")

self.omc_process = omc_process

def __del__(self):

del self.omc_process

@staticmethod

def escape_str(value: str) -> str:

"""

return OMCSession.escape_str(value=value)

def omcpath(self, *path) -> OMCPath:

"""

return self.omc_process.omcpath(*path)

def omcpath_tempdir(self, tempdir_base: Optional[OMCPath] = None) -> OMCPath:

"""

return self.omc_process.omcpath_tempdir(tempdir_base=tempdir_base)

def omc_run_data_update(self, omc_run_data: OMCSessionRunData) -> OMCSessionRunData:

"""

return self.omc_process.omc_run_data_update(omc_run_data=omc_run_data)

@staticmethod

def run_model_executable(cmd_run_data: OMCSessionRunData) -> int:

"""

return OMCSession.run_model_executable(cmd_run_data=cmd_run_data)

def execute(self, command: str):

return self.omc_process.execute(command=command)

def sendExpression(self, command: str, parsed: bool = True) -> Any:

"""

"""

def __call__(cls, *args, **kwargs):

obj = type.__call__(cls, *args, **kwargs)

obj.__post_init__()

"""

"""

def __init__(

self,

timeout: float = 10.00,

**kwargs,

) -> None:

"""

# store variables

self._timeout = timeout

# generate a random string for this instance of OMC

self._random_string = uuid.uuid4().hex

# get a temporary directory

self._temp_dir = pathlib.Path(tempfile.gettempdir())

# omc process

self._omc_process: Optional[subprocess.Popen] = None

# omc ZMQ port to use

self._omc_port: Optional[str] = None

# omc port and log file

self._omc_filebase = f"openmodelica.{self._random_string}"

# ZMQ socket to communicate with OMC

self._omc_zmq: Optional[zmq.Socket[bytes]] = None

# setup log file - this file must be closed in the destructor

logfile = self._temp_dir / (self._omc_filebase + ".log")

self._omc_loghandle: Optional[io.TextIOWrapper] = None

try:

self._omc_loghandle = open(file=logfile, mode="w+", encoding="utf-8")

except OSError as ex:

raise OMCSessionException(f"Cannot open log file {logfile}.") from ex

# variables to store compiled re expressions use in self.sendExpression()

self._re_log_entries: Optional[re.Pattern[str]] = None

self._re_log_raw: Optional[re.Pattern[str]] = None

self._re_portfile_path = re.compile(pattern=r'\nDumped server port in file: (.*?)($|\n)',

flags=re.MULTILINE | re.DOTALL)

def __post_init__(self) -> None:

"""

port = self.get_port()

if not isinstance(port, str):

raise OMCSessionException(f"Invalid content for port: {port}")

# Create the ZeroMQ socket and connect to OMC server

context = zmq.Context.instance()

omc = context.socket(zmq.REQ)

omc.setsockopt(zmq.LINGER, 0) # Dismisses pending messages if closed

omc.setsockopt(zmq.IMMEDIATE, True) # Queue messages only to completed connections

omc.connect(port)

self._omc_zmq = omc

def __del__(self):

if isinstance(self._omc_zmq, zmq.Socket):

try:

self.sendExpression("quit()")

except OMCSessionException:

pass

finally:

self._omc_zmq = None

if self._omc_loghandle is not None:

try:

self._omc_loghandle.close()

except (OSError, IOError):

pass

finally:

self._omc_loghandle = None

if isinstance(self._omc_process, subprocess.Popen):

try:

self._omc_process.wait(timeout=2.0)

except subprocess.TimeoutExpired:

if self._omc_process:

logger.warning("OMC did not exit after being sent the quit() command; "

"killing the process with pid=%s", self._omc_process.pid)

self._omc_process.kill()

self._omc_process.wait()

finally:

self._omc_process = None

@staticmethod

def escape_str(value: str) -> str:

"""

return value.replace("\\", "\\\\").replace('"', '\\"')

def omcpath(self, *path) -> OMCPath:

"""

# fallback solution for Python < 3.12; a modified pathlib.Path object is used as OMCPath replacement

if sys.version_info < (3, 12):

if isinstance(self, OMCSessionLocal):

# noinspection PyArgumentList

return OMCPath(*path)

raise OMCSessionException("OMCPath is supported for Python < 3.12 only if OMCSessionLocal is used!")

return OMCPath(*path, session=self)

def omcpath_tempdir(self, tempdir_base: Optional[OMCPath] = None) -> OMCPath:

"""

names = [str(uuid.uuid4()) for _ in range(100)]

if tempdir_base is None:

# fallback solution for Python < 3.12; a modified pathlib.Path object is used as OMCPath replacement

if sys.version_info < (3, 12):

tempdir_str = tempfile.gettempdir()

else:

tempdir_str = self.sendExpression("getTempDirectoryPath()")

tempdir_base = self.omcpath(tempdir_str)

tempdir: Optional[OMCPath] = None

for name in names:

# create a unique temporary directory name

tempdir = tempdir_base / name

if tempdir.exists():

continue

tempdir.mkdir(parents=True, exist_ok=False)

break

if tempdir is None or not tempdir.is_dir():

raise OMCSessionException("Cannot create a temporary directory!")

return tempdir

@staticmethod

def run_model_executable(cmd_run_data: OMCSessionRunData) -> int:

"""

my_env = os.environ.copy()

if isinstance(cmd_run_data.cmd_library_path, str):

my_env["PATH"] = cmd_run_data.cmd_library_path + os.pathsep + my_env["PATH"]

cmdl = cmd_run_data.get_cmd()

logger.debug("Run OM command %s in %s", repr(cmdl), cmd_run_data.cmd_path)

try:

cmdres = subprocess.run(

cmdl,

capture_output=True,

text=True,

env=my_env,

cwd=cmd_run_data.cmd_cwd_local,

timeout=cmd_run_data.cmd_timeout,

check=True,

)

stdout = cmdres.stdout.strip()

stderr = cmdres.stderr.strip()

returncode = cmdres.returncode

logger.debug("OM output for command %s:\n%s", repr(cmdl), stdout)

if stderr:

raise OMCSessionException(f"Error running model executable {repr(cmdl)}: {stderr}")

except subprocess.TimeoutExpired as ex:

raise OMCSessionException(f"Timeout running model executable {repr(cmdl)}") from ex

except subprocess.CalledProcessError as ex:

raise OMCSessionException(f"Error running model executable {repr(cmdl)}") from ex

return returncode

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:

"""

# this is needed if the class is not fully initialized or in the process of deletion

if hasattr(self, '_timeout'):

timeout = self._timeout

else:

timeout = 1.0

if self._omc_zmq is None:

raise OMCSessionException("No OMC running. Please create a new instance of OMCSession!")

logger.debug("sendExpression(%r, parsed=%r)", command, parsed)

attempts = 0

while True:

try:

self._omc_zmq.send_string(str(command), flags=zmq.NOBLOCK)

break

except zmq.error.Again:

pass

attempts += 1

if attempts >= 50:

# in the deletion process, the content is cleared. Thus, any access to a class attribute must be checked

try:

log_content = self.get_log()

except OMCSessionException:

log_content = 'log not available'

raise OMCSessionException(f"No connection with OMC (timeout={timeout}). "

f"Log-file says: \n{log_content}")

time.sleep(timeout / 50.0)

if command == "quit()":

self._omc_zmq.close()

self._omc_zmq = None

return None

result = self._omc_zmq.recv_string()

if result.startswith('Error occurred building AST'):

raise OMCSessionException(f"OMC error: {result}")

if command == "getErrorString()":

# no error handling if 'getErrorString()' is called

if parsed:

logger.warning("Result of 'getErrorString()' cannot be parsed!")

return result

if command == "getMessagesStringInternal()":

# no error handling if 'getMessagesStringInternal()' is called

if parsed:

logger.warning("Result of 'getMessagesStringInternal()' cannot be parsed!")

return result

# always check for error

self._omc_zmq.send_string('getMessagesStringInternal()', flags=zmq.NOBLOCK)

error_raw = self._omc_zmq.recv_string()

# run error handling only if there is something to check

msg_long_list = []

has_error = False

if error_raw != "{}\n":

if not self._re_log_entries:

self._re_log_entries = re.compile(pattern=r'record OpenModelica\.Scripting\.ErrorMessage'

'(.*?)'

r'end OpenModelica\.Scripting\.ErrorMessage;',

flags=re.MULTILINE | re.DOTALL)

if not self._re_log_raw:

self._re_log_raw = re.compile(

pattern=r"\s*info = record OpenModelica\.Scripting\.SourceInfo\n"

r"\s*filename = \"(.*?)\",\n"

r"\s*readonly = (.*?),\n"

r"\s*lineStart = (\d+),\n"

r"\s*columnStart = (\d+),\n"

r"\s*lineEnd = (\d+),\n"

r"\s*columnEnd = (\d+)\n"

r"\s*end OpenModelica\.Scripting\.SourceInfo;,\n"

r"\s*message = \"(.*?)\",\n" # message

r"\s*kind = \.OpenModelica\.Scripting\.ErrorKind\.(.*?),\n" # kind

r"\s*level = \.OpenModelica\.Scripting\.ErrorLevel\.(.*?),\n" # level

r"\s*id = (\d+)", # id

flags=re.MULTILINE | re.DOTALL)

# extract all ErrorMessage records

log_entries = self._re_log_entries.findall(string=error_raw)

for log_entry in reversed(log_entries):

log_raw = self._re_log_raw.findall(string=log_entry)

if len(log_raw) != 1 or len(log_raw[0]) != 10:

logger.warning("Invalid ErrorMessage record returned by 'getMessagesStringInternal()':"

f" {repr(log_entry)}!")

continue

log_filename = log_raw[0][0]

log_readonly = log_raw[0][1]

log_lstart = log_raw[0][2]

log_cstart = log_raw[0][3]

log_lend = log_raw[0][4]

log_cend = log_raw[0][5]

log_message = log_raw[0][6].encode().decode('unicode_escape')

log_kind = log_raw[0][7]

log_level = log_raw[0][8]

log_id = log_raw[0][9]

msg_short = (f"[OMC log for 'sendExpression({command}, {parsed})']: "

f"[{log_kind}:{log_level}:{log_id}] {log_message}")

# response according to the used log level

# see: https://build.openmodelica.org/Documentation/OpenModelica.Scripting.ErrorLevel.html

if log_level == 'error':

logger.error(msg_short)

has_error = True

elif log_level == 'warning':

logger.warning(msg_short)

elif log_level == 'notification':

logger.info(msg_short)

else: # internal

logger.debug(msg_short)

# track all messages such that this list can be reported if an error occurred

msg_long = (f"[{log_kind}:{log_level}:{log_id}] "

f"[{log_filename}:{log_readonly}:{log_lstart}:{log_cstart}:{log_lend}:{log_cend}] "

f"{log_message}")

msg_long_list.append(msg_long)

if has_error:

msg_long_str = '\n'.join(f"{idx:02d}: {msg}" for idx, msg in enumerate(msg_long_list))

raise OMCSessionException(f"OMC error occurred for 'sendExpression({command}, {parsed}):\n"

f"{msg_long_str}")

if parsed is False:

return result

try:

return om_parser_typed(result)

except pyparsing.ParseException as ex1:

logger.warning('OMTypedParser error: %s. Returning the basic parser result.', ex1.msg)

try:

return om_parser_basic(result)

except (TypeError, UnboundLocalError) as ex2:

raise OMCSessionException("Cannot parse OMC result") from ex2

def get_port(self) -> Optional[str]:

"""

if not isinstance(self._omc_port, str):

raise OMCSessionException(f"Invalid port to connect to OMC process: {self._omc_port}")

return self._omc_port

def get_log(self) -> str:

"""

if self._omc_loghandle is None:

raise OMCSessionException("Log file not available!")

self._omc_loghandle.seek(0)

log = self._omc_loghandle.read()

return log

def _get_portfile_path(self) -> Optional[pathlib.Path]:

omc_log = self.get_log()

portfile = self._re_portfile_path.findall(string=omc_log)

portfile_path = None

if portfile:

portfile_path = pathlib.Path(portfile[-1][0])

return portfile_path

@abc.abstractmethod