def __init__(self, host):
self.host = host
self.socket = None
self.cli = CommandLineInterface(
application=create_prompt_application('> '),
eventloop=create_asyncio_eventloop())
sys.stdout = self.cli.stdout_proxy()
async def td_client_interactive_shell(callback):
eventloop = create_asyncio_eventloop()
key_bindings_manager = KeyBindingManager.for_prompt()
load_td_client_kay_bindings(key_bindings_manager=key_bindings_manager)
cli = CommandLineInterface(
application=create_prompt_application('待开发指令,just echo: ',
key_bindings_registry=key_bindings_manager.registry,
get_bottom_toolbar_tokens=get_td_client_bottom_toolbar_tokens,
style=get_td_client_styles()
),
eventloop=eventloop
)
sys.stdout = cli.stdout_proxy()
while True:
try:
result = await cli.run_async()
if callback is not None:
resp = callback(user_input=result.text)
print(resp)
else:
print('You said: "{0}"'.format(result.text))
except (EOFError, KeyboardInterrupt):
return
def interactive_shell():
"""
Coroutine that shows the interactive command line.
"""
# Create an asyncio `EventLoop` object. This is a wrapper around the
# asyncio loop that can be passed into prompt_toolkit.
eventloop = create_asyncio_eventloop()
# Create interface.
cli = CommandLineInterface(application=create_default_application(
'Say something inside the event loop: '),
eventloop=eventloop)
# Patch stdout in something that will always print *above* the prompt when
# something is written to stdout.
sys.stdout = cli.stdout_proxy()
# Run echo loop. Read text from stdin, and reply it back.
while True:
try:
result = yield from cli.run_async()
print('You said: "%s"\n' % result.text)
except (EOFError, KeyboardInterrupt):
loop.stop()
print('Qutting event loop. Bye.')
return
def interactive_shell():
"""
Coroutine that shows the interactive command line.
"""
# Create an asyncio `EventLoop` object. This is a wrapper around the
# asyncio loop that can be passed into prompt_toolkit.
eventloop = create_asyncio_eventloop()
# Create interface.
cli = CommandLineInterface(
application=create_default_application('Say something inside the event loop: '),
eventloop=eventloop)
# Patch stdout in something that will always print *above* the prompt when
# something is written to stdout.
sys.stdout = cli.stdout_proxy()
# Run echo loop. Read text from stdin, and reply it back.
while True:
try:
result = yield from cli.run_async()
print('You said: "%s"\n' % result.text)
except (EOFError, KeyboardInterrupt):
loop.stop()
print('Qutting event loop. Bye.')
return
async def connected(self):
# prompt_toolkit internally checks if it's on windows during output rendering but
# we need to force that we use Vt100_Output not Win32_Output
from prompt_toolkit import renderer
renderer.is_windows = lambda: False
def get_size():
return self._size
self._cli = CommandLineInterface(
application=create_prompt_application(self._shell.prompt),
eventloop=UnstoppableEventLoop(create_asyncio_eventloop(self._loop)),
input=PatchedStdinInput(sys.stdin),
output=Vt100_Output(self, get_size))
self._cb = self._cli.create_eventloop_callbacks()
self._inputstream = InputStream(self._cb.feed_key)
# Taken from prompt_toolkit telnet server
# https://github.com/jonathanslenders/python-prompt-toolkit/blob/99fa7fae61c9b4ed9767ead3b4f9b1318cfa875d/prompt_toolkit/contrib/telnet/server.py#L165
self._cli._is_running = True
if self._shell.welcome_message is not None:
self.send(self._shell.welcome_message.encode())
self._cli._redraw()
def connected(self):
# prompt_toolkit internally checks if it's on windows during output rendering but
# we need to force that we use Vt100_Output not Win32_Output
from prompt_toolkit import renderer
renderer.is_windows = lambda: False
def get_size():
return self._size
self._cli = CommandLineInterface(
application=create_prompt_application(self._shell.prompt),
eventloop=UnstoppableEventLoop(create_asyncio_eventloop(
self._loop)),
input=PatchedStdinInput(sys.stdin),
output=Vt100_Output(self, get_size))
self._cb = self._cli.create_eventloop_callbacks()
self._inputstream = InputStream(self._cb.feed_key)
# Taken from prompt_toolkit telnet server
# https://github.com/jonathanslenders/python-prompt-toolkit/blob/99fa7fae61c9b4ed9767ead3b4f9b1318cfa875d/prompt_toolkit/contrib/telnet/server.py#L165
self._cli._is_running = True
if self._shell.welcome_message is not None:
self.send(self._shell.welcome_message.encode())
self._cli._redraw()
async def interactive_shell():
"""
Like `interactive_shell`, but doing things manual.
"""
# Create an asyncio `EventLoop` object. This is a wrapper around the
# asyncio loop that can be passed into prompt_toolkit.
eventloop = create_asyncio_eventloop()
# Create interface.
cli = CommandLineInterface(
application=create_prompt_application('Say something inside the event loop: '),
eventloop=eventloop
)
# Patch stdout in something that will always print *above* the prompt when
# something is written to stdout.
sys.stdout = cli.stdout_proxy()
# Run echo loop. Read text from stdin, and reply it back.
while True:
try:
result = await cli.run_async()
print('You said: "{0}"'.format(result.text))
except (EOFError, KeyboardInterrupt):
return
def main(args=sys.argv[1:]):
parser, args = parseargs(args)
if args.debug:
log.setLevel(logging.DEBUG)
loop = asyncio.get_event_loop()
grbl = SerialGrbl(args.device, args.baudrate, loop)
registry = load_key_bindings_for_prompt()
history = InMemoryHistory()
app_loop = create_asyncio_eventloop(loop=loop)
app = create_prompt_application(message='> ',
history=history,
key_bindings_registry=registry)
cli = CommandLineInterface(application=app, eventloop=app_loop)
for key, func in key_to_func.items():
func = functools.partial(func, grbl=grbl, loop=loop)
registry.add_binding(key, eager=True)(func)
try:
main_task = asyncio.ensure_future(main_coro(loop, grbl, cli))
return loop.run_until_complete(main_task)
except (EOFError, KeyboardInterrupt):
main_task.cancel()
return 1
except serial.SerialException as error:
log.fatal(error)
return 1
def __init__(self, base_dir, config):
for module in config.get('modules'):
import_module(module)
self.tasks = TaskManager(self)
self.window = MainWindow(self)
self.style = ToshStyle(config.get('ui', 'style'))
self._parser = CommandLineParser(self, base_dir)
self.config = config
self.variables = {}
application = Application(
layout=self.window,
buffer=Buffer(
enable_history_search=True,
complete_while_typing=False,
is_multiline=False,
history=FileHistory(base_dir + "/history"),
# validator=validator,
completer=CommandLineCompleter(self),
auto_suggest=AutoSuggestFromHistory(),
accept_action=AcceptAction(self.run_command),
),
mouse_support=config.get('ui', 'mouse'),
style=self.style,
key_bindings_registry=get_key_bindings(self),
use_alternate_screen=True)
self._cli = CommandLineInterface(application=application,
eventloop=create_asyncio_eventloop(),
output=create_output(true_color=True))
def __init__(self, name=None):
ptk_loop = create_asyncio_eventloop()
self.loop = ptk_loop.loop
self.cli = self._get_cli(ptk_loop)
sys.stdout = self.cli.stdout_proxy(raw=True)
super().__init__(name=name)
self._prompt = PROMPT
self._prompt_more = PROMPT_MORE
self._multi_line = False
self._exit_on_next_kb_interrupt = False
def embed(globals=None,
locals=None,
vi_mode=False,
history_filename=None,
no_colors=False,
startup_paths=None,
patch_stdout=False,
return_asyncio_coroutine=False):
"""
Call this to embed Python shell at the current point in your program.
It's similar to `IPython.embed` and `bpython.embed`. ::
from prompt_toolkit.contrib.repl import embed
embed(globals(), locals(), vi_mode=False)
:param vi_mode: Boolean. Use Vi instead of Emacs key bindings.
"""
globals = globals or {}
locals = locals or globals
def get_globals():
return globals
def get_locals():
return locals
# Create eventloop.
if return_asyncio_coroutine:
eventloop = create_asyncio_eventloop()
else:
eventloop = create_eventloop()
# Create REPL.
repl = PythonRepl(eventloop,
get_globals,
get_locals,
vi_mode=vi_mode,
history_filename=history_filename,
style=(None if no_colors else PythonStyle))
# Start repl.
patch_context = repl.cli.patch_stdout_context(
) if patch_stdout else DummyContext()
if return_asyncio_coroutine:
def coroutine():
with patch_context:
for future in repl.asyncio_start_repl():
yield future
return coroutine()
else:
with patch_context:
repl.start_repl(startup_paths=startup_paths)
def __init__(self):
application = Application(
buffers=self.buffers,
layout=self.layout,
key_bindings_registry=self.manager.registry,
mouse_support=True,
use_alternate_screen=True,
)
eventloop = create_asyncio_eventloop()
self.cli = CommandLineInterface(application=application,
eventloop=eventloop)
sys.stdout = self.cli.stdout_proxy()
def main():
loop = asyncio.get_event_loop()
try:
coro = loop.create_connection(Client, '192.168.1.2', 9999)
loop.run_until_complete(coro)
asyncio. async (client_talk(create_asyncio_eventloop(loop), coro))
except ConnectionRefusedError:
sys.stderr.write("Error connecting.\nQuitting.\n")
return
try:
loop.run_forever()
except KeyboardInterrupt:
pass
loop.close()
def run_async(self):
''' Runs the user interface as an async task. '''
eventloop = create_asyncio_eventloop()
self.cli = CommandLineInterface(application=self.application,
eventloop=eventloop)
self.cli.focus(COMMAND_BUFFER)
try:
while True:
result = yield from self.cli.run_async()
if result is None:
print('Exiting...')
return
except (EOFError, KeyboardInterrupt):
return
finally:
eventloop.close()
def __init__(self, get_globals, get_locals=None):
assert callable(get_globals)
assert get_locals is None or callable(get_locals)
self._chan = None
def _globals():
data = get_globals()
data.setdefault('print', self._print)
return data
repl = PythonRepl(get_globals=_globals,
get_locals=get_locals or _globals)
# Disable open-in-editor and system prompt. Because it would run and
# display these commands on the server side, rather than in the SSH
# client.
repl.enable_open_in_editor = False
repl.enable_system_bindings = False
# PipInput object, for sending input in the CLI.
# (This is something that we can use in the prompt_toolkit event loop,
# but still write date in manually.)
self._input_pipe = PipeInput()
# Output object. Don't render to the real stdout, but write everything
# in the SSH channel.
class Stdout(object):
def write(s, data):
if self._chan is not None:
self._chan.write(data.replace('\n', '\r\n'))
def flush(s):
pass
# Create command line interface.
self.cli = CommandLineInterface(
application=repl.create_application(),
eventloop=create_asyncio_eventloop(),
input=self._input_pipe,
output=Vt100_Output(Stdout(), self._get_size))
self._callbacks = self.cli.create_eventloop_callbacks()
def __init__(self, get_globals, get_locals=None):
assert callable(get_globals)
assert get_locals is None or callable(get_locals)
self._chan = None
def _globals():
data = get_globals()
data.setdefault('print', self._print)
return data
repl = PythonRepl(get_globals=_globals,
get_locals=get_locals or _globals)
# Disable open-in-editor and system prompt. Because it would run and
# display these commands on the server side, rather than in the SSH
# client.
repl.enable_open_in_editor = False
repl.enable_system_bindings = False
# PipInput object, for sending input in the CLI.
# (This is something that we can use in the prompt_toolkit event loop,
# but still write date in manually.)
self._input_pipe = PipeInput()
# Output object. Don't render to the real stdout, but write everything
# in the SSH channel.
class Stdout(object):
def write(s, data):
if self._chan is not None:
self._chan.write(data.replace('\n', '\r\n'))
def flush(s):
pass
# Create command line interface.
self.cli = CommandLineInterface(application=repl.create_application(),
eventloop=create_asyncio_eventloop(),
input=self._input_pipe,
output=Vt100_Output(
Stdout(), self._get_size))
self._callbacks = self.cli.create_eventloop_callbacks()
def embed(globals=None, locals=None, vi_mode=False, history_filename=None, no_colors=False,
startup_paths=None, patch_stdout=False, return_asyncio_coroutine=False):
"""
Call this to embed Python shell at the current point in your program.
It's similar to `IPython.embed` and `bpython.embed`. ::
from prompt_toolkit.contrib.repl import embed
embed(globals(), locals(), vi_mode=False)
:param vi_mode: Boolean. Use Vi instead of Emacs key bindings.
"""
globals = globals or {}
locals = locals or globals
def get_globals():
return globals
def get_locals():
return locals
# Create eventloop.
if return_asyncio_coroutine:
eventloop = create_asyncio_eventloop()
else:
eventloop = create_eventloop()
# Create REPL.
repl = PythonRepl(eventloop, get_globals, get_locals, vi_mode=vi_mode,
history_filename=history_filename,
style=(None if no_colors else PythonStyle))
# Start repl.
patch_context = repl.cli.patch_stdout_context() if patch_stdout else DummyContext()
if return_asyncio_coroutine:
def coroutine():
with patch_context:
for future in repl.asyncio_start_repl():
yield future
return coroutine()
else:
with patch_context:
repl.start_repl(startup_paths=startup_paths)
def main():
# Create an asynchronous event loop.
loop = asyncio.get_event_loop()
try:
# We are creating a coroutine - a tcp client
couroutine = loop.create_connection(Client, 'localhost', 9999)
loop.run_until_complete(couroutine)
# setting a future allows you to declare something that hasn't been called yet.
# So we set a client which will get called down the line, but not yet.
asyncio.ensure_future(client_talk(create_asyncio_eventloop(loop)))
except ConnectionRefusedError:
sys.stderr.write("Error connecting.\nQuitting.\n")
return
try:
loop.run_forever() # Now run forever except for a keyboard interrupt.
except KeyboardInterrupt:
pass
loop.close() # Then close the event loop when done.
def __init__(self, repository, eventloop, tests, config, em, runner_class):
self.repository = repository
self.history = InMemoryHistory()
self.tests = tests
self.config = config
self.displayer = TestDisplayer(self.tests)
self.eventloop = eventloop
self.runner_class = runner_class
self.em = em
# Register the callbacks
self.em.register(self.displayer.parse_message)
self.application = create_prompt_application("> ",
history=self.history,
completer=completer)
self.cli = CommandLineInterface(
application=self.application,
eventloop=create_asyncio_eventloop(eventloop))
sys.stdout = self.cli.stdout_proxy()
def __init__(self, style):
self._commands = {}
for d in dir(self.__class__):
if d.startswith('do_'):
name = d[3:]
func = getattr(self, d)
doc = textwrap.dedent(func.__doc__ or '')
self._commands[name] = (func, doc)
self._history = InMemoryHistory()
self._application = create_prompt_application(
get_prompt_tokens=self.get_prompt_tokens,
style=style,
on_abort=AbortAction.RETURN_NONE,
history=self._history)
self._cli = CommandLineInterface(application=self._application,
output=create_output(true_color=True),
eventloop=create_asyncio_eventloop())
self._style = style
async def interactive_shell(bot):
eventloop = create_asyncio_eventloop(bot.loop)
cli = CommandLineInterface(
application=create_prompt_application(':> ',
completer=myCompleter(bot)),
eventloop=eventloop,
)
sys.stdout = cli.stdout_proxy()
while True:
try:
result = await cli.run_async()
if result.text.startswith("#"):
parse = total.parseString(result.text[1:], parseAll=True)
try:
resp = await bot.run_parse(parse, Message(server='SHELL'))
for res in resp:
print(res.text)
except PipeError as e:
for loc, err in sorted(e.exs, key=lambda x: x[0]):
if isinstance(err, PipeError):
for loc2, err2 in sorted(err.exs,
key=lambda x: x[0]):
try:
raise err2
except Exception: # how to print to terminal
traceback.print_exc()
else:
try:
raise err
except Exception: # how to print to terminal
traceback.print_exc()
else:
try:
await aexec(result.text, local={'bot': bot})
except Exception:
traceback.print_exc()
except (EOFError, KeyboardInterrupt):
bot.loop.stop()
async def interactive_shell():
"""
Like `interactive_shell`, but doing things manual.
"""
# Create an asyncio `EventLoop` object. This is a wrapper around the
# asyncio loop that can be passed into prompt_toolkit.
eventloop = create_asyncio_eventloop()
# Create interface.
cli = CommandLineInterface(application=create_prompt_application(
'Say something inside the event loop: '),
eventloop=eventloop)
# Patch stdout in something that will always print *above* the prompt when
# something is written to stdout.
sys.stdout = cli.stdout_proxy()
# Run echo loop. Read text from stdin, and reply it back.
while True:
try:
result = await cli.run_async()
print('You said: "{0}"'.format(result.text))
except (EOFError, KeyboardInterrupt):
return
def embed(globals=None, locals=None, configure=None,
vi_mode=False, history_filename=None, title=None,
startup_paths=None, patch_stdout=False, return_asyncio_coroutine=False):
"""
Call this to embed Python shell at the current point in your program.
It's similar to `IPython.embed` and `bpython.embed`. ::
from prompt_toolkit.contrib.repl import embed
embed(globals(), locals())
:param vi_mode: Boolean. Use Vi instead of Emacs key bindings.
:param configure: Callable that will be called with the `PythonRepl` as a first
argument, to trigger configuration.
:param title: Title to be displayed in the terminal titlebar. (None or string.)
"""
assert configure is None or callable(configure)
# Default globals/locals
if globals is None:
globals = {
'__name__': '__main__',
'__package__': None,
'__doc__': None,
'__builtins__': six.moves.builtins,
}
locals = locals or globals
def get_globals():
return globals
def get_locals():
return locals
# Create eventloop.
if return_asyncio_coroutine:
eventloop = create_asyncio_eventloop()
else:
eventloop = create_eventloop()
# Create REPL.
repl = PythonRepl(get_globals, get_locals, vi_mode=vi_mode,
history_filename=history_filename,
startup_paths=startup_paths)
if title:
repl.terminal_title = title
if configure:
configure(repl)
cli = PythonCommandLineInterface(python_input=repl, eventloop=eventloop)
# Start repl.
patch_context = cli.patch_stdout_context() if patch_stdout else DummyContext()
if return_asyncio_coroutine:
def coroutine():
with patch_context:
for future in cli.run_async():
yield future
return coroutine()
else:
with patch_context:
cli.run()
# This can be done another way in bulk, but it is easier to send them one and display it in terminal
# on the client side, instead of having the client responsible for formatting the display.
for c in contacts:
self.send("{}".format(c))
# ===============================================================================
if __name__ == '__main__':
print("{0:s} [SERVER]: starting.".format(tstamp()))
loop = asyncio.get_event_loop()
# Creates the asychronous server, is a generic base class of asynchio
coroutine = loop.create_server(Server, 'localhost', 9999)
server = loop.run_until_complete(coroutine)
# If this is kinda confusing look up what "futures" are in python
# This creates a "future" coroutine for the console. It hasn't been created yet though.
asyncio.ensure_future(server_console(create_asyncio_eventloop(loop)))
for socket in server.sockets:
# Just printing the address and port that it is running on.
print("{0:s} [SERVER]: running on {1:}".format(tstamp(), socket.getsockname()))
try:
loop.run_forever() # Now run forever, lest you get a keyboard interrupt (ctrl+c)
except KeyboardInterrupt:
loop.close()
print("Bye bye.")
Window(content=BufferControl(buffer_name=ASYNC_BUFFER)),
])
buffers={
DEFAULT_BUFFER: Buffer(is_multiline=True),
ASYNC_BUFFER: Buffer(is_multiline=True),
}
@registry.add_binding(Keys.ControlC, eager=True)
def key_close(event):
event.cli.set_return_value(KILL_APP)
eventloop = create_asyncio_eventloop()
application = Application(buffers=buffers,
key_bindings_registry=registry,
layout=layout,
use_alternate_screen=True)
cli = CommandLineInterface(
application=application,
eventloop=eventloop)
WARHAMMER_QUOTES = ['A good soldier obeys without question. A good officer commands without doubt.',
'Blessed is the mind too small for doubt.',
'To admit defeat is to blaspheme against the Emperor.',
'For those who seek perfection there can be no rest on this side of the grave.',
'The difference between heresy and treachery is ignorance.',
'Knowledge is power, guard it well.',
async def xmpp_client():
try:
with open(os.path.join(os.getenv("HOME"), ".xc.conf"), "r") as config_file:
config = json.load(config_file)
if "jid" not in config:
raise Exception("No JID")
except Exception as e:
print("Error reading configuration file.\n" + str(e) + "Please create ~/.xc.conf with content like:\n{\"jid\": \"[email protected]\"}")
sys.exit(1)
async def get_secret(jid, attempt):
if attempt > 2:
return None
try:
return await prompt_async("Secret (will not be stored): ", is_password=True)
except:
return None
async def tls_handshake_callback(verifier):
print("Warning: blindly accepting TLS certificate from %s" % verifier.transport.get_extra_info("server_hostname"))
return True
pin_store = PublicKeyPinStore()
pin_store.import_from_json(config.get("pkps", {}))
my_jid = aioxmpp.JID.fromstr(config["jid"])
security = aioxmpp.make_security_layer(get_secret, pin_store=pin_store, pin_type=PinType.PUBLIC_KEY, post_handshake_deferred_failure=tls_handshake_callback)
client = aioxmpp.PresenceManagedClient(my_jid, security)
presence = client.summon(aioxmpp.presence.Service)
roster = client.summon(aioxmpp.roster.Service)
class RosterItemAndCommandCompleter(Completer):
def get_completions(self, document, complete_event):
text = document.text
if not text or " " in text or ":" in text:
return
if text[0] == "/":
part = text[1:]
for command in ("roster", "name", "add", "del", "help", "quit"):
if command.startswith(part):
yield Completion(command + " ", start_position=-len(part), display=command)
elif roster is not None:
for item in roster.items.values():
if item.name.startswith(text):
yield Completion(item.name + ": ", start_position=-len(text), display=item.name)
completer = RosterItemAndCommandCompleter()
history = InMemoryHistory()
next_recipient = None
def get_prompt_tokens(_):
return ((Token.Prompt, "%s> " % (next_recipient or "")),)
cli_app = create_prompt_application(get_prompt_tokens=get_prompt_tokens,
completer=completer,
reserve_space_for_menu=0,
history=history,
get_title=lambda: "xc")
cli_loop = create_asyncio_eventloop()
cli = CommandLineInterface(application=cli_app, eventloop=cli_loop)
above_prompt = cli.stdout_proxy()
def name_for_jid(jid):
try:
return roster.items[jid].name
except:
return str(jid)
def peer_available(jid, presence):
above_prompt.write("%s is now online\n" % name_for_jid(jid.bare()))
presence.on_available.connect(peer_available)
def peer_unavailable(jid, presence):
above_prompt.write("%s is now offline\n" % name_for_jid(jid.bare()))
presence.on_unavailable.connect(peer_unavailable)
def message_received(msg):
content = " ".join(msg.body.values())
if content:
above_prompt.write("%s: %s\n" % (name_for_jid(msg.from_.bare()), content))
client.stream.register_message_callback("chat", None, message_received)
try:
async with client.connected() as stream:
while True:
try:
document = await cli.run_async()
except (KeyboardInterrupt, EOFError):
break
line = document.text
if line.startswith("/"):
try:
command, *args = line[1:].split(" ")
if command == "roster":
rows = [(item.name, str(jid), item.subscription) for jid, item in roster.items.items() if jid != my_jid]
widths = [max(len(row[i] or "") for row in rows) for i in range(len(rows[0] or ""))]
for row in rows:
above_prompt.write(" ".join((cell or "").ljust(widths[i]) for i, cell in enumerate(row)) + "\n")
elif command == "name":
try:
jid = args[0]
name = args[1]
except IndexError:
above_prompt.write("usage: /name JID NAME\n")
else:
jid = aioxmpp.JID.fromstr(jid)
await roster.set_entry(jid, name=name)
elif command == "add":
try:
jid = args[0]
except IndexError:
above_prompt.write("usage: /add JID\n")
else:
jid = aioxmpp.JID.fromstr(jid)
await roster.set_entry(jid)
roster.subscribe(jid)
roster.approve(jid)
elif command == "del":
try:
jid = args[0]
except IndexError:
above_prompt.write("usage: /del JID\n")
else:
jid = aioxmpp.JID.fromstr(jid)
await roster.remove_entry(jid)
elif command == "quit":
break
elif command == "help":
above_prompt.write("NAME: MESSAGE send MESSAGE to NAME\n"
"MESSAGE send MESSAGE to the last correspondent\n"
"/roster print the roster\n"
"/add JID add JID to the roster\n"
"/del JID remove JID from the roster\n"
"/name JID NAME set the name of JID to NAME\n"
"/quit disconnect and then quit (also ctrl-d, ctrl-c)\n"
"/help this help\n")
else:
above_prompt.write("unrecognised command\n")
except Exception as e:
above_prompt.write("exception handling command: %s\n" % e)
else:
try:
try:
recipient, message = line.split(": ", 1)
except ValueError:
if next_recipient is not None:
recipient = next_recipient
message = line
else:
above_prompt.write("recipient: message\n")
continue
jid_for_name = lambda r: next((jid for jid, item in roster.items.items() if item.name == r), None)
jid = jid_for_name(recipient)
if jid is None:
if next_recipient is not None and recipient != next_recipient:
recipient = next_recipient
jid = jid_for_name(recipient)
message = line
if jid is None:
above_prompt.write("unknown recipient: %s\n" % recipient)
continue
msg = aioxmpp.Message(to=jid, type_="chat")
msg.body[None] = message
await stream.send_and_wait_for_sent(msg)
next_recipient = recipient
except Exception as e:
above_prompt.write("exception sending message: %s\n" % e)
print("Disconnecting…")
client.stop()
except Exception as e:
print("Failed to connect: %s" % e)
def prompt(self, message="", **kwargs):
"""Get input from the user and return it.
This is a wrapper around a lot of prompt_toolkit functionality and
can be a replacement for raw_input. (or GNU readline.) If you want
to keep your history across several calls, create one
`~prompt_toolkit.history.History instance and pass it every
time. This function accepts many keyword arguments. Except for the
following. they are a proxy to the arguments of
create_prompt_application().
Parameters
----------
patch_stdout : file-like, optional
Replace ``sys.stdout`` by a proxy that ensures that print
statements from other threads won't destroy the prompt. (They
will be printed above the prompt instead.)
return_asyncio_coroutine : bool, optional
When True, return a asyncio coroutine. (Python >3.3)
Notes
-----
This method was forked from the mainline prompt-toolkit repo.
Copyright (c) 2014, Jonathan Slenders, All rights reserved.
"""
patch_stdout = kwargs.pop("patch_stdout", False)
return_asyncio_coroutine = kwargs.pop("return_asyncio_coroutine",
False)
if return_asyncio_coroutine:
eventloop = create_asyncio_eventloop()
else:
eventloop = kwargs.pop("eventloop", None) or create_eventloop()
# Create CommandLineInterface.
if self.cli is None:
if builtins.__xonsh_env__.get("VI_MODE"):
editing_mode = EditingMode.VI
else:
editing_mode = EditingMode.EMACS
kwargs["editing_mode"] = editing_mode
cli = CommandLineInterface(
application=create_prompt_application(message, **kwargs),
eventloop=eventloop,
output=create_output(),
)
self.cli = cli
else:
cli = self.cli
# Replace stdout.
patch_context = cli.patch_stdout_context(
) if patch_stdout else DummyContext()
# Read input and return it.
if return_asyncio_coroutine:
# Create an asyncio coroutine and call it.
exec_context = {"patch_context": patch_context, "cli": cli}
exec(
textwrap.dedent("""
import asyncio
@asyncio.coroutine
def prompt_coro():
with patch_context:
document = yield from cli.run_async(reset_current_buffer=False)
if document:
return document.text
"""),
exec_context,
)
return exec_context["prompt_coro"]()
else:
# Note: We pass `reset_current_buffer=False`, because that way
# it's easy to give DEFAULT_BUFFER a default value, without it
# getting erased. We don't have to reset anyway, because this is
# the first and only time that this CommandLineInterface will run.
try:
with patch_context:
document = cli.run(reset_current_buffer=False)
if document:
return document.text
except Exception:
xt.print_exception()
# return something to prevent xonsh crash when any
# exceptions raise
return ""
finally:
eventloop.close()
def prompt(self, message="", **kwargs):
"""Get input from the user and return it.
This is a wrapper around a lot of prompt_toolkit functionality and
can be a replacement for raw_input. (or GNU readline.) If you want
to keep your history across several calls, create one
`~prompt_toolkit.history.History instance and pass it every
time. This function accepts many keyword arguments. Except for the
following. they are a proxy to the arguments of
create_prompt_application().
Parameters
----------
patch_stdout : file-like, optional
Replace ``sys.stdout`` by a proxy that ensures that print
statements from other threads won't destroy the prompt. (They
will be printed above the prompt instead.)
return_asyncio_coroutine : bool, optional
When True, return a asyncio coroutine. (Python >3.3)
Notes
-----
This method was forked from the mainline prompt-toolkit repo.
Copyright (c) 2014, Jonathan Slenders, All rights reserved.
"""
patch_stdout = kwargs.pop("patch_stdout", False)
return_asyncio_coroutine = kwargs.pop("return_asyncio_coroutine", False)
if return_asyncio_coroutine:
eventloop = create_asyncio_eventloop()
else:
eventloop = kwargs.pop("eventloop", None) or create_eventloop()
# Create CommandLineInterface.
if self.cli is None:
if builtins.__xonsh__.env.get("VI_MODE"):
editing_mode = EditingMode.VI
else:
editing_mode = EditingMode.EMACS
kwargs["editing_mode"] = editing_mode
cli = CommandLineInterface(
application=create_prompt_application(message, **kwargs),
eventloop=eventloop,
output=create_output(),
)
self.cli = cli
else:
cli = self.cli
# Replace stdout.
patch_context = cli.patch_stdout_context() if patch_stdout else DummyContext()
# Read input and return it.
if return_asyncio_coroutine:
# Create an asyncio coroutine and call it.
exec_context = {"patch_context": patch_context, "cli": cli}
exec(
textwrap.dedent(
"""
import asyncio
@asyncio.coroutine
def prompt_coro():
with patch_context:
document = yield from cli.run_async(reset_current_buffer=False)
if document:
return document.text
"""
),
exec_context,
)
return exec_context["prompt_coro"]()
else:
# Note: We pass `reset_current_buffer=False`, because that way
# it's easy to give DEFAULT_BUFFER a default value, without it
# getting erased. We don't have to reset anyway, because this is
# the first and only time that this CommandLineInterface will run.
try:
with patch_context:
document = cli.run(reset_current_buffer=False)
if document:
return document.text
except Exception:
xt.print_exception()
# return something to prevent xonsh crash when any
# exceptions raise
return ""
finally:
eventloop.close()
def __init__(self, looper, tmpdir, nodeReg, cliNodeReg, debug=False,
logFileName=None):
self.curClientPort = None
logging.root.addHandler(CliHandler(self.out))
self.looper = looper
self.tmpdir = tmpdir
self.nodeReg = nodeReg
self.cliNodeReg = cliNodeReg
# Used to store created clients
self.clients = {} # clientId -> Client
# To store the created requests
self.requests = {}
# To store the nodes created
self.nodes = {}
self.cliCmds = {'status', 'new'}
self.nodeCmds = self.cliCmds | {'keyshare'}
self.helpablesCommands = self.cliCmds | self.nodeCmds
self.simpleCmds = {'status', 'exit', 'quit', 'license'}
self.commands = {'list', 'help'} | self.simpleCmds
self.cliActions = {'send', 'show'}
self.commands.update(self.cliCmds)
self.commands.update(self.nodeCmds)
self.node_or_cli = ['node', 'client']
self.nodeNames = list(self.nodeReg.keys()) + ["all"]
self.debug = debug
self.plugins = []
'''
examples:
status
new node Alpha
new node all
new client Joe
client Joe send <msg>
client Joe show 1
'''
def re(seq):
return '(' + '|'.join(seq) + ')'
grams = [
"(\s* (?P<simple>{}) \s*) |".format(re(self.simpleCmds)),
"(\s* (?P<client_command>{}) \s+ (?P<node_or_cli>clients?) \s+ (?P<client_name>[a-zA-Z0-9]+) \s*) |".format(re(self.cliCmds)),
"(\s* (?P<node_command>{}) \s+ (?P<node_or_cli>nodes?) \s+ (?P<node_name>[a-zA-Z0-9]+)\s*) |".format(re(self.nodeCmds)),
"(\s* (?P<client>client) \s+ (?P<client_name>[a-zA-Z0-9]+) \s+ (?P<cli_action>send) \s+ (?P<msg>\{\s*\".*\}) \s*) |",
"(\s* (?P<client>client) \s+ (?P<client_name>[a-zA-Z0-9]+) \s+ (?P<cli_action>show) \s+ (?P<req_id>[0-9]+) \s*) |",
"(\s* (?P<load_plugins>load\s+plugins\s+from) \s+ (?P<plugin_dir>[a-zA-Z0-9-{}]+) \s*) |".format(os.path.sep),
"(\s* (?P<load>load) \s+ (?P<file_name>[.a-zA-z0-9{}]+) \s*) |".format(os.path.sep),
"(\s* (?P<command>help) (\s+ (?P<helpable>[a-zA-Z0-9]+) )? (\s+ (?P<node_or_cli>{}) )?\s*) |".format(re(self.node_or_cli)),
"(\s* (?P<command>list) \s*)".format(re(self.commands))
]
self.grammar = compile("".join(grams))
lexer = GrammarLexer(self.grammar, lexers={
'node_command': SimpleLexer(Token.Keyword),
'command': SimpleLexer(Token.Keyword),
'helpable': SimpleLexer(Token.Keyword),
'load_plugins': SimpleLexer(Token.Keyword),
'load': SimpleLexer(Token.Keyword),
'node_or_cli': SimpleLexer(Token.Keyword),
'arg1': SimpleLexer(Token.Name),
'node_name': SimpleLexer(Token.Name),
'more_nodes': SimpleLexer(Token.Name),
'simple': SimpleLexer(Token.Keyword),
'client_command': SimpleLexer(Token.Keyword),
})
self.clientWC = WordCompleter([])
completer = GrammarCompleter(self.grammar, {
'node_command': WordCompleter(self.nodeCmds),
'client_command': WordCompleter(self.cliCmds),
'client': WordCompleter(['client']),
'command': WordCompleter(self.commands),
'node_or_cli': WordCompleter(self.node_or_cli),
'node_name': WordCompleter(self.nodeNames),
'more_nodes': WordCompleter(self.nodeNames),
'helpable': WordCompleter(self.helpablesCommands),
'load_plugins': WordCompleter(['load plugins from']),
'client_name': self.clientWC,
'cli_action': WordCompleter(self.cliActions),
'simple': WordCompleter(self.simpleCmds)
})
self.style = PygmentsStyle.from_defaults({
Token.Operator: '#33aa33 bold',
Token.Number: '#aa3333 bold',
Token.Name: '#ffff00 bold',
Token.Heading: 'bold',
Token.TrailingInput: 'bg:#662222 #ffffff',
Token.BoldGreen: '#33aa33 bold',
Token.BoldOrange: '#ff4f2f bold',
Token.BoldBlue: '#095cab bold'})
self.functionMappings = self.createFunctionMappings()
self.voidMsg = "<none>"
# Create an asyncio `EventLoop` object. This is a wrapper around the
# asyncio loop that can be passed into prompt_toolkit.
eventloop = create_asyncio_eventloop(looper.loop)
pers_hist = FileHistory('.plenum-cli-history')
# Create interface.
app = create_prompt_application('plenum> ',
lexer=lexer,
completer=completer,
style=self.style,
history=pers_hist)
self.cli = CommandLineInterface(
application=app,
eventloop=eventloop,
output=CustomOutput.from_pty(sys.__stdout__, true_color=True))
# Patch stdout in something that will always print *above* the prompt
# when something is written to stdout.
sys.stdout = self.cli.stdout_proxy()
setupLogging(TRACE_LOG_LEVEL,
Console.Wordage.mute,
filename=logFileName)
self.logger = getlogger("cli")
self.print("\nplenum-CLI (c) 2016 Evernym, Inc.")
self.print("Node registry loaded.")
self.print("None of these are created or running yet.")
self.showNodeRegistry()
self.print("Type 'help' for more information.")
import prompt_toolkit.shortcuts
from prompt_toolkit.shortcuts import create_prompt_application, create_asyncio_eventloop, prompt_async
from prompt_toolkit.styles import style_from_dict
from prompt_toolkit.token import Token
import sys
import logging
import importlib
logging.basicConfig(level='ERROR')
import concurrent
import asyncio
import unha2.client as client
from unha2.model.base import RoomType
from unha2.methods import MethodError
eventloop = create_asyncio_eventloop()
cli = CommandLineInterface(
application=create_prompt_application('> '),
eventloop=eventloop)
sys.stdout = cli.stdout_proxy()
STYLE_DICT = {
Token.Title: 'bold',
Token.Error: '#ansired',
Token.Nick: '#ansiyellow',
Token.Server: '#ansiblue',
Token.Chat: '#ansigreen',
Token.Direct: '#ansifuchsia',
Token.Private: '#ansiblue',
Token.Time: '#ansilightgray',
Token.Separator: '#ansilightgray bold',
async def xmpp_client():
try:
with open(os.path.join(os.getenv("HOME"), ".xc.conf"),
"r") as config_file:
config = json.load(config_file)
if "jid" not in config:
raise Exception("No JID")
except Exception as e:
print(
"Error reading configuration file.\n" + str(e) +
"Please create ~/.xc.conf with content like:\n{\"jid\": \"[email protected]\"}"
)
sys.exit(1)
async def get_secret(jid, attempt):
if attempt > 2:
return None
try:
return await prompt_async("Secret (will not be stored): ",
is_password=True)
except:
return None
async def tls_handshake_callback(verifier):
print("Warning: blindly accepting TLS certificate from %s" %
verifier.transport.get_extra_info("server_hostname"))
return True
pin_store = PublicKeyPinStore()
pin_store.import_from_json(config.get("pkps", {}))
my_jid = aioxmpp.JID.fromstr(config["jid"])
security = aioxmpp.make_security_layer(
get_secret,
pin_store=pin_store,
pin_type=PinType.PUBLIC_KEY,
post_handshake_deferred_failure=tls_handshake_callback)
client = aioxmpp.PresenceManagedClient(my_jid, security)
presence = client.summon(aioxmpp.presence.Service)
roster = client.summon(aioxmpp.roster.Service)
class RosterItemAndCommandCompleter(Completer):
def get_completions(self, document, complete_event):
text = document.text
if not text or " " in text or ":" in text:
return
if text[0] == "/":
part = text[1:]
for command in ("roster", "name", "add", "del", "help",
"quit"):
if command.startswith(part):
yield Completion(command + " ",
start_position=-len(part),
display=command)
elif roster is not None:
for item in roster.items.values():
if item.name.startswith(text):
yield Completion(item.name + ": ",
start_position=-len(text),
display=item.name)
completer = RosterItemAndCommandCompleter()
history = InMemoryHistory()
next_recipient = None
def get_prompt_tokens(_):
return ((Token.Prompt, "%s> " % (next_recipient or "")), )
cli_app = create_prompt_application(get_prompt_tokens=get_prompt_tokens,
completer=completer,
reserve_space_for_menu=0,
history=history,
get_title=lambda: "xc")
cli_loop = create_asyncio_eventloop()
cli = CommandLineInterface(application=cli_app, eventloop=cli_loop)
above_prompt = cli.stdout_proxy()
def name_for_jid(jid):
try:
return roster.items[jid].name
except:
return str(jid)
def peer_available(jid, presence):
above_prompt.write("%s is now online\n" % name_for_jid(jid.bare()))
presence.on_available.connect(peer_available)
def peer_unavailable(jid, presence):
above_prompt.write("%s is now offline\n" % name_for_jid(jid.bare()))
presence.on_unavailable.connect(peer_unavailable)
def message_received(msg):
content = " ".join(msg.body.values())
if content:
above_prompt.write("%s: %s\n" %
(name_for_jid(msg.from_.bare()), content))
client.stream.register_message_callback("chat", None, message_received)
try:
async with client.connected() as stream:
while True:
try:
document = await cli.run_async()
except (KeyboardInterrupt, EOFError):
break
line = document.text
if line.startswith("/"):
try:
command, *args = line[1:].split(" ")
if command == "roster":
rows = [(item.name, str(jid), item.subscription)
for jid, item in roster.items.items()
if jid != my_jid]
widths = [
max(len(row[i] or "") for row in rows)
for i in range(len(rows[0] or ""))
]
for row in rows:
above_prompt.write(" ".join(
(cell or "").ljust(widths[i])
for i, cell in enumerate(row)) + "\n")
elif command == "name":
try:
jid = args[0]
name = args[1]
except IndexError:
above_prompt.write("usage: /name JID NAME\n")
else:
jid = aioxmpp.JID.fromstr(jid)
await roster.set_entry(jid, name=name)
elif command == "add":
try:
jid = args[0]
except IndexError:
above_prompt.write("usage: /add JID\n")
else:
jid = aioxmpp.JID.fromstr(jid)
await roster.set_entry(jid)
roster.subscribe(jid)
roster.approve(jid)
elif command == "del":
try:
jid = args[0]
except IndexError:
above_prompt.write("usage: /del JID\n")
else:
jid = aioxmpp.JID.fromstr(jid)
await roster.remove_entry(jid)
elif command == "quit":
break
elif command == "help":
above_prompt.write(
"NAME: MESSAGE send MESSAGE to NAME\n"
"MESSAGE send MESSAGE to the last correspondent\n"
"/roster print the roster\n"
"/add JID add JID to the roster\n"
"/del JID remove JID from the roster\n"
"/name JID NAME set the name of JID to NAME\n"
"/quit disconnect and then quit (also ctrl-d, ctrl-c)\n"
"/help this help\n")
else:
above_prompt.write("unrecognised command\n")
except Exception as e:
above_prompt.write("exception handling command: %s\n" %
e)
else:
try:
try:
recipient, message = line.split(": ", 1)
except ValueError:
if next_recipient is not None:
recipient = next_recipient
message = line
else:
above_prompt.write("recipient: message\n")
continue
jid_for_name = lambda r: next(
(jid for jid, item in roster.items.items()
if item.name == r), None)
jid = jid_for_name(recipient)
if jid is None:
if next_recipient is not None and recipient != next_recipient:
recipient = next_recipient
jid = jid_for_name(recipient)
message = line
if jid is None:
above_prompt.write("unknown recipient: %s\n" %
recipient)
continue
msg = aioxmpp.Message(to=jid, type_="chat")
msg.body[None] = message
await stream.send_and_wait_for_sent(msg)
next_recipient = recipient
except Exception as e:
above_prompt.write("exception sending message: %s\n" %
e)
print("Disconnecting…")
client.stop()
except Exception as e:
print("Failed to connect: %s" % e)
def prompt(self, message='', **kwargs):
"""Get input from the user and return it.
This is a wrapper around a lot of prompt_toolkit functionality and
can be a replacement for raw_input. (or GNU readline.) If you want
to keep your history across several calls, create one
`~prompt_toolkit.history.History instance and pass it every
time. This function accepts many keyword arguments. Except for the
following. they are a proxy to the arguments of
create_prompt_application().
Parameters
----------
patch_stdout : file-like, optional
Replace ``sys.stdout`` by a proxy that ensures that print
statements from other threads won't destroy the prompt. (They
will be printed above the prompt instead.)
return_asyncio_coroutine : bool, optional
When True, return a asyncio coroutine. (Python >3.3)
Notes
-----
This method was forked from the mainline prompt-toolkit repo.
Copyright (c) 2014, Jonathan Slenders, All rights reserved.
"""
patch_stdout = kwargs.pop('patch_stdout', False)
return_asyncio_coroutine = kwargs.pop('return_asyncio_coroutine',
False)
if return_asyncio_coroutine:
eventloop = create_asyncio_eventloop()
else:
eventloop = kwargs.pop('eventloop', None) or create_eventloop()
# Create CommandLineInterface.
if self.cli is None:
if self.major_minor < (0, 57):
kwargs.pop('reserve_space_for_menu', None)
if self.major_minor <= (0, 57):
kwargs.pop('get_rprompt_tokens', None)
kwargs.pop('get_continuation_tokens', None)
# VI_Mode handling changed in prompt_toolkit v1.0
if self.major_minor >= (1, 0):
from prompt_toolkit.enums import EditingMode
if builtins.__xonsh_env__.get('VI_MODE'):
editing_mode = EditingMode.VI
else:
editing_mode = EditingMode.EMACS
kwargs['editing_mode'] = editing_mode
kwargs['vi_mode'] = builtins.__xonsh_env__.get('VI_MODE')
cli = CommandLineInterface(application=create_prompt_application(
message, **kwargs),
eventloop=eventloop,
output=create_output())
self.cli = cli
else:
cli = self.cli
# Replace stdout.
patch_context = cli.patch_stdout_context(
) if patch_stdout else DummyContext()
# Read input and return it.
if return_asyncio_coroutine:
# Create an asyncio coroutine and call it.
exec_context = {'patch_context': patch_context, 'cli': cli}
exec(
textwrap.dedent('''
import asyncio
@asyncio.coroutine
def prompt_coro():
with patch_context:
document = yield from cli.run_async(reset_current_buffer=False)
if document:
return document.text
'''), exec_context)
return exec_context['prompt_coro']()
else:
# Note: We pass `reset_current_buffer=False`, because that way
# it's easy to give DEFAULT_BUFFER a default value, without it
# getting erased. We don't have to reset anyway, because this is
# the first and only time that this CommandLineInterface will run.
try:
with patch_context:
document = cli.run(reset_current_buffer=False)
if document:
return document.text
finally:
eventloop.close()
def __init__(self, looper, basedirpath, nodeReg, cliNodeReg, output=None, debug=False,
logFileName=None):
self.curClientPort = None
logging.root.addHandler(CliHandler(self.out))
self.looper = looper
self.basedirpath = basedirpath
self.nodeReg = nodeReg
self.cliNodeReg = cliNodeReg
# Used to store created clients
self.clients = {} # clientName -> Client
# To store the created requests
self.requests = {}
# To store the nodes created
self.nodes = {}
self.externalClientKeys = {} # type: Dict[str,str]
self.cliCmds = {'status', 'new'}
self.nodeCmds = self.cliCmds | {'keyshare'}
self.helpablesCommands = self.cliCmds | self.nodeCmds
self.simpleCmds = {'status', 'exit', 'quit', 'license'}
self.commands = {'list', 'help'} | self.simpleCmds
self.cliActions = {'send', 'show'}
self.commands.update(self.cliCmds)
self.commands.update(self.nodeCmds)
self.node_or_cli = ['node', 'client']
self.nodeNames = list(self.nodeReg.keys()) + ["all"]
self.debug = debug
self.plugins = {}
'''
examples:
status
new node Alpha
new node all
new client Joe
client Joe send <msg>
client Joe show 1
'''
psep = re.escape(os.path.sep)
self.utilGrams = [
"(\s* (?P<simple>{}) \s*) |".format(self.relist(self.simpleCmds)),
"(\s* (?P<load>load) \s+ (?P<file_name>[.a-zA-z0-9{}]+) \s*) |".format(psep),
"(\s* (?P<command>help) (\s+ (?P<helpable>[a-zA-Z0-9]+) )? (\s+ (?P<node_or_cli>{}) )?\s*) |".format(self.relist(self.node_or_cli)),
"(\s* (?P<command>list) \s*)"
]
self.nodeGrams = [
"(\s* (?P<node_command>{}) \s+ (?P<node_or_cli>nodes?) \s+ (?P<node_name>[a-zA-Z0-9]+)\s*) |".format(self.relist(self.nodeCmds)),
"(\s* (?P<load_plugins>load\s+plugins\s+from) \s+ (?P<plugin_dir>[a-zA-Z0-9-:{}]+) \s*)".format(psep),
]
self.clientGrams = [
"(\s* (?P<client_command>{}) \s+ (?P<node_or_cli>clients?) \s+ (?P<client_name>[a-zA-Z0-9]+) \s*) |".format(self.relist(self.cliCmds)),
"(\s* (?P<client>client) \s+ (?P<client_name>[a-zA-Z0-9]+) \s+ (?P<cli_action>send) \s+ (?P<msg>\{\s*.*\}) \s*) |",
"(\s* (?P<client>client) \s+ (?P<client_name>[a-zA-Z0-9]+) \s+ (?P<cli_action>show) \s+ (?P<req_id>[0-9]+) \s*) |",
"(\s* (?P<add_key>add\s+key) \s+ (?P<verkey>[a-fA-F0-9]+) \s+ (?P<for_client>for\s+client) \s+ (?P<identifier>[a-zA-Z0-9]+) \s*)",
]
self.lexers = {
'node_command': SimpleLexer(Token.Keyword),
'command': SimpleLexer(Token.Keyword),
'helpable': SimpleLexer(Token.Keyword),
'load_plugins': SimpleLexer(Token.Keyword),
'load': SimpleLexer(Token.Keyword),
'node_or_cli': SimpleLexer(Token.Keyword),
'arg1': SimpleLexer(Token.Name),
'node_name': SimpleLexer(Token.Name),
'more_nodes': SimpleLexer(Token.Name),
'simple': SimpleLexer(Token.Keyword),
'client_command': SimpleLexer(Token.Keyword),
'add_key': SimpleLexer(Token.Keyword),
'verkey': SimpleLexer(Token.Literal),
'for_client': SimpleLexer(Token.Keyword),
'identifier': SimpleLexer(Token.Name),
}
self.clientWC = WordCompleter([])
self.completers = {
'node_command': WordCompleter(self.nodeCmds),
'client_command': WordCompleter(self.cliCmds),
'client': WordCompleter(['client']),
'command': WordCompleter(self.commands),
'node_or_cli': WordCompleter(self.node_or_cli),
'node_name': WordCompleter(self.nodeNames),
'more_nodes': WordCompleter(self.nodeNames),
'helpable': WordCompleter(self.helpablesCommands),
'load_plugins': WordCompleter(['load plugins from']),
'client_name': self.clientWC,
'cli_action': WordCompleter(self.cliActions),
'simple': WordCompleter(self.simpleCmds),
'add_key': WordCompleter(['add key']),
'for_client': WordCompleter(['for client']),
}
self.initializeGrammar()
self.initializeGrammarLexer()
self.initializeGrammarCompleter()
self.style = PygmentsStyle.from_defaults({
Token.Operator: '#33aa33 bold',
Token.Number: '#aa3333 bold',
Token.Name: '#ffff00 bold',
Token.Heading: 'bold',
Token.TrailingInput: 'bg:#662222 #ffffff',
Token.BoldGreen: '#33aa33 bold',
Token.BoldOrange: '#ff4f2f bold',
Token.BoldBlue: '#095cab bold'})
self.functionMappings = self.createFunctionMappings()
self.voidMsg = "<none>"
# Create an asyncio `EventLoop` object. This is a wrapper around the
# asyncio loop that can be passed into prompt_toolkit.
eventloop = create_asyncio_eventloop(looper.loop)
pers_hist = FileHistory('.{}-cli-history'.format(self.name))
# Create interface.
app = create_prompt_application('{}> '.format(self.name),
lexer=self.grammarLexer,
completer=self.grammarCompleter,
style=self.style,
history=pers_hist)
if output:
out = output
else:
if is_windows():
if is_conemu_ansi():
out = ConEmuOutput(sys.__stdout__)
else:
out = Win32Output(sys.__stdout__)
else:
out = CustomOutput.from_pty(sys.__stdout__, true_color=True)
self.cli = CommandLineInterface(
application=app,
eventloop=eventloop,
output=out)
# Patch stdout in something that will always print *above* the prompt
# when something is written to stdout.
sys.stdout = self.cli.stdout_proxy()
setupLogging(TRACE_LOG_LEVEL,
Console.Wordage.mute,
filename=logFileName)
self.logger = getlogger("cli")
self.print("\n{}-CLI (c) 2016 Evernym, Inc.".format(self.properName))
self.print("Node registry loaded.")
self.print("None of these are created or running yet.")
self.showNodeRegistry()
self.print("Type 'help' for more information.")
def prompt(self, message='', **kwargs):
"""Get input from the user and return it.
This is a wrapper around a lot of prompt_toolkit functionality and
can be a replacement for raw_input. (or GNU readline.) If you want
to keep your history across several calls, create one
`~prompt_toolkit.history.History instance and pass it every
time. This function accepts many keyword arguments. Except for the
following. they are a proxy to the arguments of
create_prompt_application().
Parameters
----------
patch_stdout : file-like, optional
Replace ``sys.stdout`` by a proxy that ensures that print
statements from other threads won't destroy the prompt. (They
will be printed above the prompt instead.)
return_asyncio_coroutine : bool, optional
When True, return a asyncio coroutine. (Python >3.3)
Notes
-----
This method was forked from the mainline prompt-toolkit repo.
Copyright (c) 2014, Jonathan Slenders, All rights reserved.
"""
patch_stdout = kwargs.pop('patch_stdout', False)
return_asyncio_coroutine = kwargs.pop('return_asyncio_coroutine', False)
if return_asyncio_coroutine:
eventloop = create_asyncio_eventloop()
else:
eventloop = kwargs.pop('eventloop', None) or create_eventloop()
# Create CommandLineInterface.
if self.cli is None:
if self.major_minor < (0, 57):
kwargs.pop('reserve_space_for_menu', None)
if self.major_minor <= (0, 57):
kwargs.pop('get_rprompt_tokens', None)
kwargs.pop('get_continuation_tokens', None)
# VI_Mode handling changed in prompt_toolkit v1.0
if self.major_minor >= (1, 0):
from prompt_toolkit.enums import EditingMode
if builtins.__xonsh_env__.get('VI_MODE'):
editing_mode = EditingMode.VI
else:
editing_mode = EditingMode.EMACS
kwargs['editing_mode'] = editing_mode
kwargs['vi_mode'] = builtins.__xonsh_env__.get('VI_MODE')
cli = CommandLineInterface(
application=create_prompt_application(message, **kwargs),
eventloop=eventloop,
output=create_output())
self.cli = cli
else:
cli = self.cli
# Replace stdout.
patch_context = cli.patch_stdout_context() if patch_stdout else DummyContext()
# Read input and return it.
if return_asyncio_coroutine:
# Create an asyncio coroutine and call it.
exec_context = {'patch_context': patch_context, 'cli': cli}
exec(textwrap.dedent('''
import asyncio
@asyncio.coroutine
def prompt_coro():
with patch_context:
document = yield from cli.run_async(reset_current_buffer=False)
if document:
return document.text
'''), exec_context)
return exec_context['prompt_coro']()
else:
# Note: We pass `reset_current_buffer=False`, because that way
# it's easy to give DEFAULT_BUFFER a default value, without it
# getting erased. We don't have to reset anyway, because this is
# the first and only time that this CommandLineInterface will run.
try:
with patch_context:
document = cli.run(reset_current_buffer=False)
if document:
return document.text
finally:
eventloop.close()
def embed(globals=None,
locals=None,
configure=None,
vi_mode=False,
history_filename=None,
title=None,
startup_paths=None,
patch_stdout=False,
return_asyncio_coroutine=False):
"""
Call this to embed Python shell at the current point in your program.
It's similar to `IPython.embed` and `bpython.embed`. ::
from prompt_toolkit.contrib.repl import embed
embed(globals(), locals())
:param vi_mode: Boolean. Use Vi instead of Emacs key bindings.
:param configure: Callable that will be called with the `PythonRepl` as a first
argument, to trigger configuration.
:param title: Title to be displayed in the terminal titlebar. (None or string.)
"""
assert configure is None or callable(configure)
# Default globals/locals
if globals is None:
globals = {
'__name__': '__main__',
'__package__': None,
'__doc__': None,
'__builtins__': six.moves.builtins,
}
locals = locals or globals
def get_globals():
return globals
def get_locals():
return locals
# Create eventloop.
if return_asyncio_coroutine:
eventloop = create_asyncio_eventloop()
else:
eventloop = create_eventloop()
# Create REPL.
repl = PythonRepl(get_globals,
get_locals,
vi_mode=vi_mode,
history_filename=history_filename,
startup_paths=startup_paths)
if title:
repl.terminal_title = title
if configure:
configure(repl)
cli = PythonCommandLineInterface(python_input=repl, eventloop=eventloop)
# Start repl.
patch_context = cli.patch_stdout_context(
) if patch_stdout else DummyContext()
if return_asyncio_coroutine:
def coroutine():
with patch_context:
for future in cli.run_async():
yield future
return coroutine()
else:
with patch_context:
cli.run()
cList[data.username] = self
def handle_request(self, data):
print(data)
if data.req == "contacts":
contacts = self.db.query_contact(self.username)
print("{0:s} [SERVER]: contacts for: {1:}".format(
tstamp(), self.username))
print(*tuple(contacts[i] for i in range(len(contacts))), sep="\n")
for c in contacts:
self.send("{}".format(c))
# ===============================================================================
if __name__ == '__main__':
print("{0:s} [SERVER]: starting.".format(tstamp()))
loop = asyncio.get_event_loop()
coroutine = loop.create_server(Server, '127.0.0.1', 9999)
server = loop.run_until_complete(coroutine)
asyncio. async (server_console(create_asyncio_eventloop(loop)))
for socket in server.sockets:
print("{0:s} [SERVER]: running on {1:}".format(tstamp(),
socket.getsockname()))
try:
loop.run_forever()
except KeyboardInterrupt:
pass
