Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.8/site-packages/IPython/core/magic.py: 40%
266 statements
« prev ^ index » next coverage.py v7.4.4, created at 2024-04-20 06:09 +0000
1# encoding: utf-8
2"""Magic functions for InteractiveShell.
3"""
5#-----------------------------------------------------------------------------
6# Copyright (C) 2001 Janko Hauser <jhauser@zscout.de> and
7# Copyright (C) 2001 Fernando Perez <fperez@colorado.edu>
8# Copyright (C) 2008 The IPython Development Team
10# Distributed under the terms of the BSD License. The full license is in
11# the file COPYING, distributed as part of this software.
12#-----------------------------------------------------------------------------
14import os
15import re
16import sys
17from getopt import getopt, GetoptError
19from traitlets.config.configurable import Configurable
20from . import oinspect
21from .error import UsageError
22from .inputtransformer2 import ESC_MAGIC, ESC_MAGIC2
23from ..utils.ipstruct import Struct
24from ..utils.process import arg_split
25from ..utils.text import dedent
26from traitlets import Bool, Dict, Instance, observe
27from logging import error
29#-----------------------------------------------------------------------------
30# Globals
31#-----------------------------------------------------------------------------
33# A dict we'll use for each class that has magics, used as temporary storage to
34# pass information between the @line/cell_magic method decorators and the
35# @magics_class class decorator, because the method decorators have no
36# access to the class when they run. See for more details:
37# http://stackoverflow.com/questions/2366713/can-a-python-decorator-of-an-instance-method-access-the-class
39magics = dict(line={}, cell={})
41magic_kinds = ('line', 'cell')
42magic_spec = ('line', 'cell', 'line_cell')
43magic_escapes = dict(line=ESC_MAGIC, cell=ESC_MAGIC2)
45#-----------------------------------------------------------------------------
46# Utility classes and functions
47#-----------------------------------------------------------------------------
49class Bunch: pass
52def on_off(tag):
53 """Return an ON/OFF string for a 1/0 input. Simple utility function."""
54 return ['OFF','ON'][tag]
57def compress_dhist(dh):
58 """Compress a directory history into a new one with at most 20 entries.
60 Return a new list made from the first and last 10 elements of dhist after
61 removal of duplicates.
62 """
63 head, tail = dh[:-10], dh[-10:]
65 newhead = []
66 done = set()
67 for h in head:
68 if h in done:
69 continue
70 newhead.append(h)
71 done.add(h)
73 return newhead + tail
76def needs_local_scope(func):
77 """Decorator to mark magic functions which need to local scope to run."""
78 func.needs_local_scope = True
79 return func
81#-----------------------------------------------------------------------------
82# Class and method decorators for registering magics
83#-----------------------------------------------------------------------------
85def magics_class(cls):
86 """Class decorator for all subclasses of the main Magics class.
88 Any class that subclasses Magics *must* also apply this decorator, to
89 ensure that all the methods that have been decorated as line/cell magics
90 get correctly registered in the class instance. This is necessary because
91 when method decorators run, the class does not exist yet, so they
92 temporarily store their information into a module global. Application of
93 this class decorator copies that global data to the class instance and
94 clears the global.
96 Obviously, this mechanism is not thread-safe, which means that the
97 *creation* of subclasses of Magic should only be done in a single-thread
98 context. Instantiation of the classes has no restrictions. Given that
99 these classes are typically created at IPython startup time and before user
100 application code becomes active, in practice this should not pose any
101 problems.
102 """
103 cls.registered = True
104 cls.magics = dict(line = magics['line'],
105 cell = magics['cell'])
106 magics['line'] = {}
107 magics['cell'] = {}
108 return cls
111def record_magic(dct, magic_kind, magic_name, func):
112 """Utility function to store a function as a magic of a specific kind.
114 Parameters
115 ----------
116 dct : dict
117 A dictionary with 'line' and 'cell' subdicts.
118 magic_kind : str
119 Kind of magic to be stored.
120 magic_name : str
121 Key to store the magic as.
122 func : function
123 Callable object to store.
124 """
125 if magic_kind == 'line_cell':
126 dct['line'][magic_name] = dct['cell'][magic_name] = func
127 else:
128 dct[magic_kind][magic_name] = func
131def validate_type(magic_kind):
132 """Ensure that the given magic_kind is valid.
134 Check that the given magic_kind is one of the accepted spec types (stored
135 in the global `magic_spec`), raise ValueError otherwise.
136 """
137 if magic_kind not in magic_spec:
138 raise ValueError('magic_kind must be one of %s, %s given' %
139 magic_kinds, magic_kind)
142# The docstrings for the decorator below will be fairly similar for the two
143# types (method and function), so we generate them here once and reuse the
144# templates below.
145_docstring_template = \
146"""Decorate the given {0} as {1} magic.
148The decorator can be used with or without arguments, as follows.
150i) without arguments: it will create a {1} magic named as the {0} being
151decorated::
153 @deco
154 def foo(...)
156will create a {1} magic named `foo`.
158ii) with one string argument: which will be used as the actual name of the
159resulting magic::
161 @deco('bar')
162 def foo(...)
164will create a {1} magic named `bar`.
166To register a class magic use ``Interactiveshell.register_magic(class or instance)``.
167"""
169# These two are decorator factories. While they are conceptually very similar,
170# there are enough differences in the details that it's simpler to have them
171# written as completely standalone functions rather than trying to share code
172# and make a single one with convoluted logic.
174def _method_magic_marker(magic_kind):
175 """Decorator factory for methods in Magics subclasses.
176 """
178 validate_type(magic_kind)
180 # This is a closure to capture the magic_kind. We could also use a class,
181 # but it's overkill for just that one bit of state.
182 def magic_deco(arg):
183 if callable(arg):
184 # "Naked" decorator call (just @foo, no args)
185 func = arg
186 name = func.__name__
187 retval = arg
188 record_magic(magics, magic_kind, name, name)
189 elif isinstance(arg, str):
190 # Decorator called with arguments (@foo('bar'))
191 name = arg
192 def mark(func, *a, **kw):
193 record_magic(magics, magic_kind, name, func.__name__)
194 return func
195 retval = mark
196 else:
197 raise TypeError("Decorator can only be called with "
198 "string or function")
199 return retval
201 # Ensure the resulting decorator has a usable docstring
202 magic_deco.__doc__ = _docstring_template.format('method', magic_kind)
203 return magic_deco
206def _function_magic_marker(magic_kind):
207 """Decorator factory for standalone functions.
208 """
209 validate_type(magic_kind)
211 # This is a closure to capture the magic_kind. We could also use a class,
212 # but it's overkill for just that one bit of state.
213 def magic_deco(arg):
214 # Find get_ipython() in the caller's namespace
215 caller = sys._getframe(1)
216 for ns in ['f_locals', 'f_globals', 'f_builtins']:
217 get_ipython = getattr(caller, ns).get('get_ipython')
218 if get_ipython is not None:
219 break
220 else:
221 raise NameError('Decorator can only run in context where '
222 '`get_ipython` exists')
224 ip = get_ipython()
226 if callable(arg):
227 # "Naked" decorator call (just @foo, no args)
228 func = arg
229 name = func.__name__
230 ip.register_magic_function(func, magic_kind, name)
231 retval = arg
232 elif isinstance(arg, str):
233 # Decorator called with arguments (@foo('bar'))
234 name = arg
235 def mark(func, *a, **kw):
236 ip.register_magic_function(func, magic_kind, name)
237 return func
238 retval = mark
239 else:
240 raise TypeError("Decorator can only be called with "
241 "string or function")
242 return retval
244 # Ensure the resulting decorator has a usable docstring
245 ds = _docstring_template.format('function', magic_kind)
247 ds += dedent("""
248 Note: this decorator can only be used in a context where IPython is already
249 active, so that the `get_ipython()` call succeeds. You can therefore use
250 it in your startup files loaded after IPython initializes, but *not* in the
251 IPython configuration file itself, which is executed before IPython is
252 fully up and running. Any file located in the `startup` subdirectory of
253 your configuration profile will be OK in this sense.
254 """)
256 magic_deco.__doc__ = ds
257 return magic_deco
260MAGIC_NO_VAR_EXPAND_ATTR = "_ipython_magic_no_var_expand"
261MAGIC_OUTPUT_CAN_BE_SILENCED = "_ipython_magic_output_can_be_silenced"
264def no_var_expand(magic_func):
265 """Mark a magic function as not needing variable expansion
267 By default, IPython interprets `{a}` or `$a` in the line passed to magics
268 as variables that should be interpolated from the interactive namespace
269 before passing the line to the magic function.
270 This is not always desirable, e.g. when the magic executes Python code
271 (%timeit, %time, etc.).
272 Decorate magics with `@no_var_expand` to opt-out of variable expansion.
274 .. versionadded:: 7.3
275 """
276 setattr(magic_func, MAGIC_NO_VAR_EXPAND_ATTR, True)
277 return magic_func
280def output_can_be_silenced(magic_func):
281 """Mark a magic function so its output may be silenced.
283 The output is silenced if the Python code used as a parameter of
284 the magic ends in a semicolon, not counting a Python comment that can
285 follow it.
286 """
287 setattr(magic_func, MAGIC_OUTPUT_CAN_BE_SILENCED, True)
288 return magic_func
290# Create the actual decorators for public use
292# These three are used to decorate methods in class definitions
293line_magic = _method_magic_marker('line')
294cell_magic = _method_magic_marker('cell')
295line_cell_magic = _method_magic_marker('line_cell')
297# These three decorate standalone functions and perform the decoration
298# immediately. They can only run where get_ipython() works
299register_line_magic = _function_magic_marker('line')
300register_cell_magic = _function_magic_marker('cell')
301register_line_cell_magic = _function_magic_marker('line_cell')
303#-----------------------------------------------------------------------------
304# Core Magic classes
305#-----------------------------------------------------------------------------
307class MagicsManager(Configurable):
308 """Object that handles all magic-related functionality for IPython.
309 """
310 # Non-configurable class attributes
312 # A two-level dict, first keyed by magic type, then by magic function, and
313 # holding the actual callable object as value. This is the dict used for
314 # magic function dispatch
315 magics = Dict()
316 lazy_magics = Dict(
317 help="""
318 Mapping from magic names to modules to load.
320 This can be used in IPython/IPykernel configuration to declare lazy magics
321 that will only be imported/registered on first use.
323 For example::
325 c.MagicsManager.lazy_magics = {
326 "my_magic": "slow.to.import",
327 "my_other_magic": "also.slow",
328 }
330 On first invocation of `%my_magic`, `%%my_magic`, `%%my_other_magic` or
331 `%%my_other_magic`, the corresponding module will be loaded as an ipython
332 extensions as if you had previously done `%load_ext ipython`.
334 Magics names should be without percent(s) as magics can be both cell
335 and line magics.
337 Lazy loading happen relatively late in execution process, and
338 complex extensions that manipulate Python/IPython internal state or global state
339 might not support lazy loading.
340 """
341 ).tag(
342 config=True,
343 )
345 # A registry of the original objects that we've been given holding magics.
346 registry = Dict()
348 shell = Instance('IPython.core.interactiveshell.InteractiveShellABC', allow_none=True)
350 auto_magic = Bool(True, help=
351 "Automatically call line magics without requiring explicit % prefix"
352 ).tag(config=True)
353 @observe('auto_magic')
354 def _auto_magic_changed(self, change):
355 self.shell.automagic = change['new']
357 _auto_status = [
358 'Automagic is OFF, % prefix IS needed for line magics.',
359 'Automagic is ON, % prefix IS NOT needed for line magics.']
361 user_magics = Instance('IPython.core.magics.UserMagics', allow_none=True)
363 def __init__(self, shell=None, config=None, user_magics=None, **traits):
365 super(MagicsManager, self).__init__(shell=shell, config=config,
366 user_magics=user_magics, **traits)
367 self.magics = dict(line={}, cell={})
368 # Let's add the user_magics to the registry for uniformity, so *all*
369 # registered magic containers can be found there.
370 self.registry[user_magics.__class__.__name__] = user_magics
372 def auto_status(self):
373 """Return descriptive string with automagic status."""
374 return self._auto_status[self.auto_magic]
376 def lsmagic(self):
377 """Return a dict of currently available magic functions.
379 The return dict has the keys 'line' and 'cell', corresponding to the
380 two types of magics we support. Each value is a list of names.
381 """
382 return self.magics
384 def lsmagic_docs(self, brief=False, missing=''):
385 """Return dict of documentation of magic functions.
387 The return dict has the keys 'line' and 'cell', corresponding to the
388 two types of magics we support. Each value is a dict keyed by magic
389 name whose value is the function docstring. If a docstring is
390 unavailable, the value of `missing` is used instead.
392 If brief is True, only the first line of each docstring will be returned.
393 """
394 docs = {}
395 for m_type in self.magics:
396 m_docs = {}
397 for m_name, m_func in self.magics[m_type].items():
398 if m_func.__doc__:
399 if brief:
400 m_docs[m_name] = m_func.__doc__.split('\n', 1)[0]
401 else:
402 m_docs[m_name] = m_func.__doc__.rstrip()
403 else:
404 m_docs[m_name] = missing
405 docs[m_type] = m_docs
406 return docs
408 def register_lazy(self, name: str, fully_qualified_name: str):
409 """
410 Lazily register a magic via an extension.
413 Parameters
414 ----------
415 name : str
416 Name of the magic you wish to register.
417 fully_qualified_name :
418 Fully qualified name of the module/submodule that should be loaded
419 as an extensions when the magic is first called.
420 It is assumed that loading this extensions will register the given
421 magic.
422 """
424 self.lazy_magics[name] = fully_qualified_name
426 def register(self, *magic_objects):
427 """Register one or more instances of Magics.
429 Take one or more classes or instances of classes that subclass the main
430 `core.Magic` class, and register them with IPython to use the magic
431 functions they provide. The registration process will then ensure that
432 any methods that have decorated to provide line and/or cell magics will
433 be recognized with the `%x`/`%%x` syntax as a line/cell magic
434 respectively.
436 If classes are given, they will be instantiated with the default
437 constructor. If your classes need a custom constructor, you should
438 instanitate them first and pass the instance.
440 The provided arguments can be an arbitrary mix of classes and instances.
442 Parameters
443 ----------
444 *magic_objects : one or more classes or instances
445 """
446 # Start by validating them to ensure they have all had their magic
447 # methods registered at the instance level
448 for m in magic_objects:
449 if not m.registered:
450 raise ValueError("Class of magics %r was constructed without "
451 "the @register_magics class decorator")
452 if isinstance(m, type):
453 # If we're given an uninstantiated class
454 m = m(shell=self.shell)
456 # Now that we have an instance, we can register it and update the
457 # table of callables
458 self.registry[m.__class__.__name__] = m
459 for mtype in magic_kinds:
460 self.magics[mtype].update(m.magics[mtype])
462 def register_function(self, func, magic_kind='line', magic_name=None):
463 """Expose a standalone function as magic function for IPython.
465 This will create an IPython magic (line, cell or both) from a
466 standalone function. The functions should have the following
467 signatures:
469 * For line magics: `def f(line)`
470 * For cell magics: `def f(line, cell)`
471 * For a function that does both: `def f(line, cell=None)`
473 In the latter case, the function will be called with `cell==None` when
474 invoked as `%f`, and with cell as a string when invoked as `%%f`.
476 Parameters
477 ----------
478 func : callable
479 Function to be registered as a magic.
480 magic_kind : str
481 Kind of magic, one of 'line', 'cell' or 'line_cell'
482 magic_name : optional str
483 If given, the name the magic will have in the IPython namespace. By
484 default, the name of the function itself is used.
485 """
487 # Create the new method in the user_magics and register it in the
488 # global table
489 validate_type(magic_kind)
490 magic_name = func.__name__ if magic_name is None else magic_name
491 setattr(self.user_magics, magic_name, func)
492 record_magic(self.magics, magic_kind, magic_name, func)
494 def register_alias(self, alias_name, magic_name, magic_kind='line', magic_params=None):
495 """Register an alias to a magic function.
497 The alias is an instance of :class:`MagicAlias`, which holds the
498 name and kind of the magic it should call. Binding is done at
499 call time, so if the underlying magic function is changed the alias
500 will call the new function.
502 Parameters
503 ----------
504 alias_name : str
505 The name of the magic to be registered.
506 magic_name : str
507 The name of an existing magic.
508 magic_kind : str
509 Kind of magic, one of 'line' or 'cell'
510 """
512 # `validate_type` is too permissive, as it allows 'line_cell'
513 # which we do not handle.
514 if magic_kind not in magic_kinds:
515 raise ValueError('magic_kind must be one of %s, %s given' %
516 magic_kinds, magic_kind)
518 alias = MagicAlias(self.shell, magic_name, magic_kind, magic_params)
519 setattr(self.user_magics, alias_name, alias)
520 record_magic(self.magics, magic_kind, alias_name, alias)
522# Key base class that provides the central functionality for magics.
525class Magics(Configurable):
526 """Base class for implementing magic functions.
528 Shell functions which can be reached as %function_name. All magic
529 functions should accept a string, which they can parse for their own
530 needs. This can make some functions easier to type, eg `%cd ../`
531 vs. `%cd("../")`
533 Classes providing magic functions need to subclass this class, and they
534 MUST:
536 - Use the method decorators `@line_magic` and `@cell_magic` to decorate
537 individual methods as magic functions, AND
539 - Use the class decorator `@magics_class` to ensure that the magic
540 methods are properly registered at the instance level upon instance
541 initialization.
543 See :mod:`magic_functions` for examples of actual implementation classes.
544 """
545 # Dict holding all command-line options for each magic.
546 options_table = None
547 # Dict for the mapping of magic names to methods, set by class decorator
548 magics = None
549 # Flag to check that the class decorator was properly applied
550 registered = False
551 # Instance of IPython shell
552 shell = None
554 def __init__(self, shell=None, **kwargs):
555 if not(self.__class__.registered):
556 raise ValueError('Magics subclass without registration - '
557 'did you forget to apply @magics_class?')
558 if shell is not None:
559 if hasattr(shell, 'configurables'):
560 shell.configurables.append(self)
561 if hasattr(shell, 'config'):
562 kwargs.setdefault('parent', shell)
564 self.shell = shell
565 self.options_table = {}
566 # The method decorators are run when the instance doesn't exist yet, so
567 # they can only record the names of the methods they are supposed to
568 # grab. Only now, that the instance exists, can we create the proper
569 # mapping to bound methods. So we read the info off the original names
570 # table and replace each method name by the actual bound method.
571 # But we mustn't clobber the *class* mapping, in case of multiple instances.
572 class_magics = self.magics
573 self.magics = {}
574 for mtype in magic_kinds:
575 tab = self.magics[mtype] = {}
576 cls_tab = class_magics[mtype]
577 for magic_name, meth_name in cls_tab.items():
578 if isinstance(meth_name, str):
579 # it's a method name, grab it
580 tab[magic_name] = getattr(self, meth_name)
581 else:
582 # it's the real thing
583 tab[magic_name] = meth_name
584 # Configurable **needs** to be initiated at the end or the config
585 # magics get screwed up.
586 super(Magics, self).__init__(**kwargs)
588 def arg_err(self,func):
589 """Print docstring if incorrect arguments were passed"""
590 print('Error in arguments:')
591 print(oinspect.getdoc(func))
593 def format_latex(self, strng):
594 """Format a string for latex inclusion."""
596 # Characters that need to be escaped for latex:
597 escape_re = re.compile(r'(%|_|\$|#|&)',re.MULTILINE)
598 # Magic command names as headers:
599 cmd_name_re = re.compile(r'^(%s.*?):' % ESC_MAGIC,
600 re.MULTILINE)
601 # Magic commands
602 cmd_re = re.compile(r'(?P<cmd>%s.+?\b)(?!\}\}:)' % ESC_MAGIC,
603 re.MULTILINE)
604 # Paragraph continue
605 par_re = re.compile(r'\\$',re.MULTILINE)
607 # The "\n" symbol
608 newline_re = re.compile(r'\\n')
610 # Now build the string for output:
611 #strng = cmd_name_re.sub(r'\n\\texttt{\\textsl{\\large \1}}:',strng)
612 strng = cmd_name_re.sub(r'\n\\bigskip\n\\texttt{\\textbf{ \1}}:',
613 strng)
614 strng = cmd_re.sub(r'\\texttt{\g<cmd>}',strng)
615 strng = par_re.sub(r'\\\\',strng)
616 strng = escape_re.sub(r'\\\1',strng)
617 strng = newline_re.sub(r'\\textbackslash{}n',strng)
618 return strng
620 def parse_options(self, arg_str, opt_str, *long_opts, **kw):
621 """Parse options passed to an argument string.
623 The interface is similar to that of :func:`getopt.getopt`, but it
624 returns a :class:`~IPython.utils.struct.Struct` with the options as keys
625 and the stripped argument string still as a string.
627 arg_str is quoted as a true sys.argv vector by using shlex.split.
628 This allows us to easily expand variables, glob files, quote
629 arguments, etc.
631 Parameters
632 ----------
633 arg_str : str
634 The arguments to parse.
635 opt_str : str
636 The options specification.
637 mode : str, default 'string'
638 If given as 'list', the argument string is returned as a list (split
639 on whitespace) instead of a string.
640 list_all : bool, default False
641 Put all option values in lists. Normally only options
642 appearing more than once are put in a list.
643 posix : bool, default True
644 Whether to split the input line in POSIX mode or not, as per the
645 conventions outlined in the :mod:`shlex` module from the standard
646 library.
647 """
649 # inject default options at the beginning of the input line
650 caller = sys._getframe(1).f_code.co_name
651 arg_str = '%s %s' % (self.options_table.get(caller,''),arg_str)
653 mode = kw.get('mode','string')
654 if mode not in ['string','list']:
655 raise ValueError('incorrect mode given: %s' % mode)
656 # Get options
657 list_all = kw.get('list_all',0)
658 posix = kw.get('posix', os.name == 'posix')
659 strict = kw.get('strict', True)
661 preserve_non_opts = kw.get("preserve_non_opts", False)
662 remainder_arg_str = arg_str
664 # Check if we have more than one argument to warrant extra processing:
665 odict = {} # Dictionary with options
666 args = arg_str.split()
667 if len(args) >= 1:
668 # If the list of inputs only has 0 or 1 thing in it, there's no
669 # need to look for options
670 argv = arg_split(arg_str, posix, strict)
671 # Do regular option processing
672 try:
673 opts,args = getopt(argv, opt_str, long_opts)
674 except GetoptError as e:
675 raise UsageError(
676 '%s ( allowed: "%s" %s)' % (e.msg, opt_str, " ".join(long_opts))
677 ) from e
678 for o, a in opts:
679 if mode == "string" and preserve_non_opts:
680 # remove option-parts from the original args-string and preserve remaining-part.
681 # This relies on the arg_split(...) and getopt(...)'s impl spec, that the parsed options are
682 # returned in the original order.
683 remainder_arg_str = remainder_arg_str.replace(o, "", 1).replace(
684 a, "", 1
685 )
686 if o.startswith("--"):
687 o = o[2:]
688 else:
689 o = o[1:]
690 try:
691 odict[o].append(a)
692 except AttributeError:
693 odict[o] = [odict[o],a]
694 except KeyError:
695 if list_all:
696 odict[o] = [a]
697 else:
698 odict[o] = a
700 # Prepare opts,args for return
701 opts = Struct(odict)
702 if mode == 'string':
703 if preserve_non_opts:
704 args = remainder_arg_str.lstrip()
705 else:
706 args = " ".join(args)
708 return opts,args
710 def default_option(self, fn, optstr):
711 """Make an entry in the options_table for fn, with value optstr"""
713 if fn not in self.lsmagic():
714 error("%s is not a magic function" % fn)
715 self.options_table[fn] = optstr
718class MagicAlias(object):
719 """An alias to another magic function.
721 An alias is determined by its magic name and magic kind. Lookup
722 is done at call time, so if the underlying magic changes the alias
723 will call the new function.
725 Use the :meth:`MagicsManager.register_alias` method or the
726 `%alias_magic` magic function to create and register a new alias.
727 """
728 def __init__(self, shell, magic_name, magic_kind, magic_params=None):
729 self.shell = shell
730 self.magic_name = magic_name
731 self.magic_params = magic_params
732 self.magic_kind = magic_kind
734 self.pretty_target = '%s%s' % (magic_escapes[self.magic_kind], self.magic_name)
735 self.__doc__ = "Alias for `%s`." % self.pretty_target
737 self._in_call = False
739 def __call__(self, *args, **kwargs):
740 """Call the magic alias."""
741 fn = self.shell.find_magic(self.magic_name, self.magic_kind)
742 if fn is None:
743 raise UsageError("Magic `%s` not found." % self.pretty_target)
745 # Protect against infinite recursion.
746 if self._in_call:
747 raise UsageError("Infinite recursion detected; "
748 "magic aliases cannot call themselves.")
749 self._in_call = True
750 try:
751 if self.magic_params:
752 args_list = list(args)
753 args_list[0] = self.magic_params + " " + args[0]
754 args = tuple(args_list)
755 return fn(*args, **kwargs)
756 finally:
757 self._in_call = False