Coverage for local/lib/python2.7/site-packages/sage/interfaces/expect.py : 54%

# -*- coding: utf-8 -*- 

""" 

Common Interface Functionality through Pexpect 

See the examples in the other sections for how to use specific 

interfaces. The interface classes all derive from the generic 

interface that is described in this section. 

AUTHORS: 

- William Stein (2005): initial version 

- William Stein (2006-03-01): got rid of infinite loop on startup if 

client system missing 

- Felix Lawrence (2009-08-21): edited ._sage_() to support lists and float exponents in foreign notation. 

- Simon King (2010-09-25): Expect._local_tmpfile() depends on 

Expect.pid() and is cached; Expect.quit() clears that cache, 

which is important for forking. 

- Jean-Pierre Flori (2010,2011): Split non Pexpect stuff into a parent class. 

- Simon King (2010-11-23): Ensure that the interface is started again 

after a crash, when a command is executed in _eval_line. Allow 

synchronisation of the GAP interface. 

- François Bissey, Bill Page, Jeroen Demeyer (2015-12-09): Upgrade to 

pexpect 4.0.1 + patches, see :trac:`10295`. 

""" 

#***************************************************************************** 

# Copyright (C) 2005 William Stein <wstein@gmail.com> 

# 

# This program is free software: you can redistribute it and/or modify 

# it under the terms of the GNU General Public License as published by 

# the Free Software Foundation, either version 2 of the License, or 

# (at your option) any later version. 

# http://www.gnu.org/licenses/ 

#***************************************************************************** 

from __future__ import print_function, absolute_import 

from six import string_types 

import os 

import signal 

import sys 

import weakref 

import time 

import gc 

from . import quit 

from . import cleaner 

from random import randrange 

import pexpect 

from pexpect import ExceptionPexpect 

from sage.interfaces.sagespawn import SageSpawn 

from sage.interfaces.interface import (Interface, InterfaceElement, 

InterfaceFunction, InterfaceFunctionElement, AsciiArtString) 

from sage.structure.element import RingElement 

from sage.misc.misc import SAGE_TMP_INTERFACE 

from sage.env import SAGE_EXTCODE, LOCAL_IDENTIFIER 

from sage.misc.object_multiplexer import Multiplex 

from sage.docs.instancedoc import instancedoc 

from six import reraise as raise_ 

BAD_SESSION = -2 

# The subprocess is a shared resource. In a multi-threaded 

# environment, there would have to be a lock to control access to the 

# subprocess. Fortunately, Sage does not use Python threads. 

# Unfortunately, the combination of the garbage collector and __del__ 

# methods gives rise to the same issues. So, in places where we need 

# to do a sequence of operations on the subprocess and make sure 

# nothing else intervenes (for example, when we write a command and 

# then read back the result) we need to disable the garbage collector. 

# See TRAC #955 for a more detailed description of this problem. 

# To turn off the garbage collector for a particular region of code, 

# do: 

# with gc_disabled(): 

# ... your code goes here ... 

# The garbage collector will be returned to its original state 

# whenever the code exits by any means (falling off the end, executing 

# "return", "break", or "continue", raising an exception, ...) 

class gc_disabled(object): 

""" 

This is a "with" statement context manager. Garbage collection is 

disabled within its scope. Nested usage is properly handled. 

EXAMPLES:: 

sage: import gc 

sage: from sage.interfaces.expect import gc_disabled 

sage: gc.isenabled() 

True 

sage: with gc_disabled(): 

....: print(gc.isenabled()) 

....: with gc_disabled(): 

....: print(gc.isenabled()) 

....: print(gc.isenabled()) 

False 

False 

False 

sage: gc.isenabled() 

True 

""" 

def __enter__(self): 

self._enabled = gc.isenabled() 

gc.disable() 

def __exit__(self, ty, val, tb): 

if self._enabled: 

gc.enable() 

return False 

class Expect(Interface): 

""" 

Expect interface object. 

""" 

def __init__(self, name, prompt, command=None, env={}, server=None, 

server_tmpdir=None, 

ulimit = None, maxread=None, 

script_subdirectory=None, restart_on_ctrlc=False, 

verbose_start=False, init_code=[], max_startup_time=None, 

logfile = None, eval_using_file_cutoff=0, 

do_cleaner=True, remote_cleaner=False, path=None, 

terminal_echo=True): 

Interface.__init__(self, name) 

# Read environment variables 

env_name = 'SAGE_%s_{}'%self.name().upper() 

import os 

if server is None: 

server = os.getenv(env_name.format('SERVER')) 

if server_tmpdir is None: 

server_tmpdir = os.getenv(env_name.format('TMPDIR')) 

if command is None: 

command = os.getenv(env_name.format('COMMAND')) 

if script_subdirectory is None: 

script_subdirectory = os.getenv(env_name.format('SCRIPT_SUBDIRECTORY')) 

self.__is_remote = False 

self.__remote_cleaner = remote_cleaner 

self._expect = None 

self._eval_using_file_cutoff = eval_using_file_cutoff 

self.__verbose_start = verbose_start 

self.set_server_and_command(server, command, server_tmpdir, ulimit) 

self._env = env 

self.__do_cleaner = do_cleaner 

self._prompt = prompt 

self._restart_on_ctrlc = restart_on_ctrlc 

if path is not None: 

self.__path = os.path.abspath(path) 

elif script_subdirectory is None: 

self.__path = os.getcwd() 

else: 

self.__path = os.path.join(SAGE_EXTCODE, name, script_subdirectory) 

if not os.path.isdir(self.__path): 

raise EnvironmentError("path %r does not exist" % self.__path) 

self.__initialized = False 

self.__seq = -1 

self._session_number = 0 

self.__init_code = init_code 

#Handle the log file 

if isinstance(logfile, string_types): 

self.__logfile = None 

self.__logfilename = logfile 

else: 

self.__logfile = logfile 

self.__logfilename = None 

quit.expect_objects.append(weakref.ref(self)) 

self._available_vars = [] 

self._terminal_echo = terminal_echo 

def set_server_and_command(self, server=None, command=None, server_tmpdir=None, ulimit=None): 

""" 

Changes the server and the command to use for this interface. 

This raises a Runtime error if the interface is already started. 

EXAMPLES:: 

sage: magma.set_server_and_command(server = 'remote', command = 'mymagma') # indirect doctest 

No remote temporary directory (option server_tmpdir) specified, using /tmp/ on remote 

sage: magma.server() 

'remote' 

sage: magma.command() 

"sage-native-execute ssh -t remote 'mymagma'" 

""" 

if self._expect: 

raise RuntimeError("interface has already started") 

if command is None: 

command = self.name() 

self._server = server 

if server is not None: 

if ulimit: 

command = "sage-native-execute ssh -t %s 'ulimit %s; %s'"%(server, ulimit, command) 

else: 

command = "sage-native-execute ssh -t %s '%s'"%(server, command) 

self.__is_remote = True 

self._eval_using_file_cutoff = 0 # don't allow this! 

if self.__verbose_start: 

print("Using remote server") 

print(command) 

if server_tmpdir is None: 

# TO DO: Why default to /tmp/? Might be better to use the expect process itself to get a tmp folder 

print("No remote temporary directory (option server_tmpdir) specified, using /tmp/ on "+server) 

self.__remote_tmpdir = "/tmp/" 

else: 

self.__remote_tmpdir = server_tmpdir 

else: 

self.__is_remote = False 

self.__command = command 

def server(self): 

""" 

Returns the server used in this interface. 

EXAMPLES:: 

sage: magma.set_server_and_command(server = 'remote') 

No remote temporary directory (option server_tmpdir) specified, using /tmp/ on remote 

sage: magma.server() # indirect doctest 

'remote' 

""" 

return self._server 

def command(self): 

""" 

Returns the command used in this interface. 

EXAMPLES:: 

sage: magma.set_server_and_command(command = 'magma-2.19') 

sage: magma.command() # indirect doctest 

'magma-2.19' 

""" 

return self.__command 

def _get(self, wait=0.1, alternate_prompt=None): 

if self._expect is None: 

self._start() 

E = self._expect 

wait = float(wait) 

try: 

if alternate_prompt is None: 

E.expect(self._prompt, timeout=wait) 

else: 

E.expect(alternate_prompt, timeout=wait) 

except pexpect.TIMEOUT: 

return False, E.before 

except pexpect.EOF: 

return True, E.before 

except Exception: # weird major problem! 

return True, E.before 

return True, E.before 

def _send(self, cmd): 

if self._expect is None: 

self._start() 

E = self._expect 

self.__so_far = '' 

E.sendline(cmd) 

def is_running(self): 

""" 

Return True if self is currently running. 

""" 

if self._expect is None: 

return False 

try: 

os.kill(self._expect.pid,0) 

except OSError: 

# This means the process is not running 

return False 

return True 

def _so_far(self, wait=0.1, alternate_prompt=None): 

""" 

Return whether done and output so far and new output since last 

time called. 

""" 

done, new = self._get(wait=wait, alternate_prompt=alternate_prompt) 

try: 

if done: 

#if new is not None: 

X = self.__so_far + new 

del self.__so_far 

return True, X, new 

#new = self._expect.before 

try: 

self.__so_far += new 

except (AttributeError, TypeError): 

self.__so_far = new 

return False, self.__so_far, new 

except AttributeError as msg: # no __so_far 

raise RuntimeError(msg) 

def is_remote(self): 

return self.__is_remote 

def is_local(self): 

return not self.__is_remote 

def user_dir(self): 

return self.__path 

def _change_prompt(self, prompt): 

self._prompt = prompt 

def path(self): 

return self.__path 

def expect(self): 

if self._expect is None: 

self._start() 

return self._expect 

def pid(self): 

""" 

Return the PID of the underlying sub-process. 

REMARK: 

If the interface terminates unexpectedly, the original 

PID will still be used. But if it was terminated using 

:meth:`quit`, a new sub-process with a new PID is 

automatically started. 

EXAMPLES:: 

sage: pid = gap.pid() 

sage: gap.eval('quit;') 

'' 

sage: pid == gap.pid() 

True 

sage: gap.quit() 

sage: pid == gap.pid() 

False 

""" 

if self._expect is None: 

self._start() 

return self._expect.pid 

def _install_hints(self): 

r""" 

Hints for installing needed slave program on your computer. 

There are no hints by default. 

""" 

return '' 

def _install_hints_ssh(self): 

r""" 

Hints for installing passwordless authentication on your 

computer... 

""" 

# Written by Paul-Olivier Dehaye 2007/08/23 

return """ 

In order for Sage (on "local") to launch a "slave" process on "remote", the following command needs to work from local's console, without the need to enter any password: 

"ssh -t remote slave", 

where "slave" could be "math" (for text-mode Mathematica), "gap", "magma", "sage", "maple", etc. 

This thus requires passwordless authentication to be setup, which can be done with commands like these: 

cd; ssh-keygen -t rsa; scp .ssh/id_rsa.pub remote:.ssh/authorized_keys2\n 

(WARNING: this would overwrite your current list of authorized keys on "remote") 

In many cases, the server that can actually run "slave" is not accessible from the internet directly, but you have to hop through an intermediate trusted server, say "gate". 

If that is your case, get help with _install_hints_ssh_through_gate(). 

""" 

def _install_hints_ssh_through_gate(self): 

r""" 

Hints for installing passwordless authentication through a gate 

""" 

# Written by Paul-Olivier Dehaye 2007/08/23 

return """ 

We assume you would like to run a "slave" process on a machine called "remote" from a machine running Sage called "local". We also assume "remote" can only be accessed from "local" by ssh'ing first to "gate" (this is a fairly common setup). Sometimes, "gate" and "remote" have a shared filesystem, and this helps a bit. 

Note: You cannot just create shell scripts on "local" and "gate" that would use two successive SSH connections to "remote" in order to simulate running "slave" locally. This is because Sage will sometimes use files (and scp) to communicate with "remote", which shell scripts would not take care of. 

You need to setup: 

* passwordless authentication to "gate" from "local" 

* add passwordless authentication to "remote" from "local", 

for instance by appending the file local:~/.ssh/id_rsa.pub to remote:~/.ssh/authorized_keys2 and logging in once 

(this is only needed if "remote" and "gate" don\'t share filesystem) 

* add a few lines to your local:~/.ssh/ssh_config. Mine look like 

Host remote_for_sage 

ProxyCommand ssh gate nc -w 1 remote 22 

That's it, normally. 

The last step tells ssh that whenever an ssh connection is required to 

the host "remote_for_sage", it should tunnel it through "gate". Any 

attempt to scp-connect to "remote_for_sage" will use ssh and thus 

this configuration file, and properly channel those file transfers 

through the tunnel. 

A good test is to attempt an scp connection from the command-line 

of "local" to "remote_for_sage" as if no tunnel through "gate" was 

required. No password should be asked for the second time around. 

Finally, we created the new name "remote_for_sage" for "remote", 

but this name only exists locally. this is to avoid interfering 

with any other program that might already ssh to "remote" in 

their own way. 

If this all works, you can then make calls like: 

math = Mathematica(server="remote_for_sage") 

""" 

def _do_cleaner(self): 

try: 

return self.__do_cleaner 

except AttributeError: 

return False 

def _start(self, alt_message=None, block_during_init=True): 

from sage.misc.misc import sage_makedirs 

self.quit() # in case one is already running 

self._session_number += 1 

if self.__logfile is None: 

# If the 'SAGE_PEXPECT_LOG' environment variable is set and 

# there is no logfile already defined, then create a 

# logfile in .sage/pexpect_logs/ 

if self.__logfilename is None and 'SAGE_PEXPECT_LOG' in os.environ: 

from sage.env import DOT_SAGE 

logs = os.path.join(DOT_SAGE, 'pexpect_logs') 

sage_makedirs(logs) 

self.__logfilename = '%s/%s-%s-%s-%s.log'%(logs, self.name(), os.getpid(), id(self), self._session_number) 

if self.__logfilename is not None: 

self.__logfile = open(self.__logfilename, 'w') 

cmd = self.__command 

if self.__verbose_start: 

print(cmd) 

print("Starting %s" % cmd.split()[0]) 

if self.__remote_cleaner and self._server: 

c = 'sage-native-execute ssh %s "nohup sage -cleaner" &'%self._server 

os.system(c) 

# Unset some environment variables for the children to 

# reduce the chances they do something complicated breaking 

# the terminal interface. 

# See Trac #12221 and #13859. 

pexpect_env = dict(os.environ) 

pexpect_env.update(self._env) 

pexpect_del_vars = ['TERM', 'COLUMNS'] 

for i in pexpect_del_vars: 

try: 

del pexpect_env[i] 

except KeyError: 

pass 

# Run child from self.__path 

currentdir = os.getcwd() 

os.chdir(self.__path) 

try: 

try: 

self._expect = SageSpawn(cmd, 

logfile=self.__logfile, 

timeout=None, # no timeout 

env=pexpect_env, 

name=self._repr_(), 

echo=self._terminal_echo, 

# Work around https://bugs.python.org/issue1652 

preexec_fn=lambda: signal.signal(signal.SIGPIPE, signal.SIG_DFL), 

quit_string=self._quit_string()) 

except (ExceptionPexpect, pexpect.EOF) as e: 

# Change pexpect errors to RuntimeError 

raise RuntimeError("unable to start %s because the command %r failed: %s\n%s" % 

(self.name(), cmd, e, self._install_hints())) 

except BaseException: 

self._expect = None 

self._session_number = BAD_SESSION 

raise 

finally: 

os.chdir(currentdir) 

if self._do_cleaner(): 

cleaner.cleaner(self._expect.pid, cmd) 

try: 

self._expect.expect(self._prompt) 

except (pexpect.TIMEOUT, pexpect.EOF): 

self._expect = None 

self._session_number = BAD_SESSION 

raise RuntimeError("unable to start %s" % self.name()) 

self._expect.timeout = None 

with gc_disabled(): 

if block_during_init: 

for X in self.__init_code: 

self.eval(X) 

else: 

for X in self.__init_code: 

self._send(X) 

def clear_prompts(self): 

while True: 

try: 

self._expect.expect(self._prompt, timeout=0.1) 

except pexpect.TIMEOUT: 

return 

def _reset_expect(self): 

""" 

Delete ``self._expect`` and reset any state. 

This is called by :meth:`quit` and :meth:`detach`. 

EXAMPLES:: 

sage: gp("eulerphi(49)") 

42 

sage: print(gp._expect) 

PARI/GP interpreter with PID ... 

sage: gp._reset_expect() 

sage: print(gp._expect) 

None 

sage: gp("eulerphi(49)") 

42 

""" 

self._session_number += 1 

try: 

del self.__local_tmpfile 

except AttributeError: 

pass 

self._expect = None 

def quit(self, verbose=False): 

""" 

Quit the running subprocess. 

INPUT: 

- ``verbose`` -- (boolean, default ``False``) print a message 

when quitting this process? 

EXAMPLES:: 

sage: a = maxima('y') 

sage: maxima.quit(verbose=True) 

Exiting Maxima with PID ... running .../bin/maxima ... 

sage: a._check_valid() 

Traceback (most recent call last): 

... 

ValueError: The maxima session in which this object was defined is no longer running. 

Calling ``quit()`` a second time does nothing:: 

sage: maxima.quit(verbose=True) 

""" 

if self._expect is not None: 

if verbose: 

if self.is_remote(): 

print("Exiting %r (running on %s)" % (self._expect, self._server)) 

else: 

print("Exiting %r" % (self._expect,)) 

self._expect.close() 

self._reset_expect() 

def detach(self): 

""" 

Forget the running subprocess: keep it running but pretend that 

it's no longer running. 

EXAMPLES:: 

sage: a = maxima('y') 

sage: saved_expect = maxima._expect # Save this to close later 

sage: maxima.detach() 

sage: a._check_valid() 

Traceback (most recent call last): 

... 

ValueError: The maxima session in which this object was defined is no longer running. 

sage: saved_expect.close() # Close child process 

Calling ``detach()`` a second time does nothing:: 

sage: maxima.detach() 

""" 

try: 

self._expect._keep_alive() 

except AttributeError: 

pass 

self._reset_expect() 

def _quit_string(self): 

""" 

Return the string which will be used to quit the application. 

EXAMPLES:: 

sage: gp._quit_string() 

'\\q' 

sage: maxima._quit_string() 

'quit();' 

""" 

return 'quit' 

def _send_interrupt(self): 

""" 

Send an interrupt to the application. This is used internally 

by :meth:`interrupt`. 

First CTRL-C to stop the current command, then quit. 

""" 

self._expect.sendline(chr(3)) 

self._expect.sendline(self._quit_string()) 

def _local_tmpfile(self): 

""" 

Return a filename that is used to buffer long command lines for this interface 

INPUT: 

``e`` -- an expect interface instance 

OUTPUT: 

A string that provides a temporary filename and is unique for the 

given interface. 

TESTS: 

The filename is cached:: 

sage: gap._local_tmpfile() is gap._local_tmpfile() 

True 

The following two problems were fixed in :trac:`10004`. 

1. Different interfaces have different temp-files:: 

sage: gap._local_tmpfile() != singular._local_tmpfile() 

True 

2. Interface instances in different branches of a parallelised 

function have different temp-files:: 

sage: @parallel 

....: def f(n): 

....: return gap._local_tmpfile() 

sage: L = [t[1] for t in f(list(range(5)))] 

sage: len(set(L)) 

5 

The following used to fail:: 

sage: s = gap._local_tmpfile() 

sage: L = [t[1] for t in f(list(range(5)))] 

sage: len(set(L)) 

5 

AUTHOR: 

- Simon King (2010-09): Making the tmp-file unique for the interface instance 

""" 

try: 

return self.__local_tmpfile 

except AttributeError: 

self.__local_tmpfile = os.path.join(SAGE_TMP_INTERFACE, 'tmp' + str(self.pid())) 

return self.__local_tmpfile 

def _remote_tmpdir(self): 

return self.__remote_tmpdir 

def _remote_tmpfile(self): 

try: 

return self.__remote_tmpfile 

except AttributeError: 

self.__remote_tmpfile = self._remote_tmpdir()+"/interface_%s:%s"%(LOCAL_IDENTIFIER,self.pid()) 

return self.__remote_tmpfile 

def _send_tmpfile_to_server(self, local_file=None, remote_file=None): 

if local_file is None: 

local_file = self._local_tmpfile() 

if remote_file is None: 

remote_file = self._remote_tmpfile() 

cmd = 'scp "%s" %s:"%s" 1>&2 2>/dev/null'%(local_file, self._server, remote_file) 

os.system(cmd) 

def _get_tmpfile_from_server(self, local_file=None,remote_file=None): 

if local_file is None: 

local_file = self._local_tmpfile() 

if remote_file is None: 

remote_file = self._remote_tmpfile() 

cmd = 'scp %s:"%s" "%s" 1>&2 2>/dev/null'%( self._server, remote_file, local_file) 

os.system(cmd) 

def _remove_tmpfile_from_server(self): 

if not (self.__remote_tmpfile is None): 

raise NotImplementedError 

def _eval_line_using_file(self, line, restart_if_needed=True): 

""" 

Evaluate a line of commands, using a temporary file. 

REMARK: 

By default, this is called when a long command is 

evaluated in :meth:`eval`. 

If the command can not be evaluated since the interface 

has crashed, it is automatically restarted and tried 

again *once*. 

INPUT: 

- ``line`` -- (string) a command. 

- ``restart_if_needed`` - (optional bool, default ``True``) -- 

If it is ``True``, the command evaluation is evaluated 

a second time after restarting the interface, if an 

``EOFError`` occured. 

TESTS:: 

sage: singular._eval_line_using_file('def a=3;') 

'' 

sage: singular('a') 

3 

sage: singular.eval('quit;') 

'' 

sage: singular._eval_line_using_file('def a=3;') 

Singular crashed -- automatically restarting. 

'' 

sage: singular('a') 

3 

sage: singular.eval('quit;') 

'' 

sage: singular._eval_line_using_file('def a=3;', restart_if_needed=False) 

Traceback (most recent call last): 

... 

RuntimeError: Singular terminated unexpectedly while reading in a large line... 

We end by triggering a re-start of Singular, since otherwise 

the doc test of another method would fail by a side effect. 

:: 

sage: singular(3) 

Singular crashed -- automatically restarting. 

3 

""" 

with open(self._local_tmpfile(), 'w') as F: 

F.write(line + '\n') 

tmp_to_use = self._local_tmpfile() 

if self.is_remote(): 

self._send_tmpfile_to_server() 

tmp_to_use = self._remote_tmpfile() 

try: 

s = self._eval_line(self._read_in_file_command(tmp_to_use), allow_use_file=False, restart_if_needed=False) 

except pexpect.EOF as msg: 

if self._quit_string() in line: 

# we expect to get an EOF if we're quitting. 

return '' 

elif restart_if_needed: # the subprocess might have crashed 

try: 

self._synchronize() 

return self._post_process_from_file(self._eval_line_using_file(line, restart_if_needed=False)) 

except RuntimeError as msg: 

raise RuntimeError('%s terminated unexpectedly while reading in a large line:\n%s'%(self,msg[0])) 

except TypeError: 

pass 

raise RuntimeError('%s terminated unexpectedly while reading in a large line'%self) 

except RuntimeError as msg: 

if self._quit_string() in line: 

if self._expect is None or not self._expect.isalive(): 

return '' 

raise 

if restart_if_needed and (self._expect is None or not self._expect.isalive()): 

try: 

self._synchronize() 

return self._post_process_from_file(self._eval_line_using_file(line, restart_if_needed=False)) 

except TypeError: 

pass 

except RuntimeError as msg: 

raise RuntimeError('%s terminated unexpectedly while reading in a large line'%self) 

if "Input/output error" in msg[0]: # This occurs on non-linux machines 

raise RuntimeError('%s terminated unexpectedly while reading in a large line'%self) 

raise RuntimeError('%s terminated unexpectedly while reading in a large line:\n%s'%(self,msg[0])) 

return self._post_process_from_file(s) 

def _post_process_from_file(self, s): 

return s 

def _eval_line(self, line, allow_use_file=True, wait_for_prompt=True, restart_if_needed=True): 

""" 

Evaluate a line of commands. 

REMARK: 

By default, a long command (length exceeding ``self._eval_using_file_cutoff``) 

is evaluated using :meth:`_eval_line_using_file`. 

If the command can not be evaluated since the interface 

has crashed, it is automatically restarted and tried 

again *once*. 

If the optional ``wait_for_prompt`` is ``False`` then even a very 

long line will not be evaluated by :meth:`_eval_line_using_file`, 

since this does not support the ``wait_for_prompt`` option. 

INPUT: 

- ``line`` -- (string) a command. 

- ``allow_use_file`` (optional bool, default ``True``) -- 

allow to evaluate long commands using :meth:`_eval_line_using_file`. 

- ``wait_for_prompt`` (optional bool, default ``True``) -- 

wait until the prompt appears in the sub-process' output. 

- ``restart_if_needed`` (optional bool, default ``True``) -- 

If it is ``True``, the command evaluation is evaluated 

a second time after restarting the interface, if an 

``EOFError`` occured. 

TESTS:: 

sage: singular._eval_line('def a=3;') 

'' 

sage: singular('a') 

3 

sage: singular.eval('quit;') 

'' 

sage: singular._eval_line('def a=3;') 

Singular crashed -- automatically restarting. 

'' 

sage: singular('a') 

3 

sage: singular.eval('kill a') 

'' 

We are now sending a command that would run forever. But since 

we declare that we are not waiting for a prompt, we can interrupt 

it without a KeyboardInterrupt. At the same time, we test that 

the line is not forwarded to :meth:`_eval_line_using_file`, since 

that method would not support the ``wait_for_prompt`` option. 

For reasons which are currently not understood, the ``interrupt`` 

test usually returns immediately, but sometimes it takes a very 

long time on the same system. :: 

sage: cutoff = singular._eval_using_file_cutoff 

sage: singular._eval_using_file_cutoff = 4 

sage: singular._eval_line('for(int i=1;i<=3;i++){i=1;};', wait_for_prompt=False) 

'' 

sage: singular.interrupt() 

True 

sage: singular._eval_using_file_cutoff = cutoff 

The interface still works after this interrupt:: 

sage: singular('2+3') 

5 

Last, we demonstrate that by default the execution of a command 

is tried twice if it fails the first time due to a crashed 

interface:: 

sage: singular.eval('quit;') 

'' 

sage: singular._eval_line_using_file('def a=3;', restart_if_needed=False) 

Traceback (most recent call last): 

... 

RuntimeError: Singular terminated unexpectedly while reading in a large line... 

Since the test of the next method would fail, we re-start 

Singular now. :: 

sage: singular('2+3') 

Singular crashed -- automatically restarting. 

5 

""" 

if allow_use_file and wait_for_prompt and self._eval_using_file_cutoff and len(line) > self._eval_using_file_cutoff: 

return self._eval_line_using_file(line) 

try: 

if self._expect is None: 

self._start() 

E = self._expect 

try: 

if len(line) >= 4096: 

raise RuntimeError("Sending more than 4096 characters with %s on a line may cause a hang and you're sending %s characters"%(self, len(line))) 

E.sendline(line) 

if not wait_for_prompt: 

return '' 

except OSError as msg: 

if restart_if_needed: 

# The subprocess most likely crashed. 

# If it's really still alive, we fall through 

# and raise RuntimeError. 

if sys.platform.startswith('sunos'): 

# On (Open)Solaris, we might need to wait a 

# while because the process might not die 

# immediately. See Trac #14371. 

for t in [0.5, 1.0, 2.0]: 

if E.isalive(): 

time.sleep(t) 

else: 

break 

if not E.isalive(): 

try: 

self._synchronize() 

except (TypeError, RuntimeError): 

pass 

return self._eval_line(line,allow_use_file=allow_use_file, wait_for_prompt=wait_for_prompt, restart_if_needed=False) 

raise_(RuntimeError, "%s\nError evaluating %s in %s"%(msg, line, self), sys.exc_info()[2]) 

if len(line)>0: 

try: 

if isinstance(wait_for_prompt, string_types): 

E.expect(wait_for_prompt) 

else: 

E.expect(self._prompt) 

except pexpect.EOF as msg: 

try: 

if self.is_local(): 

tmp_to_use = self._local_tmpfile() 

else: 

tmp_to_use = self._remote_tmpfile() 

if self._read_in_file_command(tmp_to_use) in line: 

raise pexpect.EOF(msg) 

except NotImplementedError: 

pass 

if self._quit_string() in line: 

# we expect to get an EOF if we're quitting. 

return '' 

elif restart_if_needed: # the subprocess might have crashed 

try: 

self._synchronize() 

return self._eval_line(line,allow_use_file=allow_use_file, wait_for_prompt=wait_for_prompt, restart_if_needed=False) 

except (TypeError, RuntimeError): 

pass 

raise RuntimeError("%s\n%s crashed executing %s"%(msg,self, line)) 

if self._terminal_echo: 

out = E.before 

else: 

out = E.before.rstrip('\n\r') 

else: