Esempio n. 1
0
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")
Esempio n. 2
0
    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
Esempio n. 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)
Esempio n. 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")
Esempio n. 5
0
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_)
Esempio n. 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'))
Esempio n. 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)
Esempio n. 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)
Esempio n. 9
0
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_)
Esempio n. 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
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
Esempio n. 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())
Esempio n. 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)
Esempio n. 14
0
 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)
Esempio n. 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)
Esempio n. 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())
Esempio n. 17
0
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)
Esempio n. 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)
Esempio n. 19
0
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)
Esempio n. 20
0
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)
Esempio n. 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)
Esempio n. 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
Esempio n. 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)
Esempio n. 24
0
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.'
        )
Esempio n. 25
0
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))
Esempio n. 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())))
Esempio n. 27
0
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)
Esempio n. 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)
Esempio n. 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)
Esempio n. 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
Esempio n. 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))
Esempio n. 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)
Esempio n. 33
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)
Esempio n. 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.'
        )
Esempio n. 35
0
 def _config_default(self):
     return get_config()
Esempio n. 36
0
 def __init__(self, config=None):
     super(MetricaIdsMixin, self).__init__(config=get_config())
Esempio n. 37
0
    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'