def ipython_ui(self): from IPython.terminal.ipapp import TerminalIPythonApp import automate self.system.namespace.allow_overwrite.extend(['_', '__', '___', '_i', '_ii', '_iii', 'quit']) self.system.namespace.update({k: v for k, v in list(automate.__dict__.items()) if k not in self.system.namespace}) term = TerminalIPythonApp(user_ns=self.system.namespace) self.system.namespace['term'] = term term.initialize([]) term.start()
def load_config_for_embed_ipython(profile_name='debug'): """Load the a config file from the default ipython_dir. """ ipython_dir = get_ipython_dir() profile_dir = os.path.join(ipython_dir, f'profile_{profile_name}') app = TerminalIPythonApp() app.config_file_paths.append(profile_dir) app.load_config_file() config = app.config # XXX: setting the profile in config seems to have no effect for InteractiveShellEmbed. # TODO: learn more about IPython internals... # fix history location with a little workaround if 'hist_file' not in config.HistoryAccessor: config.HistoryManager.hist_file = os.path.join(profile_dir, 'history.sqlite') return config
def debug(self, err): import IPython ec, ev, tb = err # This is to work around issue #16, that occured when the exception # value was being passed as a string. if isinstance(ev, str): ev = ec(ev) stdout = sys.stdout sys.stdout = sys.__stdout__ sys.stderr.write('\n- TRACEBACK --------------------------------------------------------------------\n') traceback.print_exception(ec, ev, tb) sys.stderr.write('--------------------------------------------------------------------------------\n') try: from IPython.terminal.ipapp import TerminalIPythonApp app = TerminalIPythonApp.instance() app.initialize(argv=['--no-banner']) try: # ipython >= 5.0 p = IPython.terminal.debugger.TerminalPdb(app.shell.colors) except AttributeError: p = IPython.core.debugger.Pdb(app.shell.colors) p.reset() # inspect.getinnerframes() returns a list of frames information # from this frame to the one that raised the exception being # treated frame, filename, line, func_name, ctx, idx = inspect.getinnerframes(tb)[-1] p.interaction(frame, tb) finally: sys.stdout = stdout
def start(user_ns=None): # Make sure the log level is changed to warning CodecFactory() taurus.setLogLevel(taurus.Warning) try: check_requirements() except exception.SpockMissingRequirement as requirement: print(str(requirement)) sys.exit(-1) except exception.SpockMissingRecommended as recommended: print(str(recommended)) user_ns = user_ns or {} try: user_ns.update(get_args(sys.argv)) except exception.SpockException as e: print(e) print('Starting normal IPython console') except KeyboardInterrupt: print("\nUser pressed Ctrl+C. Exiting...") sys.exit() except Exception as e: print('spock exited with an unmanaged exception: %s' % str(e)) sys.exit(-2) app = TerminalIPythonApp.instance() app.initialize() #config = get_config() return app
def shell(): """Start an interactive iPython shell""" from IPython.terminal.ipapp import TerminalIPythonApp import app.model as m from trex.support import quantum context = dict( app = app, quantum = quantum, m = m, ) rc_file = os.path.normpath(os.path.join(app.root_path, os.pardir, 'shell.rc')) if os.access(rc_file, os.R_OK): execfile(rc_file, context, dict(context=context)) shell = TerminalIPythonApp.instance( display_banner = False, quick = True, user_ns = context, ) shell.initialize(argv=[]) shell.shell.confirm_exit = False context = app.test_request_context('__shell__') context.push() shell.start() context.pop()
def shell(): """Start an interactive iPython shell""" from IPython.terminal.ipapp import TerminalIPythonApp import app.model as m from trex.support import quantum context = dict( app = app, quantum = quantum, m = m, ) rc_file = os.path.normpath(os.path.join(app.root_path, os.pardir, 'shell.rc')) if os.access(rc_file, os.R_OK): execfile(rc_file, context, dict(context=context)) shell = TerminalIPythonApp.instance( display_banner = False, quick = True, user_ns = context, ) shell.initialize(argv=[]) shell.shell.confirm_exit = False def pretty_print(self, arg): from pprint import pformat import mongoengine import texttable output = None for line in self.shell.history_manager.get_tail(50): try: output = self.shell.history_manager.output_hist[line[1]] except KeyError: pass if isinstance(output, mongoengine.QuerySet): table = texttable.Texttable(max_width=0) table.set_deco(texttable.Texttable.HEADER) fields = output[0]._fields.keys() table.add_row(fields) for obj in output: table.add_row([str(getattr(obj, field)) for field in fields]) pretty_output = table.draw() elif isinstance(output, mongoengine.Document) or isinstance(output, mongoengine.EmbeddedDocument): pretty_output = pformat(output.to_mongo().to_dict()) else: pretty_output = pformat(output) print pretty_output return None shell.shell.define_magic('pp', pretty_print) context = app.test_request_context('__shell__') context.push() shell.start() context.pop()
def run_shell(self, no_ipython, no_bpython, quiet): # based on the flask-script Shell.run() method context = self.get_context() if not no_bpython: try: from bpython import embed embed(banner=self.banner, locals_=context) return except ImportError: pass if not no_ipython: try: from IPython.terminal.ipapp import TerminalIPythonApp ipython_app = TerminalIPythonApp.instance(user_ns=context, display_banner=not quiet) ipython_app.initialize(argv=[]) ipython_app.shell.show_banner(self.banner) ipython_app.start() return except ImportError: pass # Use basic python shell import code code.interact(self.banner, local=context)
def shell_cmd(verbose, with_req_context): try: from IPython.terminal.ipapp import TerminalIPythonApp except ImportError: click.echo( cformat( '%{red!}You need to `pip install ipython` to use the SNMS shell' )) sys.exit(1) current_app.config['REPL'] = True # disables e.g. memoize_request request_stats_request_started() context, info = _make_shell_context() banner = cformat('%{yellow!}SNMS v{} is ready for your commands').format( snms.__version__) if verbose: banner = '\n'.join(info + ['', banner]) ctx = current_app.make_shell_context() ctx.update(context) # clearCache() stack = ExitStack() if with_req_context: stack.enter_context( current_app.test_request_context(base_url=config.BASE_URL)) with stack: ipython_app = TerminalIPythonApp.instance(user_ns=ctx, display_banner=False) ipython_app.initialize(argv=[]) ipython_app.shell.show_banner(banner) ipython_app.start()
def __init__(self): """Constructor. Imports IPython's embedded shell with separator lines removed.""" Shell.__init__(self) ConsoleProgressBarMixin.__init__(self) # We cannot use IPShellEmbed here because generator expressions do not # work there (e.g., set(g.degree(x) for x in [1,2,3])) where g comes # from an external context import sys from IPython import __version__ as ipython_version self.ipython_version = ipython_version try: # IPython >= 0.11 supports this try: from IPython.terminal.ipapp import TerminalIPythonApp except ImportError: from IPython.frontend.terminal.ipapp import TerminalIPythonApp self._shell = TerminalIPythonApp.instance() sys.argv.append("--nosep") except ImportError: # IPython 0.10 and earlier import IPython.Shell self._shell = IPython.Shell.start() self._shell.IP.runsource("from igraph import *") sys.argv.append("-nosep")
def shell(): """IPython shell""" from IPython.terminal.ipapp import TerminalIPythonApp app = TerminalIPythonApp.instance() app.user_ns = _make_shell_context() app.display_banner = False app.initialize(argv=[]) app.start()
def run_python_interpreter(local_dict): from IPython import start_ipython as start from IPython.terminal.ipapp import TerminalIPythonApp mainModule = sys.modules["__main__"] start(user_ns=local_dict) sys.modules["__main__"] = mainModule TerminalIPythonApp.instance().display_banner = False return # Pass in the dictionary, for continuity from one session to the next. setquit() try: fd = sys.stdin.fileno() interacted = False if get_terminal_size(fd)[1] == 0: try: import termios old = termios.tcgetattr(fd) if old[3] & termios.ECHO: # Need to turn off echoing and restore new = termios.tcgetattr(fd) new[3] = new[3] & ~termios.ECHO try: termios.tcsetattr(fd, termios.TCSADRAIN, new) interacted = True code.interact( banner="Python Interactive Interpreter. To exit, type 'quit()', 'exit()'.", readfunc=readfunc_stdio, local=local_dict, ) finally: termios.tcsetattr(fd, termios.TCSADRAIN, old) except: pass # Don't need to turn off echoing if not interacted: code.interact( banner="Python Interactive Interpreter. To exit, type 'quit()', 'exit()' or Ctrl-D.", readfunc=readfunc_stdio, local=local_dict, ) else: # We have a real interactive terminal code.interact( banner="Python Interactive Interpreter. To exit, type 'quit()', 'exit()' or Ctrl-D.", local=local_dict ) except SystemExit as e: global g_builtin_override_called if not g_builtin_override_called: print("Script exited with %s" % (e))
def debug_shell(user_ns, user_global_ns, traceback=None, execWrapper=None): ipshell = None try: import IPython have_ipython = True except ImportError: have_ipython = False if not ipshell and traceback and have_ipython: try: from IPython.core.debugger import Pdb from IPython.terminal.debugger import TerminalPdb from IPython.terminal.ipapp import TerminalIPythonApp ipapp = TerminalIPythonApp.instance() ipapp.interact = False # Avoid output (banner, prints) ipapp.initialize(argv=[]) def_colors = ipapp.shell.colors pdb_obj = TerminalPdb(def_colors) pdb_obj.botframe = None # not sure. exception otherwise at quit ipshell = lambda: pdb_obj.interaction(None, traceback=traceback) except Exception: print("IPython Pdb exception:") better_exchook(*sys.exc_info(), autodebugshell=False) if not ipshell and have_ipython: try: import IPython import IPython.terminal.embed class DummyMod(object): pass module = DummyMod() module.__dict__ = user_global_ns module.__name__ = "_DummyMod" if "__name__" not in user_ns: user_ns = user_ns.copy() user_ns["__name__"] = "_DummyUserNsMod" ipshell = IPython.terminal.embed.InteractiveShellEmbed.instance( user_ns=user_ns, user_module=module) except Exception: print("IPython not available:") better_exchook(*sys.exc_info(), autodebugshell=False) else: if execWrapper: old = ipshell.run_code ipshell.run_code = lambda code: execWrapper(lambda: old(code)) if ipshell: ipshell() else: print("Use simple debug shell:") if traceback: import pdb pdb.post_mortem(traceback) else: simple_debug_shell(user_global_ns, user_ns)
def launch_lambda_console(args, lib_dir=None, kernel_dir=None): install_kernelspec(lib_dir, kernel_dir) c = Config() # no idea why this doesn't work, but it doesn't... #c.IPythonConsoleApp.kernel_name="lambda-notebook" c.InteractiveShellApp.exec_lines=["import sys; sys.path.append(r\"%s\"); import lamb.lnsetup; lamb.lnsetup.ipython_setup()" % lib_dir] app = TerminalIPythonApp.instance(config=c) app.initialize(argv=args[1:]) app.start()
def run_python_interpreter(local_dict): from IPython import start_ipython as start from IPython.terminal.ipapp import TerminalIPythonApp mainModule = sys.modules['__main__'] start(user_ns=local_dict) sys.modules['__main__'] = mainModule TerminalIPythonApp.instance().display_banner = False return # Pass in the dictionary, for continuity from one session to the next. setquit() try: fd = sys.stdin.fileno() interacted = False if get_terminal_size(fd)[1] == 0: try: import termios old = termios.tcgetattr(fd) if old[3] & termios.ECHO: # Need to turn off echoing and restore new = termios.tcgetattr(fd) new[3] = new[3] & ~termios.ECHO try: termios.tcsetattr(fd, termios.TCSADRAIN, new) interacted = True code.interact( banner= "Python Interactive Interpreter. To exit, type 'quit()', 'exit()'.", readfunc=readfunc_stdio, local=local_dict) finally: termios.tcsetattr(fd, termios.TCSADRAIN, old) except: pass # Don't need to turn off echoing if not interacted: code.interact( banner= "Python Interactive Interpreter. To exit, type 'quit()', 'exit()' or Ctrl-D.", readfunc=readfunc_stdio, local=local_dict) else: # We have a real interactive terminal code.interact( banner= "Python Interactive Interpreter. To exit, type 'quit()', 'exit()' or Ctrl-D.", local=local_dict) except SystemExit as e: global g_builtin_override_called if not g_builtin_override_called: print('Script exited with %s' % (e))
def debug_shell(app, parser): from IPython.terminal.ipapp import TerminalIPythonApp ip = TerminalIPythonApp.instance() ip.initialize(argv=[]) ip.shell.user_global_ns['app'] = app ip.shell.user_global_ns['log'] = log ip.shell.user_global_ns['parser'] = parser def ipy_import(module_name, identifier): import importlib module = importlib.import_module(module_name) ip.shell.user_global_ns[identifier] = getattr(module, identifier) ip.start()
def debug_shell(app): from IPython.terminal.ipapp import TerminalIPythonApp ip = TerminalIPythonApp.instance() ip.initialize(argv=[]) ip.shell.user_global_ns['app'] = app ip.shell.user_global_ns['repo'] = app.repo ip.shell.user_global_ns['git'] = app.git ip.shell.user_global_ns['trac'] = app.trac def ipy_import(module_name, identifier): module = importlib.import_module(module_name) ip.shell.user_global_ns[identifier] = getattr(module, identifier) ipy_import('git_trac.git_interface', 'GitInterface') ipy_import('git_trac.trac_server', 'TracServer') ip.start()
def launch_lambda_console(args, lib_dir=None, kernel_dir=None): install_kernelspec(lib_dir, kernel_dir) c = Config() # no idea why this doesn't work, but it doesn't... #c.IPythonConsoleApp.kernel_name="lambda-notebook" c.InteractiveShellApp.exec_lines = [ "import sys; sys.path.insert(1,r\"%s\"); import lamb.lnsetup; lamb.lnsetup.ipython_setup()" % lib_dir ] app = TerminalIPythonApp.instance(config=c) app.initialize(argv=args[1:]) app.start()
def _get_debugger_cls(): shell = get_ipython() if shell is None: # Not inside IPython # Build a terminal app in order to force ipython to load the # configuration ipapp = TerminalIPythonApp() # Avoid output (banner, prints) ipapp.interact = False ipapp.initialize(["--no-term-title"]) shell = ipapp.shell else: # Running inside IPython # Detect if embed shell or not and display a message if isinstance(shell, InteractiveShellEmbed): sys.stderr.write( "\nYou are currently into an embedded ipython shell,\n" "the configuration will not be loaded.\n\n") # Let IPython decide about which debugger class to use # This is especially important for tools that fiddle with stdout return shell.debugger_cls
def get_debugger(): import IPython from IPython.terminal.ipapp import TerminalIPythonApp app = TerminalIPythonApp.instance() app.initialize(argv=['--no-banner']) try: # ipython >= 5.0 p = IPython.terminal.debugger.TerminalPdb(app.shell.colors) except AttributeError: p = IPython.core.debugger.Pdb(app.shell.colors) p.reset() return p.interaction
def debug_shell(self, app): """ Variant of :meth:`run_forever` that drops us into an IPython shell """ from IPython.terminal.ipapp import TerminalIPythonApp ip = TerminalIPythonApp.instance() ip.initialize(argv=[]) ip.shell.user_global_ns['app'] = app def ipy_import(module_name, identifier): module = importlib.import_module(module_name) ip.shell.user_global_ns[identifier] = getattr(module, identifier) #ipy_import('sage_notebook.model.git_interface', 'GitInterface') from IPython.lib.inputhook import inputhook_manager inputhook_manager.set_inputhook(self.ipython_inputhook) ip.start()
def debug(self, err): import IPython ec, ev, tb = err # This is to work around issue #16, that occured when the exception # value was being passed as a string. if isinstance(ev, str): ev = ec(ev) stdout = sys.stdout sys.stdout = sys.__stdout__ sys.stderr.write( '\n- TRACEBACK --------------------------------------------------------------------\n' ) traceback.print_exception(ec, ev, tb) sys.stderr.write( '--------------------------------------------------------------------------------\n' ) try: try: # ipython >= 1.0 from IPython.terminal.ipapp import TerminalIPythonApp app = TerminalIPythonApp.instance() app.initialize(argv=['--no-banner']) p = IPython.core.debugger.Pdb(app.shell.colors) except ImportError: try: # 0.11 <= ipython <= 0.13 ip = IPython.core.ipapi.get() p = IPython.core.debugger.Pdb(ip.colors) except AttributeError: # ipython <= 0.10 shell = IPython.Shell.IPShell(argv=['']) ip = IPython.ipapi.get() p = IPython.Debugger.Pdb(ip.options.colors) p.reset() # inspect.getinnerframes() returns a list of frames information # from this frame to the one that raised the exception being # treated frame, filename, line, func_name, ctx, idx = inspect.getinnerframes( tb)[-1] p.interaction(frame, tb) finally: sys.stdout = stdout
def ipython_ui(self): from IPython.terminal.ipapp import TerminalIPythonApp import automate self.system.namespace.allow_overwrite.extend( ['_', '__', '___', '_i', '_ii', '_iii', 'quit']) self.system.namespace.update({ k: v for k, v in list(automate.__dict__.items()) if k not in self.system.namespace }) term = TerminalIPythonApp(user_ns=self.system.namespace) self.system.namespace['term'] = term term.initialize([]) term.start()
def debug_shell(user_ns, user_global_ns, traceback=None, execWrapper=None): ipshell = None if traceback: try: from IPython.core.debugger import Pdb from IPython.terminal.ipapp import TerminalIPythonApp ipapp = TerminalIPythonApp.instance() ipapp.interact = False # Avoid output (banner, prints) ipapp.initialize(argv=[]) def_colors = ipapp.shell.colors pdb_obj = Pdb(def_colors) pdb_obj.botframe = None # not sure. exception otherwise at quit ipshell = lambda: pdb_obj.interaction(None, traceback=traceback) except Exception: pass if not ipshell: try: import IPython import IPython.terminal.embed class DummyMod(object): pass module = DummyMod() module.__dict__ = user_global_ns module.__name__ = "DummyMod" ipshell = IPython.terminal.embed.InteractiveShellEmbed( user_ns=user_ns, user_module=module) except Exception: pass else: if execWrapper: old = ipshell.run_code ipshell.run_code = lambda code: execWrapper(lambda: old(code)) if ipshell: ipshell() else: if traceback: import pdb pdb.post_mortem(traceback) else: simple_debug_shell(user_global_ns, user_ns)
def _launch_qt_console(ppid, connection_file): """called as a new process""" from IPython.terminal.ipapp import TerminalIPythonApp import threading import psutil import time # start a thread to kill this process when the parent process exits def thread_func(): while True: if not psutil.pid_exists(ppid): os._exit(1) time.sleep(5) thread = threading.Thread(target=thread_func) thread.daemon = True thread.start() # start the qtconsole app app = TerminalIPythonApp.instance() app.initialize(["qtconsole", "--existing", connection_file]) app.start()
def run(self, pipe, no_ipython, no_bpython): if pipe: # User is attempting to pipe in script through stdin. text = sys.stdin.read() exec(text, None, _make_context()) return # Try IPython (with autoreload) try: from IPython.terminal.ipapp import TerminalIPythonApp app = TerminalIPythonApp(user_ns=self.get_context()) config_file = path.join(path.dirname(alchemist.__file__), "ipython_startup.ipy") app.init_shell() app.shell.banner = self.banner app.initialize(argv=["-i", config_file]) app.start() return except ImportError: pass # Fallback to normal cycle. super(Shell, self).run(no_ipython=no_ipython, no_bpython=no_bpython)
def shell_cmd(verbose, with_req_context): try: from IPython.terminal.ipapp import TerminalIPythonApp except ImportError: click.echo(cformat('%{red!}You need to `pip install ipython` to use the Indico shell')) sys.exit(1) current_app.config['REPL'] = True # disables e.g. memoize_request request_stats_request_started() context, info = _make_shell_context() banner = cformat('%{yellow!}Indico v{} is ready for your commands').format(indico.__version__) if verbose: banner = '\n'.join(info + ['', banner]) ctx = current_app.make_shell_context() ctx.update(context) clearCache() stack = ExitStack() if with_req_context: stack.enter_context(current_app.test_request_context(base_url=config.BASE_URL)) with stack: ipython_app = TerminalIPythonApp.instance(user_ns=ctx, display_banner=False) ipython_app.initialize(argv=[]) ipython_app.shell.show_banner(banner) ipython_app.start()
def run(self, pipe, no_ipython, no_bpython): if pipe: # User is attempting to pipe in script through stdin. text = sys.stdin.read() exec(text, None, _make_context()) return # Try IPython (with autoreload) try: from IPython.terminal.ipapp import TerminalIPythonApp app = TerminalIPythonApp(user_ns=self.get_context()) config_file = path.join( path.dirname(alchemist.__file__), "ipython_startup.ipy") app.init_shell() app.shell.banner = self.banner app.initialize(argv=["-i", config_file]) app.start() return except ImportError: pass # Fallback to normal cycle. super(Shell, self).run(no_ipython=no_ipython, no_bpython=no_bpython)
if dac_index < 0 or dac_index >= 6: raise ValueError("dac_index out of bounds") return self._write_reg(value, ADDR_DAC, dac_index) def interp_write(self, index, value, steps): if index < 0 or index >= 6: raise ValueError("dac_index out of bounds") self._write_reg(steps, ADDR_INTERP, index + 6) self._write_reg(value, ADDR_INTERP, index) def interp_read(self, index): if index < 0 or index >= 6: raise ValueError("dac_index out of bounds") steps = self._read_reg(ADDR_INTERP, index + 6) value = self._read_reg(ADDR_INTERP, index) return value, steps if __name__ == "__main__": fpga = FPGA_USB_Interface() dct = {"fpga": fpga} from IPython.terminal.ipapp import TerminalIPythonApp TerminalIPythonApp.display_banner = True app = TerminalIPythonApp() app.initialize(argv=[]) app.shell.push(dct) app.shell.write("\nBuilt-in objects: %s\n" % str(dct)) app.start() del app, fpga, dct
def ipython(): from IPython.terminal.ipapp import TerminalIPythonApp app = TerminalIPythonApp.instance() app.initialize(argv=[]) # argv=[] instructs IPython to ignore sys.argv app.start()
from contextlib import contextmanager __version__= "0.10.3" from IPython import get_ipython from IPython.core.debugger import BdbQuit_excepthook from IPython.terminal.ipapp import TerminalIPythonApp from IPython.terminal.embed import InteractiveShellEmbed shell = get_ipython() if shell is None: # Not inside IPython # Build a terminal app in order to force ipython to load the # configuration ipapp = TerminalIPythonApp() # Avoid output (banner, prints) ipapp.interact = False ipapp.initialize([]) shell = ipapp.shell else: # Running inside IPython # Detect if embed shell or not and display a message if isinstance(shell, InteractiveShellEmbed): sys.stderr.write( "\nYou are currently into an embedded ipython shell,\n" "the configuration will not be loaded.\n\n" ) # Let IPython decide about which debugger class to use
trait_aliases = reverse_aliases(app) filename = options / (name + ".rst") text = [title, "=" * len(title), "\n"] if preamble is not None: text.append(preamble + "\n") text.append(app.document_config_options()) text.extend( class_config_rst_doc(c, trait_aliases) for c in app._classes_inc_parents() ) filename.write_text("\n".join(text)) if __name__ == "__main__": # Touch this file for the make target Path(generated).write_text("") write_doc("terminal", "Terminal IPython options", TerminalIPythonApp()) write_doc( "kernel", "IPython kernel options", IPKernelApp(), preamble=( "These options can be used in :file:`ipython_kernel_config.py`. " "The kernel also respects any options in `ipython_config.py`" ), )
from contextlib import contextmanager __version__ = "0.10.3" from IPython import get_ipython from IPython.core.debugger import BdbQuit_excepthook from IPython.terminal.ipapp import TerminalIPythonApp from IPython.terminal.embed import InteractiveShellEmbed shell = get_ipython() if shell is None: # Not inside IPython # Build a terminal app in order to force ipython to load the # configuration ipapp = TerminalIPythonApp() # Avoid output (banner, prints) ipapp.interact = False ipapp.initialize([]) shell = ipapp.shell else: # Running inside IPython # Detect if embed shell or not and display a message if isinstance(shell, InteractiveShellEmbed): sys.stderr.write( "\nYou are currently into an embedded ipython shell,\n" "the configuration will not be loaded.\n\n") # Let IPython decide about which debugger class to use # This is especially important for tools that fiddle with stdout
def main(argv=None): if argv is None: argv = sys.argv try: prog_name = argv[0] with_ipshell = False ignore_lock = False no_latex_output = True list_invoices = False output_file_name = "data.lco" invoice_number = None try: opts, args = getopt.getopt(argv[1:], "fhiln:po:", ["help"]) except getopt.error as msg: raise Usage(msg) for opt in opts: if opt[0] in ["-f"]: print("ignoring lock") ignore_lock = True if opt[0] in ["-h", "--help"]: raise Usage("Help:") if opt[0] in ["-i"]: print("Using ipshell") with_ipshell = True if opt[0] in ["-l"]: print("listing all invoices") list_invoices = True if opt[0] in ["-n"]: invoice_number = int(opt[1]) print("using invoice number", invoice_number) no_latex_output = False if opt[0] in ["-o"]: output_file_name = opt[1] print("using output file", output_file_name) if len(args) > 1: print("opts:", opts, "args:", args) raise Usage("Only one input can be accepted !") if len(args) == 0: raise Usage("No input given !") input_url = args[0] except Usage as err: if err.msg == "Help:": retcode = 0 else: print("Error:", err.msg, file=sys.stderr) print("for help use --help", file=sys.stderr) retcode = 2 print("Generate a LaTeX invoice or print out all invoices.") print() print("Usage:") print() print("Invoke with", prog_name, "input.") print("where input is") print(" filename") print("or file://filename") print("or mysql://user:password@host/databasename") print() print("-f force open = ignore lock") print("-h or --help for this help") print("-i for ipython shell") print("-l list all invoices") print( "-n number use invoice number (no. from previous run with -l)" ) print("-o name use name as outputfile. default: data.lco") return retcode # Try to open the given input try: session = gnucash.Session(input_url, ignore_lock=ignore_lock) except Exception as exception: print("Problem opening input.") print(exception) return 2 book = session.book root_account = book.get_root_account() comm_table = book.get_table() EUR = comm_table.lookup("CURRENCY", "EUR") invoice_list = get_all_invoices(book) if list_invoices: for number, invoice in enumerate(invoice_list): print(str(number) + ")") print(invoice) if not (no_latex_output): if invoice_number == None: print("Using the first invoice:") invoice_number = 0 invoice = invoice_list[invoice_number] print("Using the following invoice:") print(invoice) lco_str = invoice_to_lco(invoice) # Opening output file f = open(output_file_name, "w") lco_str = lco_str.encode("latin1") f.write(lco_str) f.close() if with_ipshell: app = TerminalIPythonApp.instance() app.initialize(argv=[]) # argv=[] instructs IPython to ignore sys.argv app.start() #session.save() session.end()
f.write(('=' * len(title)) + '\n') f.write('\n') if preamble is not None: f.write(preamble + '\n\n') f.write(configdoc) with open('source/config/options/generated', 'a') as f: f.write(filename + '\n') if __name__ == '__main__': # create empty file with open('source/config/options/generated', 'w'): pass write_doc('terminal', 'Terminal IPython options', TerminalIPythonApp().classes) write_doc( 'kernel', 'IPython kernel options', kernel_classes, preamble= "These options can be used in :file:`ipython_notebook_config.py` " "or in :file:`ipython_qtconsole_config.py`") nbclasses = set(NotebookApp().classes) - set(kernel_classes) write_doc('notebook', 'IPython notebook options', nbclasses, preamble="Any of the :doc:`kernel` can also be used.") try: from IPython.qt.console.qtconsoleapp import IPythonQtConsoleApp
if not (no_latex_output): if invoice_number == None: print "Using the first invoice:" invoice_number=0 invoice=invoice_list[invoice_number] print "Using the following invoice:" print invoice lco_str=invoice_to_lco(invoice) # Opening output file f=open(output_file_name,"w") lco_str=lco_str.encode("latin1") f.write(lco_str) f.close() if with_ipshell: app = TerminalIPythonApp.instance() app.initialize(argv=[]) # argv=[] instructs IPython to ignore sys.argv app.start() #session.save() session.end() if __name__ == "__main__": sys.exit(main())
raise ValueError("dac_index out of bounds") return self._write_reg(value, ADDR_DAC, dac_index) def interp_write(self, index, value, steps): if index < 0 or index >= 6: raise ValueError("dac_index out of bounds") self._write_reg(steps, ADDR_INTERP, index+6) self._write_reg(value, ADDR_INTERP, index) def interp_read(self, index): if index < 0 or index >= 6: raise ValueError("dac_index out of bounds") steps = self._read_reg(ADDR_INTERP, index+6) value = self._read_reg(ADDR_INTERP, index) return value, steps if __name__ == "__main__": fpga = FPGA_USB_Interface() dct = {"fpga": fpga} from IPython.terminal.ipapp import TerminalIPythonApp TerminalIPythonApp.display_banner = True app = TerminalIPythonApp() app.initialize(argv=[]) app.shell.push(dct) app.shell.write("\nBuilt-in objects: %s\n" % str(dct)) app.start() del app, fpga, dct
from IPython import get_ipython from IPython.core.debugger import BdbQuit_excepthook from IPython.terminal.ipapp import TerminalIPythonApp from IPython.terminal.embed import InteractiveShellEmbed try: import configparser except: import ConfigParser as configparser shell = get_ipython() if shell is None: # Not inside IPython # Build a terminal app in order to force ipython to load the # configuration ipapp = TerminalIPythonApp() # Avoid output (banner, prints) ipapp.interact = False ipapp.initialize(['--no-term-title']) shell = ipapp.shell else: # Running inside IPython # Detect if embed shell or not and display a message if isinstance(shell, InteractiveShellEmbed): sys.stderr.write( "\nYou are currently into an embedded ipython shell,\n" "the configuration will not be loaded.\n\n") # Let IPython decide about which debugger class to use # This is especially important for tools that fiddle with stdout
def main(argv=None): if argv is None: argv = sys.argv try: prog_name = argv[0] with_ipshell = False ignore_lock = False no_latex_output = True list_invoices = False output_file_name = "data.lco" invoice_number = None try: opts, args = getopt.getopt(argv[1:], "fhiln:po:", ["help"]) except getopt.error as msg: raise Usage(msg) for opt in opts: if opt[0] in ["-f"]: print("ignoring lock") ignore_lock = True if opt[0] in ["-h","--help"]: raise Usage("Help:") if opt[0] in ["-i"]: print("Using ipshell") with_ipshell = True if opt[0] in ["-l"]: print("listing all invoices") list_invoices=True if opt[0] in ["-n"]: invoice_number = int(opt[1]) print("using invoice number", invoice_number) no_latex_output = False if opt[0] in ["-o"]: output_file_name = opt[1] print("using output file", output_file_name) if len(args)>1: print("opts:",opts,"args:",args) raise Usage("Only one input can be accepted !") if len(args)==0: raise Usage("No input given !") input_url = args[0] except Usage as err: if err.msg == "Help:": retcode=0 else: print("Error:", err.msg, file=sys.stderr) print("for help use --help", file=sys.stderr) retcode=2 print("Generate a LaTeX invoice or print out all invoices.") print() print("Usage:") print() print("Invoke with",prog_name,"input.") print("where input is") print(" filename") print("or file://filename") print("or mysql://user:password@host/databasename") print() print("-f force open = ignore lock") print("-h or --help for this help") print("-i for ipython shell") print("-l list all invoices") print("-n number use invoice number (no. from previous run with -l)") print("-o name use name as outputfile. default: data.lco") return retcode # Try to open the given input try: session = gnucash.Session(input_url,ignore_lock=ignore_lock) except Exception as exception: print("Problem opening input.") print(exception) return 2 book = session.book root_account = book.get_root_account() comm_table = book.get_table() EUR = comm_table.lookup("CURRENCY", "EUR") invoice_list=get_all_invoices(book) if list_invoices: for number,invoice in enumerate(invoice_list): print(str(number)+")") print(invoice) if not (no_latex_output): if invoice_number == None: print("Using the first invoice:") invoice_number=0 invoice=invoice_list[invoice_number] print("Using the following invoice:") print(invoice) lco_str=invoice_to_lco(invoice) # Opening output file f=open(output_file_name,"w") lco_str=lco_str.encode("latin1") f.write(lco_str) f.close() if with_ipshell: app = TerminalIPythonApp.instance() app.initialize(argv=[]) # argv=[] instructs IPython to ignore sys.argv app.start() #session.save() session.end()
here = abspath(dirname(__file__)) options = join(here, 'source', 'config', 'options') generated = join(options, 'config-generated.txt') def write_doc(name, title, app, preamble=None): filename = join(options, name + '.rst') with open(filename, 'w') as f: f.write(title + '\n') f.write(('=' * len(title)) + '\n') f.write('\n') if preamble is not None: f.write(preamble + '\n\n') f.write(app.document_config_options()) if __name__ == '__main__': # Touch this file for the make target with open(generated, 'w'): pass write_doc('terminal', 'Terminal IPython options', TerminalIPythonApp()) write_doc( 'kernel', 'IPython kernel options', IPKernelApp(), preamble=( "These options can be used in :file:`ipython_kernel_config.py`. " "The kernel also respects any options in `ipython_config.py`"), )
print str(recommended) user_ns = user_ns or {} try: user_ns.update(get_args(sys.argv)) except exception.SpockException, e: print e.message print 'Starting normal IPython console' except KeyboardInterrupt: print "\nUser pressed Ctrl+C. Exiting..." sys.exit() except Exception, e: print 'spock exited with an unmanaged exception: %s' % str(e) sys.exit(-2) app = TerminalIPythonApp.instance() app.initialize() #config = get_config() return app def mainloop(app=None, user_ns=None): if app is None: app = start(user_ns) app.start() def prepare_input_handler(): # initialize input handler as soon as possible import sardana.spock.inputhandler _ = sardana.spock.inputhandler.InputHandler()