예제 #1
0
def interactive(idx=0, DongleClass=RfCat, intro=''):
    global d
    import rflib.chipcon_nic as rfnic
    import atexit

    d = DongleClass(idx=idx)
    d.setModeIDLE()       # this puts the dongle into Idle mode
    atexit.register(cleanupInteractiveAtExit)

    gbls = globals()
    lcls = locals()

    try:
        import IPython.Shell
        ipsh = IPython.Shell.IPShell(argv=[''], user_ns=lcls, user_global_ns=gbls)
        print intro
        ipsh.mainloop(intro)

    except ImportError, e:
        try:
            from IPython.terminal.interactiveshell import TerminalInteractiveShell
            ipsh = TerminalInteractiveShell()
            ipsh.user_global_ns.update(gbls)
            ipsh.user_global_ns.update(lcls)
            ipsh.autocall = 2       # don't require parenthesis around *everything*.  be smart!
            ipsh.mainloop(intro)
        except ImportError, e:
            print e
            shell = code.InteractiveConsole(gbls)
            shell.interact(intro)
예제 #2
0
def repl(ctx, config, community, network, keyfile, password, trezor,
         trezor_path, derivation_path, chain, artifactdir, input, timeout):
    config = Config.from_yaml(config, Chain.from_str(chain))

    if network not in config.network_configs:
        click.echo('No such network {0} defined, check configuration', network)
        sys.exit(1)

    network = configure_network(config, network, keyfile, password, trezor,
                                trezor_path, derivation_path)
    deployer = Deployer(community, network, artifactdir)

    # Default to homechain.json/sidechain.json
    if not input:
        input = chain + 'chain.json'

    click.echo('Waiting for deployment results')
    if not wait_for_file(input, timeout):
        click.echo('Timeout waiting for deployment results file')
        sys.exit(1)

    with open(input, 'r') as f:
        deployer.load_results(f)

    user_ns = {
        'config': config,
        'network': network,
        'deployer': deployer,
    }
    shell = TerminalInteractiveShell(user_ns=user_ns)
    shell.mainloop()
예제 #3
0
def shell():
    from api.app import rowboat

    namespace = {}

    try:
        from IPython.terminal.interactiveshell import TerminalInteractiveShell
        console = TerminalInteractiveShell(user_ns=namespace)
        print 'Starting iPython Shell'
    except ImportError:
        import code
        import rlcompleter
        c = rlcompleter.Completer(namespace)

        # Setup readline for autocomplete.
        try:
            # noinspection PyUnresolvedReferences
            import readline
            readline.set_completer(c.complete)
            readline.parse_and_bind('tab: complete')
            readline.parse_and_bind('set show-all-if-ambiguous on')
            readline.parse_and_bind('"\C-r": reverse-search-history')
            readline.parse_and_bind('"\C-s": forward-search-history')

        except ImportError:
            pass

        console = code.InteractiveConsole(namespace)
        print 'Starting Poverty Shell (install IPython to use improved shell)'

    with rowboat.app.app_context():
        console.interact()
예제 #4
0
def dbg_interact(lcls, gbls):
    intro = "Let's interact!"
    try:
        import IPython.Shell
        ipsh = IPython.Shell.IPShell(argv=[''],
                                     user_ns=lcls,
                                     user_global_ns=gbls)
        print(intro)
        ipsh.mainloop()

    except ImportError as e:
        try:
            from IPython.terminal.interactiveshell import TerminalInteractiveShell
            ipsh = TerminalInteractiveShell()
            ipsh.user_global_ns.update(gbls)
            ipsh.user_global_ns.update(lcls)
            ipsh.autocall = 2  # don't require parenthesis around *everything*.  be smart!
            print(intro)
            ipsh.mainloop()
        except ImportError as e:
            try:
                from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell
                ipsh = TerminalInteractiveShell()
                ipsh.user_global_ns.update(gbls)
                ipsh.user_global_ns.update(lcls)
                ipsh.autocall = 2  # don't require parenthesis around *everything*.  be smart!

                print(intro)
                ipsh.mainloop()
            except ImportError, e:
                print(e)
                shell = code.InteractiveConsole(gbls)
                print(intro)
                shell.interact()
예제 #5
0
    def __call__(self):
        from IPython.terminal.prompts import Prompts, Token
        from IPython.terminal.interactiveshell import TerminalInteractiveShell

        token = self._token

        class RFQuackShellPrompts(Prompts):
            def in_prompt_tokens(self, cli=None):
                return [(Token, token), (Token.Prompt, '> ')]

        TerminalInteractiveShell.prompts_class = RFQuackShellPrompts
        shell = TerminalInteractiveShell()
        shell.autocall = 0
        shell.show_banner(self._banner)

        q = RFQuack(self._transport, "rfquack", shell,
                    self._select_first_dongle)
        shell_objs = dict(q=q, pb=rfquack_pb2)

        # For each message field add a fake object with the same name,
        # this to achieve a **very basic** autocomp.
        for message_type in rfquack_pb2.DESCRIPTOR.message_types_by_name.values(
        ):
            for message_field in message_type.fields:
                shell_objs[
                    message_field.
                    name] = "This is a fake variable, used for autocompletion"

        shell.push(shell_objs)

        shell.mainloop()
def get_ipython():
    from IPython.terminal.interactiveshell import TerminalInteractiveShell
    if TerminalInteractiveShell._instance:
        return TerminalInteractiveShell.instance()

    config = tools.default_config()
    config.TerminalInteractiveShell.simple_prompt = True

    # Create and initialize our test-friendly IPython instance.
    shell = TerminalInteractiveShell.instance(config=config)
    return shell
예제 #7
0
  def test_magic_registration(self, ip: TerminalInteractiveShell):
    """Test registering a magic."""
    res = ip.run_cell(raw_cell=MAGIC_DEFINITION)
    self.assertions.assertTrue(res.success)

    magics = ip.run_line_magic(magic_name='picatrixmagics', line='')
    self.assertions.assertFalse(magics[magics.name == 'my_silly_magic'].empty)

    line = ip.run_line_magic(
        magic_name='my_silly_magic', line='--magnitude 23 this is my string')

    expected_return = (
        'This magical magic produced 23 magics of this is my string')
    self.assertions.assertEqual(line, expected_return)
예제 #8
0
    def test_context_date(self, ip: TerminalInteractiveShell):
        """Test querying for contex surrounding a date."""
        _ = self._get_sketch(ip)
        df = ip.run_line_magic(
            magic_name='timesketch_context_date',
            line=
            ('--minutes 10 --fields datetime,message,data_type,event_identifier'
             ',username,workstation 2020-09-18T22:24:36'))

        self.assertions.assertTrue(df.shape[0] > 5000)
        logon_df = df[df.event_identifier == 4624]
        logged_in_users = list(logon_df.username.unique())
        self.assertions.assertTrue('Administrator' in logged_in_users)
        self.assertions.assertTrue('DWM-1' in logged_in_users)

        df.sort_values('datetime', inplace=True)
        first_series = df.iloc[0]
        last_series = df.iloc[-1]

        first_time = first_series.datetime
        last_time = last_series.datetime
        delta = last_time - first_time
        delta_rounded = delta.round('min')

        # This should be 10 minutes or 600 seconds.
        self.assertions.assertTrue(delta_rounded.total_seconds() == 600.0)
예제 #9
0
def main(obj):
    click.echo("Welcome to IPython designed for running RHAMT code.")
    ipython = TerminalInteractiveShell.instance()

    for code_import in IMPORTS:
        click.echo(f"> {code_import}")
        ipython.run_cell(code_import)

    # create default app
    ipython.run_cell("app = Application()")
    click.echo("> app = $magic Application")

    from rhamt.utils.path import CONF_PATH

    custom_import_path = CONF_PATH / "rhmt_shell_startup.py"

    if custom_import_path.exists():
        with open(custom_import_path, "r") as custom_import_file:
            custom_import_code = custom_import_file.read()
        click.echo(f"Importing custom code:\n{custom_import_code.strip()}")
        ipython.run_cell(custom_import_code)
    else:
        click.echo(
            "You can create your own python file with imports you use frequently. "
            "Just create a conf/rhmt_shell_startup.py file in your repo. "
            "This file can contain arbitrary python code that is executed in this context."
        )
    ipython.interact()
예제 #10
0
 def test_list_views(self, ip: TerminalInteractiveShell):
     """Test listing up the available views for a sketch."""
     _ = self._get_sketch(ip)
     views = ip.run_line_magic(magic_name='timesketch_list_views', line='')
     expected_views = set(
         ['18:Szechuan Hits', '19:Szechuan All Hits', '16:email_addresses'])
     self.assertions.assertEqual(set(views.keys()), expected_views)
예제 #11
0
파일: shell.py 프로젝트: DXist/pudb
def run_ipython_shell_v11(locals, globals, first_time):
    '''IPython shell from IPython version 0.11'''
    if first_time:
        banner = "Hit Ctrl-D to return to PuDB."
    else:
        banner = ""

    try:
        # IPython 1.0 got rid of the frontend intermediary, and complains with
        # a deprecated warning when you use it.
        from IPython.terminal.interactiveshell import TerminalInteractiveShell
        from IPython.terminal.ipapp import load_default_config
    except ImportError:
        from IPython.frontend.terminal.interactiveshell import \
                TerminalInteractiveShell
        from IPython.frontend.terminal.ipapp import load_default_config
    # XXX: in the future it could be useful to load a 'pudb' config for the
    # user (if it exists) that could contain the user's macros and other
    # niceities.
    config = load_default_config()
    shell = TerminalInteractiveShell.instance(config=config,
            banner2=banner)
    # XXX This avoids a warning about not having unique session/line numbers.
    # See the HistoryManager.writeout_cache method in IPython.core.history.
    shell.history_manager.new_session()
    # Save the originating namespace
    old_locals = shell.user_ns
    old_globals = shell.user_global_ns
    # Update shell with current namespace
    _update_ns(shell, locals, globals)
    shell.mainloop(banner)
    # Restore originating namespace
    _update_ns(shell, old_locals, old_globals)
예제 #12
0
def main():
    """Use quickstart to ensure we have correct env, then execute imports in ipython and done."""
    quickstart.main(
        quickstart.parser.parse_args(['--mk-virtualenv', sys.prefix]))
    print('Welcome to IPython designed for running CFME QE code.')
    ipython = TerminalInteractiveShell.instance()
    from cfme.utils import appliance
    appliance.CREATE_IS_PEDANTIC = False
    for code_import in IMPORTS:
        print('> {}'.format(code_import))
        ipython.run_cell(code_import)
    from cfme.utils.path import conf_path
    custom_import_path = conf_path.join('miq_python_startup.py')
    if custom_import_path.exists():
        with open(custom_import_path.strpath, 'r') as custom_import_file:
            custom_import_code = custom_import_file.read()
        print('Importing custom code:\n{}'.format(custom_import_code.strip()))
        ipython.run_cell(custom_import_code)
    else:
        print(
            'You can create your own python file with imports you use frequently. '
            'Just create a conf/miq_python_startup.py file in your repo. '
            'This file can contain arbitrary python code that is executed in this context.'
        )
    ipython.interact()
예제 #13
0
    def __init__(self, color_scheme=None, completekey=None, stdin=None, stdout=None, context=5):

        # Parent constructor:
        try:
            self.context = int(context)
            if self.context <= 0:
                raise ValueError("Context must be a positive integer")
        except (TypeError, ValueError):
            raise ValueError("Context must be a positive integer")

        OldPdb.__init__(self, completekey, stdin, stdout)

        # IPython changes...
        self.shell = get_ipython()

        if self.shell is None:
            # No IPython instance running, we must create one
            from IPython.terminal.interactiveshell import TerminalInteractiveShell

            self.shell = TerminalInteractiveShell.instance()

        if color_scheme is not None:
            warnings.warn("The `color_scheme` argument is deprecated since version 5.1", DeprecationWarning)
        else:
            color_scheme = self.shell.colors

        self.aliases = {}

        # Create color table: we copy the default one from the traceback
        # module and add a few attributes needed for debugging
        self.color_scheme_table = exception_colors()

        # shorthands
        C = coloransi.TermColors
        cst = self.color_scheme_table

        cst["NoColor"].colors.prompt = C.NoColor
        cst["NoColor"].colors.breakpoint_enabled = C.NoColor
        cst["NoColor"].colors.breakpoint_disabled = C.NoColor

        cst["Linux"].colors.prompt = C.Green
        cst["Linux"].colors.breakpoint_enabled = C.LightRed
        cst["Linux"].colors.breakpoint_disabled = C.Red

        cst["LightBG"].colors.prompt = C.Blue
        cst["LightBG"].colors.breakpoint_enabled = C.LightRed
        cst["LightBG"].colors.breakpoint_disabled = C.Red

        cst["Neutral"].colors.prompt = C.Blue
        cst["Neutral"].colors.breakpoint_enabled = C.LightRed
        cst["Neutral"].colors.breakpoint_disabled = C.Red

        self.set_colors(color_scheme)

        # Add a python parser so we can syntax highlight source while
        # debugging.
        self.parser = PyColorize.Parser()

        # Set the prompt - the default prompt is '(Pdb)'
        self.prompt = prompt
예제 #14
0
def main(no_quickstart):
    """Use quickstart to ensure we have correct env, then execute imports in ipython and done."""
    if not no_quickstart:
        from cfme.scripting import quickstart

        quickstart.main(quickstart.args_for_current_venv())
    print('Welcome to IPython designed for running CFME QE code.')
    ipython = TerminalInteractiveShell.instance()
    for code_import in IMPORTS:
        print('> {}'.format(code_import))
        ipython.run_cell(code_import)
    from cfme.utils.path import conf_path
    custom_import_path = conf_path.join('miq_python_startup.py')
    if custom_import_path.exists():
        with open(custom_import_path.strpath, 'r') as custom_import_file:
            custom_import_code = custom_import_file.read()
        print('Importing custom code:\n{}'.format(custom_import_code.strip()))
        ipython.run_cell(custom_import_code)
    else:
        print(
            'You can create your own python file with imports you use frequently. '
            'Just create a conf/miq_python_startup.py file in your repo. '
            'This file can contain arbitrary python code that is executed in this context.'
        )
    ipython.interact()
예제 #15
0
def run_ipython_shell_v11(locals, globals, first_time):
    '''IPython shell from IPython version 0.11'''
    if first_time:
        banner = "Hit Ctrl-D to return to PuDB."
    else:
        banner = ""

    try:
        # IPython 1.0 got rid of the frontend intermediary, and complains with
        # a deprecated warning when you use it.
        from IPython.terminal.interactiveshell import TerminalInteractiveShell
        from IPython.terminal.ipapp import load_default_config
    except ImportError:
        from IPython.frontend.terminal.interactiveshell import \
                TerminalInteractiveShell
        from IPython.frontend.terminal.ipapp import load_default_config
    # XXX: in the future it could be useful to load a 'pudb' config for the
    # user (if it exists) that could contain the user's macros and other
    # niceities.
    config = load_default_config()
    shell = TerminalInteractiveShell.instance(config=config, banner2=banner)
    # XXX This avoids a warning about not having unique session/line numbers.
    # See the HistoryManager.writeout_cache method in IPython.core.history.
    shell.history_manager.new_session()
    # Save the originating namespace
    old_locals = shell.user_ns
    old_globals = shell.user_global_ns
    # Update shell with current namespace
    _update_ns(shell, locals, globals)
    shell.mainloop(banner)
    # Restore originating namespace
    _update_ns(shell, old_locals, old_globals)
예제 #16
0
 def _setup_client(self, ip: TerminalInteractiveShell):
     """Setup the TimesketchAPI object into the IPython session."""
     ip.run_cell(raw_cell='from timesketch_api_client import client')
     res = ip.run_cell(
         raw_cell=('_client = client.TimesketchApi(\n'
                   '    host_uri="https://demo.timesketch.org",\n'
                   '    username="******",\n'
                   '    password="******",\n'
                   '    verify=True,\n'
                   '    auth_mode="userpass")'))
     self.assertions.assertTrue(res.success)
     res = ip.run_cell(raw_cell=(
         'from picatrix.lib import state\n'
         'state_obj = state.state()\n'
         'state_obj.add_to_cache(\'timesketch_client\', _client)\n'))
     self.assertions.assertTrue(res.success)
예제 #17
0
def get_python_console(namespace=None):
    """
    Return a interactive python console instance with caller's stack
    """

    if namespace is None:
        import inspect

        frame = inspect.currentframe()
        caller = frame.f_back
        if not caller:
            logging.error("can't find caller who start this console.")
            caller = frame
        namespace = dict(caller.f_globals)
        namespace.update(caller.f_locals)

    try:
        from IPython.terminal.interactiveshell import TerminalInteractiveShell

        shell = TerminalInteractiveShell(user_ns=namespace)
    except ImportError:
        try:
            import readline
            import rlcompleter

            readline.set_completer(rlcompleter.Completer(namespace).complete)
            readline.parse_and_bind("tab: complete")
        except ImportError:
            pass
        import code

        shell = code.InteractiveConsole(namespace)
        shell._quit = False

        def exit():
            shell._quit = True

        def readfunc(prompt=""):
            if shell._quit:
                raise EOFError
            return six.moves.input(prompt)

        # inject exit method
        shell.ask_exit = exit
        shell.raw_input = readfunc

    return shell
예제 #18
0
def get_jeanmishell():
    try:
        import IPython.Shell
        return IPython.Shell.IPShell(argv=[''], user_ns=locals(), user_global_ns=globals())
    except ImportError as e:
        try:
            from IPython.terminal.interactiveshell import TerminalInteractiveShell
        except ImportError:
            try:
                from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell
            except ImportError:
                return None
        ipsh = TerminalInteractiveShell()
        ipsh.user_global_ns.update(globals())
        ipsh.user_global_ns.update(locals())
        ipsh.autocall = 2
        return ipsh
예제 #19
0
 def _get_shell(self):
     if ipy.get_ipython() is None:
         shell = ipy_shell.instance()
         if shell is None:
             self._create_profile()
             self._get_shell()
         shell.user_ns['shell'] = shell
     return ipy.get_ipython()
예제 #20
0
파일: ishell.py 프로젝트: wakenmeng/js_tree
        def init_shell(self):
            banner1 = 'Umeng development shell, do whatever you want.\n' if DEVELOP_MODE else \
                'Umeng production shell, use it carefully!\n'
            self.shell = TerminalInteractiveShell.instance(config=self.config,
                                                           display_banner=False, profile_dir=self.profile_dir,
                                                           ipython_dir=self.ipython_dir, banner1=banner1, banner2='')

            self.shell.configurables.append(self)
예제 #21
0
 def prefilter(self, IP, line, continuation):
     """prefilter pre-processes input to do PyRAF substitutions before
        passing it on to IPython.
        NOTE: this is ONLY used for VERY_OLD_IPY, since we use the transform
        hooks for the later versions.
     """
     line = self.cmd(str(line))  # use type str here, not unicode
     return TerminalInteractiveShell._prefilter(IP, line, continuation)
예제 #22
0
    def __init__(self,color_scheme='NoColor',completekey=None,
                 stdin=None, stdout=None, context=5):

        # Parent constructor:
        try:
            self.context=int(context)
            if self.context <= 0:
                raise ValueError("Context must be a positive integer")
        except (TypeError, ValueError):
                raise ValueError("Context must be a positive integer")

        OldPdb.__init__(self,completekey,stdin,stdout)

        # IPython changes...
        self.shell = get_ipython()

        if self.shell is None:
            # No IPython instance running, we must create one
            from IPython.terminal.interactiveshell import \
                TerminalInteractiveShell
            self.shell = TerminalInteractiveShell.instance()

        self.aliases = {}

        # Create color table: we copy the default one from the traceback
        # module and add a few attributes needed for debugging
        self.color_scheme_table = exception_colors()

        # shorthands
        C = coloransi.TermColors
        cst = self.color_scheme_table

        cst['NoColor'].colors.prompt = C.NoColor
        cst['NoColor'].colors.breakpoint_enabled = C.NoColor
        cst['NoColor'].colors.breakpoint_disabled = C.NoColor

        cst['Linux'].colors.prompt = C.Green
        cst['Linux'].colors.breakpoint_enabled = C.LightRed
        cst['Linux'].colors.breakpoint_disabled = C.Red

        cst['LightBG'].colors.prompt = C.Blue
        cst['LightBG'].colors.breakpoint_enabled = C.LightRed
        cst['LightBG'].colors.breakpoint_disabled = C.Red

        self.set_colors(color_scheme)

        # Add a python parser so we can syntax highlight source while
        # debugging.
        self.parser = PyColorize.Parser()

        # Set the prompt - the default prompt is '(Pdb)'
        Colors = cst.active_colors
        if color_scheme == 'NoColor':
            self.prompt = prompt
        else:
            # The colour markers are wrapped by bytes 01 and 02 so that readline
            # can calculate the width.
            self.prompt = u'\x01%s\x02%s\x01%s\x02' % (Colors.prompt, prompt, Colors.Normal)
예제 #23
0
def dbg_interact(lcls, gbls, intro=None):
    shelltype = STYPE_NONE

    if intro is None:
        intro = "Let's interact!"

    print(intro)
    try:
        from IPython import embed
        shelltype = STYPE_IPYTHON_NEW

    except ImportError as e:
        try:
            import IPython.Shell
            ipsh = IPython.Shell.IPShell(argv=[''],
                                         user_ns=lcls,
                                         user_global_ns=gbls)
            shelltype = STYPE_IPYTHON

        except ImportError as e:
            try:
                from IPython.terminal.interactiveshell import TerminalInteractiveShell
                ipsh = TerminalInteractiveShell()
                ipsh.user_global_ns.update(gbls)
                ipsh.user_global_ns.update(lcls)
                ipsh.autocall = 2  # don't require parenthesis around *everything*.  be smart!
                shelltype = STYPE_IPYTHON

            except ImportError as e:
                try:
                    from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell
                    ipsh = TerminalInteractiveShell()
                    ipsh.user_global_ns.update(gbls)
                    ipsh.user_global_ns.update(lcls)
                    ipsh.autocall = 2  # don't require parenthesis around *everything*.  be smart!
                    shelltype = STYPE_IPYTHON

                except ImportError as e:
                    print(e)
                    shell = code.InteractiveConsole(gbls)
                    shelltype = STYPE_IPYTHON

    if shelltype == STYPE_IPYTHON_NEW:
        globals().update(gbls)
        locals().update(lcls)
        embed()

    elif shelltype == STYPE_IPYTHON:
        ipsh.mainloop()

    elif shelltype == STYPE_CODE_INTERACT:
        shell.interact()

    else:
        print("SORRY, NO INTERACTIVE OPTIONS AVAILABLE!!  wtfo?")
예제 #24
0
 def init_shell(self):
     self.shell = TerminalInteractiveShell(prompts_class=MyPrompt,
                                           highlighting_style='emacs',
                                           display_banner=False,
                                           profile_dir=self.profile_dir,
                                           ipython_dir=self.ipython_dir,
                                           banner1=get_banner(),
                                           banner2='')
     self.shell.configurables.append(self)
예제 #25
0
def run():
    shell = TerminalInteractiveShell.instance()
    shell.user_ns['shell'] = shell
    shell.define_macro('x', 'a,b=1,2')
    shell.define_macro('y', 'a,b=3,4')
    shell.config['using'] = True
    a, b = 0, 0
    x, y = shell.user_ns['x'], shell.user_ns['y']
    ipy.embed(display_banner=False, config=shell.config)
예제 #26
0
 def init_shell(self):
     self.shell = TerminalInteractiveShell.instance(
         config=self.config,
         display_banner=False,
         profile_dir=self.profile_dir,
         ipython_dir=self.ipython_dir,
         banner1=get_banner(),
         banner2='')
     self.shell.configurables.append(self)
예제 #27
0
def main():
    ipython = TerminalInteractiveShell.instance()
    for import_statement in DEFAULT_IMPORTS:
        click.echo(f'> {import_statement}')
        ipython.run_cell(import_statement)
        # This can be improved to read a default conf file location
        # So that users can write their own default imports for their local clone

    ipython.interact()
예제 #28
0
    def __init__(self,
                 color_scheme='NoColor',
                 completekey=None,
                 stdin=None,
                 stdout=None,
                 context=5):

        # Parent constructor:
        try:
            self.context = int(context)
            if self.context <= 0:
                raise ValueError("Context must be a positive integer")
        except (TypeError, ValueError):
            raise ValueError("Context must be a positive integer")

        OldPdb.__init__(self, completekey, stdin, stdout)

        # IPython changes...
        self.shell = get_ipython()

        if self.shell is None:
            # No IPython instance running, we must create one
            from IPython.terminal.interactiveshell import \
                TerminalInteractiveShell
            self.shell = TerminalInteractiveShell.instance()

        self.aliases = {}

        # Create color table: we copy the default one from the traceback
        # module and add a few attributes needed for debugging
        self.color_scheme_table = exception_colors()

        # shorthands
        C = coloransi.TermColors
        cst = self.color_scheme_table

        cst['NoColor'].colors.prompt = C.NoColor
        cst['NoColor'].colors.breakpoint_enabled = C.NoColor
        cst['NoColor'].colors.breakpoint_disabled = C.NoColor

        cst['Linux'].colors.prompt = C.Green
        cst['Linux'].colors.breakpoint_enabled = C.LightRed
        cst['Linux'].colors.breakpoint_disabled = C.Red

        cst['LightBG'].colors.prompt = C.Blue
        cst['LightBG'].colors.breakpoint_enabled = C.LightRed
        cst['LightBG'].colors.breakpoint_disabled = C.Red

        self.set_colors(color_scheme)

        # Add a python parser so we can syntax highlight source while
        # debugging.
        self.parser = PyColorize.Parser()

        # Set the prompt - the default prompt is '(Pdb)'
        self.prompt = prompt
예제 #29
0
파일: ishell.py 프로젝트: wakenmeng/js_tree
def main():
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "cto_tree.settings")
    try:
        if len(sys.argv) >= 2 and sys.argv[1] == '--plain':
            raise ImportError
        user_ns = locals()
        if has_ushell:
            app = UmengIPythonApp.instance()
            app.initialize()
            app.shell.user_ns.update(user_ns)
            sys.exit(app.start())
        else:
            from IPython.terminal.interactiveshell import TerminalInteractiveShell
            shell = TerminalInteractiveShell(user_ns=user_ns)
            shell.mainloop()
    except ImportError:
        import code
        shell = code.InteractiveConsole(locals=locals())
        shell.interact()
예제 #30
0
파일: ipapp.py 프로젝트: lynch1972/ipython
 def init_shell(self):
     """initialize the InteractiveShell instance"""
     # Create an InteractiveShell instance.
     # shell.display_banner should always be False for the terminal
     # based app, because we call shell.show_banner() by hand below
     # so the banner shows *before* all extension loading stuff.
     self.shell = TerminalInteractiveShell.instance(parent=self,
                     display_banner=False, profile_dir=self.profile_dir,
                     ipython_dir=self.ipython_dir, user_ns=self.user_ns)
     self.shell.configurables.append(self)
예제 #31
0
 def init_shell(self):
     """initialize the InteractiveShell instance"""
     # Create an InteractiveShell instance.
     # shell.display_banner should always be False for the terminal
     # based app, because we call shell.show_banner() by hand below
     # so the banner shows *before* all extension loading stuff.
     self.shell = TerminalInteractiveShell.instance(parent=self,
                     display_banner=False, profile_dir=self.profile_dir,
                     ipython_dir=self.ipython_dir, user_ns=self.user_ns)
     self.shell.configurables.append(self)
예제 #32
0
def get_python_console(namespace=None):
    """
    Return a interactive python console instance with caller's stack
    """

    if namespace is None:
        import inspect
        frame = inspect.currentframe()
        caller = frame.f_back
        if not caller:
            logging.error("can't find caller who start this console.")
            caller = frame
        namespace = dict(caller.f_globals)
        namespace.update(caller.f_locals)

    try:
        from IPython.terminal.interactiveshell import TerminalInteractiveShell
        shell = TerminalInteractiveShell(user_ns=namespace)
    except ImportError:
        try:
            import readline
            import rlcompleter
            readline.set_completer(rlcompleter.Completer(namespace).complete)
            readline.parse_and_bind("tab: complete")
        except ImportError:
            pass
        import code
        shell = code.InteractiveConsole(namespace)
        shell._quit = False

        def exit():
            shell._quit = True

        def readfunc(prompt=""):
            if shell._quit:
                raise EOFError
            return six.moves.input(prompt)

        # inject exit method
        shell.ask_exit = exit
        shell.raw_input = readfunc

    return shell
예제 #33
0
파일: shell.py 프로젝트: CMGS/eru-core
 def init_shell(self):
     self.shell = TerminalInteractiveShell.instance(
         config=self.config,
         display_banner=False,
         profile_dir=self.profile_dir,
         ipython_dir=self.ipython_dir,
         banner1=get_banner(),
         banner2=''
     )
     self.shell.configurables.append(self)
    def setUp(self) -> None:
        super().setUp()

        ip = get_ipython()
        if ip is None:
            ip = TerminalInteractiveShell().instance()
        self.ip = ip

        self.ip.magic('load_ext graph_notebook.magics')
        self.ip.run_cell_magic('graph_notebook_config', '',
                               json.dumps(self.config.to_dict()))
예제 #35
0
 def run(self):
     install.run(self)
     try:
         from IPython.terminal.interactiveshell import TerminalInteractiveShell
         startup_dir = TerminalInteractiveShell.instance().get_ipython(
         ).profile_dir.startup_dir
         copyfile(os.path.join(here, 'ipypandex', '__init__.py'),
                  os.path.join(startup_dir, '90-ipypandex.py'))
     except ModuleNotFoundError:
         raise RuntimeError(
             "ipypandex requires an ipython installation to work")
예제 #36
0
    def post_mortem(self):
        try:
            traceback.print_exc()
            tb = sys.exc_info()[2]

            if self.force_ipdb or is_ipython():
                # https://github.com/gotcha/ipdb/blob/master/ipdb/__main__.py
                from IPython.terminal.interactiveshell import (
                    TerminalInteractiveShell)
                p = TerminalInteractiveShell().debugger_cls()
                p.botframe = sys._getframe().f_back  # I do not know why this
                # is nessesary, but without this hack it does not work
                p.interaction(None, tb)
            else:
                pdb.post_mortem(tb)
        except Exception as e:
            print('#' * 40)
            print('debug_on does not alwais work with sacred. '
                  'Use -D for sacred applications')
            print('#' * 40)
            raise e
예제 #37
0
 def raw_input(self, *args, **kw):
     try:
         return TerminalInteractiveShell.raw_input(self,
             *args, **kw) # needs decoding (see below)?
     except EOFError:
         r = raw_input("Do you wish to commit your "
                     "database changes? [yes]")
         if not r.lower().startswith("n"):
             if using_sqlalchemy:
                 self.push("session.flush()")
             else:
                 self.push("hub.commit()")
         raise EOFError
예제 #38
0
파일: shell.py 프로젝트: inducer/pudb
def run_ipython_shell_v11(globals, locals):
    """IPython shell from IPython version 0.11"""
    if SHELL_FIRST_TIME:
        banner = "Hit Ctrl-D to return to PuDB."
        SHELL_FIRST_TIME.pop()
    else:
        banner = ""

    try:
        # IPython 1.0 got rid of the frontend intermediary, and complains with
        # a deprecated warning when you use it.
        from IPython.terminal.interactiveshell import TerminalInteractiveShell
        from IPython.terminal.ipapp import load_default_config
    except ImportError:
        from IPython.frontend.terminal.interactiveshell import \
                TerminalInteractiveShell
        from IPython.frontend.terminal.ipapp import load_default_config
    # XXX: in the future it could be useful to load a 'pudb' config for the
    # user (if it exists) that could contain the user's macros and other
    # niceities.
    config = load_default_config()
    shell = TerminalInteractiveShell.instance(config=config, banner2=banner)
    # XXX This avoids a warning about not having unique session/line numbers.
    # See the HistoryManager.writeout_cache method in IPython.core.history.
    shell.history_manager.new_session()
    # Save the originating namespace
    old_locals = shell.user_ns
    old_globals = shell.user_global_ns

    # Update shell with current namespace
    _update_ipython_ns(shell, globals, locals)

    args = []
    if ipython_version() < (5, 0, 0):
        args.append(banner)
    else:
        print(banner)

    # XXX Quick and dirty way to fix issues with IPython 8.0.0+, introduced
    # by commit 08d54c0e367b535fd88aca5273fd09e5e70d08f8.
    # Setting _atexit_once_called = True will prevent call to
    # IPython.core.interactiveshell.InteractiveShell._atexit_once() from inside
    # IPython.terminal.interactiveshell.TerminalInteractiveShell.mainloop()
    # This allows us to repeatedly re-call mainloop() and the whole
    # run_ipython_shell_v11() function
    shell._atexit_once_called = True
    shell.mainloop(*args)
    del shell._atexit_once_called

    # Restore originating namespace
    _update_ipython_ns(shell, old_globals, old_locals)
예제 #39
0
def main():
    """Use quickstart to ensure we have correct env, then execute imports in ipython and done."""
    quickstart.main(quickstart.parser.parse_args(['--mk-virtualenv', sys.prefix]))
    print('Welcome to IPython designed for running CFME QE code.')
    ipython = TerminalInteractiveShell.instance()
    for code_import in IMPORTS:
        print('> {}'.format(code_import))
        ipython.run_cell(code_import)
    from cfme.utils.path import conf_path
    custom_import_path = conf_path.join('miq_python_startup.py')
    if custom_import_path.exists():
        with open(custom_import_path.strpath, 'r') as custom_import_file:
            custom_import_code = custom_import_file.read()
        print('Importing custom code:\n{}'.format(custom_import_code.strip()))
        ipython.run_cell(custom_import_code)
    else:
        print(
            'You can create your own python file with imports you use frequently. '
            'Just create a conf/miq_python_startup.py file in your repo. '
            'This file can contain arbitrary python code that is executed in this context.')
    ipython.interact()
예제 #40
0
def interactive(idx=0, DongleClass=RfCat, intro=''):
    global d
    import rflib.chipcon_nic as rfnic
    import atexit

    d = DongleClass(idx=idx)
    d.setModeRX()       # this puts the dongle into receive mode
    atexit.register(cleanupInteractiveAtExit)

    gbls = globals()
    lcls = locals()

    try:
        import IPython.Shell
        ipsh = IPython.Shell.IPShell(argv=[''], user_ns=lcls, user_global_ns=gbls)
        print intro
        ipsh.mainloop(intro)

    except ImportError, e:
        try:
            from IPython.terminal.interactiveshell import TerminalInteractiveShell
            ipsh = TerminalInteractiveShell()
            ipsh.user_global_ns.update(gbls)
            ipsh.user_global_ns.update(lcls)
            ipsh.autocall = 2       # don't require parenthesis around *everything*.  be smart!
            ipsh.mainloop(intro)
        except ImportError, e:
            try:
                from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell
                ipsh = TerminalInteractiveShell()
                ipsh.user_global_ns.update(gbls)
                ipsh.user_global_ns.update(lcls)
                ipsh.autocall = 2       # don't require parenthesis around *everything*.  be smart!
                ipsh.mainloop(intro)
            except ImportError, e:
                print e
                shell = code.InteractiveConsole(gbls)
                shell.interact(intro)
예제 #41
0
def interactive(port='/dev/ttyACM0', InterfaceClass=CanInterface, intro='', load_filename=None):
    global c
    import atexit

    c = InterfaceClass(port=port, load_filename=load_filename)
    atexit.register(cleanupInteractiveAtExit)

    gbls = globals()
    lcls = locals()

    try:
        import IPython.Shell
        ipsh = IPython.Shell.IPShell(argv=[''], user_ns=lcls, user_global_ns=gbls)
        print intro
        ipsh.mainloop(intro)

    except ImportError, e:
        try:
            from IPython.terminal.interactiveshell import TerminalInteractiveShell
            ipsh = TerminalInteractiveShell()
            ipsh.user_global_ns.update(gbls)
            ipsh.user_global_ns.update(lcls)
            ipsh.autocall = 2       # don't require parenthesis around *everything*.  be smart!
            ipsh.mainloop(intro)
        except ImportError, e:
            try:
                from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell
                ipsh = TerminalInteractiveShell()
                ipsh.user_global_ns.update(gbls)
                ipsh.user_global_ns.update(lcls)
                ipsh.autocall = 2       # don't require parenthesis around *everything*.  be smart!
                ipsh.mainloop(intro)
            except ImportError, e:
                print e
                shell = code.InteractiveConsole(gbls)
                shell.interact(intro)
 def __init__(self, *args, **kwargs):        
     #Initialization based on: from IPython.testing.globalipapp import start_ipython
     
     self._curr_exec_line = 0
     # Store certain global objects that IPython modifies
     _displayhook = sys.displayhook
     _excepthook = sys.excepthook
 
     # Create and initialize our IPython instance.
     shell = TerminalInteractiveShell.instance()
 
     shell.showtraceback = _showtraceback
     # IPython is ready, now clean up some global state...
     
     # Deactivate the various python system hooks added by ipython for
     # interactive convenience so we don't confuse the doctest system
     sys.displayhook = _displayhook
     sys.excepthook = _excepthook
 
     # So that ipython magics and aliases can be doctested (they work by making
     # a call into a global _ip object).  Also make the top-level get_ipython
     # now return this without recursively calling here again.
     get_ipython = shell.get_ipython
     try:
         import __builtin__
     except:
         import builtins as __builtin__
     __builtin__._ip = shell
     __builtin__.get_ipython = get_ipython
     
     # We want to print to stdout/err as usual.
     io.stdout = original_stdout
     io.stderr = original_stderr
 
     
     self._curr_exec_lines = []
     self.ipython = shell
예제 #43
0
def ipython():
    config = default_config()
    config.TerminalInteractiveShell.simple_prompt = True
    shell = TerminalInteractiveShell.instance(config=config)
    return shell
예제 #44
0
def start_ipython():
    """Start a global IPython shell, which we need for IPython-specific syntax.
    """
    global get_ipython

    # This function should only ever run once!
    if hasattr(start_ipython, 'already_called'):
        return
    start_ipython.already_called = True

    # Store certain global objects that IPython modifies
    _displayhook = sys.displayhook
    _excepthook = sys.excepthook
    _main = sys.modules.get('__main__')

    # Create custom argv and namespaces for our IPython to be test-friendly
    config = tools.default_config()

    # Create and initialize our test-friendly IPython instance.
    shell = TerminalInteractiveShell.instance(config=config,
                                              )

    # A few more tweaks needed for playing nicely with doctests...

    # remove history file
    shell.tempfiles.append(config.HistoryManager.hist_file)

    # These traps are normally only active for interactive use, set them
    # permanently since we'll be mocking interactive sessions.
    shell.builtin_trap.activate()

    # Modify the IPython system call with one that uses getoutput, so that we
    # can capture subcommands and print them to Python's stdout, otherwise the
    # doctest machinery would miss them.
    shell.system = py3compat.MethodType(xsys, shell)
    
    shell._showtraceback = py3compat.MethodType(_showtraceback, shell)

    # IPython is ready, now clean up some global state...

    # Deactivate the various python system hooks added by ipython for
    # interactive convenience so we don't confuse the doctest system
    sys.modules['__main__'] = _main
    sys.displayhook = _displayhook
    sys.excepthook = _excepthook

    # So that ipython magics and aliases can be doctested (they work by making
    # a call into a global _ip object).  Also make the top-level get_ipython
    # now return this without recursively calling here again.
    _ip = shell
    get_ipython = _ip.get_ipython
    builtin_mod._ip = _ip
    builtin_mod.get_ipython = get_ipython

    # To avoid extra IPython messages during testing, suppress io.stdout/stderr
    io.stdout = StreamProxy('stdout')
    io.stderr = StreamProxy('stderr')
    
    # Override paging, so we don't require user interaction during the tests.
    def nopage(strng, start=0, screen_lines=0, pager_cmd=None):
        print(strng)
    
    page.orig_page = page.page
    page.page = nopage

    return _ip
예제 #45
0
파일: cli.py 프로젝트: subecho/Iridium
 def raw_input(self, prompt=""):
     # TODO correct eof issue with custom prompt.
     prompt = "iridium >>>"
     return TerminalInteractiveShell.raw_input(self, prompt)
예제 #46
0
    def __init__(self, color_scheme="NoColor", completekey=None, stdin=None, stdout=None):

        # Parent constructor:
        if has_pydb and completekey is None:
            OldPdb.__init__(self, stdin=stdin, stdout=io.stdout)
        else:
            OldPdb.__init__(self, completekey, stdin, stdout)

        # IPython changes...
        self.is_pydb = has_pydb

        self.shell = get_ipython()

        if self.shell is None:
            # No IPython instance running, we must create one
            from IPython.terminal.interactiveshell import TerminalInteractiveShell

            self.shell = TerminalInteractiveShell.instance()

        if self.is_pydb:

            # interactiveshell.py's ipalias seems to want pdb's checkline
            # which located in pydb.fn
            import pydb.fns

            self.checkline = lambda filename, lineno: pydb.fns.checkline(self, filename, lineno)

            self.curframe = None
            self.do_restart = self.new_do_restart

            self.old_all_completions = self.shell.Completer.all_completions
            self.shell.Completer.all_completions = self.all_completions

            self.do_list = decorate_fn_with_doc(self.list_command_pydb, OldPdb.do_list)
            self.do_l = self.do_list
            self.do_frame = decorate_fn_with_doc(self.new_do_frame, OldPdb.do_frame)

        self.aliases = {}

        # Create color table: we copy the default one from the traceback
        # module and add a few attributes needed for debugging
        self.color_scheme_table = exception_colors()

        # shorthands
        C = coloransi.TermColors
        cst = self.color_scheme_table

        cst["NoColor"].colors.prompt = C.NoColor
        cst["NoColor"].colors.breakpoint_enabled = C.NoColor
        cst["NoColor"].colors.breakpoint_disabled = C.NoColor

        cst["Linux"].colors.prompt = C.Green
        cst["Linux"].colors.breakpoint_enabled = C.LightRed
        cst["Linux"].colors.breakpoint_disabled = C.Red

        cst["LightBG"].colors.prompt = C.Blue
        cst["LightBG"].colors.breakpoint_enabled = C.LightRed
        cst["LightBG"].colors.breakpoint_disabled = C.Red

        self.set_colors(color_scheme)

        # Add a python parser so we can syntax highlight source while
        # debugging.
        self.parser = PyColorize.Parser()

        # Set the prompt
        Colors = cst.active_colors
        self.prompt = u"%s%s%s" % (Colors.prompt, prompt, Colors.Normal)  # The default prompt is '(Pdb)'
예제 #47
0
    def __init__(self,color_scheme='NoColor',completekey=None,
                 stdin=None, stdout=None, context=5):

        # Parent constructor:
        try:
            self.context=int(context)
            if self.context <= 0:
                raise ValueError("Context must be a positive integer")
        except (TypeError, ValueError):
                raise ValueError("Context must be a positive integer")

        if has_pydb and completekey is None:
            OldPdb.__init__(self,stdin=stdin,stdout=io.stdout)
        else:
            OldPdb.__init__(self,completekey,stdin,stdout)

        # IPython changes...
        self.is_pydb = has_pydb

        self.shell = get_ipython()

        if self.shell is None:
            # No IPython instance running, we must create one
            from IPython.terminal.interactiveshell import \
                TerminalInteractiveShell
            self.shell = TerminalInteractiveShell.instance()

        if self.is_pydb:

            # interactiveshell.py's ipalias seems to want pdb's checkline
            # which located in pydb.fn
            import pydb.fns
            self.checkline = lambda filename, lineno: \
                             pydb.fns.checkline(self, filename, lineno)

            self.curframe = None
            self.do_restart = self.new_do_restart

            self.old_all_completions = self.shell.Completer.all_completions
            self.shell.Completer.all_completions=self.all_completions

            self.do_list = decorate_fn_with_doc(self.list_command_pydb,
                                                OldPdb.do_list)
            self.do_l     = self.do_list
            self.do_frame = decorate_fn_with_doc(self.new_do_frame,
                                                 OldPdb.do_frame)

        self.aliases = {}

        # Create color table: we copy the default one from the traceback
        # module and add a few attributes needed for debugging
        self.color_scheme_table = exception_colors()

        # shorthands
        C = coloransi.TermColors
        cst = self.color_scheme_table

        cst['NoColor'].colors.prompt = C.NoColor
        cst['NoColor'].colors.breakpoint_enabled = C.NoColor
        cst['NoColor'].colors.breakpoint_disabled = C.NoColor

        cst['Linux'].colors.prompt = C.Green
        cst['Linux'].colors.breakpoint_enabled = C.LightRed
        cst['Linux'].colors.breakpoint_disabled = C.Red

        cst['LightBG'].colors.prompt = C.Blue
        cst['LightBG'].colors.breakpoint_enabled = C.LightRed
        cst['LightBG'].colors.breakpoint_disabled = C.Red

        self.set_colors(color_scheme)

        # Add a python parser so we can syntax highlight source while
        # debugging.
        self.parser = PyColorize.Parser()

        # Set the prompt - the default prompt is '(Pdb)'
        Colors = cst.active_colors
        if color_scheme == 'NoColor':
            self.prompt = prompt
        else:
            # The colour markers are wrapped by bytes 01 and 02 so that readline
            # can calculate the width.
            self.prompt = u'\x01%s\x02%s\x01%s\x02' % (Colors.prompt, prompt, Colors.Normal)
예제 #48
0
파일: emissary.py 프로젝트: craSH/Emissary
def main():
    import optparse

    parser = optparse.OptionParser()
    # Shall we fuzz the request, response, or both?
    # Set via optparse in main
    global sr_request  # search/replace tuple for requests - (True, [search, replace]) where true means to use regex
    global sr_response  # search/replace tuple for responses - (True, [search, replace]) where true means to use regex
    global fuzz_request
    global fuzz_response

    # Other module-wide variables
    global debug
    global term
    global logger
    global fwdr

    parser.add_option("-l", "--local-addr", dest="local_addr", default="127.0.0.1", help="Local address to bind to")
    parser.add_option("-p", "--local-port", type="int", dest="local_port", default=1234, help="Local port to bind to")
    parser.add_option("-r", "--remote-addr", dest="remote_addr", help="Remote address to bind to")
    parser.add_option("-P", "--remote-port", type="int", dest="remote_port", default=80, help="Remote port to bind to")

    parser.add_option(
        "--search-request",
        dest="search_request",
        default="",
        help="String that if found will be replaced by --replace-request's value",
    )
    parser.add_option(
        "--replace-request", dest="replace_request", default="", help="String to replace the value of --search-request"
    )
    parser.add_option(
        "--search-response",
        dest="search_response",
        default="",
        help="String that if found will be replaced by --replace-request's value",
    )
    parser.add_option(
        "--replace-response",
        dest="replace_response",
        default="",
        help="String to replace the value of --search-request",
    )

    parser.add_option(
        "--regex-request",
        action="store_true",
        dest="request_use_regex",
        help="Requests: Use regular expressions for search and replace instead of string constants",
    )
    parser.add_option(
        "--regex-response",
        action="store_true",
        dest="response_use_regex",
        help="Responses: Use regular expressions for search and replace instead of string constants",
    )

    parser.add_option(
        "--fuzz-request",
        action="store_true",
        dest="fuzz_request",
        help="Fuzz the request which the proxy gets from the connecting client \
            prior to sending it to the remote host",
    )
    parser.add_option(
        "--fuzz-response",
        action="store_true",
        dest="fuzz_response",
        help="Fuzz the response which the proxy gets from the remote host prior \
            to sending it to the conecting client",
    )

    parser.add_option(
        "-i",
        "--run-info",
        dest="run_info",
        default="",
        help="Additional information string to add to database run_info entry",
    )

    parser.add_option(
        "-d",
        "--debug",
        type="int",
        dest="debug",
        default=0,
        help="Debug level (0-5, 0: No debugging; 1: Simple conneciton \
            information; 2: Simple data information; 3: Listener data display; 4: \
            Sender data display; 5: All data display)",
    )

    (options, args) = parser.parse_args()

    if not options.remote_addr or not options.remote_port:
        parser.print_help()
        exit(1)

    # Validate options for search/replace
    if (options.search_request and not options.replace_request) or (
        options.replace_request and not options.search_request
    ):
        print >> sys.stderr, "Both --search-request and --replace-request must be provided together"
        exit(1)

    if (options.search_response and not options.replace_response) or (
        options.replace_response and not options.search_response
    ):
        print >> sys.stderr, "Both --search-response and --replace-response must be provided together"
        exit(1)

    # Setup a TerminalController for formatted output
    term = TerminalController()

    # Print the current run information
    print (
        term.render(
            """\nSetting up asynch. TCP proxy with the following settings:
    ${GREEN}Local binding Address: %s
    Local binding Port:    %s${NORMAL}

    ${RED}Remote host address:   %s
    Remote host port:      %s${NORMAL}
    """
        )
        % (options.local_addr, options.local_port, options.remote_addr, options.remote_port)
    )

    # Set the debug value
    debug = options.debug

    # If run info was passed in on the command line, use that for the run_info table
    # additional info field (It will have what's being fuzzed prepended to it as well)
    run_additional_info = options.run_info

    # Print the selected debug value
    if debug > 0:
        if debug == 1:
            print ("    Debug: Level 1 (Show simple connection information)")
        elif debug == 2:
            print ("    Debug: Level 2 (Show simple data information, such as the size of sent/received messages)")
        elif debug == 3:
            print ("    Debug: Level 3 (Show listener data and size of sent/received messages)")
        elif debug == 4:
            print ("    Debug: Level 4 (Show sender data and size of sent/received messages)")
        elif debug == 5:
            print (
                "    Debug: Level 5 (Show all possible information, including the size of sent/received messages, and their data for listener and sender)"
            )
    print ("")

    # Display and setup search/replace things
    if options.search_request and options.replace_request:
        sr_request = [
            None,
            options.search_request.decode("string-escape"),
            options.replace_request.decode("string-escape"),
        ]
        # Check if we want to use regex instead of string constants
        if options.request_use_regex:
            # Use regex instead of string replace
            print (
                term.render(
                    "Running regex search/replace on ${BOLD}REQUESTS${NORMAL} with regex: 's/%s/%s'"
                    % (sr_request[1], sr_request[2])
                )
            )
            sr_request[0] = True
        else:
            print (
                term.render(
                    "Running string search/replace on ${BOLD}REQUESTS${NORMAL} with search/replace: 's/%s/%s'"
                    % (sr_request[1], sr_request[2])
                )
            )
            sr_request[0] = False
    else:
        sr_request = None

    if options.search_response and options.replace_response:
        sr_response = [
            None,
            options.search_response.decode("string-escape"),
            options.replace_response.decode("string-escape"),
        ]
        # Check if we want to use regex instead of string constants
        if options.response_use_regex:
            print (
                term.render(
                    "Running regex search/replace on ${BOLD}RESPONSES${NORMAL} with regex: 's/%s/%s'"
                    % (sr_response[1], sr_response[2])
                )
            )
            sr_response[0] = True
        else:
            print (
                term.render(
                    "Running string search/replace on ${BOLD}RESPONSES${NORMAL} with search/replace: 's/%s/%s'"
                    % (sr_response[1], sr_response[2])
                )
            )
            sr_response[0] = False
    else:
        sr_response = None

    # Setup which to fuzz - request, response, neither, both?
    if options.fuzz_request:
        fuzz_request = options.fuzz_request
        run_additional_info = "Fuzzing REQUESTS; " + run_additional_info
        print (term.render("Fuzzing ${BOLD}REQUESTS${NORMAL}"))
    else:
        fuzz_request = False

    if options.fuzz_response:
        fuzz_response = options.fuzz_response
        run_additional_info = "Fuzzing RESPONSES; " + run_additional_info
        print (term.render("Fuzzing ${BOLD}RESPONSES${NORMAL}"))
    else:
        fuzz_response = False

    if not (options.fuzz_response or options.fuzz_request):
        run_additional_info = "Fuzzing NONE; " + run_additional_info
        print (
            term.render(
                "Fuzzing ${BOLD}<NOTHING>${NORMAL} (Maybe you wanted ${BOLD}--fuzz-request or --fuzz-response${NORMAL}?)"
            )
        )

    if fuzz_request and fuzz_response:
        print (
            term.render(
                "${YELLOW}\nWARNING! WARNING!\n${BOLD}Fuzzing BOTH the request and response is probably a bad idea, ensure this is what you want to do!${NORMAL}${YELLOW}\nWARNING! WARNING!\n${NORMAL}"
            )
        )

    # host, db, username, passwd
    if logging_enabled:
        logger = postgresLogger("postgreshost", "dbname", "dbuser", "dbpass")

        logger.log_run_info("CompanyName", "ProjectName-v1.2.3", run_additional_info)

    # create object that spawns reciever/sender pairs upon connection
    fwdr = forwarder(options.local_addr, options.local_port, options.remote_addr, options.remote_port)
    print ("Listener running...")
    # asyncore.loop()

    # A quick hack to be able to control fuzz on/off while running
    # separate asyncore.loop into its own thread so we can have terminal control
    asyncThread = Thread(target=asyncore.loop)
    asyncThread.start()

    # start a console (ipython)
    from IPython.terminal.interactiveshell import TerminalInteractiveShell

    shell = TerminalInteractiveShell(user_ns=globals())
    shell.mainloop()

    # cleanup otherwise thread wont die and program hangs
    fwdr.close()
    # asyncore.close_all()
    asyncThread._Thread__stop()