def parse_options(self, arg_str, opt_str, *long_opts, **kw):
"""Parse options passed to an argument string.
The interface is similar to that of getopt(), but it returns back a
Struct with the options as keys and the stripped argument string still
as a string.
arg_str is quoted as a true sys.argv vector by using shlex.split.
This allows us to easily expand variables, glob files, quote
arguments, etc.
Options:
-mode: default 'string'. If given as 'list', the argument string is
returned as a list (split on whitespace) instead of a string.
-list_all: put all option values in lists. Normally only options
appearing more than once are put in a list.
-posix (True): whether to split the input line in POSIX mode or not,
as per the conventions outlined in the shlex module from the
standard library."""
# inject default options at the beginning of the input line
caller = sys._getframe(1).f_code.co_name
arg_str = "%s %s" % (self.options_table.get(caller, ""), arg_str)
mode = kw.get("mode", "string")
if mode not in ["string", "list"]:
raise ValueError, "incorrect mode given: %s" % mode
# Get options
list_all = kw.get("list_all", 0)
posix = kw.get("posix", os.name == "posix")
strict = kw.get("strict", True)
# Check if we have more than one argument to warrant extra processing:
odict = {} # Dictionary with options
args = arg_str.split()
if len(args) >= 1:
# If the list of inputs only has 0 or 1 thing in it, there's no
# need to look for options
argv = arg_split(arg_str, posix, strict)
# Do regular option processing
try:
opts, args = getopt(argv, opt_str, long_opts)
except GetoptError, e:
raise UsageError('%s ( allowed: "%s" %s)' % (e.msg, opt_str, " ".join(long_opts)))
for o, a in opts:
if o.startswith("--"):
o = o[2:]
else:
o = o[1:]
try:
odict[o].append(a)
except AttributeError:
odict[o] = [odict[o], a]
except KeyError:
if list_all:
odict[o] = [a]
else:
odict[o] = a
def pudb(line):
"""
Debug a script (like %run -d) in the IPython process, using PuDB.
Usage:
%pudb test.py [args]
Run script test.py under PuDB.
"""
# Get the running instance
if not line.strip():
print(pudb.__doc__)
return
from IPython.utils.process import arg_split
args = arg_split(line)
path = os.path.abspath(args[0])
args = args[1:]
if not os.path.isfile(path):
from IPython.core.error import UsageError
raise UsageError("%%pudb: file %s does not exist" % path)
from pudb import runscript
runscript(path, args)
def test_arg_split():
"""Ensure that argument lines are correctly split like in a shell."""
tests = [['hi', ['hi']],
[u'hi', [u'hi']],
]
for argstr, argv in tests:
nt.assert_equal(arg_split(argstr), argv)
def pudb(line):
"""
Debug a script (like %run -d) in the IPython process, using PuDB.
Usage:
%pudb test.py [args]
Run script test.py under PuDB.
"""
# Get the running instance
if not line.strip():
print(pudb.__doc__)
return
from IPython.utils.process import arg_split
args = arg_split(line)
path = os.path.abspath(args[0])
args = args[1:]
if not os.path.isfile(path):
from IPython.core.error import UsageError
raise UsageError("%%pudb: file %s does not exist" % path)
from pudb import runscript
runscript(path, args)
def test_arg_split():
"""Ensure that argument lines are correctly split like in a shell."""
tests = [
['hi', ['hi']],
[u'hi', [u'hi']],
]
for argstr, argv in tests:
nt.assert_equal(arg_split(argstr), argv)
def test_arg_split_win32():
"""Ensure that argument lines are correctly split like in a shell."""
tests = [['hi', ['hi']],
['hi', ['hi']],
['hello there', ['hello', 'there']],
['h\u01cello', ['h\u01cello']],
['something "with quotes"', ['something', 'with quotes']],
]
for argstr, argv in tests:
nt.assert_equal(arg_split(argstr), argv)
def test_arg_split():
"""Ensure that argument lines are correctly split like in a shell."""
tests = [['hi', ['hi']],
['hi', ['hi']],
['hello there', ['hello', 'there']],
['h\N{LATIN SMALL LETTER A WITH CARON}llo', ['h\N{LATIN SMALL LETTER A WITH CARON}llo']],
['something "with quotes"', ['something', '"with quotes"']],
]
for argstr, argv in tests:
nt.assert_equal(arg_split(argstr), argv)
def test_arg_split_win32():
"""Ensure that argument lines are correctly split like in a shell."""
tests = [['hi', ['hi']],
[u'hi', [u'hi']],
['hello there', ['hello', 'there']],
[u'h\u01cello', [u'h\u01cello']],
['something "with quotes"', ['something', 'with quotes']],
]
for argstr, argv in tests:
nt.assert_equal(arg_split(argstr), argv)
def test_arg_split_win32():
"""Ensure that argument lines are correctly split like in a shell."""
tests = [
["hi", ["hi"]],
[u"hi", [u"hi"]],
["hello there", ["hello", "there"]],
[u"h\u01cello", [u"h\u01cello"]],
['something "with quotes"', ["something", "with quotes"]],
]
for argstr, argv in tests:
nt.assert_equal(arg_split(argstr), argv)
def magic_qtconsole(self, arg_s):
"""Open a qtconsole connected to this kernel.
Useful for connecting a qtconsole to running notebooks, for better
debugging.
"""
try:
p = connect_qtconsole(argv=arg_split(arg_s, os.name=='posix'))
except Exception as e:
error("Could not start qtconsole: %r" % e)
return
def magic_qtconsole(self, arg_s):
"""Open a qtconsole connected to this kernel.
Useful for connecting a qtconsole to running notebooks, for better
debugging.
"""
try:
p = connect_qtconsole(argv=arg_split(arg_s, os.name=='posix'))
except Exception as e:
error("Could not start qtconsole: %r" % e)
return
def test_arg_split():
"""Ensure that argument lines are correctly split like in a shell."""
tests = [
["hi", ["hi"]],
[u"hi", [u"hi"]],
["hello there", ["hello", "there"]],
[u"h\N{LATIN SMALL LETTER A WITH CARON}llo", [u"h\N{LATIN SMALL LETTER A WITH CARON}llo"]],
['something "with quotes"', ["something", '"with quotes"']],
]
for argstr, argv in tests:
nt.assert_equal(arg_split(argstr), argv)
def _sqlalias(line, cell=None):
"""Alias to %sql"""
opts, args = [], []
for chunk in arg_split(line):
# XXX: what about math?!:
# select -1 + 5 * something from blah;
if chunk.startswith('-') and len(chunk.strip()) > 1:
opts.append(chunk)
else:
args.append(chunk)
line = '%s %s %s' % (' '.join(opts), alias, ' '.join(args))
return sqlmagics.sql(line, cell)
def _sqlalias(line, cell=None):
"""Alias to %sql"""
opts, args = [], []
for chunk in arg_split(line):
# XXX: what about math?!:
# select -1 + 5 * something from blah;
if chunk.startswith('-') and len(chunk.strip()) > 1:
opts.append(chunk)
else:
args.append(chunk)
line = '%s %s %s' % (' '.join(opts), alias, ' '.join(args))
return sqlmagics.sql(line, cell)
def test_arg_split():
"""Ensure that argument lines are correctly split like in a shell."""
tests = [['hi', ['hi']],
['hi', ['hi']],
['hello there', ['hello', 'there']],
# \u01ce == \N{LATIN SMALL LETTER A WITH CARON}
# Do not use \N because the tests crash with syntax error in
# some cases, for example windows python2.6.
['h\u01cello', ['h\u01cello']],
['something "with quotes"', ['something', '"with quotes"']],
]
for argstr, argv in tests:
nt.assert_equal(arg_split(argstr), argv)
def test_arg_split():
"""Ensure that argument lines are correctly split like in a shell."""
tests = [['hi', ['hi']],
[u'hi', [u'hi']],
['hello there', ['hello', 'there']],
# \u01ce == \N{LATIN SMALL LETTER A WITH CARON}
# Do not use \N because the tests crash with syntax error in
# some cases, for example windows python2.6.
[u'h\u01cello', [u'h\u01cello']],
['something "with quotes"', ['something', '"with quotes"']],
]
for argstr, argv in tests:
nt.assert_equal(arg_split(argstr), argv)
def test_arg_split():
"""Ensure that argument lines are correctly split like in a shell."""
tests = [
['hi', ['hi']],
[u'hi', [u'hi']],
['hello there', ['hello', 'there']],
[
u'h\N{LATIN SMALL LETTER A WITH CARON}llo',
[u'h\N{LATIN SMALL LETTER A WITH CARON}llo']
],
['something "with quotes"', ['something', '"with quotes"']],
]
for argstr, argv in tests:
nt.assert_equal(arg_split(argstr), argv)
def shebang(self, line, cell):
"""Run a cell via a shell command
The `%%script` line is like the #! line of script,
specifying a program (bash, perl, ruby, etc.) with which to run.
The rest of the cell is run by that program.
Examples
--------
::
In [1]: %%script bash
...: for i in 1 2 3; do
...: echo $i
...: done
1
2
3
"""
argv = arg_split(line, posix = not sys.platform.startswith('win'))
args, cmd = self.shebang.parser.parse_known_args(argv)
p = Popen(cmd, stdout=PIPE, stderr=PIPE, stdin=PIPE)
cell = cell.encode('utf8', 'replace')
if args.bg:
if args.out:
self.shell.user_ns[args.out] = p.stdout
if args.err:
self.shell.user_ns[args.err] = p.stderr
self.job_manager.new(self._run_script, p, cell)
return
out, err = p.communicate(cell)
out = py3compat.bytes_to_str(out)
err = py3compat.bytes_to_str(err)
if args.out:
self.shell.user_ns[args.out] = out
else:
sys.stdout.write(out)
sys.stdout.flush()
if args.err:
self.shell.user_ns[args.err] = err
else:
sys.stderr.write(err)
sys.stderr.flush()
def call_pydb(self, args):
"""Invoke pydb with the supplied parameters."""
try:
import pydb
except ImportError:
raise ImportError("pydb doesn't seem to be installed.")
if not hasattr(pydb.pydb, "runv"):
raise ImportError("You need pydb version 1.19 or later installed.")
argl = arg_split(args)
# print argl # dbg
if len(inspect.getargspec(pydb.runv)[0]) == 2:
pdb = debugger.Pdb(color_scheme=self.colors)
ip.history_saving_wrapper(lambda: pydb.runv(argl, pdb))()
else:
ip.history_saving_wrapper(lambda: pydb.runv(argl))()
def call_pydb(self, args):
"""Invoke pydb with the supplied parameters."""
try:
import pydb
except ImportError:
raise ImportError("pydb doesn't seem to be installed.")
if not hasattr(pydb.pydb, "runv"):
raise ImportError("You need pydb version 1.19 or later installed.")
argl = arg_split(args)
# print argl # dbg
if len(inspect.getargspec(pydb.runv)[0]) == 2:
pdb = debugger.Pdb(color_scheme=self.colors)
ip.history_saving_wrapper(lambda: pydb.runv(argl, pdb))()
else:
ip.history_saving_wrapper(lambda: pydb.runv(argl))()
def qtconsole(self, arg_s):
"""Open a qtconsole connected to this kernel.
Useful for connecting a qtconsole to running notebooks, for better
debugging.
"""
# %qtconsole should imply bind_kernel for engines:
# FIXME: move to ipyparallel Kernel subclass
if 'ipyparallel' in sys.modules:
from ipyparallel import bind_kernel
bind_kernel()
try:
connect_qtconsole(argv=arg_split(arg_s, os.name=='posix'))
except Exception as e:
warnings.warn("Could not start qtconsole: %r" % e)
return
def qtconsole(self, arg_s):
"""Open a qtconsole connected to this kernel.
Useful for connecting a qtconsole to running notebooks, for better
debugging.
"""
# %qtconsole should imply bind_kernel for engines:
try:
from IPython.parallel import bind_kernel
except ImportError:
# technically possible, because parallel has higher pyzmq min-version
pass
else:
bind_kernel()
try:
p = connect_qtconsole(argv=arg_split(arg_s, os.name=='posix'))
except Exception as e:
error("Could not start qtconsole: %r" % e)
return
def arguments(self, func, line): # pylint: disable=no-self-use
"""Get arguments from magic"""
argv = arg_split(line, posix=not sys.platform.startswith("win"))
args = magic_arguments.parse_argstring(func, line)
return argv, args
def shebang(self, line, cell):
"""Run a cell via a shell command
The `%%script` line is like the #! line of script,
specifying a program (bash, perl, ruby, etc.) with which to run.
The rest of the cell is run by that program.
Examples
--------
::
In [1]: %%script bash
...: for i in 1 2 3; do
...: echo $i
...: done
1
2
3
"""
argv = arg_split(line, posix = not sys.platform.startswith('win'))
args, cmd = self.shebang.parser.parse_known_args(argv)
try:
p = Popen(cmd, stdout=PIPE, stderr=PIPE, stdin=PIPE)
except OSError as e:
if e.errno == errno.ENOENT:
print("Couldn't find program: %r" % cmd[0])
return
else:
raise
cell = cell.encode('utf8', 'replace')
if args.bg:
self.bg_processes.append(p)
self._gc_bg_processes()
if args.out:
self.shell.user_ns[args.out] = p.stdout
if args.err:
self.shell.user_ns[args.err] = p.stderr
self.job_manager.new(self._run_script, p, cell, daemon=True)
if args.proc:
self.shell.user_ns[args.proc] = p
return
try:
out, err = p.communicate(cell)
except KeyboardInterrupt:
try:
p.send_signal(signal.SIGINT)
time.sleep(0.1)
if p.poll() is not None:
print("Process is interrupted.")
return
p.terminate()
time.sleep(0.1)
if p.poll() is not None:
print("Process is terminated.")
return
p.kill()
print("Process is killed.")
except OSError:
pass
except Exception as e:
print("Error while terminating subprocess (pid=%i): %s" \
% (p.pid, e))
return
out = py3compat.bytes_to_str(out)
err = py3compat.bytes_to_str(err)
if args.out:
self.shell.user_ns[args.out] = out
else:
sys.stdout.write(out)
sys.stdout.flush()
if args.err:
self.shell.user_ns[args.err] = err
else:
sys.stderr.write(err)
sys.stderr.flush()
def run_cell(self, line, cell):
"""Run a cell via a shell command
The `%%anybody` invokes the anybody console application on the rest of
the cell.
Parameters
----------
--dir <Path>
--out <output var>
--bg <>
--proc <baground process variable >
--anybodycon <path to anybodycon>
Examples
--------
::
In [1]: %%anybody
...: load "mymodel.any"
...: operation Main.MyStudy.Kinematics
...: run
"""
argv = arg_split(line, posix=not sys.platform.startswith('win'))
args, dummy = self.run_cell.parser.parse_known_args(argv)
if args.anybodycon:
if os.path.exists(args.anybodycon):
abcpath = args.anybodycon
elif self.shell.user_ns.has_key(args.anybodycon):
abcpath = self.shell.user_ns[args.anybodycon]
elif sys.platform == 'win32':
import _winreg
try:
abpath = _winreg.QueryValue(
_winreg.HKEY_CLASSES_ROOT,
'AnyBody.AnyScript\shell\open\command')
abpath = abpath.rsplit(' ', 1)[0].strip('"')
abcpath = os.path.join(os.path.dirname(abpath),
'AnyBodyCon.exe')
except:
raise Exception(
'Could not find AnyBody Modeling System in windows registry'
)
else:
raise Exception('Cannot find the specified anybodycon')
if not os.path.exists(abcpath):
raise Exception('Cannot find the specified anybodycon: %s' %
abcpath)
if args.dir and os.path.isdir(args.dir):
folder = args.dir
elif self.shell.user_ns.has_key(args.dir):
folder = self.shell.user_ns[args.dir]
else:
folder = os.getcwd()
cell = cell.encode('utf8', 'replace')
macro = cell if cell.endswith('\n') else cell + '\n'
macrofile = NamedTemporaryFile(mode='w+b',
prefix='macro_',
suffix='.anymcr',
dir=folder,
delete=False)
macrofile.write(macro)
macrofile.flush()
cmd = [
abcpath, '/d', folder, '--macro=', macrofile.name, '/ni', "1>&2"
]
try:
p = Popen(cmd, stdout=PIPE, stderr=PIPE, stdin=PIPE, shell=True)
except OSError as e:
if e.errno == errno.ENOENT:
print "Couldn't find program: %r" % cmd[0]
return
else:
raise
if args.bg:
self.bg_processes.append(p)
self._gc_bg_processes()
if args.out:
self.shell.user_ns[args.out] = p.stderr
self.job_manager.new(self._run_script, p, macrofile, daemon=True)
if args.proc:
self.shell.user_ns[args.proc] = p
return
random_tag = ''.join(random.sample(string.ascii_uppercase, 6))
def htmlbox(text):
raw_html = """<div id="anyscriptbox_{0}" style="height: 120px ; width : auto; border:1px dotted black;padding:0.5em;overflow:auto;background-color:#E0E0E0 ; font:3px Geogia"><font size="2px" face="courier"> {1} </font></div> <script> var myDiv = document.getElementById("anyscriptbox_{0}");
myDiv.scrollTop = myDiv.scrollHeight;</script> """.format(
random_tag, text)
return HTML(raw_html)
try:
raw_out = []
for line in iter(p.stderr.readline, b''):
line = py3compat.bytes_to_str(line)
raw_out.append(line)
if not args.pager:
clear_output()
display(htmlbox("<br/>".join(raw_out)))
#sys.stdout.flush()
if args.pager:
page("".join(raw_out))
p.communicate()
except KeyboardInterrupt:
try:
p.send_signal(signal.SIGINT)
time.sleep(0.1)
if p.poll() is not None:
print "Process is interrupted."
return
p.terminate()
time.sleep(0.1)
if p.poll() is not None:
print "Process is terminated."
return
p.kill()
print "Process is killed."
except OSError:
pass
except Exception as e:
print "Error while terminating subprocess (pid=%i): %s" \
% (p.pid, e)
return
if args.out:
self.shell.user_ns[args.out] = "\n".join(raw_out)
if args.dump:
output = _parse_anybodycon_output("\n".join(raw_out))
if len(output.keys()):
print 'Dumped variables:'
for k, v in output.iteritems():
varname = k.replace('.', '_')
self.shell.user_ns[varname] = v
print '- ' + varname
try:
macrofile.close()
os.remove(macrofile.name)
except:
print 'Error removing macro file'
def test_arg_split_win32(argstr, argv):
"""Ensure that argument lines are correctly split like in a shell."""
assert arg_split(argstr) == argv
def file_matches(self, text):
"""Match filenames, expanding ~USER type strings.
Most of the seemingly convoluted logic in this completer is an
attempt to handle filenames with spaces in them. And yet it's not
quite perfect, because Python's readline doesn't expose all of the
GNU readline details needed for this to be done correctly.
For a filename with a space in it, the printed completions will be
only the parts after what's already been typed (instead of the
full completions, as is normally done). I don't think with the
current (as of Python 2.3) Python readline it's possible to do
better."""
#io.rprint('Completer->file_matches: <%r>' % text) # dbg
# chars that require escaping with backslash - i.e. chars
# that readline treats incorrectly as delimiters, but we
# don't want to treat as delimiters in filename matching
# when escaped with backslash
if text.startswith('!'):
text = text[1:]
text_prefix = '!'
else:
text_prefix = ''
text_until_cursor = self.text_until_cursor
# track strings with open quotes
open_quotes = has_open_quotes(text_until_cursor)
if '(' in text_until_cursor or '[' in text_until_cursor:
lsplit = text
else:
try:
# arg_split ~ shlex.split, but with unicode bugs fixed by us
lsplit = arg_split(text_until_cursor)[-1]
except ValueError:
# typically an unmatched ", or backslash without escaped char.
if open_quotes:
lsplit = text_until_cursor.split(open_quotes)[-1]
else:
return []
except IndexError:
# tab pressed on empty line
lsplit = ""
if not open_quotes and lsplit != protect_filename(lsplit):
# if protectables are found, do matching on the whole escaped name
has_protectables = True
text0,text = text,lsplit
else:
has_protectables = False
text = os.path.expanduser(text)
if text == "":
return [text_prefix + protect_filename(f) for f in self.glob("*")]
# Compute the matches from the filesystem
m0 = self.clean_glob(text.replace('\\',''))
if has_protectables:
# If we had protectables, we need to revert our changes to the
# beginning of filename so that we don't double-write the part
# of the filename we have so far
len_lsplit = len(lsplit)
matches = [text_prefix + text0 +
protect_filename(f[len_lsplit:]) for f in m0]
else:
if open_quotes:
# if we have a string with an open quote, we don't need to
# protect the names at all (and we _shouldn't_, as it
# would cause bugs when the filesystem call is made).
matches = m0
else:
matches = [text_prefix +
protect_filename(f) for f in m0]
#io.rprint('mm', matches) # dbg
# Mark directories in input list by appending '/' to their names.
matches = [x+'/' if os.path.isdir(x) else x for x in matches]
return matches
def arguments(self, func, line):
argv = arg_split(line, posix = not sys.platform.startswith('win'))
args = magic_arguments.parse_argstring(func, line)
return argv, args
def arguments(self, func, line): # pylint: disable=no-self-use
"""Get arguments from magic"""
argv = arg_split(line, posix=not sys.platform.startswith("win"))
args = magic_arguments.parse_argstring(func, line)
return argv, args
def parse_argstring(self, argstring):
""" Split a string into an argument list and parse that argument list.
"""
argv = arg_split(argstring)
return self.parse_args(argv)
def shebang(self, line, cell):
"""Run a cell via a shell command
The `%%script` line is like the #! line of script,
specifying a program (bash, perl, ruby, etc.) with which to run.
The rest of the cell is run by that program.
Examples
--------
::
In [1]: %%script bash
...: for i in 1 2 3; do
...: echo $i
...: done
1
2
3
"""
async def _handle_stream(stream, stream_arg, file_object):
while True:
line = (await stream.readline()).decode("utf8")
if not line:
break
if stream_arg:
self.shell.user_ns[stream_arg] = line
else:
file_object.write(line)
file_object.flush()
async def _stream_communicate(process, cell):
process.stdin.write(cell)
process.stdin.close()
stdout_task = asyncio.create_task(
_handle_stream(process.stdout, args.out, sys.stdout))
stderr_task = asyncio.create_task(
_handle_stream(process.stderr, args.err, sys.stderr))
await asyncio.wait([stdout_task, stderr_task])
await process.wait()
if sys.platform.startswith("win"):
asyncio.set_event_loop_policy(
asyncio.WindowsProactorEventLoopPolicy())
loop = asyncio.get_event_loop()
argv = arg_split(line, posix=not sys.platform.startswith("win"))
args, cmd = self.shebang.parser.parse_known_args(argv)
try:
p = loop.run_until_complete(
asyncio.create_subprocess_exec(
*cmd,
stdout=asyncio.subprocess.PIPE,
stderr=asyncio.subprocess.PIPE,
stdin=asyncio.subprocess.PIPE,
))
except OSError as e:
if e.errno == errno.ENOENT:
print("Couldn't find program: %r" % cmd[0])
return
else:
raise
if not cell.endswith('\n'):
cell += '\n'
cell = cell.encode('utf8', 'replace')
if args.bg:
self.bg_processes.append(p)
self._gc_bg_processes()
to_close = []
if args.out:
self.shell.user_ns[args.out] = p.stdout
else:
to_close.append(p.stdout)
if args.err:
self.shell.user_ns[args.err] = p.stderr
else:
to_close.append(p.stderr)
self.job_manager.new(self._run_script,
p,
cell,
to_close,
daemon=True)
if args.proc:
self.shell.user_ns[args.proc] = p
return
try:
loop.run_until_complete(_stream_communicate(p, cell))
except KeyboardInterrupt:
try:
p.send_signal(signal.SIGINT)
time.sleep(0.1)
if p.returncode is not None:
print("Process is interrupted.")
return
p.terminate()
time.sleep(0.1)
if p.returncode is not None:
print("Process is terminated.")
return
p.kill()
print("Process is killed.")
except OSError:
pass
except Exception as e:
print("Error while terminating subprocess (pid=%i): %s" %
(p.pid, e))
return
if args.raise_error and p.returncode != 0:
# If we get here and p.returncode is still None, we must have
# killed it but not yet seen its return code. We don't wait for it,
# in case it's stuck in uninterruptible sleep. -9 = SIGKILL
rc = p.returncode or -9
raise CalledProcessError(rc, cell)
def run_cell(self, line, cell):
"""Run a cell via a shell command
The `%%anybody` invokes the anybody console application on the rest of
the cell.
Parameters
----------
--dir <Path>
--out <output var>
--bg <>
--proc <baground process variable >
--anybodycon <path to anybodycon>
Examples
--------
::
In [1]: %%anybody
...: load "mymodel.any"
...: operation Main.MyStudy.Kinematics
...: run
"""
argv = arg_split(line, posix = not sys.platform.startswith('win'))
args, dummy = self.run_cell.parser.parse_known_args(argv)
if args.anybodycon:
if os.path.exists(args.anybodycon):
abcpath = args.anybodycon
elif self.shell.user_ns.has_key(args.anybodycon):
abcpath = self.shell.user_ns[args.anybodycon]
elif sys.platform == 'win32':
import _winreg
try:
abpath = _winreg.QueryValue(_winreg.HKEY_CLASSES_ROOT,
'AnyBody.AnyScript\shell\open\command')
abpath = abpath.rsplit(' ',1)[0].strip('"')
abcpath = os.path.join(os.path.dirname(abpath),'AnyBodyCon.exe')
except:
raise Exception('Could not find AnyBody Modeling System in windows registry')
else:
raise Exception('Cannot find the specified anybodycon')
if not os.path.exists(abcpath):
raise Exception('Cannot find the specified anybodycon: %s'%abcpath)
if args.dir and os.path.isdir(args.dir):
folder = args.dir
elif self.shell.user_ns.has_key(args.dir):
folder = self.shell.user_ns[args.dir]
else:
folder = os.getcwd()
cell = cell.encode('utf8', 'replace')
macro = cell if cell.endswith('\n') else cell+'\n'
macrofile = NamedTemporaryFile(mode='w+b',
prefix ='macro_',
suffix='.anymcr',
dir= folder,
delete = False)
macrofile.write(macro)
macrofile.flush()
cmd = [abcpath ,'/d',folder, '--macro=', macrofile.name, '/ni', "1>&2"]
try:
p = Popen(cmd, stdout=PIPE, stderr=PIPE, stdin=PIPE, shell= True)
except OSError as e:
if e.errno == errno.ENOENT:
print "Couldn't find program: %r" % cmd[0]
return
else:
raise
if args.bg:
self.bg_processes.append(p)
self._gc_bg_processes()
if args.out:
self.shell.user_ns[args.out] = p.stderr
self.job_manager.new(self._run_script, p, macrofile, daemon=True)
if args.proc:
self.shell.user_ns[args.proc] = p
return
random_tag = ''.join( random.sample(string.ascii_uppercase,6) )
def htmlbox(text):
raw_html = """<div id="anyscriptbox_{0}" style="height: 120px ; width : auto; border:1px dotted black;padding:0.5em;overflow:auto;background-color:#E0E0E0 ; font:3px Geogia"><font size="2px" face="courier"> {1} </font></div> <script> var myDiv = document.getElementById("anyscriptbox_{0}");
myDiv.scrollTop = myDiv.scrollHeight;</script> """.format(random_tag, text )
return HTML(raw_html)
try:
raw_out = []
for line in iter(p.stderr.readline,b''):
line = py3compat.bytes_to_str( line )
raw_out.append(line)
if not args.pager:
clear_output()
display( htmlbox("<br/>".join( raw_out ) ) )
#sys.stdout.flush()
if args.pager:
page("".join(raw_out))
p.communicate();
except KeyboardInterrupt:
try:
p.send_signal(signal.SIGINT)
time.sleep(0.1)
if p.poll() is not None:
print "Process is interrupted."
return
p.terminate()
time.sleep(0.1)
if p.poll() is not None:
print "Process is terminated."
return
p.kill()
print "Process is killed."
except OSError:
pass
except Exception as e:
print "Error while terminating subprocess (pid=%i): %s" \
% (p.pid, e)
return
if args.out:
self.shell.user_ns[args.out] = "\n".join(raw_out)
if args.dump:
output = _parse_anybodycon_output( "\n".join(raw_out) )
if len(output.keys()):
print 'Dumped variables:'
for k,v in output.iteritems():
varname = k.replace('.','_')
self.shell.user_ns[varname] = v
print '- ' + varname
try:
macrofile.close()
os.remove(macrofile.name)
except:
print 'Error removing macro file'
def parse_options(self, arg_str, opt_str, *long_opts, **kw):
"""Parse options passed to an argument string.
The interface is similar to that of :func:`getopt.getopt`, but it
returns a :class:`~IPython.utils.struct.Struct` with the options as keys
and the stripped argument string still as a string.
arg_str is quoted as a true sys.argv vector by using shlex.split.
This allows us to easily expand variables, glob files, quote
arguments, etc.
Parameters
----------
arg_str : str
The arguments to parse.
opt_str : str
The options specification.
mode : str, default 'string'
If given as 'list', the argument string is returned as a list (split
on whitespace) instead of a string.
list_all : bool, default False
Put all option values in lists. Normally only options
appearing more than once are put in a list.
posix : bool, default True
Whether to split the input line in POSIX mode or not, as per the
conventions outlined in the :mod:`shlex` module from the standard
library.
"""
# inject default options at the beginning of the input line
caller = sys._getframe(1).f_code.co_name
arg_str = '%s %s' % (self.options_table.get(caller,''),arg_str)
mode = kw.get('mode','string')
if mode not in ['string','list']:
raise ValueError('incorrect mode given: %s' % mode)
# Get options
list_all = kw.get('list_all',0)
posix = kw.get('posix', os.name == 'posix')
strict = kw.get('strict', True)
# Check if we have more than one argument to warrant extra processing:
odict = {} # Dictionary with options
args = arg_str.split()
if len(args) >= 1:
# If the list of inputs only has 0 or 1 thing in it, there's no
# need to look for options
argv = arg_split(arg_str, posix, strict)
# Do regular option processing
try:
opts,args = getopt(argv, opt_str, long_opts)
except GetoptError as e:
raise UsageError('%s ( allowed: "%s" %s)' % (e.msg,opt_str,
" ".join(long_opts)))
for o,a in opts:
if o.startswith('--'):
o = o[2:]
else:
o = o[1:]
try:
odict[o].append(a)
except AttributeError:
odict[o] = [odict[o],a]
except KeyError:
if list_all:
odict[o] = [a]
else:
odict[o] = a
# Prepare opts,args for return
opts = Struct(odict)
if mode == 'string':
args = ' '.join(args)
return opts,args
def shebang(self, line, cell):
"""Run a cell via a shell command
The `%%script` line is like the #! line of script,
specifying a program (bash, perl, ruby, etc.) with which to run.
The rest of the cell is run by that program.
Examples
--------
::
In [1]: %%script bash
...: for i in 1 2 3; do
...: echo $i
...: done
1
2
3
"""
# Create the event loop in which to run script magics
# this operates on a background thread
if self.event_loop is None:
if sys.platform == "win32":
# don't override the current policy,
# just create an event loop
event_loop = asyncio.WindowsProactorEventLoopPolicy(
).new_event_loop()
else:
event_loop = asyncio.new_event_loop()
self.event_loop = event_loop
# start the loop in a background thread
asyncio_thread = Thread(target=event_loop.run_forever, daemon=True)
asyncio_thread.start()
else:
event_loop = self.event_loop
def in_thread(coro):
"""Call a coroutine on the asyncio thread"""
return asyncio.run_coroutine_threadsafe(coro, event_loop).result()
async def _handle_stream(stream, stream_arg, file_object):
while True:
line = (await stream.readline()).decode("utf8")
if not line:
break
if stream_arg:
self.shell.user_ns[stream_arg] = line
else:
file_object.write(line)
file_object.flush()
async def _stream_communicate(process, cell):
process.stdin.write(cell)
process.stdin.close()
stdout_task = asyncio.create_task(
_handle_stream(process.stdout, args.out, sys.stdout))
stderr_task = asyncio.create_task(
_handle_stream(process.stderr, args.err, sys.stderr))
await asyncio.wait([stdout_task, stderr_task])
await process.wait()
argv = arg_split(line, posix=not sys.platform.startswith("win"))
args, cmd = self.shebang.parser.parse_known_args(argv)
try:
p = in_thread(
asyncio.create_subprocess_exec(
*cmd,
stdout=asyncio.subprocess.PIPE,
stderr=asyncio.subprocess.PIPE,
stdin=asyncio.subprocess.PIPE,
))
except OSError as e:
if e.errno == errno.ENOENT:
print("Couldn't find program: %r" % cmd[0])
return
else:
raise
if not cell.endswith('\n'):
cell += '\n'
cell = cell.encode('utf8', 'replace')
if args.bg:
self.bg_processes.append(p)
self._gc_bg_processes()
to_close = []
if args.out:
self.shell.user_ns[args.out] = _AsyncIOProxy(
p.stdout, event_loop)
else:
to_close.append(p.stdout)
if args.err:
self.shell.user_ns[args.err] = _AsyncIOProxy(
p.stderr, event_loop)
else:
to_close.append(p.stderr)
event_loop.call_soon_threadsafe(
lambda: asyncio.Task(self._run_script(p, cell, to_close)))
if args.proc:
proc_proxy = _AsyncIOProxy(p, event_loop)
proc_proxy.stdout = _AsyncIOProxy(p.stdout, event_loop)
proc_proxy.stderr = _AsyncIOProxy(p.stderr, event_loop)
self.shell.user_ns[args.proc] = proc_proxy
return
try:
in_thread(_stream_communicate(p, cell))
except KeyboardInterrupt:
try:
p.send_signal(signal.SIGINT)
in_thread(asyncio.wait_for(p.wait(), timeout=0.1))
if p.returncode is not None:
print("Process is interrupted.")
return
p.terminate()
in_thread(asyncio.wait_for(p.wait(), timeout=0.1))
if p.returncode is not None:
print("Process is terminated.")
return
p.kill()
print("Process is killed.")
except OSError:
pass
except Exception as e:
print("Error while terminating subprocess (pid=%i): %s" %
(p.pid, e))
return
if args.raise_error and p.returncode != 0:
# If we get here and p.returncode is still None, we must have
# killed it but not yet seen its return code. We don't wait for it,
# in case it's stuck in uninterruptible sleep. -9 = SIGKILL
rc = p.returncode or -9
raise CalledProcessError(rc, cell)
