async def login(self) -> AsyncClient: # If there are no previously-saved credentials, we'll use the password if not os.path.exists(self.config.state_file): self.logger.info( "First time use. Did not find credential file. Using environment variables" ) client = AsyncClient(self.config.homeserver, self.config.account_name) resp = await client.login(self.config.account_password, device_name=self.config.device_name) # check that we logged in succesfully if (isinstance(resp, LoginResponse)): write_details_to_disk(resp, self.config) else: self.logger.warning( f'homeserver = "{self.config.homeserver}"; user = "******"' ) self.logger.warning(f'Failed to log in: {resp}') exit(1) self.logger.info( 'Logged in using a password. Credentials were stored.', 'Try running the script again to login with credentials') # Otherwise the config file exists, so we'll use the stored credentials else: client = AsyncClient(self.config.homeserver) client.access_token = self.access_token client.user_id = self.user_id client.device_id = self.device_id return client
async def main() -> None: # If there are no previously-saved credentials, we'll use the password if not os.path.exists(CONFIG_FILE): print("First time use. Did not find credential file. Asking for " "homeserver, user, and password to create credential file.") homeserver = "https://matrix.example.org" homeserver = input(f"Enter your homeserver URL: [{homeserver}] ") if not (homeserver.startswith("https://") or homeserver.startswith("http://")): homeserver = "https://" + homeserver user_id = "@user:example.org" user_id = input(f"Enter your full user ID: [{user_id}] ") device_name = "matrix-nio" device_name = input(f"Choose a name for this device: [{device_name}] ") client = AsyncClient(homeserver, user_id) pw = getpass.getpass() resp = await client.login(pw, device_name=device_name) # check that we logged in succesfully if (isinstance(resp, LoginResponse)): write_details_to_disk(resp, homeserver) else: print(f"homeserver = \"{homeserver}\"; user = \"{user_id}\"") print(f"Failed to log in: {resp}") sys.exit(1) print( "Logged in using a password. Credentials were stored.", "Try running the script again to login with credentials." ) # Otherwise the config file exists, so we'll use the stored credentials else: # open the file in read-only mode with open(CONFIG_FILE, "r") as f: config = json.load(f) client = AsyncClient(config['homeserver']) client.access_token = config['access_token'] client.user_id = config['user_id'] client.device_id = config['device_id'] # Now we can send messages as the user room_id = "!myfavouriteroomid:example.org" room_id = input(f"Enter room id for image message: [{room_id}] ") image = "exampledir/samplephoto.jpg" image = input(f"Enter file name of image to send: [{image}] ") await send_image(client, room_id, image) print("Logged in using stored credentials. Sent a test message.") # Close the client connection after we are done with it. await client.close()
async def main() -> None: # If there are no previously-saved credentials, we'll use the password if not os.path.exists(CONFIG_FILE): print("First time use. Did not find credential file. Asking for " "homeserver, user, and password to create credential file.") homeserver = "https://matrix.example.org" homeserver = input(f"Enter your homeserver URL: [{homeserver}] ") if not (homeserver.startswith("https://") or homeserver.startswith("http://")): homeserver = "https://" + homeserver user_id = "@user:example.org" user_id = input(f"Enter your full user ID: [{user_id}] ") client = AsyncClient(homeserver, user_id) pw = getpass.getpass() resp = await client.login(pw) # check that we logged in succesfully if (isinstance(resp, LoginResponse)): write_details_to_disk(resp, homeserver) else: print(f"homeserver = \"{homeserver}\"; user = \"{user_id}\"") print(f"Failed to log in: {resp}") sys.exit(1) print("Logged in using a password. Credentials were stored.", "Try running the script again to login with credentials.") # Otherwise the config file exists, so we'll use the stored credentials else: # open the file in read-only mode with open(CONFIG_FILE, "r") as f: config = json.load(f) client = AsyncClient(config['homeserver']) client.access_token = config['access_token'] client.user_id = config['user_id'] client.device_id = config['device_id'] # Now we can send messages as the user room_id = "!myfavouriteroomid:example.org" room_id = input(f"Enter room id for test message: [{room_id}] ") await client.room_send(room_id, message_type="m.room.message", content={ "msgtype": "m.text", "body": "Hello world!" }) print("Logged in using stored credentials. Sent a test message.") # Either way we're logged in here, too await client.close()
async def post_picture_to_room(matrix_config: MatrixConfig, image: Image) -> None: client = AsyncClient(matrix_config.homeserver_url) client.access_token = matrix_config.access_token client.user_id = matrix_config.mxid client.device_id = matrix_config.device_id room_id = matrix_config.target_room f = io.BytesIO() image.save(f, format="JPEG", optimize=True, progressive=True) # Get the (post-resize) file size f.seek(0, io.SEEK_END) image_file_size = f.tell() print(f"Image resized down to {image_file_size} bytes") f.seek(0) # rewind to the start # First upload the image and get an MXC URI in response resp, _maybe_keys = await client.upload( lambda _got_429, _got_timeouts: f, # No need to really use aiofiles when we have a BytesIO content_type="image/jpeg", filesize=image_file_size) if not isinstance(resp, UploadResponse): raise RuntimeError(f"Failed to send image: {resp}") # Then send a (image) message to the room pointing to the uploaded image's MXC URI. today_str = str(datetime.date.today()) content = { "body": f"Image of the day {today_str}", "info": { "size": image_file_size, "mimetype": "image/jpeg", "w": image.width, "h": image.height, "thumbnail_info": None, "thumbnail_url": None, }, "msgtype": "m.image", "url": resp.content_uri, } await client.room_send(room_id, message_type="m.room.message", content=content) f.close() await client.close()
async def do_sendmsg(roomid, message, path, endpoint) -> None: full_path = os.path.join(path, CONFIG_FILE) if not os.path.exists(full_path): print(f"Didn't find {full_path}, perhaps you should run init first") return # open the file in read-only mode with open(full_path, "r") as f: config = json.load(f) client = AsyncClient(config["homeserver"]) client.access_token = config["access_token"] client.user_id = config["user_id"] client.device_id = config["device_id"] if not roomid: try: roomid = config["room_id"] except KeyError: print("Must either specify roomid or put it config file") raise if endpoint: do_check_health(endpoint, 10) else: try: endpoint = config["endpoint"] except KeyError: pass else: do_check_health(endpoint, 10) resp = await client.room_send( roomid, message_type="m.room.message", content={ "msgtype": "m.text", "body": message, }, ) if isinstance(resp, RoomSendResponse): print("Logged in using stored credentials. Sent message.") else: print(f"Bad response: {resp}") await client.close()
async def login() -> None: try: with open(CREDS_FILE) as f: creds = json.load(f) client = AsyncClient(creds["homeserver"]) client.access_token = creds["access_token"] client.user_id = creds["user_id"] client.device_id = creds["device_id"] except (FileNotFoundError, json.JSONDecodeError, KeyError): print(f"Did not find credentials in {CREDS_FILE}. " "Asking for login info.") matrix_server_str = "matrix.org" matrix_server_str = (input("Enter your matrix server URL " f"(default = {matrix_server_str!r}): ") or matrix_server_str) url = urlsplit(matrix_server_str) url = (url._replace(scheme=url.scheme or "https")._replace( netloc=url.netloc or url.path)._replace(path="")) matrix_server = urlunsplit(url) user_id = input("Enter your user ID: ") user, *server_maybe = user_id.lstrip("@").split(":", 1) user_id = f"@{user}:" + (server_maybe[0] if server_maybe else url.netloc) device_name = "diplomatrix_client" device_name = (input("Choose a name for this device " f"(default = {device_name!r}): ") or device_name) client = AsyncClient(matrix_server, user_id) pw = getpass.getpass() resp = await client.login(pw, device_name=device_name) if isinstance(resp, LoginResponse): save_login(resp, matrix_server) print(f"Logged in. Credentials saved to {CREDS_FILE!r}") else: print(f'server = "{matrix_server}"; user = "******"') print(f"Failed to log in: {resp}") sys.exit(1) await client.close()
async def main() -> None: client = AsyncClient("https://the-apothecary.club", "@bot-sync:the-apothecary.club") # imports login data with open(CONFIG_FILE, "r") as f: config = json.load(f) client.access_token = config["access_token"] client.user_id = config["user_id"] client.device_id = config["device_id"] # import room data with open(ROOMS_FILE, "r") as f: config = json.load(f) bot_control_room = config["control_room"] bot_template_room = config["template_room"] bot_rooms = config["rooms"] ## await bot_send_msg(client, "Online", bot_control_room) # get room state room_state = await client.room_get_state(bot_template_room) ## print(room_state) # execute in each room for room in bot_rooms: # logs room cycle print("Syncing state in:", room["id"]) # join rooms if not already joined await client.join(room["id"]) # sends a test message ##resp = await bot_send_msg(client, "Syncing...", room["id"]) ##print(resp) # sends a test state event resp = await bot_set_emote(client, room["id"]) print(resp) # ends the connection await client.close()
async def main(sugaroid: Sugaroid) -> None: config = Config.from_environment() client = AsyncClient(config['homeserver']) client.access_token = config['access_token'] client.user_id = config['user_id'] client.device_id = config['device_id'] print("Status: sleeping for 30000") await client.sync(30000) print("Resuming:") cb = Callbacks(client, sugaroid=sugaroid) client.add_event_callback(cb.message, RoomMessageText) while True: try: await client.sync_forever(timeout=30000, full_state=True) except KeyboardInterrupt: break except (ClientConnectionError, ServerDisconnectedError): print("Unable to connect to homeserver, retrying in 15s") time.sleep(15) finally: await client.close()
async def main() -> None: client = AsyncClient("https://matrix.example.org", "@alice:example.org") # If there are no previously-saved credentials, we'll use the password if not os.path.exists(CONFIG_FILE): resp = await client.login("hunter2") # check that we logged in succesfully if (isinstance(resp, LoginResponse)): write_details_to_disk(resp) else: print(f"Failed to log in: {resp}") sys.exit(1) print("Logged in using a password.", "Try running the script again to login with an access token") # Otherwise the config file exists, so we'll use the stored credentials else: # open the file in read-only mode with open(CONFIG_FILE, "r") as f: config = json.load(f) client.access_token = config['access_token'] client.user_id = config['user_id'] client.device_id = config['device_id'] # Now we can send messages as the user await client.room_send(room_id="!myfavouriteroomid:example.org", message_type="m.room.message", content={ "msgtype": "m.text", "body": "Hello world!" }) print("Logged in using stored credentials") # Either way we're logged in here, too await client.close()