def main(verbose, interactive, multiline, serve, batch, test, fname='',
*extra):
"Runner for plac tools, plac batch files and plac tests"
baseparser = plac.parser_from(main)
if not fname:
baseparser.print_help()
elif sys.argv[1] == fname: # script mode
plactool = plac.import_main(fname)
plactool.prog = os.path.basename(sys.argv[0]) + ' ' + fname
out = plac.call(plactool, sys.argv[2:], eager=False)
if plac.iterable(out):
for output in out:
print(output)
else:
print(out)
elif interactive or multiline or serve:
plactool = plac.import_main(fname, *extra)
plactool.prog = ''
i = plac.Interpreter(plactool)
if interactive:
i.interact(verbose=verbose)
elif multiline:
i.multiline(verbose=verbose)
elif serve:
i.start_server(serve)
elif batch:
run((fname,) + extra, 'execute', verbose)
elif test:
run((fname,) + extra, 'doctest', verbose)
print('run %s plac test(s)' % (len(extra) + 1))
else:
baseparser.print_usage()
def test():
with plac.Interpreter(ishelve.main) as i:
i.check('.clear', 'cleared the shelve')
i.check('a=1', 'setting a=1')
i.check('a', '1')
i.check('.delete=a', 'deleted a')
i.check('a', 'a: not found')
def main(interactive, *subcommands):
"""
This script works both interactively and non-interactively.
Use .help to see the internal commands.
"""
if interactive:
plac.Interpreter(ishelve.main).interact()
else:
for out in plac.call(ishelve.main, subcommands):
print(out)
def run(fnames, cmd, verbose):
"Run batch scripts and tests"
for fname in fnames:
with open(fname) as f:
lines = list(f)
if not lines[0].startswith('#!'):
sys.exit('Missing or incorrect shebang line!')
firstline = lines[0][2:] # strip the shebang
init_args = shlex.split(firstline)
tool = plac.import_main(*init_args)
command = getattr(plac.Interpreter(tool), cmd) # doctest or execute
if verbose:
sys.stdout.write('Running %s with %s' % (fname, firstline))
command(lines[1:], verbose=verbose)
def startPlacServer(self, mode):
if mode == ROUTER_MODE_DISABLED:
return
self.interpreter = plac.Interpreter(self.shell)
if mode == ROUTER_MODE_TELNET:
self.interpreter.start_server() # Loop
elif mode == ROUTER_MODE_DBUS:
from util import dbus_ctrl
dbus_ctrl.startDbusProcess(self) # Loop
elif mode == ROUTER_MODE_INTERACTIVE:
path = self.simCtrl.getCurrentFile().path
self.interpreter.interact(prompt="\n%s>" % path)
else:
raise Exception("Unexpected mode")
def submit_tasks(self):
npoints = math.ceil(self.npoints / self.n_cpu)
self.i = plac.Interpreter(self).__enter__()
return [
self.i.submit('calc_pi %d' % npoints) for _ in range(self.n_cpu)
]
from __future__ import with_statement
from Tkinter import *
from importer3 import FakeImporter
def taskwidget(root, task, tick=500):
"A Label widget showing the output of a task every 500 ms"
sv = StringVar(root)
lb = Label(root, textvariable=sv)
def show_outlist():
try:
out = task.outlist[-1]
except IndexError: # no output yet
out = ''
sv.set('%s %s' % (task, out))
root.after(tick, show_outlist)
root.after(0, show_outlist)
return lb
def monitor(tasks):
root = Tk()
for task in tasks:
task.run()
taskwidget(root, task).pack()
root.mainloop()
if __name__ == '__main__':
import plac
with plac.Interpreter(plac.call(FakeImporter)) as i:
tasks = [i.submit('import_file f1'), i.submit('import_file f2')]
monitor(tasks)
from __future__ import with_statement
import plac
class Hello(object):
mpcommands = ['hello', 'quit']
def hello(self):
yield 'hello'
def quit(self):
raise plac.Interpreter.Exit
if __name__ == '__main__':
i = plac.Interpreter(Hello())
i.add_monitor(plac.TkMonitor('tkmon'))
i.interact()
def __exit__(self, etype, exc, tb):
self.sh.close()
def set(self, name, value):
"set name value"
yield 'setting %s=%s' % (name, value)
self.sh[name] = value
def show(self, *names):
"show given parameters"
for name in names:
yield '%s = %s' % (name, self.sh[name]) # no error checking
def showall(self):
"show all parameters"
for name in self.sh:
yield '%s = %s' % (name, self.sh[name])
def delete(self, name=''):
"delete given parameter (or everything)"
if name == '':
yield 'deleting everything'
self.sh.clear()
else:
yield 'deleting %s' % name
del self.sh[name] # no error checking
if __name__ == '__main__':
plac.Interpreter(plac.call(ShelveInterface)).interact()
"install packages"
return ('installing ', packages)
@plac.annotations(packages='package(s) to operate on')
def remove(packages):
"Remove packages"
return ('Removing ', packages)
@plac.annotations(message=('commit message', 'option'))
def update(message):
"download latest packages info from mirror"
return ('update ', message)
@plac.annotations(quiet=('summary information', 'flag', 'q'))
def setup(quiet):
"create Osgeo4w filesystem skeleton"
return ('setup ', quiet)
def __missing__(name):
return ('Command %r does not exist' % name, )
def __exit__(etype, exc, tb):
"Will be called automatically at the end of the interpreter loop"
if etype in (None, GeneratorExit): # success
print('ok')
if __name__ == '__main__':
plac.Interpreter(plac.call(AptInterface)).interact()
#@-leo
import multiprocessing, subprocess, random, time
import plac
from ishelve2 import ShelveInterface
i = plac.Interpreter(ShelveInterface(configfile=None))
COMMANDS = ['''\
help
set a 1
''',
'''\
set b 1
wrong command
showall
''']
def telnet(commands, port):
po = subprocess.Popen(['telnet', 'localhost', str(port)],
stdin=subprocess.PIPE)
try:
for cmd in commands.splitlines():
po.stdin.write((cmd + '\n').encode('ascii'))
time.sleep(.1) # wait a bit for the server to answer
finally:
po.stdin.close()
def test():
port = random.choice(range(2000, 20000))
server = multiprocessing.Process(target=i.start_server, args=(port,))
server.start()
clients = []
"""
You can run this script as
$ python read_stdin.py < ishelve.bat
"""
from __future__ import with_statement
import sys
from ishelve import ishelve
import plac
if __name__ == '__main__':
with plac.Interpreter(ishelve) as i:
for line in sys.stdin:
print(i.send(line))
def main(port=2199):
main = FakeImporter('dsn')
plac.Interpreter(main).start_server(port)
