"""Turn a string of range for %%load into 2-tuples of (start, stop)

for range_str in ranges_str.split():

rmatch = range_re.match(range_str)

if not rmatch:

continue

sep = rmatch.group("sep")

start = rmatch.group("start")

end = rmatch.group("end")

if sep == '-':

start = int(start) - 1 if start else None

end = int(end) if end else None

elif sep == ':':

start = int(start) - 1 if start else None

end = int(end) - 1 if end else None

else:

end = int(start)

start = int(start) - 1

"""

symbols = symbols.split(',')

# this will raise SyntaxError if code isn't valid Python

py_code = ast.parse(code)

marks = [(getattr(s, 'name', None), s.lineno) for s in py_code.body]

code = code.split('\n')

symbols_lines = {}

# we already know the start_lineno of each symbol (marks).

# To find each end_lineno, we traverse in reverse order until each

# non-blank line

end = len(code)

for name, start in reversed(marks):

while not code[end - 1].strip():

end -= 1

if name:

symbols_lines[name] = (start - 1, end)

end = start - 1

# Now symbols_lines is a map

# {'symbol_name': (start_lineno, end_lineno), ...}

# fill a list with chunks of codes for each requested symbol

blocks = []

not_found = []

for symbol in symbols:

if symbol in symbols_lines:

start, end = symbols_lines[symbol]

blocks.append('\n'.join(code[start:end]) + '\n')

else:

not_found.append(symbol)

"""For %load, strip indent from lines until finding an unindented line.

indent_re = re.compile(r'\s+')

it = iter(lines)

first_line = next(it)

indent_match = indent_re.match(first_line)

if indent_match:

# First line was indented

indent = indent_match.group()

yield first_line[len(indent):]

for line in it:

if line.startswith(indent):

yield line[len(indent):]

else:

# Less indented than the first line - stop dedenting

yield line

break

else:

yield first_line

# Pass the remaining lines through without dedenting

for line in it:

"""Magics related to code management (loading, saving, editing, ...)."""

def __init__(self, *args, **kwargs):

self._knowntemps = set()

super(CodeMagics, self).__init__(*args, **kwargs)

@line_magic

def save(self, parameter_s=''):

"""Save a set of lines or a macro to a given filename.

opts,args = self.parse_options(parameter_s,'fra',mode='list')

if not args:

raise UsageError('Missing filename.')

raw = 'r' in opts

force = 'f' in opts

append = 'a' in opts

mode = 'a' if append else 'w'

ext = '.ipy' if raw else '.py'

fname, codefrom = args[0], " ".join(args[1:])

if not fname.endswith(('.py','.ipy')):

fname += ext

file_exists = os.path.isfile(fname)

if file_exists and not force and not append:

try:

overwrite = self.shell.ask_yes_no('File `%s` exists. Overwrite (y/[N])? ' % fname, default='n')

except StdinNotImplementedError:

print("File `%s` exists. Use `%%save -f %s` to force overwrite" % (fname, parameter_s))

return

if not overwrite :

print('Operation cancelled.')

return

try:

cmds = self.shell.find_user_code(codefrom,raw)

except (TypeError, ValueError) as e:

print(e.args[0])

return

with io.open(fname, mode, encoding="utf-8") as f:

if not file_exists or not append:

f.write("# coding: utf-8\n")

f.write(cmds)

# make sure we end on a newline

if not cmds.endswith('\n'):

f.write('\n')

print('The following commands were written to file `%s`:' % fname)

print(cmds)

@line_magic

def pastebin(self, parameter_s=''):

"""Upload code to dpaste's paste bin, returning the URL.

opts, args = self.parse_options(parameter_s, 'd:')

try:

code = self.shell.find_user_code(args)

except (ValueError, TypeError) as e:

print(e.args[0])

return

post_data = urlencode({

"title": opts.get('d', "Pasted from IPython"),

"syntax": "python3",

"content": code

}).encode('utf-8')

response = urlopen("http://dpaste.com/api/v2/", post_data)

return response.headers.get('Location')

@line_magic

def loadpy(self, arg_s):

"""Alias of `%load`

self.load(arg_s)

@line_magic

def load(self, arg_s):

"""Load code into the current frontend.

opts,args = self.parse_options(arg_s,'yns:r:')

if not args:

raise UsageError('Missing filename, URL, input history range, '

'macro, or element in the user namespace.')

search_ns = 'n' in opts

contents = self.shell.find_user_code(args, search_ns=search_ns)

if 's' in opts:

try:

blocks, not_found = extract_symbols(contents, opts['s'])

except SyntaxError:

# non python code

error("Unable to parse the input as valid Python code")

return

if len(not_found) == 1:

warn('The symbol `%s` was not found' % not_found[0])

elif len(not_found) > 1:

warn('The symbols %s were not found' % get_text_list(not_found,

wrap_item_with='`')

)

contents = '\n'.join(blocks)

if 'r' in opts:

ranges = opts['r'].replace(',', ' ')

lines = contents.split('\n')

slices = extract_code_ranges(ranges)

contents = [lines[slice(*slc)] for slc in slices]

contents = '\n'.join(strip_initial_indent(chain.from_iterable(contents)))

l = len(contents)

# 200 000 is ~ 2500 full 80 character lines

# so in average, more than 5000 lines

if l > 200000 and 'y' not in opts:

try:

ans = self.shell.ask_yes_no(("The text you're trying to load seems pretty big"\

" (%d characters). Continue (y/[N]) ?" % l), default='n' )

except StdinNotImplementedError:

#assume yes if raw input not implemented

ans = True

if ans is False :

print('Operation cancelled.')

return

contents = "# %load {}\n".format(arg_s) + contents

self.shell.set_next_input(contents, replace=True)

@staticmethod

def _find_edit_target(shell, args, opts, last_call):

"""Utility method used by magic_edit to find what to edit."""

def make_filename(arg):

"Make a filename from the given args"

try:

filename = get_py_filename(arg)

except IOError:

# If it ends with .py but doesn't already exist, assume we want

# a new file.

if arg.endswith('.py'):

filename = arg

else:

filename = None

return filename

# Set a few locals from the options for convenience:

opts_prev = 'p' in opts

opts_raw = 'r' in opts

# custom exceptions

class DataIsObject(Exception): pass

# Default line number value

lineno = opts.get('n',None)

if opts_prev:

args = '_%s' % last_call[0]

if args not in shell.user_ns:

args = last_call[1]

# by default this is done with temp files, except when the given

# arg is a filename

use_temp = True

data = ''

# First, see if the arguments should be a filename.

filename = make_filename(args)

if filename:

use_temp = False

elif args:

# Mode where user specifies ranges of lines, like in %macro.

data = shell.extract_input_lines(args, opts_raw)

if not data:

try:

# Load the parameter given as a variable. If not a string,

# process it as an object instead (below)

#print '*** args',args,'type',type(args) # dbg

data = eval(args, shell.user_ns)

if not isinstance(data, str):

raise DataIsObject

except (NameError,SyntaxError):

# given argument is not a variable, try as a filename

filename = make_filename(args)

if filename is None:

warn("Argument given (%s) can't be found as a variable "

"or as a filename." % args)

return (None, None, None)

use_temp = False

except DataIsObject as e:

# macros have a special edit function

if isinstance(data, Macro):

raise MacroToEdit(data) from e

# For objects, try to edit the file where they are defined

filename = find_file(data)

if filename:

if 'fakemodule' in filename.lower() and \

inspect.isclass(data):

# class created by %edit? Try to find source

# by looking for method definitions instead, the

# __module__ in those classes is FakeModule.

attrs = [getattr(data, aname) for aname in dir(data)]

for attr in attrs:

if not inspect.ismethod(attr):

continue

filename = find_file(attr)

if filename and \

'fakemodule' not in filename.lower():

# change the attribute to be the edit

# target instead

data = attr

break

m = ipython_input_pat.match(os.path.basename(filename))

if m:

raise InteractivelyDefined(int(m.groups()[0])) from e

datafile = 1

if filename is None:

filename = make_filename(args)

datafile = 1

if filename is not None:

# only warn about this if we get a real name

warn('Could not find file where `%s` is defined.\n'

'Opening a file named `%s`' % (args, filename))

# Now, make sure we can actually read the source (if it was

# in a temp file it's gone by now).

if datafile:

if lineno is None:

lineno = find_source_lines(data)

if lineno is None:

filename = make_filename(args)

if filename is None:

warn('The file where `%s` was defined '

'cannot be read or found.' % data)

return (None, None, None)

use_temp = False

if use_temp:

filename = shell.mktempfile(data)

print('IPython will make a temporary file named:',filename)

# use last_call to remember the state of the previous call, but don't

# let it be clobbered by successive '-p' calls.

try:

last_call[0] = shell.displayhook.prompt_count

if not opts_prev:

last_call[1] = args

except:

pass

return filename, lineno, use_temp

def _edit_macro(self,mname,macro):

"""open an editor with the macro data in a file"""

filename = self.shell.mktempfile(macro.value)

self.shell.hooks.editor(filename)

# and make a new macro object, to replace the old one

mvalue = Path(filename).read_text()

self.shell.user_ns[mname] = Macro(mvalue)

@skip_doctest

@line_magic

def edit(self, parameter_s='',last_call=['','']):

"""Bring up an editor and execute the resulting code.

opts,args = self.parse_options(parameter_s,'prxn:')

try:

filename, lineno, is_temp = self._find_edit_target(self.shell,

args, opts, last_call)

except MacroToEdit as e:

self._edit_macro(args, e.args[0])

return

except InteractivelyDefined as e:

print("Editing In[%i]" % e.index)

args = str(e.index)

filename, lineno, is_temp = self._find_edit_target(self.shell,

args, opts, last_call)

if filename is None:

# nothing was found, warnings have already been issued,

# just give up.

return

if is_temp:

self._knowntemps.add(filename)

elif (filename in self._knowntemps):

is_temp = True

# do actual editing here

print('Editing...', end=' ')

sys.stdout.flush()

filepath = Path(filename)

try:

# Quote filenames that may have spaces in them when opening

# the editor

quoted = filename = str(filepath.absolute())

if " " in quoted:

quoted = "'%s'" % quoted

self.shell.hooks.editor(quoted, lineno)

except TryNext:

warn('Could not open editor')

return

# XXX TODO: should this be generalized for all string vars?

# For now, this is special-cased to blocks created by cpaste

if args.strip() == "pasted_block":

self.shell.user_ns["pasted_block"] = filepath.read_text()

if 'x' in opts: # -x prevents actual execution

print()

else:

print('done. Executing edited code...')

with preserve_keys(self.shell.user_ns, '__file__'):

if not is_temp:

self.shell.user_ns['__file__'] = filename

if 'r' in opts: # Untranslated IPython code

source = filepath.read_text()

self.shell.run_cell(source, store_history=False)

else:

self.shell.safe_execfile(filename, self.shell.user_ns,

self.shell.user_ns)

if is_temp:

try:

return filepath.read_text()

except IOError as msg:

if Path(msg.filename) == filepath:

warn('File not found. Did you forget to save?')

return

else: