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():
"""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 __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 __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 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_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 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 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 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 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 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 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 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 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(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 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 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 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 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 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 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 _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 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 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 ipython():
from IPython.terminal.ipapp import TerminalIPythonApp
app = TerminalIPythonApp.instance()
app.initialize(argv=[]) # argv=[] instructs IPython to ignore sys.argv
app.start()
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()
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()
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()
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())
