def reload_attached_files_if_modified():
r"""
Reload attached files that have been modified
This is the internal implementation of the attach mechanism.
EXAMPLES::
sage: sage.repl.attach.reset()
sage: from sage.repl.interpreter import get_test_shell
sage: shell = get_test_shell()
sage: tmp = tmp_filename(ext='.py')
sage: open(tmp, 'w').write('a = 2\n')
sage: shell.run_cell('attach({0})'.format(repr(tmp)))
sage: shell.run_cell('a')
2
sage: sleep(1) # filesystem mtime granularity
sage: open(tmp, 'w').write('a = 3\n')
Note that the doctests are never really at the command prompt
where the automatic reload is triggered. So we have to do it
manually::
sage: shell.run_cell('from sage.repl.attach import reload_attached_files_if_modified')
sage: shell.run_cell('reload_attached_files_if_modified()')
### reloading attached file tmp_....py modified at ... ###
sage: shell.run_cell('a')
3
sage: shell.run_cell('detach({0})'.format(repr(tmp)))
sage: shell.run_cell('attached_files()')
[]
sage: shell.quit()
"""
ip = get_ipython()
for filename, mtime in modified_file_iterator():
basename = os.path.basename(filename)
timestr = time.strftime('%T', mtime)
notice = '### reloading attached file {0} modified at {1} ###'.format(
basename, timestr)
if ip and ip.pt_cli:
with ip.pt_cli.patch_stdout_context(raw=True):
print(notice)
code = load_wrap(filename, attach=True)
ip.run_cell(code)
elif ip:
print(notice)
code = load_wrap(filename, attach=True)
ip.run_cell(code)
else:
print(notice)
load(filename, globals(), attach=True)
def reload_attached_files_if_modified():
r"""
Reload attached files that have been modified
This is the internal implementation of the attach mechanism.
EXAMPLES::
sage: sage.repl.attach.reset()
sage: from sage.repl.interpreter import get_test_shell
sage: shell = get_test_shell()
sage: tmp = tmp_filename(ext='.py')
sage: open(tmp, 'w').write('a = 2\n')
sage: shell.run_cell('attach({0})'.format(repr(tmp)))
sage: shell.run_cell('a')
2
sage: sleep(1) # filesystem mtime granularity
sage: open(tmp, 'w').write('a = 3\n')
Note that the doctests are never really at the command prompt
where the automatic reload is triggered. So we have to do it
manually::
sage: shell.run_cell('from sage.repl.attach import reload_attached_files_if_modified')
sage: shell.run_cell('reload_attached_files_if_modified()')
### reloading attached file tmp_....py modified at ... ###
sage: shell.run_cell('a')
3
sage: shell.run_cell('detach({0})'.format(repr(tmp)))
sage: shell.run_cell('attached_files()')
[]
sage: shell.quit()
"""
ip = get_ipython()
for filename, mtime in modified_file_iterator():
basename = os.path.basename(filename)
timestr = time.strftime('%T', mtime)
notice = '### reloading attached file {0} modified at {1} ###'.format(basename, timestr)
if ip and ip.pt_cli:
with ip.pt_cli.patch_stdout_context():
print(notice)
code = load_wrap(filename, attach=True)
ip.run_cell(code)
elif ip:
print(notice)
code = load_wrap(filename, attach=True)
ip.run_cell(code)
else:
print(notice)
load(filename, globals(), attach=True)
def attach(self, s):
r"""
Attach the code contained in the file ``s``.
This is designed to be used from the command line as ``%attach
/path/to/file``.
- ``s`` -- string. The file to be attached
EXAMPLES::
sage: import os
sage: from sage.repl.interpreter import get_test_shell
sage: shell = get_test_shell()
sage: tmp = os.path.normpath(os.path.join(SAGE_TMP, 'run_cell.py'))
sage: f = open(tmp, 'w'); f.write('a = 2\n'); f.close()
sage: shell.run_cell('%attach ' + tmp)
sage: shell.run_cell('a')
2
sage: sleep(1) # filesystem timestamp granularity
sage: f = open(tmp, 'w'); f.write('a = 3\n'); f.close()
Note that the doctests are never really at the command prompt, so
we call the input hook manually::
sage: shell.run_cell('from sage.repl.inputhook import sage_inputhook')
sage: shell.run_cell('sage_inputhook()')
### reloading attached file run_cell.py modified at ... ###
0
sage: shell.run_cell('a')
3
sage: shell.run_cell('detach(%r)'%tmp)
sage: shell.run_cell('attached_files()')
[]
sage: os.remove(tmp)
sage: shell.quit()
"""
return self.shell.ex(load_wrap(s, attach=True))
def runfile(self, s):
r"""
Execute the code contained in the file ``s``.
This is designed to be used from the command line as
``%runfile /path/to/file``.
- ``s`` -- string. The file to be loaded.
EXAMPLES::
sage: import os
sage: from sage.repl.interpreter import get_test_shell
sage: from sage.misc.all import tmp_dir
sage: shell = get_test_shell()
sage: tmp = os.path.join(tmp_dir(), 'run_cell.py')
sage: f = open(tmp, 'w'); f.write('a = 2\n'); f.close()
sage: shell.run_cell('%runfile '+tmp)
sage: shell.run_cell('a')
2
"""
return self.shell.ex(load_wrap(s, attach=False))
def attach(self, s):
r"""
Attach the code contained in the file ``s``.
This is designed to be used from the command line as ``%attach
/path/to/file``.
- ``s`` -- string. The file to be attached
EXAMPLES::
sage: import os
sage: from sage.repl.interpreter import get_test_shell
sage: shell = get_test_shell()
sage: tmp = os.path.normpath(os.path.join(SAGE_TMP, 'run_cell.py'))
sage: f = open(tmp, 'w'); f.write('a = 2\n'); f.close()
sage: shell.run_cell('%attach ' + tmp)
sage: shell.run_cell('a')
2
sage: sleep(1) # filesystem timestamp granularity
sage: f = open(tmp, 'w'); f.write('a = 3\n'); f.close()
Note that the doctests are never really at the command prompt, so
we call the input hook manually::
sage: shell.run_cell('from sage.repl.inputhook import sage_inputhook')
sage: shell.run_cell('sage_inputhook()')
### reloading attached file run_cell.py modified at ... ###
0
sage: shell.run_cell('a')
3
sage: shell.run_cell('detach(%r)'%tmp)
sage: shell.run_cell('attached_files()')
[]
sage: os.remove(tmp)
sage: shell.quit()
"""
return self.shell.ex(load_wrap(s, attach=True))
def runfile(self, s):
r"""
Execute the code contained in the file ``s``.
This is designed to be used from the command line as
``%runfile /path/to/file``.
- ``s`` -- string. The file to be loaded.
EXAMPLES::
sage: import os
sage: from sage.repl.interpreter import get_test_shell
sage: from sage.misc.all import tmp_dir
sage: shell = get_test_shell()
sage: tmp = os.path.join(tmp_dir(), 'run_cell.py')
sage: f = open(tmp, 'w'); f.write('a = 2\n'); f.close()
sage: shell.run_cell('%runfile '+tmp)
sage: shell.run_cell('a')
2
sage: shell.quit()
"""
return self.shell.ex(load_wrap(s, attach=False))
def preparse_file(contents, globals=None, numeric_literals=True):
"""
Preparses input, attending to numeric literals and load/attach
file directives.
.. note:: Temporarily, if @parallel is in the input, then
numeric_literals is always set to False.
INPUT:
- ``contents`` - a string
- ``globals`` - dict or None (default: None); if given, then
arguments to load/attach are evaluated in the namespace of this
dict.
- ``numeric_literals`` - bool (default: True), whether to factor
out wrapping of integers and floats, so they don't get created
repeatedly inside loops
OUTPUT:
- a string
TESTS::
sage: from sage.repl.preparse import preparse_file
sage: lots_of_numbers = "[%s]" % ", ".join(str(i) for i in range(3000))
sage: _ = preparse_file(lots_of_numbers)
sage: print preparse_file("type(100r), type(100)")
_sage_const_100 = Integer(100)
type(100 ), type(_sage_const_100 )
"""
if not isinstance(contents, six.string_types):
raise TypeError("contents must be a string")
if globals is None:
globals = {}
# This is a hack, since when we use @parallel to parallelize code,
# the numeric literals that are factored out do not get copied
# to the subprocesses properly. See trac #4545.
if "@parallel" in contents:
numeric_literals = False
if numeric_literals:
contents, literals, state = strip_string_literals(contents)
contents, nums = extract_numeric_literals(contents)
contents = contents % literals
if nums:
# Stick the assignments at the top, trying not to shift
# the lines down.
ix = contents.find("\n")
if ix == -1:
ix = len(contents)
if not re.match(r"^ *(#.*)?$", contents[:ix]):
contents = "\n" + contents
assignments = ["%s = %s" % x for x in nums.items()]
# the preparser recurses on semicolons, so we only attempt
# to preserve line numbers if there are a few
if len(assignments) < 500:
contents = "; ".join(assignments) + contents
else:
contents = "\n".join(assignments) + "\n\n" + contents
# The list F contains the preparsed lines so far.
F = []
# A is the input, as a list of lines.
A = contents.splitlines()
# We are currently parsing the i-th input line.
i = 0
while i < len(A):
L = A[i]
do_preparse = True
for cmd in ["load", "attach"]:
if L.lstrip().startswith(cmd + " "):
j = L.find(cmd + " ")
s = L[j + len(cmd) + 1 :].strip()
if not s.startswith("("):
F.append(" " * j + load_wrap(s, cmd == "attach"))
do_preparse = False
continue
if do_preparse:
F.append(
preparse(L, reset=(i == 0), do_time=True, ignore_prompts=False, numeric_literals=not numeric_literals)
)
i += 1
return "\n".join(F)
def attach(*files):
"""
Attach a file or files to a running instance of Sage and also load
that file.
INPUT:
- ``files`` -- a list of filenames (strings) to attach.
OUTPUT:
Each file is read in and added to an internal list of watched files.
The meaning of reading in a file depends on the file type:
- ``.py`` files are read in with no preparsing (so, e.g., ``2^3`` is 2
bit-xor 3);
- ``.sage`` files are preparsed, then the result is read in;
- ``.pyx`` files are *not* preparsed, but rather are compiled to a
module ``m`` and then ``from m import *`` is executed.
The contents of the file are then loaded, which means they are read
into the running Sage session. For example, if ``foo.sage`` contains
``x=5``, after attaching ``foo.sage`` the variable ``x`` will be set
to 5. Moreover, any time you change ``foo.sage``, before you execute
a command, the attached file will be re-read automatically (with no
intervention on your part).
.. SEEALSO::
:meth:`~sage.repl.load.load` is the same as :func:`attach`, but
doesn't automatically reload a file when it changes.
EXAMPLES:
You attach a file, e.g., ``foo.sage`` or ``foo.py`` or
``foo.pyx``, to a running Sage session by typing::
sage: attach('foo.sage') # not tested
Here we test attaching multiple files at once::
sage: sage.repl.attach.reset()
sage: t1 = tmp_filename(ext='.py')
sage: open(t1,'w').write("print 'hello world'")
sage: t2 = tmp_filename(ext='.py')
sage: open(t2,'w').write("print 'hi there xxx'")
sage: attach(t1, t2)
hello world
hi there xxx
sage: set(attached_files()) == set([t1,t2])
True
.. SEEALSO::
- :meth:`attached_files` returns a list of
all currently attached files.
- :meth:`detach` instructs Sage to remove a
file from the internal list of watched files.
- :meth:`load_attach_path` allows you to
get or modify the current search path for loading and attaching
files.
"""
try:
ipy = get_ipython()
except NameError:
ipy = None
global attached
for filename in files:
if ipy:
code = load_wrap(filename, attach=True)
ipy.run_cell(code)
else:
load(filename, globals(), attach=True)
def attach(*files):
"""
Attach a file or files to a running instance of Sage and also load
that file.
.. NOTE::
Attaching files uses the Python inputhook, which will conflict
with other inputhook users. This generally includes GUI main loop
integrations, for example tkinter. So you can only use tkinter or
attach, but not both at the same time.
INPUT:
- ``files`` -- a list of filenames (strings) to attach.
OUTPUT:
Each file is read in and added to an internal list of watched files.
The meaning of reading in a file depends on the file type:
- ``.py`` files are read in with no preparsing (so, e.g., ``2^3`` is 2
bit-xor 3);
- ``.sage`` files are preparsed, then the result is read in;
- ``.pyx`` files are *not* preparsed, but rather are compiled to a
module ``m`` and then ``from m import *`` is executed.
The contents of the file are then loaded, which means they are read
into the running Sage session. For example, if ``foo.sage`` contains
``x=5``, after attaching ``foo.sage`` the variable ``x`` will be set
to 5. Moreover, any time you change ``foo.sage``, before you execute
a command, the attached file will be re-read automatically (with no
intervention on your part).
.. SEEALSO::
:meth:`~sage.repl.load.load` is the same as :func:`attach`, but
doesn't automatically reload a file when it changes.
EXAMPLES:
You attach a file, e.g., ``foo.sage`` or ``foo.py`` or
``foo.pyx``, to a running Sage session by typing::
sage: attach('foo.sage') # not tested
Here we test attaching multiple files at once::
sage: sage.repl.attach.reset()
sage: t1 = tmp_filename(ext='.py')
sage: open(t1,'w').write("print('hello world')")
sage: t2 = tmp_filename(ext='.py')
sage: open(t2,'w').write("print('hi there xxx')")
sage: attach(t1, t2)
hello world
hi there xxx
sage: set(attached_files()) == set([t1,t2])
True
.. SEEALSO::
- :meth:`attached_files` returns a list of
all currently attached files.
- :meth:`detach` instructs Sage to remove a
file from the internal list of watched files.
- :meth:`load_attach_path` allows you to
get or modify the current search path for loading and attaching
files.
"""
try:
ipy = get_ipython()
except NameError:
ipy = None
global attached
for filename in files:
if ipy:
code = load_wrap(filename, attach=True)
ipy.run_cell(code)
else:
load(filename, globals(), attach=True)
def preparse_file(contents, globals=None, numeric_literals=True):
"""
Preparses input, attending to numeric literals and load/attach
file directives.
.. note:: Temporarily, if @parallel is in the input, then
numeric_literals is always set to False.
INPUT:
- ``contents`` - a string
- ``globals`` - dict or None (default: None); if given, then
arguments to load/attach are evaluated in the namespace of this
dict.
- ``numeric_literals`` - bool (default: True), whether to factor
out wrapping of integers and floats, so they don't get created
repeatedly inside loops
OUTPUT:
- a string
TESTS::
sage: from sage.repl.preparse import preparse_file
sage: lots_of_numbers = "[%s]" % ", ".join(str(i) for i in range(3000))
sage: _ = preparse_file(lots_of_numbers)
sage: print(preparse_file("type(100r), type(100)"))
_sage_const_100 = Integer(100)
type(100 ), type(_sage_const_100 )
"""
if not isinstance(contents, six.string_types):
raise TypeError("contents must be a string")
if globals is None:
globals = {}
# This is a hack, since when we use @parallel to parallelize code,
# the numeric literals that are factored out do not get copied
# to the subprocesses properly. See trac #4545.
if '@parallel' in contents:
numeric_literals = False
if numeric_literals:
contents, literals, state = strip_string_literals(contents)
contents, nums = extract_numeric_literals(contents)
contents = contents % literals
if nums:
# Stick the assignments at the top, trying not to shift
# the lines down.
ix = contents.find('\n')
if ix == -1: ix = len(contents)
if not re.match(r"^ *(#.*)?$", contents[:ix]):
contents = "\n" + contents
assignments = ["%s = %s" % x for x in nums.items()]
# the preparser recurses on semicolons, so we only attempt
# to preserve line numbers if there are a few
if len(assignments) < 500:
contents = "; ".join(assignments) + contents
else:
contents = "\n".join(assignments) + "\n\n" + contents
# The list F contains the preparsed lines so far.
F = []
# A is the input, as a list of lines.
A = contents.splitlines()
# We are currently parsing the i-th input line.
i = 0
while i < len(A):
L = A[i]
do_preparse = True
for cmd in ['load', 'attach']:
if L.lstrip().startswith(cmd + ' '):
j = L.find(cmd + ' ')
s = L[j + len(cmd) + 1:].strip()
if not s.startswith('('):
F.append(' ' * j + load_wrap(s, cmd == 'attach'))
do_preparse = False
continue
if do_preparse:
F.append(
preparse(L,
reset=(i == 0),
do_time=True,
ignore_prompts=False,
numeric_literals=not numeric_literals))
i += 1
return '\n'.join(F)