def common_doctest_arguments(func): commons = [ argument( "-x", "--stop", default=False, action="store_true", help=""" Stop running tests after the first error or failure. When this option is specified, the error is recorded in IPython shell so that you can debug the error by turning on pdb flag before doctest (see ``%%pdb``) or use ``%%debug`` magic command afterward. """, ), argument( "-v", "--verbose", default=False, action="store_true", help="See :func:`doctest.run_docstring_examples`." ), argument("-n", "--name", default="NoName", help="See :func:`doctest.run_docstring_examples`."), argument("-f", "--file", default="", action="store_true", help="The object to be tested is a file"), argument( "-o", "--options", default=0, help=""" Use these doctest options, e.g. %%doctest --options=doctest.ELLIPSIS object """, ), ] for c in commons: func = c(func) return func
def exec_args(f): """decorator for adding block/targets args for execution applied to %pxconfig and %%px """ args = [ magic_arguments.argument('-b', '--block', action="store_const", const=True, dest='block', help="use blocking (sync) execution", ), magic_arguments.argument('-a', '--noblock', action="store_const", const=False, dest='block', help="use non-blocking (async) execution", ), magic_arguments.argument('-t', '--targets', type=str, help="specify the targets on which to execute", ), magic_arguments.argument('--verbose', action="store_const", const=True, dest="set_verbose", help="print a message at each execution", ), magic_arguments.argument('--no-verbose', action="store_const", const=False, dest="set_verbose", help="don't print any messages", ), ] for a in args: f = a(f) return f
def script_args(f): """single decorator for adding script args""" args = [ magic_arguments.argument( '--out', type=str, help="""The variable in which to store stdout from the script. If the script is backgrounded, this will be the stdout *pipe*, instead of the stderr text itself. """ ), magic_arguments.argument( '--err', type=str, help="""The variable in which to store stderr from the script. If the script is backgrounded, this will be the stderr *pipe*, instead of the stderr text itself. """ ), magic_arguments.argument( '--bg', action="store_true", help="""Whether to run the script in the background. If given, the only way to see the output of the command is with --out/err. """ ), magic_arguments.argument( '--proc', type=str, help="""The variable in which to store Popen instance. This is used only when --bg option is given. """ ), ] for arg in args: f = arg(f) return f
def script_args(f): """single decorator for adding script args""" args = [ magic_arguments.argument( '--out', type=str, help="""The variable in which to store stdout from the script. If the script is backgrounded, this will be the stdout *pipe*, instead of the stderr text itself. """), magic_arguments.argument( '--err', type=str, help="""The variable in which to store stderr from the script. If the script is backgrounded, this will be the stderr *pipe*, instead of the stderr text itself. """), magic_arguments.argument( '--bg', action="store_true", help="""Whether to run the script in the background. If given, the only way to see the output of the command is with --out/err. """), magic_arguments.argument( '--proc', type=str, help="""The variable in which to store Popen instance. This is used only when --bg option is given. """), ] for arg in args: f = arg(f) return f
def common_doctest_arguments(func): commons = [ argument( '-x', '--stop', default=False, action='store_true', help=""" Stop running tests after the first error or failure. When this option is specified, the error is recorded in IPython shell so that you can debug the error by turning on pdb flag before doctest (see ``%%pdb``) or use ``%%debug`` magic command afterward. """, ), argument( '-v', '--verbose', default=False, action='store_true', help='See :func:`doctest.run_docstring_examples`.', ), argument( '-n', '--name', default='NoName', help='See :func:`doctest.run_docstring_examples`.', ), argument( '-f', '--file', default='', action='store_true', help='The object to be tested is a file' ), argument( '-o', '--options', default=0, help=""" Use these doctest options, e.g. %%doctest --options=doctest.ELLIPSIS object """ ), ] for c in commons: func = c(func) return func
def output_args(f): """decorator for output-formatting args applied to %pxresult and %%px """ args = [ magic_arguments.argument( "-r", action="store_const", dest="groupby", const="order", help="collate outputs in order (same as group-outputs=order)", ), magic_arguments.argument( "-e", action="store_const", dest="groupby", const="engine", help="group outputs by engine (same as group-outputs=engine)", ), magic_arguments.argument( "--group-outputs", dest="groupby", type=str, choices=["engine", "order", "type"], default="type", help="""Group the outputs in a particular way. Choices are: type: group outputs of all engines by type (stdout, stderr, displaypub, etc.). engine: display all output for each engine together. order: like type, but individual displaypub output from each engine is collated. For example, if multiple plots are generated by each engine, the first figure of each engine will be displayed, then the second of each, etc. """, ), magic_arguments.argument( "-o", "--out", dest="save_name", type=str, help="""store the AsyncResult object for this computation in the global namespace under this name. """, ), ] for a in args: f = a(f) return f
def output_args(f): """decorator for output-formatting args applied to %pxresult and %%px """ args = [ magic_arguments.argument( '-r', action="store_const", dest='groupby', const='order', help="collate outputs in order (same as group-outputs=order)", ), magic_arguments.argument( '-e', action="store_const", dest='groupby', const='engine', help="group outputs by engine (same as group-outputs=engine)", ), magic_arguments.argument( '--group-outputs', dest='groupby', type=str, choices=['engine', 'order', 'type'], default='type', help="""Group the outputs in a particular way. Choices are: **type**: group outputs of all engines by type (stdout, stderr, displaypub, etc.). **engine**: display all output for each engine together. **order**: like type, but individual displaypub output from each engine is collated. For example, if multiple plots are generated by each engine, the first figure of each engine will be displayed, then the second of each, etc. """, ), magic_arguments.argument( '-o', '--out', dest='save_name', type=str, help="""store the AsyncResult object for this computation in the global namespace under this name. """, ), ] for a in args: f = a(f) return f
def param_arguments(cls, ggb_ipython_magic): # TODO: everything referring to ipython should be removed from this file """Arguments common for GeoGebra applets (including Java applets, HTML5 applets, etc). """ @functools.wraps(ggb_ipython_magic) @argument('--width', type=int, default=1000, help="Width of applet, in pixels") @argument('--height', type=int, default=600, help="Height of applet, in pixels") @argument('--java_arguments', '--java', default='', help="Arguments to pass to java") def wrapped_magic(self, line, cell=None): return ggb_ipython_magic(self, line, cell) for param in cls.bool_params: wrapped_magic = argument('--' + param, metavar='0/1', type=int, help=param)(wrapped_magic) return wrapped_magic
def script_args(f): """single decorator for adding script args""" args = [ magic_arguments.argument( "--out", type=str, help="""The variable in which to store stdout from the script. If the script is backgrounded, this will be the stdout *pipe*, instead of the stderr text itself and will not be auto closed. """, ), magic_arguments.argument( "--err", type=str, help="""The variable in which to store stderr from the script. If the script is backgrounded, this will be the stderr *pipe*, instead of the stderr text itself and will not be autoclosed. """, ), magic_arguments.argument( "--bg", action="store_true", help="""Whether to run the script in the background. If given, the only way to see the output of the command is with --out/err. """, ), magic_arguments.argument( "--proc", type=str, help="""The variable in which to store Popen instance. This is used only when --bg option is given. """, ), magic_arguments.argument( "--no-raise-error", action="store_false", dest="raise_error", help="""Whether you should raise an error message in addition to a stream on stderr if you get a nonzero exit code. """, ), ] for arg in args: f = arg(f) return f
def exec_args(f): """decorator for adding block/targets args for execution applied to %pxconfig and %%px """ args = [ magic_arguments.argument( '-b', '--block', action="store_const", const=True, dest='block', help="use blocking (sync) execution", ), magic_arguments.argument( '-a', '--noblock', action="store_const", const=False, dest='block', help="use non-blocking (async) execution", ), magic_arguments.argument( '-t', '--targets', type=str, help="specify the targets on which to execute", ), magic_arguments.argument( '--verbose', action="store_const", const=True, dest="set_verbose", help="print a message at each execution", ), magic_arguments.argument( '--no-verbose', action="store_const", const=False, dest="set_verbose", help="don't print any messages", ), ] for a in args: f = a(f) return f
def script_args(f): """single decorator for adding script args""" args = [ magic_arguments.argument( '--out', type=str, help="""The variable in which to store stdout from the script. If the script is backgrounded, this will be the stdout *pipe*, instead of the stderr text itself and will not be auto closed. """ ), magic_arguments.argument( '--err', type=str, help="""The variable in which to store stderr from the script. If the script is backgrounded, this will be the stderr *pipe*, instead of the stderr text itself and will not be autoclosed. """ ), magic_arguments.argument( '--bg', action="store_true", help="""Whether to run the script in the background. If given, the only way to see the output of the command is with --out/err. """ ), magic_arguments.argument( '--proc', type=str, help="""The variable in which to store Popen instance. This is used only when --bg option is given. """ ), magic_arguments.argument( '--raise-error', action="store_true", help="""Whether you should raise an error message in addition to a stream on stderr if you get a nonzero exit code. """ ) ] for arg in args: f = arg(f) return f
def exec_args(f): """decorator for adding block/targets args for execution applied to %pxconfig and %%px """ args = [ magic_arguments.argument( "-b", "--block", action="store_const", const=True, dest="block", help="use blocking (sync) execution" ), magic_arguments.argument( "-a", "--noblock", action="store_const", const=False, dest="block", help="use non-blocking (async) execution", ), magic_arguments.argument("-t", "--targets", type=str, help="specify the targets on which to execute"), magic_arguments.argument( "--local", action="store_const", const=True, dest="local", help="also execute the cell in the local namespace", ), magic_arguments.argument( "--verbose", action="store_const", const=True, dest="set_verbose", help="print a message at each execution" ), magic_arguments.argument( "--no-verbose", action="store_const", const=False, dest="set_verbose", help="don't print any messages" ), ] for a in args: f = a(f) return f
def output_args(f): """decorator for output-formatting args applied to %pxresult and %%px """ args = [ magic_arguments.argument('-r', action="store_const", dest='groupby', const='order', help="collate outputs in order (same as group-outputs=order)" ), magic_arguments.argument('-e', action="store_const", dest='groupby', const='engine', help="group outputs by engine (same as group-outputs=engine)" ), magic_arguments.argument('--group-outputs', dest='groupby', type=str, choices=['engine', 'order', 'type'], default='type', help="""Group the outputs in a particular way. Choices are: **type**: group outputs of all engines by type (stdout, stderr, displaypub, etc.). **engine**: display all output for each engine together. **order**: like type, but individual displaypub output from each engine is collated. For example, if multiple plots are generated by each engine, the first figure of each engine will be displayed, then the second of each, etc. """ ), magic_arguments.argument('-o', '--out', dest='save_name', type=str, help="""store the AsyncResult object for this computation in the global namespace under this name. """ ), ] for a in args: f = a(f) return f
def script_args(f): """single decorator for adding script args""" args = [ magic_arguments.argument( '--out', type=str, help="""The variable in which to store stdout from the script. If the script is backgrounded, this will be the stdout *pipe*, instead of the stderr text itself. """), magic_arguments.argument( '--dir', type=str, help="""The directory to run the macro commands. """), magic_arguments.argument('--anybodycon', type=str, help="""The the path to to the anybodycon. """), magic_arguments.argument( '--bg', action="store_true", help="""Whether to run the script in the background. If given, the only way to see the output of the command is with --out/err. """), magic_arguments.argument( '--proc', type=str, help="""The variable in which to store Popen instance. This is used only when --bg option is given. """), magic_arguments.argument( '--dump', action="store_true", help="""This will move all 'dump'ed varialbes to the ipython name space. """), magic_arguments.argument( '--pager', action="store_true", help= """This will open AnyBody console output in the pager instead of the cell """), ] for arg in args: f = arg(f) return f
def script_args(f): """single decorator for adding script args""" args = [ magic_arguments.argument( '--out', type=str, help="""The variable in which to store stdout from the script. If the script is backgrounded, this will be the stdout *pipe*, instead of the stderr text itself. """ ), magic_arguments.argument( '--dir', type=str, help="""The directory to run the macro commands. """ ), magic_arguments.argument( '--anybodycon', type=str, help="""The the path to to the anybodycon. """ ), magic_arguments.argument( '--bg', action="store_true", help="""Whether to run the script in the background. If given, the only way to see the output of the command is with --out/err. """ ), magic_arguments.argument( '--proc', type=str, help="""The variable in which to store Popen instance. This is used only when --bg option is given. """ ), magic_arguments.argument( '--dump', action="store_true", help="""This will move all 'dump'ed varialbes to the ipython name space. """ ), magic_arguments.argument( '--pager', action="store_true", help="""This will open AnyBody console output in the pager instead of the cell """ ), ] for arg in args: f = arg(f) return f
def _html5iframe_args(ggb_ipython_magic): """Arguments common for GeoGebra applets (including Java applets, HTML5 applets, etc). """ @functools.wraps(ggb_ipython_magic) @argument( '--width', type=int, default=1000, help="Width of applet, in pixels") @argument( '--height', type=int, default=600, help="Height of applet, in pixels") def wrapped_magic(self, line, cell=None): return ggb_ipython_magic(self, line, cell) for long_arg, short_arg, help in applet.HTML5IFrame.bool_params: wrapped_magic = argument('--' + long_arg, '--' + short_arg, metavar='0/1', type=int, help=help)(wrapped_magic) return wrapped_magic
def param_arguments(cls, ggb_ipython_magic): # TODO: everything referring to ipython should be removed from this file """Arguments common for GeoGebra applets (including Java applets, HTML5 applets, etc). """ @functools.wraps(ggb_ipython_magic) @argument( '--width', type=int, default=1000, help="Width of applet, in pixels") @argument( '--height', type=int, default=600, help="Height of applet, in pixels") @argument( '--java_arguments', '--java', default='', help="Arguments to pass to java") def wrapped_magic(self, line, cell=None): return ggb_ipython_magic(self, line, cell) for param in cls.bool_params: wrapped_magic = argument('--' + param, metavar='0/1', type=int, help=param)(wrapped_magic) return wrapped_magic
def exec_args(f): """decorator for adding block/targets args for execution applied to %pxconfig and %%px """ args = [ magic_arguments.argument( '-b', '--block', action="store_const", const=True, dest='block', help="use blocking (sync) execution", ), magic_arguments.argument( '-a', '--noblock', action="store_const", const=False, dest='block', help="use non-blocking (async) execution", ), magic_arguments.argument( '--stream', action="store_const", const=True, dest='stream', help= "stream stdout/stderr in real-time (only valid when using blocking execution)", ), magic_arguments.argument( '--no-stream', action="store_const", const=False, dest='stream', help="do not stream stdout/stderr in real-time", ), magic_arguments.argument( '-t', '--targets', type=str, help="specify the targets on which to execute", ), magic_arguments.argument( '--local', action="store_const", const=True, dest="local", help="also execute the cell in the local namespace", ), magic_arguments.argument( '--verbose', action="store_const", const=True, dest="set_verbose", help="print a message at each execution", ), magic_arguments.argument( '--no-verbose', action="store_const", const=False, dest="set_verbose", help="don't print any messages", ), ] for a in args: f = a(f) return f
def add_argument(self, *args, **kwargs): """Add argument to parser available for both IPython magic and cmd""" self.args.append(magic_arguments.argument(*args, **kwargs))
def rest_arguments(func): """Magic arguments shared by `rest` and `rest_root` commands. """ args = ( magic_arguments.magic_arguments(), magic_arguments.argument( '--verbose', '-v', action='store_true', help='Dump full HTTP session log.', default=None ), magic_arguments.argument( '--quiet', '-q', action='store_true', help='Do not print HTTP request and response.', default=None ), magic_arguments.argument( '--insecure', '-k', action='store_true', help='Disable SSL certificate verification.', default=None ), magic_arguments.argument( '--proxy', type=str, action='store', dest='proxy', help='Sets the proxy server to use for HTTP and HTTPS.', default=None ), magic_arguments.argument( '--max-redirects', type=int, action='store', dest='max_redirects', help=("Set the maximum number of redirects allowed, " "{0} by default.".format(DEFAULT_REDIRECT_LIMIT)), default=None ), magic_arguments.argument( '--timeout', type=float, action='store', dest='timeout', help=("Set the maximum number of seconds to wait for a response, " "{0} by default.".format(DEFAULT_TIMEOUT)), default=None ), magic_arguments.argument( '--extract', '-e', type=str, action='store', dest='parser_expression', metavar='expression', help='Extract parts of a response content with the given Xpath/JSONPath expression.', default=None ), magic_arguments.argument( '--parser', type=str, action='store', dest='parser', help='Set which parser to use to extract parts of a response content.', choices=ResponseParser.parsers, default=None ), func ) return functools.reduce(lambda res, f: f(res), reversed(args))
class FortranMagics(Magics): allowed_fcompilers = sorted(fcompiler.fcompiler_class.keys()) allowed_compilers = sorted(compiler_class.keys()) my_magic_arguments = compose( magic_arguments.magic_arguments(), magic_arguments.argument("-v", "--verbosity", action="count", default=0, help="increase output verbosity"), magic_arguments.argument( '--fcompiler', choices=allowed_fcompilers, help="""Specify Fortran compiler type by vendor. See %%f2py_help --fcompiler""", ), magic_arguments.argument( '--compiler', choices=allowed_compilers, help="""Specify C compiler type (as defined by distutils). See %%f2py_help --compiler"""), magic_arguments.argument('--f90flags', help="Specify F90 compiler flags"), magic_arguments.argument('--f77flags', help="Specify F77 compiler flags"), magic_arguments.argument('--opt', help="Specify optimization flags"), magic_arguments.argument( '--arch', help="Specify architecture specific optimization flags"), magic_arguments.argument('--noopt', action="store_true", help="Compile without optimization"), magic_arguments.argument('--noarch', action="store_true", help="Compile without " "arch-dependent optimization"), magic_arguments.argument('--debug', action="store_true", help="Compile with debugging " "information"), magic_arguments.argument( '--link', action='append', default=[], help="""Link extension module with LINK resource, as defined by numpy.distutils/system_info.py. E.g. to link with optimized LAPACK libraries (vecLib on MacOSX, ATLAS elsewhere), use --link lapack_opt. See also %%f2py_help --resources switch."""), magic_arguments.argument( '--extra', action='append', default=[], help= """Use --extra to pass any other argument in the f2py call. For example --extra '-L/path/to/lib/ -l<libname>' --extra '-D<define> -U<name>' --extra '-DPREPEND_FORTRAN -DUPPERCASE_FORTRAN' etc. """)) def __init__(self, shell): super(FortranMagics, self).__init__(shell=shell) self._reloads = {} self._code_cache = {} self._lib_dir = os.path.join(get_ipython_cache_dir(), 'fortran') if not os.path.exists(self._lib_dir): os.makedirs(self._lib_dir) def _import_all(self, module, verbosity=0): imported = [] for k, v in module.__dict__.items(): if not k.startswith('__'): self.shell.push({k: v}) imported.append(k) if verbosity > 0 and imported: print("\nOk. The following fortran objects " "are ready to use: %s" % ", ".join(imported)) def _run_f2py(self, argv, show_captured=False, verbosity=0): """ Here we directly call the numpy.f2py.f2py2e.run_compile() entry point, after some small amount of setup to get sys.argv and the current working directory set appropriately. """ old_argv = sys.argv old_cwd = os.getcwdu() if sys.version_info[0] == 2 else os.getcwd() try: sys.argv = ['f2py'] + list(map(str, argv)) if verbosity > 1: print("Running...\n %s" % ' '.join(sys.argv)) os.chdir(self._lib_dir) try: with capture_output() as captured: #subprocess.call(sys.argv) # Refactor subprocess call to work with jupyterhub try: p = Popen(sys.argv, stdout=PIPE, stderr=PIPE, stdin=PIPE) except OSError as e: if e.errno == errno.ENOENT: print("Couldn't find program: %r" % sys.argv[0]) return else: raise try: out, err = p.communicate(input=None) except: pass if err: sys.stderr.write(err) sys.stderr.flush() if show_captured or verbosity > 2: if out: sys.stdout.write(out) sys.stdout.flush() captured() except SystemExit as e: captured() raise UsageError(str(e)) finally: sys.argv = old_argv os.chdir(old_cwd) @magic_arguments.magic_arguments() @magic_arguments.argument( '--resources', action="store_true", help="""List system resources found by system_info.py. See also %%f2py_help --link <resource> switch. """) @magic_arguments.argument('--link', help="""Given a resource name, show what it foun. E.g. try '--link lapack. See also %%f2py_help --link <resource> switch. """) @magic_arguments.argument( '--fcompiler', action="store_true", help="List available Fortran compilers", ) @magic_arguments.argument( '--compiler', action="store_true", help="List available C compilers", ) @line_magic def f2py_help(self, line): args = magic_arguments.parse_argstring(self.f2py_help, line) if args.fcompiler: self._run_f2py(['-c', '--help-fcompiler'], True) elif args.compiler: self._run_f2py(['-c', '--help-compiler'], True) elif args.resources: self._run_f2py(['--help-link'], True) elif args.link: self._run_f2py(['--help-link', args.link], True) @my_magic_arguments @magic_arguments.argument('--defaults', action="store_true", help="Delete custom configuration " "and back to default") @line_magic def fortran_config(self, line): """ View and handle the custom configuration for %%fortran magic. %fortran_config Show the current custom configuration %fortran_config --defaults Delete the current configuration and back to defaults %fortran_config <other options> Save <other options> to use with %%fortran """ args = magic_arguments.parse_argstring(self.fortran_config, line) if args.defaults: try: del self.shell.db['fortran'] print( "Deleted custom config. Back to default arguments for %%fortran" ) except KeyError: print("No custom config found for %%fortran") elif not line: try: line = self.shell.db['fortran'] except KeyError: print("No custom config found for %%fortran") print("Current defaults arguments for %%fortran:\n\t%s" % line) else: self.shell.db['fortran'] = line print("New default arguments for %%fortran:\n\t%s" % line) @my_magic_arguments @cell_magic def fortran(self, line, cell): """Compile and import everything from a Fortran code cell, using f2py. The content of the cell is written to a `.f90` file in the directory `IPYTHONDIR/fortran` using a filename with the hash of the code. This file is then compiled. The resulting module is imported and all of its symbols are injected into the user's namespace. Usage ===== Prepend ``%%fortran`` to your fortran code in a cell:: ``%%fortran ! put your code here. `` """ try: # custom saved arguments saved_defaults = vars( magic_arguments.parse_argstring(self.fortran, self.shell.db['fortran'])) self.fortran.parser.set_defaults(**saved_defaults) except KeyError: saved_defaults = {'verbosity': 0} # verbosity is a "count" argument were each ocurrence is # added implicit. # so, for instance, -vv in %fortran_config and -vvv in %%fortran means # a nonsense verbosity=5. # To override: if verbosity is given for the magic cell # we ignore the saved config. if '-v' in line: self.fortran.parser.set_defaults(verbosity=0) args = magic_arguments.parse_argstring(self.fortran, line) # boolean flags f2py_args = ['--%s' % k for k, v in vars(args).items() if v is True] try: base_str_class = basestring except NameError: # py3 base_str_class = str kw = [ '--%s=%s' % (k, v) for k, v in vars(args).items() if isinstance(v, base_str_class) ] f2py_args.extend(kw) # link resource if args.link: resources = ['--link-%s' % r for r in args.link] f2py_args.extend(resources) if args.extra: extras = ' '.join(map(unquote, args.extra)) extras = extras.split() f2py_args.extend(extras) code = cell if cell.endswith('\n') else cell + '\n' key = code, line, sys.version_info, sys.executable, f2py2e.f2py_version module_name = "_fortran_magic_" + \ hashlib.md5(str(key).encode('utf-8')).hexdigest() module_path = os.path.join(self._lib_dir, module_name + self.so_ext) f90_file = os.path.join(self._lib_dir, module_name + '.f90') f90_file = py3compat.cast_bytes_py2( f90_file, encoding=sys.getfilesystemencoding()) with io.open(f90_file, 'w', encoding='utf-8') as f: f.write(code) self._run_f2py(f2py_args + ['-m', module_name, '-c', f90_file], verbosity=args.verbosity) self._code_cache[key] = module_name module = imp.load_dynamic(module_name, module_path) self._import_all(module, verbosity=args.verbosity) @property def so_ext(self): """The extension suffix for compiled modules.""" try: return self._so_ext except AttributeError: dist = Distribution() config_files = dist.find_config_files() try: config_files.remove('setup.cfg') except ValueError: pass dist.parse_config_files(config_files) build_extension = build_ext(dist) build_extension.finalize_options() self._so_ext = build_extension.get_ext_filename('') return self._so_ext
def add_argument(self, *args, **kwargs): self.args.append( magic_arguments.argument(*args, **kwargs) )
# Our own packages from traitlets.config.application import Application from IPython.core import magic_arguments from IPython.core.magic import Magics, magics_class, line_magic from IPython.testing.skipdoctest import skip_doctest from IPython.utils.warn import warn from IPython.core.pylabtools import backends #----------------------------------------------------------------------------- # Magic implementation classes #----------------------------------------------------------------------------- magic_gui_arg = magic_arguments.argument( 'gui', nargs='?', help="""Name of the matplotlib backend to use %s. If given, the corresponding matplotlib backend is used, otherwise it will be matplotlib's default (which you can set in your matplotlib config file). """ % str(tuple(sorted(backends.keys()))) ) @magics_class class PylabMagics(Magics): """Magics related to matplotlib's pylab support""" @skip_doctest @line_magic @magic_arguments.magic_arguments() @magic_gui_arg def matplotlib(self, line=''): """Set up matplotlib to work interactively.
def add_argument(self, *args, **kwargs): """Add argument to parser available for both IPython magic and cmd""" self.args.append( magic_arguments.argument(*args, **kwargs) )
# Our own packages from IPython.config.application import Application from IPython.core import magic_arguments from IPython.core.magic import Magics, magics_class, line_magic from IPython.testing.skipdoctest import skip_doctest from IPython.utils.warn import warn from IPython.core.pylabtools import backends #----------------------------------------------------------------------------- # Magic implementation classes #----------------------------------------------------------------------------- magic_gui_arg = magic_arguments.argument( 'gui', nargs='?', help="""Name of the matplotlib backend to use %s. If given, the corresponding matplotlib backend is used, otherwise it will be matplotlib's default (which you can set in your matplotlib config file). """ % str(tuple(sorted(backends.keys()))) ) @magics_class class PylabMagics(Magics): """Magics related to matplotlib's pylab support""" @skip_doctest @line_magic @magic_arguments.magic_arguments() @magic_gui_arg def matplotlib(self, line=''): """Set up matplotlib to work interactively.
from IPython.core import magic_arguments from IPython.core.magic import Magics, magics_class, cell_magic, line_cell_magic, line_magic from .pyamzi import Engine from .utils import find_files name_argument = magic_arguments.argument( '-n', '--name', help='Specify a name for logic server engine') @magics_class class AmziMagics(Magics): def __init__(self, shell): super(AmziMagics, self).__init__(shell) self.engines = {} def get_engine(self, args): if isinstance(args, dict): name = args.get("name", None) else: name = getattr(args, "name", None) if name is None: name = "default" if name not in self.engines: self.engines[name] = eng = Engine(name, load_init=True) return self.engines[name] @magic_arguments.magic_arguments() @name_argument @cell_magic def consult(self, line, cell):
def exec_args(f): """decorator for adding block/targets args for execution applied to %pxconfig and %%px """ args = [ magic_arguments.argument( '-b', '--block', action="store_const", const=True, dest='block', help="use blocking (sync) execution", ), magic_arguments.argument( '-a', '--noblock', action="store_const", const=False, dest='block', help="use non-blocking (async) execution", ), magic_arguments.argument( '--stream', action="store_const", const=True, dest='stream', help= "stream stdout/stderr in real-time (only valid when using blocking execution)", ), magic_arguments.argument( '--no-stream', action="store_const", const=False, dest='stream', help="do not stream stdout/stderr in real-time", ), magic_arguments.argument( '-t', '--targets', type=str, help="specify the targets on which to execute", ), magic_arguments.argument( '--local', action="store_const", const=True, dest="local", help="also execute the cell in the local namespace", ), magic_arguments.argument( '--verbose', action="store_const", const=True, dest="set_verbose", help="print a message at each execution", ), magic_arguments.argument( '--no-verbose', action="store_const", const=False, dest="set_verbose", help="don't print any messages", ), magic_arguments.argument( '--progress-after', dest="progress_after_seconds", type=float, default=None, help= """Wait this many seconds before showing a progress bar for task completion. Use -1 for no progress, 0 for always showing progress immediately. """, ), magic_arguments.argument( '--signal-on-interrupt', dest='signal_on_interrupt', type=str, default=None, help= """Send signal to engines on Keyboard Interrupt. By default a SIGINT is sent. Note that this is only applicable when running in blocking mode. Choices: SIGINT, 2, SIGKILL, 9, 0 (nop), etc. """, ), ] for a in args: f = a(f) return f
""" import itertools import sqlite3 from IPython.core.magic import Magics, magics_class, line_magic, cell_magic from IPython.core.magic_arguments import (argument, magic_arguments, parse_argstring) import texttable common_show_arguments = argument( '--limit', '-l', type=int, default=10, help=""" Maximum rows to print as table. -1 means no limit. (default: %(default)s) """) @magics_class class SQLiteMagic(Magics): @line_magic('sqlite_create') def create(self, line): """ Create in-memory SQLite DB with SQLite magic-friendly setup. """ conn = sqlite3.connect(":memory:") conn.row_factory = sqlite3.Row return conn