コード例 #1
0
ファイル: cli.py プロジェクト: briis/pyunifiprotect
def shell(
    username: str = OPTION_USERNAME,
    password: str = OPTION_PASSWORD,
    address: str = OPTION_ADDRESS,
    port: int = OPTION_PORT,
    verify: bool = OPTION_VERIFY,
) -> None:
    if embed is None or colored is None:
        typer.echo("ipython and termcolor required for shell subcommand")
        sys.exit(1)

    protect = ProtectApiClient(address,
                               port,
                               username,
                               password,
                               verify_ssl=verify)
    loop = asyncio.get_event_loop()
    loop.run_until_complete(protect.update(True))

    _setup_logger(show_level=True)

    c = get_config()
    c.InteractiveShellEmbed.colors = "Linux"
    embed(header=colored("protect = ProtectApiClient(*args)", "green"),
          config=c,
          using="asyncio")
コード例 #2
0
ファイル: ipy.py プロジェクト: zacsimile/python-microscopy
    def _start_ipython(self):
        self._old_stdout = sys.stdout
        self._old_stderr = sys.stderr
        self._old_stdin = sys.stdin

        try:
            print('Starting IPython')
            print('ns:', self._user_ns)
            sys.stdout = self.fw_out
            sys.__stdout__ = self.fw_out
            sys.stdin = self.fr_in
            sys.__stdin__ = self.fr_in
            #sys.stderr = self.fw_out

            import IPython
            from traitlets.config import get_config
            c = get_config()
            c.InteractiveShellEmbed.colors = "Linux"
            IPython.embed(config=c,
                          user_ns=self._user_ns,
                          user_module=self._user_module)
        finally:
            sys.stdout = self._old_stdout
            sys.__stdout__ = self._old_stdout
            sys.stdin = self._old_stdin
            sys.__stdin__ = self._old_stdin
            sys.stderr = self._old_stderr
コード例 #3
0
def _run_asyncio_ipython(loop, local_ns):
    import IPython, concurrent.futures
    original_run_cell = IPython.InteractiveShell.run_cell

    def run_cell_thread(self, *args, **kwargs):
        self.autoawait = False

        f = concurrent.futures.Future()

        def run():
            f.set_result(original_run_cell(self, *args, **kwargs))

        loop.call_soon_threadsafe(run)
        return f.result()

    IPython.InteractiveShell.run_cell = run_cell_thread

    from IPython import embed
    from traitlets.config import get_config
    _c = get_config()
    _c.InteractiveShellEmbed.colors = "Linux"
    IPython.terminal.embed.InteractiveShellEmbed(config=_c).mainloop(
        local_ns=local_ns)

    os._exit(0)
コード例 #4
0
def shell(
    username: str = OPTION_USERNAME,
    password: str = OPTION_PASSWORD,
    address: str = OPTION_ADDRESS,
    port: int = OPTION_PORT,
    verify: bool = OPTION_VERIFY,
    new: bool = OPTION_NEW,
) -> None:
    if embed is None or colored is None:
        typer.echo("ipython and termcolor required for shell subcommand")
        sys.exit(1)

    if new:
        protect: Union[UpvServer, ProtectApiClient] = ProtectApiClient(
            address, port, username, password, verify_ssl=verify
        )
    else:
        protect = UpvServer(None, address, port, username, password, verify_ssl=verify)
    loop = asyncio.get_event_loop()
    loop.run_until_complete(protect.update(True))

    console_handler = logging.StreamHandler()
    console_handler.setLevel(logging.DEBUG)
    _LOGGER.setLevel(logging.DEBUG)
    _LOGGER.addHandler(console_handler)

    klass = "UpvServer"
    if new:
        klass = "ProtectApiClient"

    c = get_config()
    c.InteractiveShellEmbed.colors = "Linux"
    embed(header=colored(f"protect = {klass}(*args)", "green"), config=c, using="asyncio")
コード例 #5
0
ファイル: shell.py プロジェクト: zhiiker/hypothesis
def ipython(**locals_):
    from IPython import start_ipython
    from traitlets.config import get_config

    c = get_config()
    c.TerminalInteractiveShell.banner2 = BANNER
    start_ipython(argv=[], config=c, user_ns=locals_)
コード例 #6
0
 def test_fails_with_args(self):
     c = get_config()
     c.ReportCmd.raise_config_file_errors = True
     c.ReportCmd.project = True
     with self.assertRaisesRegex(CmdException,
                                 "--project' takes no arguments, received"):
         list(report.ReportCmd(config=c).run('EXTRA_ARG'))
コード例 #7
0
    def test_output_input(self):
        c = get_config()
        c.ReportCmd.raise_config_file_errors = True
        c.ReportCmd.project = True
        with tempfile.TemporaryDirectory() as td:
            c.ProjectsDB.repo_path = td
            project.ProjectCmd.AddCmd(config=c).run('proj1')

            project.ProjectCmd.AddReportCmd(config=c).run('out=%s' %
                                                          _out_fpath)
            cmd = report.ReportCmd(config=c)
            res = cmd.run()
            self.assertIsInstance(res, types.GeneratorType)
            res = list(res)
            self.assertEqual(len(res), 3)
            for i in res:
                self.assertIsInstance(i, pd.DataFrame)

            project.ProjectCmd.AddReportCmd(config=c).run('inp=%s' %
                                                          _inp_fpath)
            cmd = report.ReportCmd(config=c)
            res = cmd.run()
            self.assertIsInstance(res, types.GeneratorType)
            res = list(res)
            self.assertEqual(len(res), 4)
            self.assertIsInstance(res[0], pd.Series)
            for i in res[1:]:
                self.assertIsInstance(i, pd.DataFrame)
コード例 #8
0
def cli_shell(config, environment, system):
    """Run a shell with access to the database."""

    # Suppress logging (e.g. on tab-completion)
    import logging
    logging.getLogger('parso.cache').setLevel(logging.WARNING)
    logging.getLogger('parso.python.diff').setLevel(logging.WARNING)
    logging.getLogger('urllib3.connectionpool').setLevel(logging.WARNING)
    logging.getLogger('asyncio').setLevel(logging.WARNING)
    del logging

    # Initialize the database
    try:
        ctx = server.init(config, environment, system)

    except error.ConfigNotFoundError:
        # Not good. Exit!
        sys.exit(1)

    server.app.app_context().push()
    db.sqla.create_all()

    # Run the iPython shell
    import IPython
    from traitlets.config import get_config
    c = get_config()
    c.InteractiveShellEmbed.colors = "Linux"

    print()
    IPython.embed(config=c)
コード例 #9
0
ファイル: shell.py プロジェクト: hypothesis/h
def ipython(**locals_):
    from IPython import start_ipython
    from traitlets.config import get_config

    c = get_config()
    c.TerminalInteractiveShell.banner2 = BANNER
    start_ipython(argv=[], config=c, user_ns=locals_)
コード例 #10
0
def get_ipython_config(device):
    # import os, sys, IPython

    # os.environ['PYTHONSTARTUP'] = ''  # Prevent running this again
    c = config.get_config()
    c.TerminalInteractiveShell.confirm_exit = False
    c.TerminalInteractiveShell.logstart = True
    c.TerminalInteractiveShell.logfile = '%s-interactive_aci.ipython.log' % device
    return c
コード例 #11
0
def get_ipython_config(device):
    # import os, sys, IPython

    # os.environ['PYTHONSTARTUP'] = ''  # Prevent running this again
    c = config.get_config()
    c.TerminalInteractiveShell.confirm_exit = False
    c.TerminalInteractiveShell.logstart = True
    c.TerminalInteractiveShell.logfile = '%s-interactive_aci.ipython.log' %device
    return c
コード例 #12
0
 def test_fails_when_no_project(self):
     c = get_config()
     c.ReportCmd.raise_config_file_errors = True
     c.ReportCmd.project = True
     with tempfile.TemporaryDirectory() as td:
         c.ProjectsDB.repo_path = td
         cmd = report.ReportCmd(config=c)
         with self.assertRaisesRegex(CmdException,
                                     r"No current-project exists yet!"):
             list(cmd.run())
コード例 #13
0
 def test_extract_output(self):
     c = get_config()
     c.ReportCmd.raise_config_file_errors = True
     cmd = report.ReportCmd(config=c)
     res = cmd.run('out=%s' % _out_fpath)
     self.assertIsInstance(res, types.GeneratorType)
     res = list(res)
     self.assertEqual(len(res), 3)
     for i in res:
         self.assertIsInstance(i, pd.DataFrame)
コード例 #14
0
ファイル: test_dice.py プロジェクト: ncolloel/CO2MPAS-TA
 def test_gen_conf(self):
     c = get_config()
     c.MainCmd.raise_config_file_errors = True
     cmd = dice.GenConfigCmd(config=c)
     with tempfile.TemporaryDirectory() as td:
         conf_fpath = osp.join(td, 'cc.py')
         cmd.run(conf_fpath)
         self.assertTrue(osp.isfile(conf_fpath),
                         (conf_fpath, os.listdir(osp.split(conf_fpath)[0])))
         stat = os.stat(conf_fpath)
         self.assertGreater(stat.st_size, 7000, stat)
コード例 #15
0
 def test_extract_both(self):
     c = get_config()
     c.ReportCmd.raise_config_file_errors = True
     cmd = report.ReportCmd(config=c)
     res = cmd.run('inp=%s' % _inp_fpath, 'out=%s' % _out_fpath)
     self.assertIsInstance(res, types.GeneratorType)
     res = list(res)
     self.assertEqual(len(res), 4)
     self.assertIsInstance(res[0], pd.Series)
     for i in res[1:]:
         self.assertIsInstance(i, pd.DataFrame)
コード例 #16
0
 def test_fails_when_empty(self):
     c = get_config()
     c.ReportCmd.raise_config_file_errors = True
     c.ReportCmd.project = True
     with tempfile.TemporaryDirectory() as td:
         c.ProjectsDB.repo_path = td
         project.ProjectCmd.AddCmd(config=c).run('proj1')
         cmd = report.ReportCmd(config=c)
         with self.assertRaisesRegex(
                 CmdException,
                 r"Current project 'proj1' contains no input/output files!"
         ):
             list(cmd.run())
コード例 #17
0
ファイル: server.py プロジェクト: mindrenee/vantage6-server
def cli_server_shell(ctx):
    """ Run a iPython shell. """
    # shell.init(ctx.environment)
    c = get_config()
    c.InteractiveShellEmbed.colors = "Linux"

    # Suppress logging (e.g. on tab-completion)
    import logging
    logging.getLogger('parso.cache').setLevel(logging.WARNING)
    logging.getLogger('parso.python.diff').setLevel(logging.WARNING)
    logging.getLogger('urllib3.connectionpool').setLevel(logging.WARNING)
    logging.getLogger('asyncio').setLevel(logging.WARNING)
    del logging

    IPython.embed(config=c)
コード例 #18
0
def start_ipython(options):
    colorama.init()
    comports = options.devices
    d = list()

    # Print out a mini intro to the interactive session --
    # Start with white and then magenta to keep the session white
    # (workaround for a bug in ipython)
    colors = {
        "c_default": colorama.Fore.WHITE + colorama.Style.BRIGHT,
        "c_highlight": colorama.Fore.YELLOW + colorama.Style.BRIGHT,
        "c_text": colorama.Fore.CYAN + colorama.Style.BRIGHT
    }

    print(USAGE_STRING.format(**colors))

    for dev_com in comports:
        d.append(
            Interactive(
                Uart(port=dev_com,
                     baudrate=options.baudrate,
                     device_name=dev_com.split("/")[-1])))

    device = d[0]
    send = device.acidev.write_aci_cmd  # NOQA: Ignore unused variable

    # Set iPython configuration
    c = config.get_config()
    if options.no_logfile:
        c.TerminalInteractiveShell.logstart = False
        c.InteractiveShellApp.db_log_output = False
    else:
        dt = DateTime.DateTime()
        logfile = "interactive_session_{}-{}-{}-{}.log".format(
            dt.yy(), dt.dayOfYear(), dt.hour(), dt.minute())

        c.TerminalInteractiveShell.logstart = True
        c.InteractiveShellApp.db_log_output = True
        c.TerminalInteractiveShell.logfile = logfile

    c.TerminalInteractiveShell.confirm_exit = False
    c.InteractiveShellApp.multiline_history = True
    c.InteractiveShellApp.log_level = logging.DEBUG

    IPython.embed(config=c)
    for dev in d:
        dev.close()
    raise SystemExit(0)
コード例 #19
0
ファイル: nbexecuter.py プロジェクト: ViennaChen/bokeh
def main(ipynb, kernel_name):
    print("running %s" % ipynb)
    nb = read(ipynb, as_version=4)

    config = get_config()
    config.BokehExecutePreprocessor.kernel_name = kernel_name
    print(config)
    ep = BokehExecutePreprocessor(config=config)
    ep.preprocess(nb, {'metadata': {'path': './'}})

    exportHtml = HTMLExporter()
    (body, resources) = exportHtml.from_notebook_node(nb)

    outfile = ipynb + ".html"
    open(outfile, 'w').write(body)
    print("wrote %s" % outfile)
コード例 #20
0
ファイル: nbexecuter.py プロジェクト: brianpanneton/bokeh
def main(ipynb, kernel_name):
    print("running %s" % ipynb)
    nb = read(ipynb, as_version=4)

    config = get_config()
    config.BokehExecutePreprocessor.kernel_name = kernel_name
    print(config)
    ep = BokehExecutePreprocessor(config=config)
    ep.preprocess(nb, {'metadata': {'path': './'}})

    exportHtml = HTMLExporter()
    (body, resources) = exportHtml.from_notebook_node(nb)

    outfile = ipynb + ".html"
    open(outfile, 'w').write(body)
    print("wrote %s" % outfile)
コード例 #21
0
def ipython():
    from app.database import db
    from app.main.models import User, Role
    from app.climbing.models import Session, Route
    from IPython import embed
    from traitlets.config import get_config
    c = get_config()
    c.InteractiveShellEmbed.colors = 'Linux'
    embed(user_ns={
        'db': db,
        'User': User,
        'Role': Role,
        'Session': Session,
        'Route': Route
    },
          config=c)
コード例 #22
0
def get_export_names(config=get_config()):
    """Return a list of the currently supported export targets

    Exporters can be found in external packages by registering
    them as an nbconvert.exporter entrypoint.
    """
    exporters = sorted(entrypoints.get_group_named('nbconvert.exporters'))
    enabled_exporters = []
    for exporter_name in exporters:
        try:
            e = get_exporter(exporter_name)(config=config)
            if e.enabled:
                enabled_exporters.append(exporter_name)
        except ExporterDisabledError:
            pass
    return enabled_exporters
コード例 #23
0
def ipython():
    """Open Ipython session"""
    from app.database import db
    from app.auditlog.models import Record, State, HrsaDesignation, Tag
    from IPython import embed
    from traitlets.config import get_config
    config = get_config()
    config.InteractiveShellEmbed.colors = 'Linux'
    embed(user_ns={
        'db': db,
        'Record': Record,
        'State': State,
        'HrsaDesignation': HrsaDesignation,
        'Tag': Tag,
    },
          config=config)
コード例 #24
0
ファイル: cli.py プロジェクト: shad0w008/pywinsandbox
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument(
        "-i",
        "--interactive",
        default=False,
        action="store_true",
        help=
        "Interactive mode with a `sandbox` instance available. Embeds an IPython shell."
    )
    parser.add_argument("--no-vgpu",
                        default=False,
                        action="store_true",
                        help="Disable the virtual GPU.")
    parser.add_argument("-s",
                        "--logon-script",
                        required=False,
                        help="Logon script for non-interactive (ipy) sandbox.",
                        default="")
    parser.add_argument("-f",
                        "--folder",
                        action="append",
                        help="Folders to map to the sandbox.",
                        default=[])
    args = parser.parse_args()

    sandbox = winsandbox.new_sandbox(networking=args.interactive,
                                     virtual_gpu=not args.no_vgpu,
                                     logon_script=args.logon_script,
                                     folder_mappers=[
                                         winsandbox.FolderMapper(
                                             folder_path=folder,
                                             read_only=False)
                                         for folder in args.folder
                                     ])

    if args.interactive:
        config = get_config()
        config.InteractiveShellEmbed.colors = "Neutral"  # Workaround to enable colors in embedded IPy.

        embed(
            config=config,
            header=
            'Welcome to the Windows Sandbox!\nUse the `sandbox` object to control the sandbox.'
        )
コード例 #25
0
ファイル: __main__.py プロジェクト: mekincode/uiautomator2
def cmd_console(args):
    import code
    import platform

    d = u2.connect(args.serial)
    model = d.shell("getprop ro.product.model").output.strip()
    serial = d.serial
    try:
        import IPython
        from traitlets.config import get_config
        c = get_config()
        c.InteractiveShellEmbed.colors = "Linux"
        IPython.embed(config=c)
    except ImportError:
        _vars = globals().copy()
        _vars.update(locals())
        shell = code.InteractiveConsole(_vars)
        shell.interact(banner="Python: %s\nDevice: %s(%s)" % (platform.python_version(), model, serial))
コード例 #26
0
def get_exporter(name, config=get_config()):
    """Given an exporter name or import path, return a class ready to be instantiated

    Raises ExporterName if exporter is not found or ExporterDisabledError if not enabled
    """

    if name == 'ipynb':
        name = 'notebook'

    try:
        exporter = entrypoints.get_single('nbconvert.exporters', name).load()
        if getattr(exporter(config=config), 'enabled', True):
            return exporter
        else:
            raise ExporterDisabledError(
                'Exporter "%s" disabled in configuration' % (name))
    except entrypoints.NoSuchEntryPoint:
        try:
            exporter = entrypoints.get_single('nbconvert.exporters',
                                              name.lower()).load()
            if getattr(exporter(config=config), 'enabled', True):
                return exporter
            else:
                raise ExporterDisabledError(
                    'Exporter "%s" disabled in configuration' % (name))
        except entrypoints.NoSuchEntryPoint:
            pass

    if '.' in name:
        try:
            exporter = import_item(name)
            if getattr(exporter(config=config), 'enabled', True):
                return exporter
            else:
                raise ExporterDisabledError(
                    'Exporter "%s" disabled in configuration' % (name))
        except ImportError:
            log = get_logger()
            log.error("Error importing %s" % name, exc_info=True)

    raise ExporterNameError('Unknown exporter "%s", did you mean one of: %s?' %
                            (name, ', '.join(get_export_names())))
コード例 #27
0
ファイル: picomusic.py プロジェクト: metrasynth/picomusic
def main():
    def shortname(v, k):
        return getattr(v, '__name__', k).split('.')[-1]

    user_ns = {
        'BASIC_KIT': BASIC_KIT,
        'Chord': Chord,
        'F': Fraction,
        'Fraction': Fraction,
        'Note': Note,
        'PIANO': PIANO,
        'Part': Part,
        'Phrase': Phrase,
        'dotted': lengths.dotted,
        'double_whole': lengths.double_whole,
        'drumkit': drumkit,
        'eighth': lengths.eighth,
        'half': lengths.half,
        'manager': StageManager(),
        'quarter': lengths.quarter,
        'sixteenth': lengths.sixteenth,
        'sixty_fourth': lengths.sixty_fourth,
        'thirty_second': lengths.thirty_second,
        'triplet': lengths.triplet,
        'whole': lengths.whole,
    }
    c = get_config()
    c.InteractiveShellApp.exec_lines = [
        '%gui pyglet',
    ]
    c.TerminalInteractiveShell.prompts_class = ClassicPrompts
    names = ', '.join(k if k == shortname(v, k) else f'{k} ({shortname(v, k)})'
                      for k, v in sorted(user_ns.items())) + '\n'
    width, _ = get_terminal_size()
    names = '\n'.join(wrap(names, width - 5))
    names = indent(names, '    ')
    c.InteractiveShell.banner2 = BANNER + names + '\n'
    c.InteractiveShell.confirm_exit = False
    c.InteractiveShellApp.display_banner = True
    start_ipython(config=c, user_ns=user_ns)
コード例 #28
0
    def handle(self, *args, **options):

        User = get_user_model()
        helpers = [
            ("Date", "datetime, timedelta, time"),
            ("django.utils", "timezone, termcolors, dateformat, translation."),
            ("%quickref", "Quick reference."),
            ("User", "Django Auth Model"),
            ("help", "Python's own help system."),
            ("object?", "Details about 'object'"),
            ("object??", "More Details about 'object' "),
        ]
        registered_models = {}
        for model in apps.get_models():
            module = model.__module__
            name = model.__name__
            locals()[name] = model
            try:
                registered_models[module].append(name)
            except:
                registered_models[module] = [name]

        for module in registered_models:
            helpers.append((module, ", ".join(registered_models[module])))

        banner2 = "\n".join(
            ["%s: %s" % (colorize(x, fg="yellow"), y)
             for x, y in helpers]) + "\n"
        banner = "Hi! \n\n" \
                 "Here some useful shortcuts (Crtl-D to exit):"

        c = get_config()

        c.InteractiveShell.banner1 = banner
        c.InteractiveShell.banner2 = banner2
        c.TerminalInteractiveShell.confirm_exit = False
        c.PromptManager.in_template = '$ '
        c.PromptManager.out_template = '> '

        embed(config=c)
コード例 #29
0
    def handle(self, *args, **options):
        User = get_user_model()
        helpers = [
            ("Date", "datetime, timedelta, time"),
            ("django.utils", "timezone, termcolors, dateformat, translation."),
            ("django.conf", "settings"),
            ("%quickref", "Quick reference."),
            ("User", "Django Auth Model"),
            ("help", "Python's own help system."),
            ("object?", "Details about 'object'"),
            ("object??", "More Details about 'object' "),
        ]
        registered_models = {}
        for model in apps.get_models():
            module = model.__module__
            name = model.__name__
            locals()[name] = model
            try:
                registered_models[module].append(name)
            except:
                registered_models[module] = [name]

        for module in registered_models:
            helpers.append((module, ", ".join(registered_models[module])))

        banner2 = "\n".join([
            "%s: %s" % (colorize(x, fg="yellow"), y) for x, y in helpers
        ]) + "\n" + colorize("RELOAD: \n %load_ext autoreload \n %autoreload",
                             fg="red") + "\n"
        banner = "Hi! \n\n" \
                 "Here some useful shortcuts (Crtl-D to exit):"

        c = get_config()

        c.InteractiveShell.banner1 = banner
        c.InteractiveShell.banner2 = banner2
        c.TerminalInteractiveShell.confirm_exit = False
        c.InteractiveShellApp.extensions = ['autoreload']
        c.InteractiveShellApp.exec_lines = ['%autoreload 2', 'print 1asd']
        rtx = embed(config=c)
コード例 #30
0
def get_export_names(config=get_config()):
    """Return a list of the currently supported export targets

    Exporters can be found in external packages by registering
    them as an nbconvert.exporter entrypoint.
    """
    exporters = sorted(entrypoints.get_group_named('nbconvert.exporters'))
    if os.environ.get("NBCONVERT_DISABLE_CONFIG_EXPORTERS"):
        get_logger().info(
            "Config exporter loading disabled, no additional exporters will be automatically included."
        )
        return exporters

    enabled_exporters = []
    for exporter_name in exporters:
        try:
            e = get_exporter(exporter_name)(config=config)
            if e.enabled:
                enabled_exporters.append(exporter_name)
        except (ExporterDisabledError, ValueError):
            pass
    return enabled_exporters
コード例 #31
0
    def test_bad_prefix(self):
        c = get_config()
        c.ReportCmd.raise_config_file_errors = True
        cmd = report.ReportCmd(config=c)

        arg = 'BAD_ARG'
        with self.assertRaisesRegexp(CmdException,
                                     re.escape("arg[1]: %s" % arg)):
            list(cmd.run(arg))

        arg = 'inp:BAD_ARG'
        with self.assertRaisesRegexp(CmdException,
                                     re.escape("arg[1]: %s" % arg)):
            list(cmd.run(arg))

        arg1 = 'inp:FOO'
        arg2 = 'out.BAR'
        with self.assertRaises(CmdException) as cm:
            list(cmd.run('inp=A', arg1, 'out=B', arg2))
        #print(cm.exception)
        self.assertIn("arg[2]: %s" % arg1, str(cm.exception))
        self.assertIn("arg[4]: %s" % arg2, str(cm.exception))
コード例 #32
0
def shell_command():
    """Runs an interactive Python shell in the context of a given
    Flask application.  The application will populate the default
    namespace of this shell according to it"s configuration.
    This is useful for executing small snippets of management code
    without having to manually configuring the application.

    This code snippet is taken from Flask"s cli module and modified to
    run IPython and falls back to the normal shell if IPython is not
    available.
    """
    import code

    banner = "Python %s on %s\nInstance Path: %s" % (
        sys.version,
        sys.platform,
        current_app.instance_path,
    )
    ctx = {"db": db}

    # Support the regular Python interpreter startup script if someone
    # is using it.
    startup = os.environ.get("PYTHONSTARTUP")
    if startup and os.path.isfile(startup):
        with open(startup, "r") as f:
            eval(compile(f.read(), startup, "exec"), ctx)

    ctx.update(current_app.make_shell_context())

    try:
        import IPython
        from traitlets.config import get_config

        c = get_config()
        # This makes the prompt to use colors again
        c.InteractiveShellEmbed.colors = "Linux"
        IPython.embed(config=c, banner1=banner, user_ns=ctx)
    except ImportError:
        code.interact(banner=banner, local=ctx)
コード例 #33
0
ファイル: shell.py プロジェクト: aliahmet/shell
    def handle(self, *args, **options):

        User = get_user_model()
        helpers = [
            ("Date", "datetime, timedelta, time"),
            ("django.utils", "timezone, termcolors, dateformat, translation."),
            ("%quickref", "Quick reference."),
            ("User", "Django Auth Model"),
            ("help", "Python's own help system."),
            ("object?", "Details about 'object'"),
            ("object??", "More Details about 'object' "),
        ]
        registered_models = {}
        for model in apps.get_models():
            module = model.__module__
            name = model.__name__
            locals()[name] = model
            try:
                registered_models[module].append(name)
            except:
                registered_models[module] = [name]

        for module in registered_models:
            helpers.append((module, ", ".join(registered_models[module])))

        banner2 = "\n".join(["%s: %s" % (colorize(x, fg="yellow"), y) for x, y in helpers]) + "\n"
        banner = "Hi! \n\n" \
                 "Here some useful shortcuts (Crtl-D to exit):"

        c = get_config()

        c.InteractiveShell.banner1 = banner
        c.InteractiveShell.banner2 = banner2
        c.TerminalInteractiveShell.confirm_exit = False
        c.PromptManager.in_template = '$ '
        c.PromptManager.out_template = '> '

        embed(config=c)
コード例 #34
0
def main():

    args = read_args()

    # Handle shell extension commands
    try:
        if args.register:
            register_shell_extension('Open Sandboxed')
            register_shell_extension('Run Sandboxed', cli_flags='--run')
            return
        elif args.unregister:
            unregister_shell_extension('Open Sandboxed')
            unregister_shell_extension('Run Sandboxed')
            return
    except PermissionError:
        print("Try running again as an Administrator")
        return

    # Launch a new sandbox
    sandbox = winsandbox.new_sandbox(networking=args.interactive,
                                     virtual_gpu=not args.no_vgpu,
                                     logon_script=args.logon_script,
                                     folder_mappers=[
                                         winsandbox.FolderMapper(
                                             folder_path=folder,
                                             read_only=False)
                                         for folder in args.folder
                                     ])

    if args.interactive:
        config = get_config()
        config.InteractiveShellEmbed.colors = "Neutral"  # Workaround to enable colors in embedded IPy.

        embed(
            config=config,
            header=
            'Welcome to the Windows Sandbox!\nUse the `sandbox` object to control the sandbox.'
        )
コード例 #35
0
ファイル: latextools.py プロジェクト: 12312113/ipython
 def _config_default(self):
     return get_config()
コード例 #36
0
ファイル: metrica.py プロジェクト: everware/everware
 def __init__(self, config=None):
     super(MetricaIdsMixin, self).__init__(config=get_config())
コード例 #37
0
ファイル: ipython_config.py プロジェクト: purpleP/vimconf
    background_color = '#002b36'


class SolarizedLight(Solarized):
    styles = {**solarized_common, **light}


class SolarizedDark(Solarized):
    styles = {**solarized_common, **dark}


def get_style_by_name(name, original=interactiveshell.get_style_by_name):
    if name.startswith('solarized'):
        return SolarizedDark if name.endswith('dark') else SolarizedLight
    else:
        return original(name)


interactiveshell.get_style_by_name = get_style_by_name
c = get_config()

c.TerminalInteractiveShell.highlighting_style = 'solarized_dark'
c.TerminalInteractiveShell.highlighting_style_overrides = {
    Token.Prompt: GREEN,
    Token.PromptNum: 'bold ' + GREEN,
    Token.OutPrompt: RED,
    Token.OutPromptNum: 'bold ' + RED,
}
c.TerminalInteractiveShell.true_color = True
c.TerminalInteractiveShell.editing_mode = 'vi'