FEATURE: connect to existing matlab sessions

Only compiled for mexa64. Also, miscelaneous PEP8 and doc updates and
logging now includes _Session output.

Author: brunobeltran

pymatbridge/matlab/matlabserver.m

@@ -1,10 +1,15 @@
 function matlabserver(socket_address, exit_when_done)
 %MATLABSERVER   Take Commands from Python via ZMQ
+% matlabserver(socket_address, exit_when_done)
 % This function takes a socket address as input and initiates a ZMQ session
-% over the socket. I then enters the listen-respond mode until it gets an
-% "exit" command
+% over the socket. It then enters the listen-respond mode until it gets an
+% "exit" command, at which point it returns (or exits if exit_when_done), or
+% until it gets a "separate" command, at which point it launches the MATLAB
+% desktop client and returns.
+%
 
-json_startup
+initialize_environment;
+json_startup;
 messenger('init', socket_address);
 
 if nargin > 1 && exit_when_done
@@ -28,10 +33,15 @@ function matlabserver(socket_address, exit_when_done)
             resp = pymat_eval(req);
             messenger('respond', resp);
 
+        case {'separate'}
+            desktop; %no-op if desktop is already up
+            c = onCleanup(@stop_messenger);
+            break;
+
         otherwise
             messenger('respond', 'i dont know what you want');
-    end
 
+    end
 end
 
 end %matlabserver
@@ -44,3 +54,12 @@ function stop_messenger_and_exit()
 function stop_messenger()
     messenger('exit');
 end
+
+function initialize_environment()
+    if ~exist('json_startup', 'file')
+        [pathstr, ~, ~] = fileparts(mfilename('fullpath'));
+        old_warning_state = warning('off','all');
+        addpath(genpath(pathstr));
+        warning(old_warning_state);
+    end
+end

pymatbridge/matlab/util/finish.m

@@ -0,0 +1,6 @@
+% make sure socket gets closed no matter how MATLAB exists (sans crash)
+if exist('messenger', 'file')
+    if messenger('check')
+        messenger('exit');
+    end
+end

pymatbridge/messenger/make.py

@@ -172,7 +172,7 @@ def get_config():
 
 
 def do_build(make_cmd, messenger_exe):
-    print('Building %s...' % messenger_exe)
+    print('Building {}...'.format(messenger_exe))
     print(make_cmd)
     messenger_dir = get_messenger_dir()
     subprocess.check_output(shlex.split(make_cmd), shell=use_shell)
@@ -188,7 +188,7 @@ def do_build(make_cmd, messenger_exe):
 def build_octave():
     paths = "-L%(octave_lib)s -I%(octave_inc)s -L%(zmq_lib)s -I%(zmq_inc)s"
     paths = paths % get_config()
-    make_cmd = "mkoctfile --mex %s -lzmq ./src/messenger.c" % paths
+    make_cmd = "mkoctfile --mex {} -lzmq ./src/messenger.c".format(paths)
     do_build(make_cmd, 'messenger.mex')
 
 
@@ -264,10 +264,10 @@ def build_matlab(static=False):
     # Build the mex file
     mex = esc(os.path.join(matlab_bin, "mex"))
     paths = "-L%(zmq_lib)s -I%(zmq_inc)s" % cfg
-    make_cmd = '%s -O %s -lzmq ./src/messenger.c' % (mex, paths)
+    make_cmd = '{} -O {} -lzmq ./src/messenger.c'.format(mex, paths)
     if static:
         make_cmd += ' -DZMQ_STATIC'
-    do_build(make_cmd, 'messenger.%s' % extension)
+    do_build(make_cmd, 'messenger.{}'.format(extension))
 
 
 if __name__ == '__main__':

pymatbridge/messenger/mexa64/messenger.mexa64

@@ -145,6 +145,10 @@ void mexFunction(int nlhs, mxArray *plhs[],
     } else if (strcmp(cmd, "exit") == 0) {
         cleanup();
         p[0] = 1;
+    } else if (strcmp(cmd, "check") == 0) {
+        if (initialized) {
+            p[0] = 1;
+        }
     } else {
         mexErrMsgTxt("Unidentified command");
     }

pymatbridge/messenger/src/messenger.c

@@ -121,7 +121,7 @@ class _Session(object):
     """
 
     def __init__(self, executable=None, socket_addr=None,
-                 id='python-matlab-bridge', log=False, maxtime=15,
+                 id='python-matlab-bridge', log="", maxtime=15,
                  platform=None, startup_options=None,
                  loglevel=logging.WARNING):
         """
@@ -141,7 +141,7 @@ def __init__(self, executable=None, socket_addr=None,
         id : str
             An identifier for this instance of the pymatbridge.
 
-        log : str | None
+        log : str
             Location to log to, defaults to sys.stdout
 
         maxtime : float
@@ -174,7 +174,7 @@ def __init__(self, executable=None, socket_addr=None,
             self.socket_addr = socket_addr
         self.context = None
         self.socket = None
-        self.logger = logging.getLogger("pymatbridge")
+        self.logger = logging.getLogger(self.id)
         self.logger.setLevel(self.loglevel)
         if self.log:
             self.loghandler = logging.FileHandler(self.log)
@@ -188,26 +188,15 @@ def __init__(self, executable=None, socket_addr=None,
     def _program_name(self):  # pragma: no cover
         raise NotImplementedError
 
-    def _preamble_code(self):
-        # suppress warnings while loading the path, in the case of
-        # overshadowing a built-in function on a newer version of
-        # Matlab (e.g. isrow)
-        return ["old_warning_state = warning('off','all');",
-                "addpath(genpath('%s'));" % MATLAB_FOLDER,
-                "warning(old_warning_state);",
-                "clear('old_warning_state');",
-                "cd('%s');" % os.getcwd()]
-
     def _execute_flag(self):  # pragma: no cover
         raise NotImplementedError
 
     def _run_server(self):
-        code = self._preamble_code()
-        code.extend([
-            "matlabserver('%s')" % self.socket_addr
-        ])
+        code = "cd('{}'); matlabserver('{}', true);".format(
+            MATLAB_FOLDER, self.socket_addr)
         command = '%s %s %s "%s"' % (self.executable, self.startup_options,
-                                     self._execute_flag(), ','.join(code))
+                                     self._execute_flag(), code)
+        self.logger.info("Running: %s", command)
         subprocess.Popen(command, shell=True, stdin=subprocess.PIPE,
                          stdout=subprocess.PIPE)
 
@@ -221,13 +210,12 @@ def start(self):
             self.socket_addr = self.socket_addr + ":%s"%rndport
 
         # Start the MATLAB server in a new process
-        self.logger.info("Starting ZMQ socket %s" \
-                % (self.socket_addr, ))
-        self.logger.info("Send 'exit' command to kill the server")
+        self.logger.info("Starting ZMQ socket %s", self.socket_addr)
+        #self.logger.info("Run _Session.stop/separate to kill the server.")
 
         if self.executable is not None:
-            self.logger.info("Launching %s, sending ZMQ 'exit' will kill it." \
-                    % (self._program_name(), ))
+            self.logger.info("Launching %s, sending ZMQ 'exit' will kill it.", \
+                    self._program_name())
             self._run_server()
 
         # Start the client
@@ -239,7 +227,7 @@ def start(self):
         if not self.is_connected():
             raise ValueError("%s failed to start" % self._program_name())
 
-        self.logger.info("%s started and connected!" % self._program_name())
+        self.logger.info("%s started and connected!", self._program_name())
         self.set_plot_settings()
         return self
 
@@ -249,14 +237,23 @@ def _response(self, **kwargs):
         resp = self.socket.recv_string()
         return resp
 
+    # open desktop matlab and disconnect
+    def separate(self):
+        if not self.started:
+            raise ValueError('Session not started, use start()')
+        if self._response(cmd='separate') == 'exit':
+            self.logger.info("%s split off", self._program_name())
+        self.started = False
+        return True
+
     # Stop the Matlab server
     def stop(self):
         if not self.started:
             return True
 
         # Matlab should respond with "exit" if successful
         if self._response(cmd='exit') == "exit":
-            self.logger.info("%s closed" % self._program_name())
+            self.logger.info("%s closed", self._program_name())
 
         self.started = False
         return True
@@ -337,6 +334,12 @@ def run_code(self, code):
         """
         return self.run_func('evalin', 'base', code, nargout=0)
 
+    def _init_run_code(self):
+        """Code to run at start of headless session to ensure sane
+        environment."""
+        code = "cd('%s')" % os.getcwd()
+        return self.run_code(code)
+
     def get_variable(self, varname, default=None):
         resp = self.run_func('evalin', 'base', varname)
         return resp['result'] if resp['success'] else default
@@ -445,13 +448,14 @@ def __init__(self, executable='matlab', socket_addr=None,
 
         socket_addr : str
             A string that represents a valid ZMQ socket address, such as
-            "ipc:///tmp/pymatbridge", "tcp://127.0.0.1:55555", etc.
+            "ipc:///tmp/pymatbridge", "tcp://127.0.0.1:55555", etc. Default is
+            to choose a random IPC file name, or a random socket (for TCP).
 
         id : str
             An identifier for this instance of the pymatbridge.
 
-        log : bool
-            Whether to save a log file in some known location.
+        log : str
+            Location to log to, defaults to sys.stdout
 
         maxtime : float
            The maximal time to wait for a response from matlab (optional,
@@ -473,7 +477,7 @@ def __init__(self, executable='matlab', socket_addr=None,
             else:
                 startup_options = ' -nodesktop -nosplash'
         if log:
-            startup_options += ' -logfile ./pymatbridge/logs/matlablog_%s.txt' % id
+            startup_options += ' -logfile "{}"'.format(log)
         super(Matlab, self).__init__(executable, socket_addr, id, log, maxtime,
                                      platform, startup_options, loglevel)
 
@@ -497,7 +501,7 @@ def __init__(self, executable='octave', socket_addr=None,
 
         executable : str
             A string that would start Octave at the terminal. Per default, this
-            is set to 'octave', so that you can alias in your bash setup
+            is set to 'octave'.
 
         socket_addr : str
             A string that represents a valid ZMQ socket address, such as
@@ -529,12 +533,12 @@ def __init__(self, executable='octave', socket_addr=None,
     def _program_name(self):
         return 'Octave'
 
-    def _preamble_code(self):
-        code = super(Octave, self)._preamble_code()
-        if self.log:
-            code.append("diary('./pymatbridge/logs/octavelog_%s.txt')" % self.id)
+    def _init_run_code(self):
+        code = super(Octave, self)._init_run_code()
         code.append("graphics_toolkit('gnuplot')")
-        return code
+        if self.log:
+            code.append("diary('{}')".format(self.id))
+        self.run_code(code)
 
     def _execute_flag(self):
         return '--eval'

pymatbridge/pymatbridge.py

@@ -71,7 +71,7 @@ def test_stack_traces(self):
         this_dir = os.path.abspath(os.path.dirname(__file__))
         test_file = os.path.join(this_dir, 'test_stack_trace.m')
 
-        self.mlab.run_code("addpath('%s')" % this_dir)
+        self.mlab.run_code("addpath('{}')".format(this_dir))
         response = self.mlab.run_code('test_stack_trace(10)')
         npt.assert_equal(response['stack'], [
             {'name': 'baz', 'line': 14, 'file': test_file},