def run_example(example_coroutine, *extra_args): """Run a hangups example coroutine. Args: example_coroutine (coroutine): Coroutine to run with a connected hangups client and arguments namespace as arguments. extra_args (str): Any extra command line arguments required by the example. """ args = _get_parser(extra_args).parse_args() logging.basicConfig(level=logging.DEBUG if args.debug else logging.WARNING) # Obtain hangups authentication cookies, prompting for credentials from # standard input if necessary. cookies = hangups.auth.get_auth_with_args("*****@*****.**", "password", "refresh_token.txt") client = hangups.Client(cookies) task = asyncio. async (_async_main(example_coroutine, client, args)) loop = asyncio.get_event_loop() try: loop.run_until_complete(task) except KeyboardInterrupt: task.cancel() loop.run_forever() finally: loop.close()
def run_example(example_coroutine, *extra_args): """Run a hangups example coroutine. Args: example_coroutine (coroutine): Coroutine to run with a connected hangups client and arguments namespace as arguments. extra_args (str): Any extra command line arguments required by the example. """ args = _get_parser(extra_args).parse_args() logging.basicConfig(level=logging.DEBUG if args.debug else logging.WARNING) # Obtain hangups authentication cookies, prompting for credentials from # standard input if necessary. cookies = hangups.auth.get_auth_stdin(args.token_path) client = hangups.Client(cookies) task = asyncio.async(_async_main(example_coroutine, client, args)) loop = asyncio.get_event_loop() try: loop.run_until_complete(task) except KeyboardInterrupt: task.cancel() loop.run_forever() except hangups.exceptions.NetworkError: print('Network problem. Try again later?')
def __init__(self, refresh_token_path, conversation_path, user_path, command, optional_command): # self.set_language() self.refresh_token_path = refresh_token_path self.conversation_path = conversation_path self.user_path = user_path self.command = command self.optional_command = optional_command self.hangups_running = False self.client = None self.conv_list = None # hangups.ConversationList self.user_list = None # hangups.UserList try: cookies = hangups.auth.get_auth_stdin(refresh_token_path) except hangups.GoogleAuthError as err: sys.exit('Login failed ({})'.format(err)) self.client = hangups.Client(cookies) self.client.on_connect.add_observer(self.on_connect) try: loop = asyncio.get_event_loop() loop.run_until_complete(self.client.connect()) except NotImplementedError: pass finally: loop.close()
def send_notification(self, message): cookies = hangups.auth.get_auth_stdin(self.REFRESH_TOKEN_PATH) client = hangups.Client(cookies) client.on_connect.add_observer(lambda: asyncio. async (self.send_message(client, message))) loop = asyncio.get_event_loop() loop.run_until_complete(client.connect())
def run(self): """Connect to Hangouts and run bot""" cookies = self.login(self._cookies_path) if cookies: # Create Hangups client self._client = hangups.Client(cookies) self._client.on_connect.add_observer(self._on_connect) self._client.on_disconnect.add_observer(self._on_disconnect) # Initialise hooks self._load_hooks() # Start asyncio event loop loop = asyncio.get_event_loop() # Start threads for web sinks self._start_sinks(loop) # Connect to Hangouts # If we are forcefully disconnected, try connecting again for retry in range(self._max_retries): try: loop.run_until_complete(self._client.connect()) sys.exit(0) except Exception as e: print('Client unexpectedly disconnected:\n{}'.format(e)) print('Waiting {} seconds...'.format(5 + retry * 5)) time.sleep(5 + retry * 5) print('Trying to connect again (try {} of {})...'.format( retry + 1, self._max_retries)) print('Maximum number of retries reached! Exiting...') sys.exit(1)
def run(self): """Connect to Hangouts and run bot""" cookies = self.login(self._cookies_path) if cookies: for retry in range(self._max_retries): try: # Create Hangups client self._client = hangups.Client(cookies) self._client.on_connect.add_observer(self._on_connect) self._client.on_disconnect.add_observer( self._on_disconnect) # Start asyncio event loop and connect to Hangouts # If we are forcefully disconnected, try connecting again loop = asyncio.get_event_loop() loop.run_until_complete(self._client.connect()) sys.exit(0) except Exception as e: print('Client unexpectedly disconnected:\n{}'.format(e)) log = open('log.txt', 'a+') log.writelines( str(datetime.now()) + ":\n " + traceback.format_exc() + "\n\n") log.close() print(traceback.format_exc()) print('Waiting {} seconds...'.format(5 + retry * 5)) time.sleep(5 + retry * 5) print('Trying to connect again (try {} of {})...'.format( retry + 1, self._max_retries)) print('Maximum number of retries reached! Exiting...') sys.exit(1)
def run(self): print("Running") cookies = hangups.auth.get_auth_stdin(self.config['hangup_token_path']) self.client = hangups.Client(cookies) self.approver_ids = list() self.conversation_id = None asyncio.run(self.co_run())
def run(self): """Connect to Hangouts and run bot""" cookies = self.login(self._refresh_token_path) if cookies: while self._retry < self._max_retries: try: # Create Hangups client self._client = hangups.Client(cookies) self._client.on_connect.add_observer(self._on_connect) self._client.on_disconnect.add_observer( self._on_disconnect) # Start asyncio event loop and connect to Hangouts # If we are forcefully disconnected, try connecting again loop = asyncio.get_event_loop() loop.run_until_complete(self._client.connect()) sys.exit(0) except Exception as e: print(_('Client unexpectedly disconnected:\n{}').format(e)) print( _('Waiting {} seconds...').format(5 + self._retry * 5)) time.sleep(5 + self._retry * 5) print( _('Trying to connect again (try {} of {})...').format( self._retry + 1, self._max_retries)) print(_('Maximum number of retries reached! Exiting...')) sys.exit(1)
def sendingMes(msg, calib): cookies = hangups.auth.get_auth_stdin(REFRESH_TOKEN_PATH) hclient = hangups.Client(cookies) hclient.on_connect.add_observer(lambda: asyncio. async (send_message(hclient, msg, calib))) loop = asyncio.get_event_loop() loop.run_until_complete(hclient.connect())
def __init__(self, refresh_token_path, keybindings, palette, palette_colors, datetimefmt, notifier): """Start the user interface.""" self._keys = keybindings self._datetimefmt = datetimefmt self._notifier = notifier set_terminal_title('hangups') # These are populated by on_connect when it's called. self._conv_list = None # hangups.ConversationList self._user_list = None # hangups.UserList self._notifier = None # hangups.notify.Notifier # Disable UI notifications by default self._disable_notifier = True try: cookies = hangups.auth.get_auth_stdin(refresh_token_path) except hangups.GoogleAuthError as e: sys.exit('Login failed ({})'.format(e)) self._client = hangups.Client(cookies) self._client.on_connect.add_observer(self._on_connect) loop = asyncio.get_event_loop() # Enable bracketed paste mode after the terminal has been switched to # the alternate screen (after MainLoop.start() to work around bug # 729533 in VTE. with bracketed_paste_mode(): try: # Returns when the connection is closed. loop.run_until_complete(self._client.connect()) finally: loop.close()
def run(self): """Connect to Hangouts and run bot""" cookies = self.login(self._cookies_path) if cookies: # Create Hangups client self._client = hangups.Client(cookies) self._client.on_connect.add_observer(self._on_connect) self._client.on_disconnect.add_observer(self._on_disconnect) for addon in self._addons: addon.set_client(self._client) # If we are forcefully disconnected, try connecting again loop = asyncio.get_event_loop() tries = 0 while True: tries += 1 try: loop.run_until_complete(self._client.connect()) sys.exit(0) except Exception as e: report('Client disconnected: {}'.format(e)) wait = tries * 5 if wait > 300: wait = 300 time.sleep(wait) report('Connecting again ({})'.format(tries)) report('Exiting!') sys.exit(1)
def Hangouts(): cookies = hangups.auth.get_auth_stdin(REFRESH_TOKEN_PATH) client = hangups.Client(cookies) client.on_connect.add_observer(lambda: asyncio. async (send_message(client))) loop = asyncio.get_event_loop() loop.run_until_complete(client.connect())
def run(self): """Connect to Hangouts and run bot""" cookies = self.login(self._cookies_path) if cookies: # Start asyncio event loop loop = asyncio.get_event_loop() # initialise pluggable framework self._load_hooks() self._start_sinks(loop) # Connect to Hangouts # If we are forcefully disconnected, try connecting again for retry in range(self._max_retries): try: # create Hangups client (recreate if its a retry) self._client = hangups.Client(cookies) self._client.on_connect.add_observer(self._on_connect) self._client.on_disconnect.add_observer(self._on_disconnect) loop.run_until_complete(self._client.connect()) sys.exit(0) except Exception as e: logging.exception(_("unrecoverable low-level error")) print(_('Client unexpectedly disconnected:\n{}').format(e)) print(_('Waiting {} seconds...').format(5 + retry * 5)) time.sleep(5 + retry * 5) print(_('Trying to connect again (try {} of {})...').format(retry + 1, self._max_retries)) print(_('Maximum number of retries reached! Exiting...')) sys.exit(1)
def run(self): cookies = self.login() if cookies: self._loop = asyncio.get_event_loop() for retry in range(MAX_RECONNECT_RETRIES): try: self._hangups = hangups.Client(cookies) self._hangups.on_connect.add_observer( self._on_hangups_connect) self._hangups.on_disconnect.add_observer( self._on_disconnect) self._loop.run_until_complete(self._hangups.connect()) except Exception as e: logger.info('Roboronya disconnected. ' 'Retrying {}/{}...'.format( retry + 1, MAX_RECONNECT_RETRIES)) logger.exception(e) time.sleep(5 + retry * 5) logger.info('Roboronya is exiting.') sys.exit(0) logger.info('Invalid login.') sys.exit(0)
def __init__(self, cookies_path, keybindings, palette): """Start the user interface.""" self._keys = keybindings # These are populated by on_connect when it's called. self._conv_widgets = {} # {conversation_id: ConversationWidget} self._tabbed_window = None # TabbedWindowWidget self._conv_list = None # hangups.ConversationList self._user_list = None # hangups.UserList self._notifier = None # hangups.notify.Notifier # TODO Add urwid widget for getting auth. try: cookies = hangups.auth.get_auth_stdin(cookies_path) except hangups.GoogleAuthError as e: sys.exit('Login failed ({})'.format(e)) self._client = hangups.Client(cookies) self._client.on_connect.add_observer(self._on_connect) loop = asyncio.get_event_loop() self._urwid_loop = urwid.MainLoop( LoadingWidget(), palette, handle_mouse=False, event_loop=urwid.AsyncioEventLoop(loop=loop)) self._urwid_loop.start() try: # Returns when the connection is closed. loop.run_until_complete(self._client.connect()) finally: # Ensure urwid cleans up properly and doesn't wreck the terminal. self._urwid_loop.stop()
def __init__(self, cookies, recieve_event_handler, loop=None): if not loop: loop = asyncio.get_event_loop() self.loop = loop self.cookies = cookies self.client = hangups.Client(cookies) self.recieve_event_handler = recieve_event_handler
def Connect(self): print("doing connect") if self._status == telepathy.CONNECTION_STATUS_DISCONNECTED: self.StatusChanged(telepathy.CONNECTION_STATUS_CONNECTING, telepathy.CONNECTION_STATUS_REASON_REQUESTED) cookies = hangups.auth.get_auth(None, None, expanduser("~/.hangups_auth_tmp")) self._client = hangups.Client(cookies) self._client.on_connect.add_observer(self._on_connect) asyncio. async (self._client.connect())
def __init__(self, loop, inQueue, outQueue, cookiePath): self.loop = loop self.inQueue = inQueue self.outQueue = outQueue cookies = hangups.auth.get_auth_stdin(cookiePath) self.client = hangups.Client(cookies) self.client.on_connect.add_observer(lambda: asyncio. async (self.on_connect())) asyncio. async (self.client.connect())
def run_example(example_coroutine, *extra_args): """Run a hangups example coroutine. Args: example_coroutine (coroutine): Coroutine to run with a connected hangups client and arguments namespace as arguments. extra_args (str): Any extra command line arguments required by the example. """ args = _get_parser().parse_args() logging.basicConfig(level=logging.DEBUG if args.debug else logging.WARNING) if args.login_and_save_token: cookies = hangups.auth.get_auth_stdin(args.token_path) #pprint(getmembers(args)) return else: # Obtain hangups authentication cookies, prompting for credentials from # standard input if necessary. refresh_token_cache = RefreshTokenCache(args.token_path) try: cookies = get_auth(NullCredentialsPrompt(), refresh_token_cache) except: print( "Hangouts login failed. Either you didn't log in yet, or your refresh token expired.\nPlease log in with --login-and-save-token" ) return while 1: print("Attempting main loop...") client = hangups.Client(cookies, max_retries=float('inf'), retry_backoff_base=1.2) task = asyncio.ensure_future( _async_main(example_coroutine, client, args)) loop = asyncio.get_event_loop() try: loop.run_until_complete(task) except KeyboardInterrupt: task.cancel() loop.run_forever() except: pass finally: time.sleep(5) try: loop.run_until_complete(task) except KeyboardInterrupt: task.cancel() loop.run_forever() finally: loop.close()
async def start(self): await super().start() self._closing = False self._client = hangups.Client( hangups.get_auth_stdin(self.config["cookie"])) self._client.on_connect.add_observer(self._connect) log.debug("Connecting client") self._looped = ensure_future(self._loop()) async with self._starting: # Block until users and conversations are loaded. await self._starting.wait() log.debug("Listening for events")
def __init__(self): self.cookies = hangups.get_auth_stdin("token.txt", True) self.client = hangups.Client(self.cookies) with open("reply_data.json", "r") as replies_file: self.reply_data = json.load(replies_file) self.handler = handler.Handler(self, self.reply_data) self.connected = asyncio.Event() # to prevent replying to self self.recent_meeper_messages = [] self.sending_lock = asyncio.Lock()
def load(cookies): global client, loop print("Loading ...") print("Creating client ...") client = hangups.Client(cookies) print("Adding client observer") client.on_connect.add_observer(on_connect) loop = asyncio.get_event_loop() t = threading.Thread(target=run_asyncio_loop_in_thread, args=(loop, )) t.start()
def login(self): cookie = None try: cookies = hangups.auth.get_auth(self.get_creds, False, ".cookies.json") except hangups.GoogleAuthError as e: print("fail connect: %s" % e) return False self.client = hangups.Client(cookies) self.client.on_connect.add_observer(self.on_connect) return True
def __init__(self, refresh_token_path, keybindings, palette, palette_colors, datetimefmt, notifier_, discreet_notifications): """Start the user interface.""" self._keys = keybindings self._datetimefmt = datetimefmt self._notifier = notifier_ self._discreet_notifications = discreet_notifications set_terminal_title('hangups') # These are populated by on_connect when it's called. self._conv_widgets = {} # {conversation_id: ConversationWidget} self._tabbed_window = None # TabbedWindowWidget self._conv_list = None # hangups.ConversationList self._user_list = None # hangups.UserList # TODO Add urwid widget for getting auth. try: cookies = hangups.auth.get_auth_stdin(refresh_token_path) except hangups.GoogleAuthError as e: sys.exit('Login failed ({})'.format(e)) self._client = hangups.Client(cookies) self._client.on_connect.add_observer(self._on_connect) loop = asyncio.get_event_loop() try: self._urwid_loop = urwid.MainLoop( LoadingWidget(), palette, handle_mouse=False, input_filter=self._input_filter, event_loop=urwid.AsyncioEventLoop(loop=loop)) except urwid.AttrSpecError as e: # Fail gracefully for invalid colour options. sys.exit(e) self._urwid_loop.screen.set_terminal_properties(colors=palette_colors) self._urwid_loop.start() # Enable bracketed paste mode after the terminal has been switched to # the alternate screen (after MainLoop.start() to work around bug # 729533 in VTE. with bracketed_paste_mode(): try: # Returns when the connection is closed. loop.run_until_complete(self._client.connect()) finally: # Ensure urwid cleans up properly and doesn't wreck the # terminal. self._urwid_loop.stop() loop.close()
def __init__(self): self.CONVERSATION_ID = 'UgyImgnHZYS2sAK-K_J4AaABAQ' self.REFRESH_TOKEN_PATH = '/home/pi/.cache/hangups/refresh_token.txt' try: self.cookies = hangups.auth.get_auth_stdin(self.REFRESH_TOKEN_PATH) self.client = hangups.Client(self.cookies) except Exception as err: print("--------------------") print(">> Network Error.") print(">> Script Exiting.") print(f">> ERR: {err}") print("--------------------") sys.exit(0)
def login(self, ame): """Login to Google account""" # Authenticate Google user with OAuth token and save it # (or load already saved OAuth token) self.ame = ame try: cookies = hangups.auth.get_auth_stdin(self._refresh_token_path) if cookies: self._client = hangups.Client(cookies) self._client.on_connect.add_observer(self._on_connect) self._client.on_disconnect.add_observer(self._on_disconnect) except hangups.GoogleAuthError as e: print(_('Login failed ({})').format(e)) return False
def hangups_start(self): """Connect to Hangouts""" cookies = self.login(self.cookies_path) if cookies: self.startHangups.emit() self.client = hangups.Client(cookies) self.client.on_connect.add_observer(self.on_connect) # Run Hangups event loop asyncio. async (self.client.connect()).add_done_callback( lambda future: future.result()) self.hangups_running = True self.update_status()
def load(cookies): global client, loop print("Loading ...") print("Creating client ...") set_loading_status("creatingClient") client = hangups.Client(cookies) client.on_state_update.add_observer(presence_changed) print("Adding client observer") set_loading_status("addingObserver") client.on_connect.add_observer(on_connect) set_loading_status("loadingChats") loop = asyncio.get_event_loop() t = threading.Thread(target=run_asyncio_loop_in_thread, args=(loop,)) t.start()
def send_alert(message): # Obtain hangups authentication cookies. cookies = authentication.get_auth(ConfigurationReader._refresh_token) # Instantiate hangups Client instance. client = hangups.Client(cookies) # Add an observer to the on_connect event to run the send_message when hangups has finished connecting. client.on_connect.add_observer(lambda: asyncio.async(send_message(client, message))) # Start an asyncio event loop by running Client.connect. This will not # return until Client.disconnect is called, or hangups becomes # disconnected. loop = asyncio.get_event_loop() loop.run_until_complete(client.connect())
def run(self): """Start the main loop.""" policy = asyncio.get_event_loop_policy() self.loop = policy.new_event_loop() policy.set_event_loop(self.loop) self.client = hangups.Client(self.cookies) self.client.on_connect.add_observer(self.on_connect) self.client.on_disconnect.add_observer(self.on_disconnect) self.client.on_reconnect.add_observer(self.on_reconnect) self.client.on_state_update.add_observer(self.on_state_update) self.loop.run_until_complete(self.client.connect()) self.send_message_to_xmpp({'what': 'disconnected'}) logger.info("Hangouts thread stopped.")