async def draw(messages_queue, sending_queue, status_updates_queue): root = tk.Tk() root.title('Chat') root_frame = tk.Frame() root_frame.pack(fill="both", expand=True) status_labels = create_status_panel(root_frame) input_frame = tk.Frame(root_frame) input_frame.pack(side="bottom", fill=tk.X) input_field = tk.Entry(input_frame) input_field.pack(side="left", fill=tk.X, expand=True) input_field.bind( "<Return>", lambda event: process_new_message(input_field, sending_queue)) send_button = tk.Button(input_frame) send_button["text"] = "Отправить" send_button["command"] = lambda: process_new_message( input_field, sending_queue) send_button.pack(side="left") conversation_panel = ScrolledText(root_frame, wrap='none') conversation_panel.pack(side="top", fill="both", expand=True) async with create_handy_nursery() as nursery: nursery.start_soon(update_tk(root_frame)) nursery.start_soon( update_conversation_history(conversation_panel, messages_queue)) nursery.start_soon( update_status_panel(status_labels, status_updates_queue))
async def main(): command_line_arguments = get_command_line_arguments() chat_host = command_line_arguments.host chat_port = command_line_arguments.port user_credentials_output_filepath = command_line_arguments.output nickname_queue = asyncio.Queue() register_button_state_queue = asyncio.Queue() async with create_handy_nursery() as nursery: nursery.start_soon( gui.draw( nickname_queue=nickname_queue, register_button_state_queue=register_button_state_queue, ), ) nursery.start_soon( run_chat_registrator( host=chat_host, port=chat_port, nickname_queue=nickname_queue, register_button_state_queue=register_button_state_queue, user_credentials_output_filepath=user_credentials_output_filepath, ) )
async def handle_connection(host, reader_port, writer_port, history, token, queues): while True: try: async with mc.get_connection(host, writer_port, history, queues) as streams: async with timeout(CONNECTION_TIMEOUT): is_authorized, account_info = await mc.authorise( *streams, token) if not is_authorized: messagebox.showerror( 'Неизвестный токен', 'Проверьте токен или зарегистрируйте заново.') raise InvalidToken event = gui.NicknameReceived(account_info['nickname']) queues['status_updates_queue'].put_nowait(event) async with utils.create_handy_nursery() as nursery: nursery.start_soon( mc.restore_history(history, queues['messages_queue'])) nursery.start_soon( read_msgs(host, reader_port, history, queues)) nursery.start_soon(send_msgs(*streams, queues)) nursery.start_soon( watch_for_connection(queues["watchdog_queue"])) nursery.start_soon( ping_pong(*streams, queues["watchdog_queue"])) except (ConnectionRefusedError, ConnectionResetError, ConnectionError, asyncio.TimeoutError): continue else: break
async def run_app(host: str, reader_port: int, writer_port: int, token: str, history_path: str) -> None: messages_queue = asyncio.Queue() sending_queue = asyncio.Queue() status_updates_queue = asyncio.Queue() history_queue = asyncio.Queue() watchdog_queue = asyncio.Queue() history.load_history(history_path, messages_queue) async with create_handy_nursery() as nursery: nursery.start_soon( gui.draw(messages_queue, sending_queue, status_updates_queue)) nursery.start_soon( history.save_messages(filepath=history_path, history_queue=history_queue)) nursery.start_soon( handle_connection(host=host, reader_port=reader_port, writer_port=writer_port, token=token, messages_queue=messages_queue, status_queue=status_updates_queue, history_queue=history_queue, sending_queue=sending_queue, watchdog_queue=watchdog_queue))
async def handle_articles(request, morph, charged_words, max_urls_count=10): urls_string = request.query.get('urls') if not urls_string: return web.json_response( {'error': 'articles URLs not given'}, status=400, ) urls = urls_string.split(',') if len(urls) > max_urls_count: return web.json_response( {'error': f'too many URLs in request, should be {max_urls_count} or less'}, status=400, ) async with ClientSession() as session: async with create_handy_nursery() as nursery: tasks = [ nursery.start_soon( process_article(session, article_url, morph, charged_words), ) for article_url in urls ] done_tasks, _ = await asyncio.wait(tasks) return web.json_response([task.result() for task in done_tasks])
async def send_msgs(host: str, port: int, token: Token, sending_queue: asyncio.Queue, status_queue: asyncio.Queue, watchdog_queue: asyncio.Queue) -> None: authorized = False async with connect( host=host, port=port, status_queue=status_queue, connect_state_mode=gui.SendingConnectionStateChanged) as (reader, writer): if not token.is_exist: status_queue.put_nowait(gui.SendingConnectionStateChanged.CLOSED) token.value, user = await registration(reader, writer) status_queue.put_nowait( gui.SendingConnectionStateChanged.INITIATED) authorized = True await watchdog_queue.put(WatchdogSwitcher.ENABLE) if not authorized: await watchdog_queue.put("Prompt before auth") user = await authorise(reader, writer, token.value) await status_queue.put(gui.NicknameReceived(user)) await watchdog_queue.put("Authorization done") status_queue.put_nowait(gui.SendingConnectionStateChanged.ESTABLISHED) async with create_handy_nursery() as nursery: nursery.start_soon( send_message(writer=writer, sending_queue=sending_queue, watchdog_queue=watchdog_queue)) nursery.start_soon(ping_pong(reader, writer, watchdog_queue))
async def handle_connection(host: str, reader_port: int, writer_port: int, token: str, messages_queue: asyncio.Queue, status_queue: asyncio.Queue, history_queue: asyncio.Queue, sending_queue: asyncio.Queue, watchdog_queue: asyncio.Queue) -> None: token = Token(token) while True: try: async with create_handy_nursery() as nursery: nursery.start_soon( connection.read_msgs(host=host, port=reader_port, messages_queue=messages_queue, status_queue=status_queue, history_queue=history_queue, watchdog_queue=watchdog_queue)) nursery.start_soon( connection.send_msgs(host=host, port=writer_port, token=token, sending_queue=sending_queue, status_queue=status_queue, watchdog_queue=watchdog_queue)) nursery.start_soon( connection.watch_for_connection( watchdog_queue=watchdog_queue)) except aionursery.MultiError as e: if not any(isinstance(ex, ConnectionError) for ex in e.exceptions): raise except ConnectionError: await asyncio.sleep(RECONNECT_DELAY) else: return
async def registration(reader: asyncio.StreamReader, writer: asyncio.StreamWriter) -> str: login_queue = asyncio.Queue(maxsize=1) async with create_handy_nursery() as nursery: nursery.start_soon(register_draw(login_queue)) tok = nursery.start_soon(register(reader, writer, login_queue)) return tok.result()
async def main(): dotenv.load_dotenv() registration_queue = asyncio.Queue() args = get_args() async with utils.create_handy_nursery() as nursery: nursery.start_soon(draw(registration_queue)) nursery.start_soon( handle_connection(args.host, args.writer_port, registration_queue))
async def main(): command_line_arguments = get_command_line_arguments() chat_host = command_line_arguments.host chat_read_port = command_line_arguments.read_port chat_write_port = command_line_arguments.write_port user_credentials_filepath = command_line_arguments.credentials chat_auth_token = command_line_arguments.token output_filepath = command_line_arguments.output if not chat_auth_token: user_credentials = await load_json_data(user_credentials_filepath) if not user_credentials: sys.exit('Auth token not given') chat_auth_token = user_credentials['account_hash'] displayed_messages_queue = asyncio.Queue() written_to_file_messages_queue = asyncio.Queue() sending_messages_queue = asyncio.Queue() status_updates_queue = asyncio.Queue() watchdog_logger.setLevel(level=logging.INFO) console_handler = logging.StreamHandler() console_handler.setLevel(level=logging.INFO) console_handler.setFormatter( logging.Formatter('%(name)s:%(levelname)s:%(message)s')) watchdog_logger.addHandler(console_handler) async with create_handy_nursery() as nursery: nursery.start_soon( handle_connection( host=chat_host, read_port=chat_read_port, write_port=chat_write_port, auth_token=chat_auth_token, displayed_messages_queue=displayed_messages_queue, written_to_file_messages_queue=written_to_file_messages_queue, sending_messages_queue=sending_messages_queue, status_updates_queue=status_updates_queue, ), ) nursery.start_soon( gui.draw( messages_queue=displayed_messages_queue, sending_queue=sending_messages_queue, status_updates_queue=status_updates_queue, ), ) nursery.start_soon( save_messages( output_filepath=output_filepath, messages_queue=written_to_file_messages_queue, ), )
async def main(): dotenv.load_dotenv() queues = get_queues() args = get_args() async with utils.create_handy_nursery() as nursery: nursery.start_soon( gui.draw(queues['messages_queue'], queues['sending_queue'], queues['status_updates_queue'])) nursery.start_soon( handle_connection(args.host, args.reader_port, args.writer_port, args.history, args.token, queues)) nursery.start_soon(save_messages(args.history, queues['history_queue']))
async def draw(messages_queue, sending_queue, status_updates_queue): root = tk.Tk() root.title('Minecraft Chat') root_frame = tk.Frame() root_frame.pack(fill='both', expand=True) status_labels = create_status_panel(root_frame) input_frame = tk.Frame(root_frame) input_frame.pack(side='bottom', fill=tk.X) input_field = tk.Entry(input_frame) input_field.pack(side='left', fill=tk.X, expand=True) input_field.bind( '<Return>', lambda event: move_message_to_queue(input_field, sending_queue), ) send_button = tk.Button(input_frame) send_button['text'] = 'Send' send_button['command'] = lambda: move_message_to_queue( input_field, sending_queue) send_button.pack(side='left') conversation_panel = ScrolledText(root_frame, wrap='none') conversation_panel.pack(side='top', fill='both', expand=True) conversation_panel.vbar.bind('<Enter>', disable_autoscrolling) conversation_panel.vbar.bind('<Leave>', enable_autoscrolling) root.update_idletasks() set_window_to_screen_center(root) async with create_handy_nursery() as nursery: nursery.start_soon(update_tk(root_frame=root_frame, ), ) nursery.start_soon( update_conversation_history( panel=conversation_panel, messages_queue=messages_queue, ), ) nursery.start_soon( update_status_panel( status_labels=status_labels, status_updates_queue=status_updates_queue, ), )
async def run_chat_writer(host, port, auth_token, sending_messages_queue, status_updates_queue, watchdog_messages_queue, successful_connection_info_queue): status_updates_queue.put_nowait( gui.SendingConnectionStateChanged.INITIATED) reader, writer = await asyncio.open_connection(host=host, port=port) try: status_updates_queue.put_nowait( gui.SendingConnectionStateChanged.ESTABLISHED) successful_connection_info_queue.put_nowait(True) user_credentials = await authorise( reader=reader, writer=writer, auth_token=auth_token, watchdog_messages_queue=watchdog_messages_queue, ) if user_credentials is None: raise InvalidToken() status_updates_queue.put_nowait( gui.NicknameReceived(user_credentials["nickname"]), ) async with create_handy_nursery() as nursery: nursery.start_soon( send_messages( reader=reader, writer=writer, sending_messages_queue=sending_messages_queue, watchdog_messages_queue=watchdog_messages_queue, ), ) nursery.start_soon( send_empty_messages( reader=reader, writer=writer, watchdog_messages_queue=watchdog_messages_queue, ), ) finally: writer.close() status_updates_queue.put_nowait( gui.SendingConnectionStateChanged.CLOSED)
async def draw(nickname_queue, register_button_state_queue): root = tk.Tk() root.title('Minecraft Chat Registrator') root.resizable(False, False) root_frame = tk.Frame() root_frame.pack(fill='both', expand=True) info_label = tk.Label(root_frame, height=2, width=30, fg='black', font='arial 14', anchor='w') info_label.pack(side='top', fill=tk.X, padx=10) info_label['text'] = 'Enter preferred nickname:' nickname_input_field = tk.Entry(root_frame, font='arial 18') nickname_input_field.pack(side='top', fill=tk.X, expand=True, padx=10) register_button = tk.Button(root_frame, font='arial 14', height=1) register_button['text'] = 'Register' register_button['command'] = lambda: handle_register_button_click( button=register_button, nickname_input_field=nickname_input_field, nickname_queue=nickname_queue, ) register_button.pack(side='top', ipady=10, pady=10) root.update_idletasks() set_window_to_screen_center(root) async with create_handy_nursery() as nursery: nursery.start_soon(update_tk(root_frame=root_frame, ), ) nursery.start_soon( handle_button_state( button=register_button, button_state_queue=register_button_state_queue, ))
async def draw(registration_queue): root = tk.Tk() root.title('Регистрация нового пользователя') root_frame = tk.Frame(root, width=300) root_frame.pack() label = tk.Label(height=1, text='Введите ник') label.pack() username_input = tk.Entry(width=20) username_input.pack(pady=5) register_button = tk.Button(text='Зарегистрироваться', bd=1) register_button.bind( '<Button-1>', lambda event: get_username(username_input, registration_queue)) register_button.pack(pady=10) async with utils.create_handy_nursery() as nursery: nursery.start_soon(gui.update_tk(root_frame))
async def handler(charged_words: List[str], morph: pymorphy2.MorphAnalyzer, request: web.Request) -> web.Response: urls = request.query.get('urls') if not urls: return web.json_response({'error': 'no urls given'}, status=400) urls_list = urls.rstrip(',').split(',') if len(urls_list) > 10: response = {'error': 'too many urls in request, should be 10 or less'} return web.json_response(response, status=400) async with aiohttp.ClientSession() as session: async with create_handy_nursery() as nursery: tasks = [] for url in urls_list: task = nursery.start_soon(process_article(session, morph, charged_words, url)) tasks.append(task) list_of_results = [task.result() for task in tasks] return web.json_response(list_of_results)
async def handle_connection(host, read_port, write_port, auth_token, displayed_messages_queue, written_to_file_messages_queue, sending_messages_queue, status_updates_queue, connection_attempts_count_without_timeout=2, timeout_between_connection_attempts=2): watchdog_messages_queue = asyncio.Queue() chat_reader_successful_connection_info_queue = asyncio.Queue() chat_writer_successful_connection_info_queue = asyncio.Queue() current_connection_attempt = 0 while True: try: current_connection_attempt += 1 async with create_handy_nursery() as nursery: nursery.start_soon( run_chat_reader( host=host, port=read_port, displayed_messages_queue=displayed_messages_queue, written_to_file_messages_queue= written_to_file_messages_queue, status_updates_queue=status_updates_queue, watchdog_messages_queue=watchdog_messages_queue, successful_connection_info_queue= chat_reader_successful_connection_info_queue, ), ) nursery.start_soon( run_chat_writer( host=host, port=write_port, auth_token=auth_token, sending_messages_queue=sending_messages_queue, status_updates_queue=status_updates_queue, watchdog_messages_queue=watchdog_messages_queue, successful_connection_info_queue= chat_writer_successful_connection_info_queue, ), ) nursery.start_soon( watch_for_connection( watchdog_messages_queue=watchdog_messages_queue, ), ) return except MultiError as e: for exc in e.exceptions: if not isinstance(exc, socket.gaierror): raise except (ConnectionError, socket.gaierror): pass if (not chat_reader_successful_connection_info_queue.empty() and not chat_writer_successful_connection_info_queue.empty()): current_connection_attempt = 0 if not chat_reader_successful_connection_info_queue.empty(): chat_reader_successful_connection_info_queue.get_nowait() if not chat_writer_successful_connection_info_queue.empty(): chat_writer_successful_connection_info_queue.get_nowait() if current_connection_attempt >= connection_attempts_count_without_timeout: await asyncio.sleep(timeout_between_connection_attempts)
async def ping_pong(reader: asyncio.StreamReader, writer: asyncio.StreamWriter, watchdog_queue: asyncio.Queue) -> None: async with create_handy_nursery() as nursery: nursery.start_soon(_ping(writer)) nursery.start_soon(_pong(reader, watchdog_queue))