remove blank lines

IPython/core/magic_arguments.py

@@ -1,312 +1,310 b''
 ''' A decorator-based method of constructing IPython magics with `argparse`
 option handling.
 
 New magic functions can be defined like so::
 
     from IPython.core.magic_arguments import (argument, magic_arguments,
         parse_argstring)
 
     @magic_arguments()
     @argument('-o', '--option', help='An optional argument.')
     @argument('arg', type=int, help='An integer positional argument.')
     def magic_cool(self, arg):
         """ A really cool magic command.
 
     """
         args = parse_argstring(magic_cool, arg)
         ...
 
 The `@magic_arguments` decorator marks the function as having argparse arguments.
 The `@argument` decorator adds an argument using the same syntax as argparse's
 `add_argument()` method. More sophisticated uses may also require the
 `@argument_group` or `@kwds` decorator to customize the formatting and the
 parsing.
 
 Help text for the magic is automatically generated from the docstring and the
 arguments::
 
     In[1]: %cool?
         %cool [-o OPTION] arg
         
         A really cool magic command.
         
         positional arguments:
           arg                   An integer positional argument.
         
         optional arguments:
           -o OPTION, --option OPTION
                                 An optional argument.
 
-
 Here is an elaborated example that uses default parameters in `argument` and calls the `args` in the cell magic::
 
     from IPython.core.magic import register_cell_magic
     from IPython.core.magic_arguments import (argument, magic_arguments,
                                             parse_argstring)
 
 
     @magic_arguments()
     @argument(
         "--option",
         "-o",
         help=("Add an option here"),
     )
     @argument(
         "--style",
         "-s",
         default="foo",
         help=("Add some style arguments"),
     )
     @register_cell_magic
     def my_cell_magic(line, cell):
         args = parse_argstring(my_cell_magic, line)
         print(f"{args.option=}")
         print(f"{args.style=}")
         print(f"{cell=}")
 
 In a jupyter notebook, this cell magic can be executed like this::
 
     %%my_cell_magic -o Hello
     print("bar")
     i = 42
 
-
 Inheritance diagram:
 
 .. inheritance-diagram:: IPython.core.magic_arguments
    :parts: 3
 
 '''
 #-----------------------------------------------------------------------------
 # Copyright (C) 2010-2011, IPython Development Team.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 import argparse
 import re
 
 # Our own imports
 from IPython.core.error import UsageError
 from IPython.utils.decorators import undoc
 from IPython.utils.process import arg_split
 from IPython.utils.text import dedent
 
 NAME_RE = re.compile(r"[a-zA-Z][a-zA-Z0-9_-]*$")
 
 @undoc
 class MagicHelpFormatter(argparse.RawDescriptionHelpFormatter):
     """A HelpFormatter with a couple of changes to meet our needs.
     """
     # Modified to dedent text.
     def _fill_text(self, text, width, indent):
         return argparse.RawDescriptionHelpFormatter._fill_text(self, dedent(text), width, indent)
 
     # Modified to wrap argument placeholders in <> where necessary.
     def _format_action_invocation(self, action):
         if not action.option_strings:
             metavar, = self._metavar_formatter(action, action.dest)(1)
             return metavar
 
         else:
             parts = []
 
             # if the Optional doesn't take a value, format is:
             #    -s, --long
             if action.nargs == 0:
                 parts.extend(action.option_strings)
 
             # if the Optional takes a value, format is:
             #    -s ARGS, --long ARGS
             else:
                 default = action.dest.upper()
                 args_string = self._format_args(action, default)
                 # IPYTHON MODIFICATION: If args_string is not a plain name, wrap
                 # it in <> so it's valid RST.
                 if not NAME_RE.match(args_string):
                     args_string = "<%s>" % args_string
                 for option_string in action.option_strings:
                     parts.append('%s %s' % (option_string, args_string))
 
             return ', '.join(parts)
 
     # Override the default prefix ('usage') to our % magic escape,
     # in a code block.
     def add_usage(self, usage, actions, groups, prefix="::\n\n  %"):
         super(MagicHelpFormatter, self).add_usage(usage, actions, groups, prefix)
 
 class MagicArgumentParser(argparse.ArgumentParser):
     """ An ArgumentParser tweaked for use by IPython magics.
     """
     def __init__(self,
                  prog=None,
                  usage=None,
                  description=None,
                  epilog=None,
                  parents=None,
                  formatter_class=MagicHelpFormatter,
                  prefix_chars='-',
                  argument_default=None,
                  conflict_handler='error',
                  add_help=False):
         if parents is None:
             parents = []
         super(MagicArgumentParser, self).__init__(prog=prog, usage=usage,
             description=description, epilog=epilog,
             parents=parents, formatter_class=formatter_class,
             prefix_chars=prefix_chars, argument_default=argument_default,
             conflict_handler=conflict_handler, add_help=add_help)
 
     def error(self, message):
         """ Raise a catchable error instead of exiting.
         """
         raise UsageError(message)
 
     def parse_argstring(self, argstring):
         """ Split a string into an argument list and parse that argument list.
         """
         argv = arg_split(argstring)
         return self.parse_args(argv)
 
 
 def construct_parser(magic_func):
     """ Construct an argument parser using the function decorations.
     """
     kwds = getattr(magic_func, 'argcmd_kwds', {})
     if 'description' not in kwds:
         kwds['description'] = getattr(magic_func, '__doc__', None)
     arg_name = real_name(magic_func)
     parser = MagicArgumentParser(arg_name, **kwds)
     # Reverse the list of decorators in order to apply them in the
     # order in which they appear in the source.
     group = None
     for deco in magic_func.decorators[::-1]:
         result = deco.add_to_parser(parser, group)
         if result is not None:
             group = result
 
     # Replace the magic function's docstring with the full help text.
     magic_func.__doc__ = parser.format_help()
 
     return parser
 
 
 def parse_argstring(magic_func, argstring):
     """ Parse the string of arguments for the given magic function.
     """
     return magic_func.parser.parse_argstring(argstring)
 
 
 def real_name(magic_func):
     """ Find the real name of the magic.
     """
     magic_name = magic_func.__name__
     if magic_name.startswith('magic_'):
         magic_name = magic_name[len('magic_'):]
     return getattr(magic_func, 'argcmd_name', magic_name)
 
 
 class ArgDecorator(object):
     """ Base class for decorators to add ArgumentParser information to a method.
     """
 
     def __call__(self, func):
         if not getattr(func, 'has_arguments', False):
             func.has_arguments = True
             func.decorators = []
         func.decorators.append(self)
         return func
 
     def add_to_parser(self, parser, group):
         """ Add this object's information to the parser, if necessary.
         """
         pass
 
 
 class magic_arguments(ArgDecorator):
     """ Mark the magic as having argparse arguments and possibly adjust the
     name.
     """
 
     def __init__(self, name=None):
         self.name = name
 
     def __call__(self, func):
         if not getattr(func, 'has_arguments', False):
             func.has_arguments = True
             func.decorators = []
         if self.name is not None:
             func.argcmd_name = self.name
         # This should be the first decorator in the list of decorators, thus the
         # last to execute. Build the parser.
         func.parser = construct_parser(func)
         return func
 
 
 class ArgMethodWrapper(ArgDecorator):
 
     """
     Base class to define a wrapper for ArgumentParser method.
 
     Child class must define either `_method_name` or `add_to_parser`.
 
     """
 
     _method_name = None
 
     def __init__(self, *args, **kwds):
         self.args = args
         self.kwds = kwds
 
     def add_to_parser(self, parser, group):
         """ Add this object's information to the parser.
         """
         if group is not None:
             parser = group
         getattr(parser, self._method_name)(*self.args, **self.kwds)
         return None
 
 
 class argument(ArgMethodWrapper):
     """ Store arguments and keywords to pass to add_argument().
 
     Instances also serve to decorate command methods.
     """
     _method_name = 'add_argument'
 
 
 class defaults(ArgMethodWrapper):
     """ Store arguments and keywords to pass to set_defaults().
 
     Instances also serve to decorate command methods.
     """
     _method_name = 'set_defaults'
 
 
 class argument_group(ArgMethodWrapper):
     """ Store arguments and keywords to pass to add_argument_group().
 
     Instances also serve to decorate command methods.
     """
 
     def add_to_parser(self, parser, group):
         """ Add this object's information to the parser.
         """
         return parser.add_argument_group(*self.args, **self.kwds)
 
 
 class kwds(ArgDecorator):
     """ Provide other keywords to the sub-parser constructor.
     """
     def __init__(self, **kwds):
         self.kwds = kwds
 
     def __call__(self, func):
         func = super(kwds, self).__call__(func)
         func.argcmd_kwds = self.kwds
         return func
 
 
 __all__ = ['magic_arguments', 'argument', 'argument_group', 'kwds',
     'parse_argstring']