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