Shortcuts on this page
r m x toggle line displays
j k next/prev highlighted chunk
0 (zero) top of page
1 (one) first highlighted chunk
1"""Implementation of magic functions for interaction with the OS.
3Note: this module is named 'osm' instead of 'os' to avoid a collision with the
4builtin.
5"""
6# Copyright (c) IPython Development Team.
7# Distributed under the terms of the Modified BSD License.
9import io
10import os
11import pathlib
12import re
13import sys
14from pprint import pformat
16from IPython.core import magic_arguments
17from IPython.core import oinspect
18from IPython.core import page
19from IPython.core.alias import AliasError, Alias
20from IPython.core.error import UsageError
21from IPython.core.magic import (
22 Magics, compress_dhist, magics_class, line_magic, cell_magic, line_cell_magic
23)
24from IPython.testing.skipdoctest import skip_doctest
25from IPython.utils.openpy import source_to_unicode
26from IPython.utils.process import abbrev_cwd
27from IPython.utils.terminal import set_term_title
28from traitlets import Bool
29from warnings import warn
32@magics_class
33class OSMagics(Magics):
34 """Magics to interact with the underlying OS (shell-type functionality).
35 """
37 cd_force_quiet = Bool(False,
38 help="Force %cd magic to be quiet even if -q is not passed."
39 ).tag(config=True)
41 def __init__(self, shell=None, **kwargs):
43 # Now define isexec in a cross platform manner.
44 self.is_posix = False
45 self.execre = None
46 if os.name == 'posix':
47 self.is_posix = True
48 else:
49 try:
50 winext = os.environ['pathext'].replace(';','|').replace('.','')
51 except KeyError:
52 winext = 'exe|com|bat|py'
53 try:
54 self.execre = re.compile(r'(.*)\.(%s)$' % winext,re.IGNORECASE)
55 except re.error:
56 warn("Seems like your pathext environmental "
57 "variable is malformed. Please check it to "
58 "enable a proper handle of file extensions "
59 "managed for your system")
60 winext = 'exe|com|bat|py'
61 self.execre = re.compile(r'(.*)\.(%s)$' % winext,re.IGNORECASE)
63 # call up the chain
64 super().__init__(shell=shell, **kwargs)
67 def _isexec_POSIX(self, file):
68 """
69 Test for executable on a POSIX system
70 """
71 if os.access(file.path, os.X_OK):
72 # will fail on maxOS if access is not X_OK
73 return file.is_file()
74 return False
78 def _isexec_WIN(self, file):
79 """
80 Test for executable file on non POSIX system
81 """
82 return file.is_file() and self.execre.match(file.name) is not None
84 def isexec(self, file):
85 """
86 Test for executable file on non POSIX system
87 """
88 if self.is_posix:
89 return self._isexec_POSIX(file)
90 else:
91 return self._isexec_WIN(file)
94 @skip_doctest
95 @line_magic
96 def alias(self, parameter_s=''):
97 """Define an alias for a system command.
99 '%alias alias_name cmd' defines 'alias_name' as an alias for 'cmd'
101 Then, typing 'alias_name params' will execute the system command 'cmd
102 params' (from your underlying operating system).
104 Aliases have lower precedence than magic functions and Python normal
105 variables, so if 'foo' is both a Python variable and an alias, the
106 alias can not be executed until 'del foo' removes the Python variable.
108 You can use the %l specifier in an alias definition to represent the
109 whole line when the alias is called. For example::
111 In [2]: alias bracket echo "Input in brackets: <%l>"
112 In [3]: bracket hello world
113 Input in brackets: <hello world>
115 You can also define aliases with parameters using %s specifiers (one
116 per parameter)::
118 In [1]: alias parts echo first %s second %s
119 In [2]: %parts A B
120 first A second B
121 In [3]: %parts A
122 Incorrect number of arguments: 2 expected.
123 parts is an alias to: 'echo first %s second %s'
125 Note that %l and %s are mutually exclusive. You can only use one or
126 the other in your aliases.
128 Aliases expand Python variables just like system calls using ! or !!
129 do: all expressions prefixed with '$' get expanded. For details of
130 the semantic rules, see PEP-215:
131 https://peps.python.org/pep-0215/. This is the library used by
132 IPython for variable expansion. If you want to access a true shell
133 variable, an extra $ is necessary to prevent its expansion by
134 IPython::
136 In [6]: alias show echo
137 In [7]: PATH='A Python string'
138 In [8]: show $PATH
139 A Python string
140 In [9]: show $$PATH
141 /usr/local/lf9560/bin:/usr/local/intel/compiler70/ia32/bin:...
143 You can use the alias facility to access all of $PATH. See the %rehashx
144 function, which automatically creates aliases for the contents of your
145 $PATH.
147 If called with no parameters, %alias prints the current alias table
148 for your system. For posix systems, the default aliases are 'cat',
149 'cp', 'mv', 'rm', 'rmdir', and 'mkdir', and other platform-specific
150 aliases are added. For windows-based systems, the default aliases are
151 'copy', 'ddir', 'echo', 'ls', 'ldir', 'mkdir', 'ren', and 'rmdir'.
153 You can see the definition of alias by adding a question mark in the
154 end::
156 In [1]: cat?
157 Repr: <alias cat for 'cat'>"""
159 par = parameter_s.strip()
160 if not par:
161 aliases = sorted(self.shell.alias_manager.aliases)
162 # stored = self.shell.db.get('stored_aliases', {} )
163 # for k, v in stored:
164 # atab.append(k, v[0])
166 print("Total number of aliases:", len(aliases))
167 sys.stdout.flush()
168 return aliases
170 # Now try to define a new one
171 try:
172 alias,cmd = par.split(None, 1)
173 except TypeError:
174 print(oinspect.getdoc(self.alias))
175 return
177 try:
178 self.shell.alias_manager.define_alias(alias, cmd)
179 except AliasError as e:
180 print(e)
181 # end magic_alias
183 @line_magic
184 def unalias(self, parameter_s=''):
185 """Remove an alias"""
187 aname = parameter_s.strip()
188 try:
189 self.shell.alias_manager.undefine_alias(aname)
190 except ValueError as e:
191 print(e)
192 return
194 stored = self.shell.db.get('stored_aliases', {} )
195 if aname in stored:
196 print("Removing %stored alias",aname)
197 del stored[aname]
198 self.shell.db['stored_aliases'] = stored
200 @line_magic
201 def rehashx(self, parameter_s=''):
202 """Update the alias table with all executable files in $PATH.
204 rehashx explicitly checks that every entry in $PATH is a file
205 with execute access (os.X_OK).
207 Under Windows, it checks executability as a match against a
208 '|'-separated string of extensions, stored in the IPython config
209 variable win_exec_ext. This defaults to 'exe|com|bat'.
211 This function also resets the root module cache of module completer,
212 used on slow filesystems.
213 """
214 from IPython.core.alias import InvalidAliasError
216 # for the benefit of module completer in ipy_completers.py
217 del self.shell.db['rootmodules_cache']
219 path = [os.path.abspath(os.path.expanduser(p)) for p in
220 os.environ.get('PATH','').split(os.pathsep)]
222 syscmdlist = []
223 savedir = os.getcwd()
225 # Now walk the paths looking for executables to alias.
226 try:
227 # write the whole loop for posix/Windows so we don't have an if in
228 # the innermost part
229 if self.is_posix:
230 for pdir in path:
231 try:
232 os.chdir(pdir)
233 except OSError:
234 continue
236 # for python 3.6+ rewrite to: with os.scandir(pdir) as dirlist:
237 dirlist = os.scandir(path=pdir)
238 for ff in dirlist:
239 if self.isexec(ff):
240 fname = ff.name
241 try:
242 # Removes dots from the name since ipython
243 # will assume names with dots to be python.
244 if not self.shell.alias_manager.is_alias(fname):
245 self.shell.alias_manager.define_alias(
246 fname.replace('.',''), fname)
247 except InvalidAliasError:
248 pass
249 else:
250 syscmdlist.append(fname)
251 else:
252 no_alias = Alias.blacklist
253 for pdir in path:
254 try:
255 os.chdir(pdir)
256 except OSError:
257 continue
259 # for python 3.6+ rewrite to: with os.scandir(pdir) as dirlist:
260 dirlist = os.scandir(pdir)
261 for ff in dirlist:
262 fname = ff.name
263 base, ext = os.path.splitext(fname)
264 if self.isexec(ff) and base.lower() not in no_alias:
265 if ext.lower() == '.exe':
266 fname = base
267 try:
268 # Removes dots from the name since ipython
269 # will assume names with dots to be python.
270 self.shell.alias_manager.define_alias(
271 base.lower().replace('.',''), fname)
272 except InvalidAliasError:
273 pass
274 syscmdlist.append(fname)
276 self.shell.db['syscmdlist'] = syscmdlist
277 finally:
278 os.chdir(savedir)
280 @skip_doctest
281 @line_magic
282 def pwd(self, parameter_s=''):
283 """Return the current working directory path.
285 Examples
286 --------
287 ::
289 In [9]: pwd
290 Out[9]: '/home/tsuser/sprint/ipython'
291 """
292 try:
293 return os.getcwd()
294 except FileNotFoundError as e:
295 raise UsageError("CWD no longer exists - please use %cd to change directory.") from e
297 @skip_doctest
298 @line_magic
299 def cd(self, parameter_s=''):
300 """Change the current working directory.
302 This command automatically maintains an internal list of directories
303 you visit during your IPython session, in the variable ``_dh``. The
304 command :magic:`%dhist` shows this history nicely formatted. You can
305 also do ``cd -<tab>`` to see directory history conveniently.
306 Usage:
308 - ``cd 'dir'``: changes to directory 'dir'.
309 - ``cd -``: changes to the last visited directory.
310 - ``cd -<n>``: changes to the n-th directory in the directory history.
311 - ``cd --foo``: change to directory that matches 'foo' in history
312 - ``cd -b <bookmark_name>``: jump to a bookmark set by %bookmark
313 - Hitting a tab key after ``cd -b`` allows you to tab-complete
314 bookmark names.
316 .. note::
317 ``cd <bookmark_name>`` is enough if there is no directory
318 ``<bookmark_name>``, but a bookmark with the name exists.
320 Options:
322 -q Be quiet. Do not print the working directory after the
323 cd command is executed. By default IPython's cd
324 command does print this directory, since the default
325 prompts do not display path information.
327 .. note::
328 Note that ``!cd`` doesn't work for this purpose because the shell
329 where ``!command`` runs is immediately discarded after executing
330 'command'.
332 Examples
333 --------
334 ::
336 In [10]: cd parent/child
337 /home/tsuser/parent/child
338 """
340 try:
341 oldcwd = os.getcwd()
342 except FileNotFoundError:
343 # Happens if the CWD has been deleted.
344 oldcwd = None
346 numcd = re.match(r'(-)(\d+)$',parameter_s)
347 # jump in directory history by number
348 if numcd:
349 nn = int(numcd.group(2))
350 try:
351 ps = self.shell.user_ns['_dh'][nn]
352 except IndexError:
353 print('The requested directory does not exist in history.')
354 return
355 else:
356 opts = {}
357 elif parameter_s.startswith('--'):
358 ps = None
359 fallback = None
360 pat = parameter_s[2:]
361 dh = self.shell.user_ns['_dh']
362 # first search only by basename (last component)
363 for ent in reversed(dh):
364 if pat in os.path.basename(ent) and os.path.isdir(ent):
365 ps = ent
366 break
368 if fallback is None and pat in ent and os.path.isdir(ent):
369 fallback = ent
371 # if we have no last part match, pick the first full path match
372 if ps is None:
373 ps = fallback
375 if ps is None:
376 print("No matching entry in directory history")
377 return
378 else:
379 opts = {}
382 else:
383 opts, ps = self.parse_options(parameter_s, 'qb', mode='string')
384 # jump to previous
385 if ps == '-':
386 try:
387 ps = self.shell.user_ns['_dh'][-2]
388 except IndexError as e:
389 raise UsageError('%cd -: No previous directory to change to.') from e
390 # jump to bookmark if needed
391 else:
392 if not os.path.isdir(ps) or 'b' in opts:
393 bkms = self.shell.db.get('bookmarks', {})
395 if ps in bkms:
396 target = bkms[ps]
397 print('(bookmark:%s) -> %s' % (ps, target))
398 ps = target
399 else:
400 if 'b' in opts:
401 raise UsageError("Bookmark '%s' not found. "
402 "Use '%%bookmark -l' to see your bookmarks." % ps)
404 # at this point ps should point to the target dir
405 if ps:
406 try:
407 os.chdir(os.path.expanduser(ps))
408 if hasattr(self.shell, 'term_title') and self.shell.term_title:
409 set_term_title(self.shell.term_title_format.format(cwd=abbrev_cwd()))
410 except OSError:
411 print(sys.exc_info()[1])
412 else:
413 cwd = pathlib.Path.cwd()
414 dhist = self.shell.user_ns['_dh']
415 if oldcwd != cwd:
416 dhist.append(cwd)
417 self.shell.db['dhist'] = compress_dhist(dhist)[-100:]
419 else:
420 os.chdir(self.shell.home_dir)
421 if hasattr(self.shell, 'term_title') and self.shell.term_title:
422 set_term_title(self.shell.term_title_format.format(cwd="~"))
423 cwd = pathlib.Path.cwd()
424 dhist = self.shell.user_ns['_dh']
426 if oldcwd != cwd:
427 dhist.append(cwd)
428 self.shell.db["dhist"] = compress_dhist(dhist)[-100:]
429 if "q" not in opts and not self.cd_force_quiet and self.shell.user_ns["_dh"]:
430 print(self.shell.user_ns["_dh"][-1])
432 @line_magic
433 def env(self, parameter_s=''):
434 """Get, set, or list environment variables.
436 Usage:\\
438 :``%env``: lists all environment variables/values
439 :``%env var``: get value for var
440 :``%env var val``: set value for var
441 :``%env var=val``: set value for var
442 :``%env var=$val``: set value for var, using python expansion if possible
443 """
444 if parameter_s.strip():
445 split = '=' if '=' in parameter_s else ' '
446 bits = parameter_s.split(split)
447 if len(bits) == 1:
448 key = parameter_s.strip()
449 if key in os.environ:
450 return os.environ[key]
451 else:
452 err = "Environment does not have key: {0}".format(key)
453 raise UsageError(err)
454 if len(bits) > 1:
455 return self.set_env(parameter_s)
456 env = dict(os.environ)
457 # hide likely secrets when printing the whole environment
458 for key in list(env):
459 if any(s in key.lower() for s in ('key', 'token', 'secret')):
460 env[key] = '<hidden>'
462 return env
464 @line_magic
465 def set_env(self, parameter_s):
466 """Set environment variables. Assumptions are that either "val" is a
467 name in the user namespace, or val is something that evaluates to a
468 string.
470 Usage:\\
471 :``%set_env var val``: set value for var
472 :``%set_env var=val``: set value for var
473 :``%set_env var=$val``: set value for var, using python expansion if possible
474 """
475 split = '=' if '=' in parameter_s else ' '
476 bits = parameter_s.split(split, 1)
477 if not parameter_s.strip() or len(bits)<2:
478 raise UsageError("usage is 'set_env var=val'")
479 var = bits[0].strip()
480 val = bits[1].strip()
481 if re.match(r'.*\s.*', var):
482 # an environment variable with whitespace is almost certainly
483 # not what the user intended. what's more likely is the wrong
484 # split was chosen, ie for "set_env cmd_args A=B", we chose
485 # '=' for the split and should have chosen ' '. to get around
486 # this, users should just assign directly to os.environ or use
487 # standard magic {var} expansion.
488 err = "refusing to set env var with whitespace: '{0}'"
489 err = err.format(val)
490 raise UsageError(err)
491 os.environ[var] = val
492 print('env: {0}={1}'.format(var,val))
494 @line_magic
495 def pushd(self, parameter_s=''):
496 """Place the current dir on stack and change directory.
498 Usage:\\
499 %pushd ['dirname']
500 """
502 dir_s = self.shell.dir_stack
503 tgt = os.path.expanduser(parameter_s)
504 cwd = os.getcwd().replace(self.shell.home_dir,'~')
505 if tgt:
506 self.cd(parameter_s)
507 dir_s.insert(0,cwd)
508 return self.shell.run_line_magic('dirs', '')
510 @line_magic
511 def popd(self, parameter_s=''):
512 """Change to directory popped off the top of the stack.
513 """
514 if not self.shell.dir_stack:
515 raise UsageError("%popd on empty stack")
516 top = self.shell.dir_stack.pop(0)
517 self.cd(top)
518 print("popd ->",top)
520 @line_magic
521 def dirs(self, parameter_s=''):
522 """Return the current directory stack."""
524 return self.shell.dir_stack
526 @line_magic
527 def dhist(self, parameter_s=''):
528 """Print your history of visited directories.
530 %dhist -> print full history\\
531 %dhist n -> print last n entries only\\
532 %dhist n1 n2 -> print entries between n1 and n2 (n2 not included)\\
534 This history is automatically maintained by the %cd command, and
535 always available as the global list variable _dh. You can use %cd -<n>
536 to go to directory number <n>.
538 Note that most of time, you should view directory history by entering
539 cd -<TAB>.
541 """
543 dh = self.shell.user_ns['_dh']
544 if parameter_s:
545 try:
546 args = map(int,parameter_s.split())
547 except:
548 self.arg_err(self.dhist)
549 return
550 if len(args) == 1:
551 ini,fin = max(len(dh)-(args[0]),0),len(dh)
552 elif len(args) == 2:
553 ini,fin = args
554 fin = min(fin, len(dh))
555 else:
556 self.arg_err(self.dhist)
557 return
558 else:
559 ini,fin = 0,len(dh)
560 print('Directory history (kept in _dh)')
561 for i in range(ini, fin):
562 print("%d: %s" % (i, dh[i]))
564 @skip_doctest
565 @line_magic
566 def sc(self, parameter_s=''):
567 """Shell capture - run shell command and capture output (DEPRECATED use !).
569 DEPRECATED. Suboptimal, retained for backwards compatibility.
571 You should use the form 'var = !command' instead. Example:
573 "%sc -l myfiles = ls ~" should now be written as
575 "myfiles = !ls ~"
577 myfiles.s, myfiles.l and myfiles.n still apply as documented
578 below.
580 --
581 %sc [options] varname=command
583 IPython will run the given command using commands.getoutput(), and
584 will then update the user's interactive namespace with a variable
585 called varname, containing the value of the call. Your command can
586 contain shell wildcards, pipes, etc.
588 The '=' sign in the syntax is mandatory, and the variable name you
589 supply must follow Python's standard conventions for valid names.
591 (A special format without variable name exists for internal use)
593 Options:
595 -l: list output. Split the output on newlines into a list before
596 assigning it to the given variable. By default the output is stored
597 as a single string.
599 -v: verbose. Print the contents of the variable.
601 In most cases you should not need to split as a list, because the
602 returned value is a special type of string which can automatically
603 provide its contents either as a list (split on newlines) or as a
604 space-separated string. These are convenient, respectively, either
605 for sequential processing or to be passed to a shell command.
607 For example::
609 # Capture into variable a
610 In [1]: sc a=ls *py
612 # a is a string with embedded newlines
613 In [2]: a
614 Out[2]: 'setup.py\\nwin32_manual_post_install.py'
616 # which can be seen as a list:
617 In [3]: a.l
618 Out[3]: ['setup.py', 'win32_manual_post_install.py']
620 # or as a whitespace-separated string:
621 In [4]: a.s
622 Out[4]: 'setup.py win32_manual_post_install.py'
624 # a.s is useful to pass as a single command line:
625 In [5]: !wc -l $a.s
626 146 setup.py
627 130 win32_manual_post_install.py
628 276 total
630 # while the list form is useful to loop over:
631 In [6]: for f in a.l:
632 ...: !wc -l $f
633 ...:
634 146 setup.py
635 130 win32_manual_post_install.py
637 Similarly, the lists returned by the -l option are also special, in
638 the sense that you can equally invoke the .s attribute on them to
639 automatically get a whitespace-separated string from their contents::
641 In [7]: sc -l b=ls *py
643 In [8]: b
644 Out[8]: ['setup.py', 'win32_manual_post_install.py']
646 In [9]: b.s
647 Out[9]: 'setup.py win32_manual_post_install.py'
649 In summary, both the lists and strings used for output capture have
650 the following special attributes::
652 .l (or .list) : value as list.
653 .n (or .nlstr): value as newline-separated string.
654 .s (or .spstr): value as space-separated string.
655 """
657 opts,args = self.parse_options(parameter_s, 'lv')
658 # Try to get a variable name and command to run
659 try:
660 # the variable name must be obtained from the parse_options
661 # output, which uses shlex.split to strip options out.
662 var,_ = args.split('=', 1)
663 var = var.strip()
664 # But the command has to be extracted from the original input
665 # parameter_s, not on what parse_options returns, to avoid the
666 # quote stripping which shlex.split performs on it.
667 _,cmd = parameter_s.split('=', 1)
668 except ValueError:
669 var,cmd = '',''
670 # If all looks ok, proceed
671 split = 'l' in opts
672 out = self.shell.getoutput(cmd, split=split)
673 if 'v' in opts:
674 print('%s ==\n%s' % (var, pformat(out)))
675 if var:
676 self.shell.user_ns.update({var:out})
677 else:
678 return out
680 @line_cell_magic
681 def sx(self, line='', cell=None):
682 """Shell execute - run shell command and capture output (!! is short-hand).
684 %sx command
686 IPython will run the given command using commands.getoutput(), and
687 return the result formatted as a list (split on '\\n'). Since the
688 output is _returned_, it will be stored in ipython's regular output
689 cache Out[N] and in the '_N' automatic variables.
691 Notes:
693 1) If an input line begins with '!!', then %sx is automatically
694 invoked. That is, while::
696 !ls
698 causes ipython to simply issue system('ls'), typing::
700 !!ls
702 is a shorthand equivalent to::
704 %sx ls
706 2) %sx differs from %sc in that %sx automatically splits into a list,
707 like '%sc -l'. The reason for this is to make it as easy as possible
708 to process line-oriented shell output via further python commands.
709 %sc is meant to provide much finer control, but requires more
710 typing.
712 3) Just like %sc -l, this is a list with special attributes:
713 ::
715 .l (or .list) : value as list.
716 .n (or .nlstr): value as newline-separated string.
717 .s (or .spstr): value as whitespace-separated string.
719 This is very useful when trying to use such lists as arguments to
720 system commands."""
722 if cell is None:
723 # line magic
724 return self.shell.getoutput(line)
725 else:
726 opts,args = self.parse_options(line, '', 'out=')
727 output = self.shell.getoutput(cell)
728 out_name = opts.get('out', opts.get('o'))
729 if out_name:
730 self.shell.user_ns[out_name] = output
731 else:
732 return output
734 system = line_cell_magic('system')(sx)
735 bang = cell_magic('!')(sx)
737 @line_magic
738 def bookmark(self, parameter_s=''):
739 """Manage IPython's bookmark system.
741 %bookmark <name> - set bookmark to current dir
742 %bookmark <name> <dir> - set bookmark to <dir>
743 %bookmark -l - list all bookmarks
744 %bookmark -d <name> - remove bookmark
745 %bookmark -r - remove all bookmarks
747 You can later on access a bookmarked folder with::
749 %cd -b <name>
751 or simply '%cd <name>' if there is no directory called <name> AND
752 there is such a bookmark defined.
754 Your bookmarks persist through IPython sessions, but they are
755 associated with each profile."""
757 opts,args = self.parse_options(parameter_s,'drl',mode='list')
758 if len(args) > 2:
759 raise UsageError("%bookmark: too many arguments")
761 bkms = self.shell.db.get('bookmarks',{})
763 if 'd' in opts:
764 try:
765 todel = args[0]
766 except IndexError as e:
767 raise UsageError(
768 "%bookmark -d: must provide a bookmark to delete") from e
769 else:
770 try:
771 del bkms[todel]
772 except KeyError as e:
773 raise UsageError(
774 "%%bookmark -d: Can't delete bookmark '%s'" % todel) from e
776 elif 'r' in opts:
777 bkms = {}
778 elif 'l' in opts:
779 bks = sorted(bkms)
780 if bks:
781 size = max(map(len, bks))
782 else:
783 size = 0
784 fmt = '%-'+str(size)+'s -> %s'
785 print('Current bookmarks:')
786 for bk in bks:
787 print(fmt % (bk, bkms[bk]))
788 else:
789 if not args:
790 raise UsageError("%bookmark: You must specify the bookmark name")
791 elif len(args)==1:
792 bkms[args[0]] = os.getcwd()
793 elif len(args)==2:
794 bkms[args[0]] = args[1]
795 self.shell.db['bookmarks'] = bkms
797 @line_magic
798 def pycat(self, parameter_s=''):
799 """Show a syntax-highlighted file through a pager.
801 This magic is similar to the cat utility, but it will assume the file
802 to be Python source and will show it with syntax highlighting.
804 This magic command can either take a local filename, an url,
805 an history range (see %history) or a macro as argument.
807 If no parameter is given, prints out history of current session up to
808 this point. ::
810 %pycat myscript.py
811 %pycat 7-27
812 %pycat myMacro
813 %pycat http://www.example.com/myscript.py
814 """
815 try:
816 cont = self.shell.find_user_code(parameter_s, skip_encoding_cookie=False)
817 except (ValueError, IOError):
818 print("Error: no such file, variable, URL, history range or macro")
819 return
821 page.page(self.shell.pycolorize(source_to_unicode(cont)))
823 @magic_arguments.magic_arguments()
824 @magic_arguments.argument(
825 '-a', '--append', action='store_true', default=False,
826 help='Append contents of the cell to an existing file. '
827 'The file will be created if it does not exist.'
828 )
829 @magic_arguments.argument(
830 'filename', type=str,
831 help='file to write'
832 )
833 @cell_magic
834 def writefile(self, line, cell):
835 """Write the contents of the cell to a file.
837 The file will be overwritten unless the -a (--append) flag is specified.
838 """
839 args = magic_arguments.parse_argstring(self.writefile, line)
840 if re.match(r'^(\'.*\')|(".*")$', args.filename):
841 filename = os.path.expanduser(args.filename[1:-1])
842 else:
843 filename = os.path.expanduser(args.filename)
845 if os.path.exists(filename):
846 if args.append:
847 print("Appending to %s" % filename)
848 else:
849 print("Overwriting %s" % filename)
850 else:
851 print("Writing %s" % filename)
853 mode = 'a' if args.append else 'w'
854 with io.open(filename, mode, encoding='utf-8') as f:
855 f.write(cell)