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

@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 = u'.ipy' if raw else u'.py'

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

if not fname.endswith((u'.py',u'.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

out = py3compat.cast_unicode(cmds)

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

if not file_exists or not append:

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

f.write(out)

# make sure we end on a newline

if not out.endswith(u'\n'):

f.write(u'\n')

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

print cmds

@line_magic

def pastebin(self, parameter_s=''):

"""Upload code to Github's Gist 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

from urllib2 import urlopen # Deferred import

import json

post_data = json.dumps({

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

"public": True,

"files": {

"file1.py": {

"content": code

}

}

}).encode('utf-8')

response = urlopen("https://api.github.com/gists", post_data)

response_data = json.loads(response.read().decode('utf-8'))

return response_data['html_url']

@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,'y')

if not args:

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

'or macro.')

contents = self.shell.find_user_code(args)

l = len(contents)

# 200 000 is ~ 2500 full 80 caracter 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:

#asume yes if raw input not implemented

ans = True

if ans is False :

print 'Operation cancelled.'

return

self.shell.set_next_input(contents)

@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"

arg = unquote_filename(arg)

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, basestring):

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:

# macros have a special edit function

if isinstance(data, Macro):

raise MacroToEdit(data)

# 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]))

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

mfile = open(filename)

mvalue = mfile.read()

mfile.close()

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

# do actual editing here

print 'Editing...',

sys.stdout.flush()

try:

# Quote filenames that may have spaces in them

if ' ' in filename:

filename = "'%s'" % filename

self.shell.hooks.editor(filename,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':

with open(filename, 'r') as f:

self.shell.user_ns['pasted_block'] = f.read()

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

with open(filename, 'r') as f:

source = f.read()

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 open(filename).read()

except IOError as msg:

if msg.filename == filename:

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

return

else: