Removed corba support

OMCSession now uses zeromq.
OMCSessionZMQ is just an alias for OMCSession. Using it will give a deprecation warning. It will be removed in the next release.

Updated README.md

Author: adeas31

OMPython/__init__.py

@@ -44,7 +44,6 @@ class which means it will use OMCSessionZMQ by default. If you want to use
 import platform
 import psutil
 import re
-import shlex
 import signal
 import subprocess
 import sys
@@ -56,7 +55,8 @@ class which means it will use OMCSessionZMQ by default. If you want to use
 import numpy as np
 import pyparsing
 import importlib
-
+import zmq
+import warnings
 
 if sys.platform == 'darwin':
     # On Mac let's assume omc is installed here and there might be a broken omniORB installed in a bad place
@@ -552,156 +552,8 @@ def getClassNames(self, className=None, recursive=False, qualified=False, sort=F
                                  str(builtin).lower(), str(showProtected).lower()))
         return value
 
-
 class OMCSession(OMCSessionHelper, OMCSessionBase):
 
-    def __init__(self, readonly = False, serverFlag ='--interactive=corba', timeout = 10.0,
-                 docker = None, dockerContainer = None, dockerExtraArgs = None, dockerOpenModelicaPath = "omc",
-                 dockerNetwork = None, omhome: str = None):
-        if dockerExtraArgs is None:
-            dockerExtraArgs = []
-
-        OMCSessionHelper.__init__(self, omhome=omhome)
-        OMCSessionBase.__init__(self, readonly)
-        self._create_omc_log_file("objid")
-        # Locating and using the IOR
-        if sys.platform != 'win32' or docker or dockerContainer:
-            self._port_file = "openmodelica." + self._currentUser + ".objid." + self._random_string
-        else:
-            self._port_file = "openmodelica.objid." + self._random_string
-        self._port_file = os.path.join("/tmp" if (docker or dockerContainer) else self._temp_dir, self._port_file).replace("\\", "/")
-        # set omc executable path and args
-        self._docker = docker
-        self._dockerContainer = dockerContainer
-        self._dockerExtraArgs = dockerExtraArgs
-        self._dockerOpenModelicaPath = dockerOpenModelicaPath
-        self._dockerNetwork = dockerNetwork
-        self._timeout = timeout
-        self._create_omc_log_file("port")
-
-        self._set_omc_command([serverFlag, "+c={0}".format(self._random_string)])
-
-        # start up omc executable, which is waiting for the CORBA connection
-        self._start_omc_process(timeout)
-        # connect to the running omc instance using CORBA
-        self._connect_to_omc(timeout)
-
-    def __del__(self):
-        OMCSessionBase.__del__(self)
-
-    def _connect_to_omc(self, timeout):
-        # add OPENMODELICAHOME\lib\python to PYTHONPATH so python can load omniORB imports
-        sys.path.append(os.path.join(self.omhome, 'lib', 'python'))
-        # import the skeletons for the global module
-        try:
-          from omniORB import CORBA
-          from OMPythonIDL import _OMCIDL
-        except ImportError:
-          self._omc_process.kill()
-          raise
-        self._omc_corba_uri = "file:///" + self._port_file
-        # See if the omc server is running
-        attempts = 0
-        while True:
-            if self._dockerCid:
-                try:
-                    self._ior = subprocess.check_output(["docker", "exec", self._dockerCid, "cat", self._port_file], stderr=subprocess.DEVNULL if (sys.version_info > (3, 0)) else subprocess.STDOUT).decode().strip()
-                    break
-                except subprocess.CalledProcessError:
-                    pass
-            if os.path.isfile(self._port_file):
-                # Read the IOR file
-                with open(self._port_file, 'r') as f_p:
-                    self._ior = f_p.readline()
-                break
-            attempts += 1
-            if attempts == 80:
-                name = self._omc_log_file.name
-                self._omc_log_file.close()
-                with open(name) as fin:
-                  contents = fin.read()
-                self._omc_process.kill()
-                raise Exception("OMC Server is down (timeout=%f). Please start it! If the OMC version is old, try OMCSession(..., serverFlag='-d=interactiveCorba') or +d=interactiveCorba. Log-file says:\n%s" % (timeout, contents))
-            time.sleep(timeout / 80.0)
-
-        while True:
-            if self._dockerCid:
-                try:
-                    self._port = subprocess.check_output(["docker", "exec", self._dockerCid, "cat", self._port_file]).decode().strip()
-                    break
-                except:
-                    pass
-            else:
-                if os.path.isfile(self._port_file):
-                    # Read the port file
-                    with open(self._port_file, 'r') as f_p:
-                        self._port = f_p.readline()
-                    os.remove(self._port_file)
-                    break
-
-            attempts += 1
-            if attempts == 80.0:
-                name = self._omc_log_file.name
-                self._omc_log_file.close()
-                logger.error("OMC Server is down (timeout=%f). Please start it! Log-file says:\n%s" % open(name).read())
-                raise Exception("OMC Server is down. Could not open file %s" % (timeout,self._port_file))
-            time.sleep(timeout / 80.0)
-
-        logger.info("OMC Server is up and running at {0}".format(self._omc_corba_uri))
-        # initialize the ORB with maximum size for the ORB set
-        sys.argv.append("-ORBgiopMaxMsgSize")
-        sys.argv.append("2147483647")
-        self._orb = CORBA.ORB_init(sys.argv, CORBA.ORB_ID)
-
-        # Find the root POA
-        self._poa = self._orb.resolve_initial_references("RootPOA")
-        # Convert the IOR into an object reference
-        self._obj_reference = self._orb.string_to_object(self._ior)
-        # Narrow the reference to the OmcCommunication object
-        self._omc = self._obj_reference._narrow(_OMCIDL.OmcCommunication)
-        # Check if we are using the right object
-        if self._omc is None:
-            logger.error("Object reference is not valid")
-            raise Exception
-
-    def execute(self, command):
-        ## check for process is running
-        p=self._omc_process.poll()
-        if (p == None):
-            result = self._omc.sendExpression(command)
-            if command == "quit()":
-                self._omc = None
-                return result
-            else:
-                answer = OMParser.check_for_values(result)
-                return answer
-        else:
-            raise Exception("Process Exited, No connection with OMC. Create a new instance of OMCSession")
-
-    def sendExpression(self, command, parsed=True):
-        ## check for process is running
-        p=self._omc_process.poll()
-        if (p== None):
-            result = self._omc.sendExpression(str(command))
-            if command == "quit()":
-                self._omc = None
-                return result
-            else:
-                if parsed is True:
-                    answer = OMTypedParser.parseString(result)
-                    return answer
-                else:
-                    return result
-        else:
-            raise Exception("Process Exited, No connection with OMC. Create a new instance of OMCSession")
-
-try:
-  import zmq
-except ImportError:
-  pass
-
-class OMCSessionZMQ(OMCSessionHelper, OMCSessionBase):
-
     def __init__(self, readonly=False, timeout = 10.00,
                  docker = None, dockerContainer = None, dockerExtraArgs = None, dockerOpenModelicaPath = "omc",
                  dockerNetwork = None, port = None, omhome: str = None):
@@ -770,7 +622,6 @@ def _connect_to_omc(self, timeout):
         logger.info("OMC Server is up and running at {0} pid={1} cid={2}".format(self._omc_zeromq_uri, self._omc_process.pid, self._dockerCid))
 
         # Create the ZeroMQ socket and connect to OMC server
-        import zmq
         context = zmq.Context.instance()
         self._omc = context.socket(zmq.REQ)
         self._omc.setsockopt(zmq.LINGER, 0) # Dismisses pending messages if closed
@@ -812,14 +663,20 @@ def sendExpression(self, command, parsed=True):
         else:
             raise Exception("Process Exited, No connection with OMC. Create a new instance of OMCSession")
 
+class OMCSessionZMQ(OMCSession):
+    def __init__(self, *args, **kwargs):
+        warnings.warn(
+            "OMCSessionZMQ is deprecated and will be remove in the next release. Please use OMCSession instead.",
+            DeprecationWarning,
+            stacklevel=2
+        )
+        super(OMCSessionZMQ, self).__init__(*args, **kwargs)
 
 class ModelicaSystemError(Exception):
     pass
 
-
 class ModelicaSystem(object):
-    def __init__(self, fileName=None, modelName=None, lmodel=None,
-                 useCorba=False, commandLineOptions=None,
+    def __init__(self, fileName=None, modelName=None, lmodel=None, commandLineOptions=None,
                  variableFilter=None, customBuildDirectory=None, verbose=True, raiseerrors=False,
                  omhome: str = None):  # 1
         """
@@ -832,10 +689,7 @@ def __init__(self, fileName=None, modelName=None, lmodel=None,
         ex: myModel = ModelicaSystem("ModelicaModel.mo", "modelName")
         """
         if fileName is None and modelName is None and not lmodel:  # all None
-            if useCorba:
-                self.getconn = OMCSession(omhome=omhome)
-            else:
-                self.getconn = OMCSessionZMQ(omhome=omhome)
+            self.getconn = OMCSession(omhome=omhome)
             return
 
         self.tree = None
@@ -857,12 +711,9 @@ def __init__(self, fileName=None, modelName=None, lmodel=None,
 
         self._verbose = verbose
 
-        if useCorba:
-            self.getconn = OMCSession(omhome=omhome)
-        else:
-            self.getconn = OMCSessionZMQ(omhome=omhome)
+        self.getconn = OMCSession(omhome=omhome)
 
-        ## needed for properly deleting the OMCSessionZMQ
+        ## needed for properly deleting the session
         self._omc_log_file = self.getconn._omc_log_file
         self._omc_process = self.getconn._omc_process
 
@@ -1885,41 +1736,3 @@ def getLinearStates(self):
         >>> getLinearStates()
         """
         return self.linearstates
-
-
-def FindBestOMCSession(*args, **kwargs):
-  """
-  Analyzes the OMC executable version string to find a suitable selection
-  of CORBA or ZMQ, as well as older flags to launch the executable (such
-  as +d=interactiveCorba for RML-based OMC).
-
-  This is mainly useful if you are testing old OpenModelica versions using
-  the latest OMPython.
-  """
-  base = OMCSessionHelper()
-  omc = base._get_omc_path()
-  versionOK = False
-  for cmd in ["--version", "+version"]:
-    try:
-      v = str(subprocess.check_output([omc, cmd], stderr=subprocess.STDOUT))
-      versionOK = True
-      break
-    except subprocess.CalledProcessError:
-      pass
-  if not versionOK:
-    raise Exception("Failed to use omc --version or omc +version. Is omc on the PATH?")
-  zmq = False
-  v = v.strip().split("-")[0].split("~")[0].strip()
-  a = re.search(r"v?([0-9]+)[.]([0-9]+)[.][0-9]+", v)
-  try:
-    major = int(a.group(1))
-    minor = int(a.group(2))
-    if major > 1 or (major==1 and minor >= 12):
-      zmq = True
-  except:
-    pass
-  if zmq:
-    return OMCSessionZMQ(*args, **kwargs)
-  if cmd == "+version":
-    return OMCSession(*args, serverFlag="+d=interactiveCorba", **kwargs)
-  return OMCSession(*args, serverFlag="-d=interactiveCorba", **kwargs)

README.md

@@ -1,53 +1,29 @@
 # OMPython
 
-OMPython is a Python interface that uses ZeroMQ or CORBA (omniORB) to
+OMPython is a Python interface that uses ZeroMQ to
 communicate with OpenModelica.
 
 [![FMITest](https://github.com/OpenModelica/OMPython/actions/workflows/FMITest.yml/badge.svg)](https://github.com/OpenModelica/OMPython/actions/workflows/FMITest.yml)
 [![Test](https://github.com/OpenModelica/OMPython/actions/workflows/Test.yml/badge.svg)](https://github.com/OpenModelica/OMPython/actions/workflows/Test.yml)
 
 ## Dependencies
 
-### Using ZeroMQ
-
 -   Python 2.7 and 3.x supported
 -   PyZMQ is required
 
-### Using omniORB
-
--   Currently, only Python 2.7 is supported
--   omniORB is required:
-    -   Windows: included in the OpenModelica installation
-    -   Linux: Install omniORB including Python 2 support (the omniidl
-        command needs to be on the PATH). On Ubuntu, this is done by
-        running
-        `sudo apt-get install omniorb python-omniorb omniidl omniidl-python`
-
 ## Installation
 
 Installation using `pip` is recommended.
 
-### Linux
-
-Install the latest OMPython master by running:
+### Via pip
 
 ```bash
-python -m pip install -U https://github.com/OpenModelica/OMPython/archive/master.zip
-```
-
-### Windows
-
-Install the version packed with your OpenModelica installation by running:
-
-```cmd
-cd %OPENMODELICAHOME%\share\omc\scripts\PythonInterface
-python -m pip install -U .
+pip install OMPython
 ```
 
-### Local installation
+### Via source
 
-To Install the latest version of the OMPython master branch
-only, previously cloned into `<OMPythonPath>`, run:
+Clone the repository and run:
 
 ```
 cd <OMPythonPath>
@@ -64,8 +40,8 @@ help(OMPython)
 ```
 
 ```python
-from OMPython import OMCSessionZMQ
-omc = OMCSessionZMQ()
+from OMPython import OMCSession
+omc = OMCSession()
 omc.sendExpression("getVersion()")
 ```
 

setup.py

@@ -1,51 +1,6 @@
 from setuptools import setup
-from subprocess import call
-import os
-import shutil
-
-def warningOrError(errorOnFailure, msg):
-    if errorOnFailure:
-        raise Exception(msg)
-    else:
-        print(msg)
-
-def generateIDL():
-    errorOnFailure = not os.path.exists(os.path.join(os.path.dirname(__file__), 'OMPythonIDL', '__init__.py'))
-    try:
-        path_to_omc = shutil.which("omc")
-        omhome = os.path.dirname(os.path.dirname(os.path.split(path_to_omc)))
-    except BaseException:
-        omhome = None
-    omhome = omhome or os.environ.get('OPENMODELICAHOME')
-
-    if omhome is None:
-        warningOrError(errorOnFailure, "Failed to find OPENMODELICAHOME (searched for environment variable as well as the omc executable)")
-        return
-    idl = os.path.join(omhome, "share", "omc", "omc_communication.idl")
-    if not os.path.exists(idl):
-        warningOrError(errorOnFailure, "Path not found: %s" % idl)
-        return
-
-    if 0 != call(["omniidl", "-bpython", "-Wbglobal=_OMCIDL", "-Wbpackage=OMPythonIDL", idl]):
-        warningOrError(errorOnFailure, "omniidl command failed")
-        return
-    print("Generated OMPythonIDL files")
-
-
-try:
-    # if we don't have omniidl or omniORB then don't try to generate OMPythonIDL files.
-    try:
-      import omniidl
-    except ImportError:
-      import omniORB
-    hasomniidl = True
-    generateIDL()
-except ImportError:
-    hasomniidl = False
 
 OMPython_packages = ['OMPython', 'OMPython.OMParser']
-if hasomniidl:
-    OMPython_packages.extend(['OMPythonIDL', 'OMPythonIDL._OMCIDL', 'OMPythonIDL._OMCIDL__POA'])
 
 setup(name='OMPython',
       version='3.6.0',