def run_task(self):
from prompt_toolkit.eventloop import use_asyncio_event_loop
from tui_app import make_tui_app
use_asyncio_event_loop()
logger.info('run_task ENTER')
wrapped_application = make_tui_app(config=self.config,
out_queue=self.tui_queue,
state=self.task_state)
application = wrapped_application.application
self.logger_buffer = application.layout.get_buffer_by_name(
'logger_buffer')
if self.logger_sink:
asyncio.ensure_future(self.pull_logger_sink())
if self.control_sink:
asyncio.ensure_future(self.pull_control_sink())
asyncio.ensure_future(self.pull_tui_sink())
asyncio.get_event_loop().run_until_complete(
application.run_async().to_asyncio_future())
logger.info('run_task EXIT')
def __init__(self, input_handler: Callable, bindings: KeyBindings,
completer: Completer):
use_asyncio_event_loop()
self.input_field = create_input_field(completer=completer)
self.output_field = create_output_field()
self.log_field = create_log_field()
self.layout = generate_layout(self.input_field, self.output_field,
self.log_field)
self.bindings = bindings
self.input_handler = input_handler
self.input_field.accept_handler = self.accept
self.app = Application(layout=self.layout,
full_screen=True,
key_bindings=self.bindings,
style=load_style(),
mouse_support=True,
clipboard=PyperclipClipboard())
self.log_lines: Deque[str] = deque()
self.log(HEADER)
# settings
self.prompt_text = ">>> "
self.pending_input = None
self.input_event = None
self.hide_input = False
async def _run_prompt_forever(self):
while True:
try:
if _is_prompt_toolkit3():
result = await self.session.prompt_async(
self.prompt, completer=self.completer)
else:
# This is done because old versions of prompt toolkit don't support Python 3.5.
# When we deprecate 3.5, this can be removed.
from prompt_toolkit.eventloop import use_asyncio_event_loop
use_asyncio_event_loop()
result = await self.session.prompt(
self.prompt, async_=True, completer=self.completer)
except EOFError:
return
if not result:
continue
args = shlex.split(result)
if args[0] in self.command_list:
try:
self._currently_running_task = asyncio.ensure_future(
self._run_single_command(args[0], args[1:]))
await self._currently_running_task
except asyncio.CancelledError:
print()
continue
except ExitPromptException:
return
else:
print("Command %s not found!" % args[0])
def __init__(self, args):
use_asyncio_event_loop()
self.args = args
self.current_context = self
self.contexts = [
TeamServers(args['<URL>']),
Listeners(),
Sessions(),
Modules(),
Stagers()
]
self.teamservers = self.contexts[0]
self.completer = STCompleter(self)
self.prompt_session = PromptSession(
HTML(("[<ansiyellow>"
f"{len(self.teamservers.connections)}"
"</ansiyellow>] ST ≫ ")),
bottom_toolbar=functools.partial(bottom_toolbar,
ts=self.teamservers),
completer=self.completer,
complete_in_thread=True,
complete_while_typing=True,
auto_suggest=AutoSuggestFromHistory(),
#rprompt=get_rprompt(False),
#style=example_style,
search_ignore_case=True)
def main():
doc = """
Mesh CLI
Usage:
meshcli [options] [<command>]
meshcli -h | --help | --version
Options:
-l --login <login> User login to platform service (email)
-p --password <password> User password to platform service (!unsecured!)
-n --project <project> Project name to be loaded from platform
--partner <partner> Partner identifier [default: silvair]
--env <environment> Environment: dev,preprod or prod [default: preprod]
-d --debug
-h --help Show this help message and exit
--version Show version and exit
"""
use_asyncio_event_loop()
arguments = docopt(doc, version="stat_checker 0.5")
logging.basicConfig(
format=
"%(asctime)s %(name)-40s %(levelname)-8s %(filename)15s:%(lineno)3s %(message)s",
level=logging.INFO,
datefmt="%Y-%m-%d %H:%M:%S",
)
loop = asyncio.get_event_loop()
mesh_cli = MeshCommandLine(loop, arguments)
with suppress(EOFError, KeyboardInterrupt), patch_stdout():
loop.run_until_complete(mesh_cli.run(arguments.get("<command>")))
def main(etmdir=""):
global item, settings, ampm, style, etmstyle, application
ampm = settings['ampm']
terminal_style = settings['style']
if terminal_style == "dark":
style = dark_style
etmstyle = dark_etmstyle
else:
style = light_style
etmstyle = light_etmstyle
agenda_view()
application = Application(
layout=Layout(
root_container,
focused_element=text_area,
),
key_bindings=bindings,
enable_page_navigation_bindings=True,
mouse_support=True,
style=style,
full_screen=True)
# Tell prompt_toolkit to use asyncio.
use_asyncio_event_loop()
# Run application async.
loop = get_event_loop()
loop.call_later(0, event_handler, loop)
loop.run_until_complete(
application.run_async().to_asyncio_future())
async def cmdloop(self):
use_asyncio_event_loop()
self.db = await aiosqlite.connect(self.db_path)
try:
while True:
#with patch_stdout():
text = await self.prompt_session.prompt(async_=True)
command = shlex.split(text)
if len(command):
# Apperently you can't call await on a coroutine retrieved via getattr() ??
# So this sucks now but thankfully we don't have a lot of commands
try:
if command[0] == 'exit':
await self.exit()
break
elif command[0] == 'show':
await self.show(command[1:])
elif command[0] == 'open':
await self.open(command[1:])
elif command[0] == 'hosts':
await self.hosts(command[1:])
elif command[0] == 'servers':
await self.servers(command[1:])
elif command[0] == 'scan':
await self.scan()
except Exception as e:
import traceback
traceback.print_exc()
print(f"Error calling command '{command[0]}': {e}")
finally:
await self.db.close()
def main():
# Tell prompt_toolkit to use asyncio.
use_asyncio_event_loop()
# Run application async.
asyncio.get_event_loop().run_until_complete(
application.run_async().to_asyncio_future())
def main():
# Tell prompt_toolkit to use asyncio.
use_asyncio_event_loop()
# Run application async.
asyncio.get_event_loop().run_until_complete(
application.run_async().to_asyncio_future())
def main():
cfg = config.parse()
rchat = api.Session(cfg)
app, appstate = build_layout(rchat)
use_asyncio_event_loop()
loop = asyncio.get_event_loop()
loop.call_soon(list_channels, loop, rchat, appstate)
loop.run_until_complete(app.run_async().to_asyncio_future())
def run(args):
configure_logger(logging.getLogger(), args.log_level)
loop = asyncio.get_event_loop()
use_asyncio_event_loop(loop)
try:
return asyncio.get_event_loop().run_until_complete(_run(args))
except KeyboardInterrupt:
logger.warn("CTRL-C pressed, exiting")
async def activate_prompt_toolkit_async_mode():
"""Configure prompt toolkit to use the asyncio event loop.
Needs to be async, so we use the right event loop in py 3.5"""
from prompt_toolkit.eventloop import use_asyncio_event_loop
global ACTIVATED_ASYNC_MODE
# Tell prompt_toolkit to use asyncio for the event loop.
use_asyncio_event_loop()
ACTIVATED_ASYNC_MODE = True
def run_scrimmage_ui():
use_asyncio_event_loop()
app = Application(
layout=layout,
key_bindings=kb,
full_screen=True,
style=style,
mouse_support=True,
enable_page_navigation_bindings=True,)
loop = asyncio.get_event_loop()
loop.run_until_complete(
app.run_async().to_asyncio_future())
def launch(self):
colorama.init()
use_asyncio_event_loop()
patch_stdout()
while self.run_again:
self.run_again = False
self._loop = True
self.loop.create_task(self.start())
try:
self.loop.run_until_complete(
self.app.run_async().to_asyncio_future())
except KeyboardInterrupt:
if self.current_ip != self.own_ip:
self.loop.run_until_complete(self.command("dc"))
def run(args):
configure_logger(logging.getLogger(), args.log_level)
loop = asyncio.get_event_loop()
use_asyncio_event_loop(loop)
try:
return asyncio.get_event_loop().run_until_complete(_run(args))
except KeyboardInterrupt:
logger.warn("CTRL-C pressed, exiting")
except Terminated:
logger.warn("Browser window terminated, exiting")
except AuthResponseError as exc:
logger.error(
f'Required attributes not found in response ("{exc}", does this endpoint do SSO?), exiting'
)
except HTTPError as exc:
logger.error(f"Request error: {exc}")
def __init__(self, *, base, loop):
use_asyncio_event_loop(loop)
self.app = App(
base=base,
loop=loop,
message_handler=self.handle_incoming_message,
friend_handler=self.handle_friend_request,
)
self.files = []
self.active_friend = None
self.prompt_session = PromptSession()
self.online_friends = []
self.offline_friends = []
self.count = 0
self.addable_entities = {}
self.friend_request_count = 0
loop.create_task(self.run_update())
def main():
"""Sets up playback and app then runs both in async loop
"""
###################################################
# Setting Up Playback object
###################################################
files = parseconfig("histfile_list")
playback_list = []
for fi, hint in files.items():
playback_list.append(Playback(fi, hint))
playback = merge_history(playback_list)
playback.playback_mode = "MANUAL"
###################################################
# Setting Up HspApp object
###################################################
hspApp = HspApp(playback, SAVE_LOCATION)
###################################################
# Setting Up async loop
###################################################
loop = asyncio.get_event_loop()
use_asyncio_event_loop()
try:
# Run command_loop and hspApp.run_async next to each other
# future: handle when one completes before the other
loop.run_until_complete(
asyncio.gather(
hspApp.command_loop(),
hspApp.run_async().to_asyncio_future(),
hspApp.playback.run_async(),
hspApp.redraw_timer(),
))
finally:
loop.close()
def main():
# Tell prompt_toolkit to use asyncio for the event loop.
use_asyncio_event_loop()
logging.basicConfig(level=logging.INFO,
format='%(levelname)s: %(message)s')
# logging.getLogger('asyncio').setLevel(logging.DEBUG)
if sys.platform == 'win32':
loop = asyncio.ProactorEventLoop()
asyncio.set_event_loop(loop)
else:
loop = asyncio.get_event_loop()
# loop.set_debug(True)
parser = argparse.ArgumentParser(
description='Run FS-UAE with enabled console debugger.')
parser.add_argument('params', nargs='*', type=str,
help='Parameters passed to FS-UAE emulator.')
args = parser.parse_args()
uae = UaeLaunch(loop, args.params)
loop.run_until_complete(uae)
loop.close()
def main():
parser = argparse.ArgumentParser()
# Network group
group = parser.add_mutually_exclusive_group()
group.add_argument("-m",
"--mainnet",
action="store_true",
default=False,
help="Use MainNet instead of the default TestNet")
group.add_argument(
"-p",
"--privnet",
nargs="?",
metavar="host",
const=True,
default=False,
help=
"Use a private net instead of the default TestNet, optionally using a custom host (default: 127.0.0.1)"
)
group.add_argument(
"--coznet",
action="store_true",
default=False,
help="Use the CoZ network instead of the default TestNet")
group.add_argument(
"-u",
"--unittest",
nargs="?",
metavar="host",
const=True,
default=False,
help=
"Use a private net instead of the default TestNet, optionally using a custom host (default: 127.0.0.1)"
)
group.add_argument("-c",
"--config",
action="store",
help="Use a specific config file")
# Theme
parser.add_argument(
"-t",
"--set-default-theme",
dest="theme",
choices=["dark", "light"],
help=
"Set the default theme to be loaded from the config file. Default: 'dark'"
)
# Verbose
parser.add_argument("-v",
"--verbose",
action="store_true",
default=False,
help="Show smart-contract events by default")
# Where to store stuff
parser.add_argument("--datadir",
action="store",
help="Absolute path to use for database directories")
# peers
parser.add_argument("--minpeers",
action="store",
type=int,
choices=range(1, 10 + 1),
metavar="[1-10]",
help="Min peers to use for P2P Joining")
parser.add_argument("--maxpeers",
action="store",
type=int,
default=5,
choices=range(1, 10 + 1),
metavar="[1-10]",
help="Max peers to use for P2P Joining")
# Show the neo-python version
parser.add_argument(
"--version",
action="version",
version="neo-python v{version}".format(version=__version__))
args = parser.parse_args()
# Setting the datadir must come before setting the network, else the wrong path is checked at net setup.
if args.datadir:
settings.set_data_dir(args.datadir)
# Setup depending on command line arguments. By default, the testnet settings are already loaded.
if args.config:
settings.setup(args.config)
elif args.mainnet:
settings.setup_mainnet()
elif args.privnet:
try:
settings.setup_privnet(args.privnet)
except PrivnetConnectionError as e:
logger.error(str(e))
return
elif args.coznet:
settings.setup_coznet()
elif args.unittest:
settings.setup_unittest_net()
# Logfile settings & setup
logfile_fn = os.path.join(settings.DATA_DIR_PATH, 'prompt.log')
logfile_max_bytes = 5e7 # 50 MB
logfile_backup_count = 3 # 3 logfiles history
settings.set_logfile(logfile_fn, logfile_max_bytes, logfile_backup_count)
if args.theme:
preferences.set_theme(args.theme)
if args.verbose:
settings.set_log_smart_contract_events(True)
def set_min_peers(num_peers) -> bool:
try:
settings.set_min_peers(num_peers)
print("Minpeers set to ", num_peers)
return True
except ValueError:
print("Please supply a positive integer for minpeers")
return False
def set_max_peers(num_peers) -> bool:
try:
settings.set_max_peers(num_peers)
print("Maxpeers set to ", num_peers)
return True
except ValueError:
print("Please supply a positive integer for maxpeers")
return False
minpeers = args.minpeers
maxpeers = args.maxpeers
if minpeers and maxpeers:
if minpeers > maxpeers:
print("minpeers setting cannot be bigger than maxpeers setting")
return
if not set_min_peers(minpeers) or not set_max_peers(maxpeers):
return
elif minpeers:
if not set_min_peers(minpeers):
return
if minpeers > settings.CONNECTED_PEER_MAX:
if not set_max_peers(minpeers):
return
elif maxpeers:
if not set_max_peers(maxpeers):
return
if maxpeers < settings.CONNECTED_PEER_MIN:
if not set_min_peers(maxpeers):
return
loop = asyncio.get_event_loop()
# put prompt_toolkit on top of asyncio to avoid blocking
use_asyncio_event_loop()
# Instantiate the blockchain and subscribe to notifications
blockchain = Blockchain(
DBFactory.getBlockchainDB(settings.chain_leveldb_path))
Blockchain.RegisterBlockchain(blockchain)
# Try to set up a notification db
if NotificationDB.instance():
NotificationDB.instance().start()
# Start the prompt interface
fn_prompt_history = os.path.join(settings.DATA_DIR_PATH,
'.prompt.py.history')
cli = PromptInterface(fn_prompt_history)
cli_task = loop.create_task(cli.run())
p2p = NetworkService()
loop.create_task(p2p.start())
async def shutdown():
all_tasks = asyncio.all_tasks()
for task in all_tasks:
task.cancel()
with suppress(asyncio.CancelledError):
await task
# prompt_toolkit hack for not cleaning up see: https://github.com/prompt-toolkit/python-prompt-toolkit/issues/787
old_attrs = termios.tcgetattr(sys.stdin)
try:
loop.run_forever()
except SystemExit:
pass
finally:
with suppress(asyncio.InvalidStateError):
app = prompt_toolkit_get_app()
if app.is_running:
app.exit()
with suppress((SystemExit, Exception)):
cli_task.exception()
loop.run_until_complete(p2p.shutdown())
loop.run_until_complete(shutdown())
loop.run_until_complete(loop.shutdown_asyncgens())
loop.stop()
loop.close()
# Run things
# After the reactor is stopped, gracefully shutdown the database.
NotificationDB.close()
Blockchain.Default().Dispose()
# clean up prompt_toolkit mess, see above
termios.tcsetattr(sys.stdin, termios.TCSANOW, old_attrs)
def runclient():
pubkey, privkey = get_keys()
parser = configparser.ConfigParser()
nloop = asyncio.new_event_loop()
if os.path.exists("./server.conf") and yes_no_dialog(
"Server", "Connect to last server?"):
parser.read("server.conf")
server = parser["server"]["server"]
port = str(int(parser["server"]["port"]))
else:
server = input_dialog("Server", "Enter Server IP/Hostname:")
port = input_dialog("Server", "Enter Port:")
try:
int(port)
except:
message_dialog("Server", "Invalid Port")
sys.exit(1)
parser["server"] = {}
parser["server"]["server"] = server
parser["server"]["port"] = port
# save the server conf to file
with open("server.conf", "w") as cfile:
parser.write(cfile)
# connect to server
nick = input_dialog("Nickname", "Enter a nickname:")
if nick is None:
nick = ""
banned = "/."
if any([x in banned for x in nick]):
message_dialog("Nickname", "Invalid nickname")
messages = TextArea("", read_only=True)
mes = []
q = queue.Queue()
def handle_message(buf):
q.put(buf.text)
inputbox = TextArea(height=1,
multiline=False,
accept_handler=handle_message)
msgbody = Frame(messages)
body = HSplit(
[msgbody,
Window(height=1, char="#", style="class:line"), inputbox])
root = HSplit([
Window(
height=1,
content=FormattedTextControl(get_titlebar_text),
align=WindowAlign.CENTER,
),
Window(height=1, char=" ", style="class:line"),
body,
])
kb = KeyBindings()
@kb.add("c-c", eager=True)
@kb.add("c-q", eager=True)
def exitevent(event):
q.put("!DISCONNECT")
eventquit.set()
event.app.exit()
nloop.stop()
myloop.stop()
iscomplete.wait(1)
sys.exit(0)
app = Application(
layout=Layout(root, focused_element=inputbox),
key_bindings=kb,
mouse_support=True,
full_screen=True,
)
async def update(serverpipe, qu):
while True:
while serverpipe.poll():
data = serverpipe.recv()
mes.append(data)
out = "\n".join(mes)
msgbody.body = TextArea(out)
get_app().invalidate()
try:
while True:
dt = qu.get_nowait()
serverpipe.send(dt)
except queue.Empty:
pass
await asyncio.sleep(0.5)
t = threading.Thread(target=startloop, args=(nloop, ), daemon=True)
t.start()
serversoc, cl = Pipe()
iscomplete = threading.Event()
eventquit = threading.Event()
myloop = asyncio.new_event_loop()
asyncio.set_event_loop(myloop)
use_asyncio_event_loop(myloop)
asyncio.run_coroutine_threadsafe(
process_code("ws://{}:{}/{}".format(server, port, nick), cl, eventquit,
iscomplete), nloop)
asyncio.get_event_loop().create_task(update(serversoc, q))
asyncio.get_event_loop().run_until_complete(app.run_async())
myloop.run_forever()
def terminal_use_async():
"""
Tell prompt_toolkit to use asyncio
"""
use_asyncio_event_loop()
import numpy as np
import prompt_toolkit
from prompt_toolkit.completion import WordCompleter
from prompt_toolkit.eventloop import use_asyncio_event_loop
from thotus.task import Task, GuiFeedback, run_in_thread
from thotus.shell_commands import commands, toggle_advanced_mode
from thotus.commands import get_scanner
from thotus.cloudify import LineMaker
from thotus.calibration.chessboard import chess_detect, chess_draw
from thotus.ui import gui
from thotus import settings
DEBUG = os.getenv('DEBUG', False)
use_asyncio_event_loop()
def s2h(t):
if t > 80:
return "%d min %ds" % divmod(t, 60)
else:
return "%.1fs" % t
class MainGUi:
running = True
visible = True
line_mode = False
async def viewer(self):
