def main(): url = "https://mstdn.poyo.me" path = Path(__file__).parent.resolve() paths = [ str(path / "token"), star(path / "figure"), str(path / "data"), str(path / "data" / "all"), str(path / "data" / "ponytail"), str(path / "data" / "kedama") ] for path in paths: check_dir(path) Mastodon.create_app( client_name="ponymofu_counter", scopes=["read", "write"], website="https://github.com/kelvin27315/ponymofu_counter", to_file=path / "clientcred.secret", api_base_url=url) mastodon = Mastodon(client_id=(path / "clientcred.secret"), api_base_url=url) mail = "*****@example.com" password = "******" mastodon.log_in(mail, password, scopes=['read', 'write'], to_file=path / "usercred.secret")
def mastodon_register(ctx: click.Context, cred_file: str, bot_name: str) -> None: "register your bot's account on the homeserver" Mastodon.create_app(bot_name, api_base_url=ctx.obj["base_url"], to_file=os.path.join(ctx.obj["secret_folder"], cred_file))
def register_app(appName, credentialFile, url): SECRET_DIR = '/home/z/prj/mastobots/secrets/' Mastodon.create_app(appName, api_base_url=url, to_file=SECRET_DIR + credentialFile)
def make_clientid(self): appname = self.ui.lineEdit.text() url = self.ui.lineEdit_2.text() cid_file = 'client_id.txt' Mastodon.create_app(appname, api_base_url=url, to_file=cid_file) with open(cid_file) as ci: self.ui.lineEdit_3.setText(ci.read())
def init_app(app_name, url, email, password): if os.path.exists(clientcred_file) is False: Mastodon.create_app(app_name, api_base_url=url, to_file=".clientcred.secret") app = Mastodon(client_id=".clientcred.secret", api_base_url=url) app.log_in(email, password, to_file=".usercred.secret")
def initialize_mastodon(): server_url = config("MASTODON_SERVER") # make data dir mastodon_data_path = Path(__file__).parents[1] / "data" / "mastodon" # フォルダの方は Error を回避 try: Path(mastodon_data_path.parent).mkdir() Path(mastodon_data_path).mkdir() except FileExistsError: print("you have already make mastodon data folder") mastodon_client_data_path = mastodon_data_path / "my_clientcred.txt" mastodon_user_data_path = mastodon_data_path / "my_usercred.txt" # If you already have data file, Raise error for path in (mastodon_user_data_path, mastodon_client_data_path): if path.exists(): raise FileExistsError(path.as_posix(), "is already exists") # get mastodon data Mastodon.create_app("client name", api_base_url=server_url, to_file=mastodon_client_data_path.as_posix()) mastodon = Mastodon(client_id=mastodon_client_data_path.as_posix(), api_base_url=server_url) mastodon.log_in(config("MASTODON_EMAIL"), config("MASTODON_PASS"), to_file=mastodon_user_data_path.as_posix())
def instantiate_bot() -> Mastodon: if not os.path.exists(config('MASTODON_SECRET_LOCATION')): BOT_LOG.info(f'Creating Mastodon app...') Mastodon.create_app( 'mastodoff', api_base_url=config('MASTODON_API'), to_file=config('MASTODON_SECRET_LOCATION'), ) if not os.path.exists(config('MASTODON_TOKEN_LOCATION')): BOT_LOG.info(f'Getting Mastodon token...') mastodon = Mastodon( client_id=config('MASTODON_SECRET_LOCATION'), api_base_url=config('MASTODON_API'), ) mastodon.log_in( config('MASTODON_USERNAME'), config('MASTODON_PASSWORD'), to_file=config('MASTODON_TOKEN_LOCATION'), ) BOT_LOG.info(f'Instantiating mastodon.Mastodon...') client = Mastodon( client_id=config('MASTODON_SECRET_LOCATION'), access_token=config('MASTODON_TOKEN_LOCATION'), api_base_url=config('MASTODON_API'), ratelimit_method='throw', ) return (client)
def login(config: CleanTootsConfig, only_missing: bool): """Fetch credentials for each app described in config file.""" if not _config_has_sections(config): return prompt = True for section in config.sections(): section = config[section] app_file_exists = config.isfile(section.get("app_secret_file")) user_file_exists = config.isfile(section.get("user_secret_file")) if not (only_missing and app_file_exists): Mastodon.create_app( "cleantoots", api_base_url=section.get("api_base_url"), to_file=config.file(section.get("app_secret_file")), ) mastodon = Mastodon( client_id=config.file(section.get("app_secret_file"))) if not (only_missing and user_file_exists and app_file_exists): _open_url(mastodon.auth_request_url(), echo=prompt) prompt = False code = click.prompt("Enter code for {}".format( section.get("api_base_url"))) mastodon.log_in(code=code, to_file=config.file( section.get("user_secret_file")))
def get_credential(**config): api_base_url = config.get('instance_url') if not api_base_url: raise Exception( 'Correctly specify instance_url on {}.'.format(CONFIG_FILE_NAME)) if not exists(CLIENT_SECRET_FILE_NAME): Mastodon.create_app( client_name=config.get('app_name') or 'chatbotdon', website=config.get('website') or 'https://github.com/kakakaya/chatbotdon', to_file=CLIENT_SECRET_FILE_NAME, api_base_url=api_base_url, ) access_token = None if exists(USER_SECRET_FILE_NAME): access_token = USER_SECRET_FILE_NAME m = Mastodon(client_id=CLIENT_SECRET_FILE_NAME, access_token=access_token, api_base_url=api_base_url) if not access_token: m.log_in( username=config.get('username'), password=config.get('password'), to_file=USER_SECRET_FILE_NAME, ) return m
def get_access_token(): config = ConfigParser() config.readfp(io.open('token.ini', 'r', encoding='utf_8_sig')) section = 'Token' api_base_url = config.get(section, 'api_base_url') username = config.get(section, 'username') password = config.get(section, 'password') client_id = config.get(section, 'client_id') access_token = config.get(section, 'access_token') scopes = ['read', 'write'] Mastodon.create_app( 'TOMOYODon', scopes=scopes, api_base_url=api_base_url, to_file=client_id ) mastodon = Mastodon( client_id=client_id, api_base_url=api_base_url ) mastodon.log_in( username=username, password=password, scopes=scopes, to_file=access_token )
def ensure_app_config(url_file, client_file, user_file): if not os.path.isfile(url_file): print("No settings found.") base_url = input("Instance URL: ") user = input("E-Mail: ") password = getpass.getpass("Password: "******"w") as f: f.write(base_url) else: print("Whoops, that went wrong - try again.") sys.exit(0) except: print("Whoops, that went wrong - try again.") sys.exit(0)
def login(): response.headers['Access-Control-Allow-Origin'] = '*' response.content_type = "application/json" username = request.forms.get("username") # pylint: disable=no-member password = request.forms.get("password") # pylint: disable=no-member instance = request.forms.get("instance") # pylint: disable=no-member if debug: appname = "Nordcast (debug)" else: appname = "Nordcast" if not os.path.exists('clientcred.' + instance + '.secret'): Mastodon.create_app(appname, api_base_url='https://' + instance, to_file='clientcred.' + instance + '.secret') mastodon = Mastodon(client_id='clientcred.' + instance + '.secret', api_base_url='https://' + instance) mastodon.log_in( username, password, to_file='authtokens/' + username + '.' + instance + '.secret', ) if not os.path.exists("usercred.secret"): suid = str(uuid.uuid1()) if r.get("nordcast/uuids/" + username + "$$" + instance) == None: r.set("nordcast/uuids/" + username + "$$" + instance, suid) else: r.set( "nordcast/uuids/" + username + "$$" + instance, str(r.get("nordcast/uuids/" + username + "$$" + instance)).replace("b'", "").replace("'", "") + "," + suid) return json.dumps({"login": "******", "uuid": suid}) else: return "{\"login\": \"error\"}"
def createmastodonapp(appname, baseurl, email, password): Mastodon.create_app(appname, api_base_url=baseurl, to_file='pytooter_clientcred.secret') # Then login. This can be done every time, or use persisted. mastodon = Mastodon(client_id='pytooter_clientcred.secret', api_base_url=baseurl) mastodon.log_in(email, password, to_file='pytooter_usercred.secret')
def send_toot(ticket, config): logging.info("toot the release") target = '' if ticket.voctoweb_enable and ticket.profile_voctoweb_enable: target = config['voctoweb']['instance_name'] if ticket.youtube_enable and ticket.profile_youtube_enable: if len(target) > 1: target += ' and ' target += 'YouTube' msg = ' has been released on ' + target title = ticket.title if len(title) >= (500 - len(msg)): title = title[0:len(msg)] message = title + msg if ticket.voctoweb_enable and ticket.profile_voctoweb_enable: voctoweb_url = ' ' + config['voctoweb'][ 'frontend_url'] + '/v/' + ticket.slug if len(voctoweb_url) <= (500 - len(message)): message = message + voctoweb_url if ticket.youtube_enable and ticket.profile_youtube_enable and len( ticket.youtube_urls['YouTube.Url0']) <= (500 - len(message)): message = message + ' ' + ticket.youtube_urls['YouTube.Url0'] try: # check if we already have our client token and secret and if not get a new one if not Path('./mastodon_clientcred.secret').exists(): logging.debug( 'no mastodon client credentials found, get fresh ones') Mastodon.create_app( 'voctopublish', api_base_url=config['mastodon']['api_base_url'], to_file='mastodon_clientcred.secret') else: logging.debug('Using exisiting Mastodon client credentials') mastodon = Mastodon(client_id='mastodon_clientcred.secret', api_base_url=config['mastodon']['api_base_url']) # check if we already have an access token, if not get a fresh one if not Path('./mastodon_usercred.secret').exists(): logging.debug( 'no mastodon user credentials found, getting a fresh token') mastodon.log_in(config['mastodon']['email'], config['mastodon']['password'], to_file='mastodon_usercred.secret') else: logging.debug('Using existing Mastodon user token') # Create actual API instance mastodon = Mastodon(access_token='mastodon_usercred.secret', api_base_url=config['mastodon']['api_base_url']) mastodon.toot(message) except Exception as e_: # we don't care if tooting fails here. logging.error('Tooting failed: ' + str(e_))
def register_app(): """ Register the bot. :note: run only once """ Mastodon.create_app('asciimimebot', api_base_url='https://botsin.space', to_file='asciimime_clientcred.secret')
def register_app(world: World, api_base_url: str) -> int: world.fs.makedirs(graftbot.dirs.config_dir()) Mastodon.create_app( "graft", api_base_url=api_base_url, website="https://github.com/andybalaam/graft", to_file=graftbot.dirs.client_file(), ) return 0
def register(self): """ Register application and saves client secret. """ print("Registering app") Mastodon.create_app(self.name, api_base_url=self.url, scopes=self.scopes, to_file=self.client_secret)
def make_cred_secret(): Mastodon.create_app('good night', api_base_url=mstd_website, to_file='pytooter_clientcred.secret') mastodon = Mastodon(client_id='pytooter_clientcred.secret', api_base_url=mstd_website) mastodon.log_in(BOT_ACCOUNT, BOT_PASSWD, to_file='pytooter_usercred.secret')
def setup(): print("------------------") print(" MASTODON SETUP ") print("------------------\n") print("To connect to Mastodon I need some informations.") mastodonWorks = False while not mastodonWorks: print("\n") mastodonURL = "https://" + input("Your Mastodon instance URL: https://") mastodonEMail = input(" Your Mastodon e-mail: ") mastodonPassword = getpass.getpass(" Your Mastodon password: "******"\nOkay, let's try to connect to Mastodon!\n") try: Mastodon.create_app( 'MastoTwitter', scopes = ['read', 'write'], api_base_url = mastodonURL, to_file = 'mastodon_client.secret' ) except Exception as error: print("Cannot create a Mastodon app: " + error) sys.exit(1) try: api = Mastodon( client_id = 'mastodon_client.secret', api_base_url = mastodonURL ) api.log_in( username = mastodonEMail, password = mastodonPassword, to_file = 'mastodon_user.secret', scopes = ["read", "write"] ) except Exception as error: print("You made a mistake, theses informations didn't worked...\nLet's start again!") print(error) else: mastodonWorks = True print("Alright, that worked!") mastodonSecrets = open(mastodonSecretsLoc, "w") mastodonSecrets.write(mastodonURL) mastodonSecrets.close() print("Theses keys are now saved inside " + mastodonSecretsLoc + ", please keep it secret!")
def create_app(file_name, api_url): """ アプリケーションを登録する """ Mastodon.create_app( client_name="mastodon-wordcloud", scopes=["read", "write"], website="https://github.com/kelvin27315/mastodon-wordcloud", to_file=PATH + file_name, api_base_url=api_url)
def init_mastodon(): Mastodon.create_app(f'paramsinstaimporter-{str(uuid.uuid4())}', api_base_url='https://mitron.social', to_file='paramsinstaimporter.secret') global mastodon mastodon = Mastodon(client_id='paramsinstaimporter.secret', api_base_url='https://mitron.social') mastodon.log_in(username='******', password='******', to_file='paramsusercred.secret')
def _ensure_client_exists_for_instance(instance): "Create the client creds file if it does not exist, and return its path." client_id = "t2m_%s_clientcred.txt" % instance if not os.path.exists(client_id): Mastodon.create_app( 't2m', to_file=client_id, api_base_url='https://%s' % instance, ) return client_id
def create_app(): global MASTODON_HOST global BASE_URL global SECRET_NAME Mastodon.create_app( APP_NAME, api_base_url=BASE_URL, to_file=SECRET_NAME )
def on_internet_available(self, agent): config = agent.config() display = agent.view() last_session = agent.last_session api_base_url = self.options['instance_url'] email = self.options['email'] password = self.options['password'] visibility = self.options['visibility'] client_cred = '/root/.mastodon.client.secret' user_cred = '/root/.mastodon.user.secret' if last_session.is_new() and last_session.handshakes > 0: logging.info('[mastodon] Detected internet and new activity: time to post!') if not os.path.isfile(user_cred) or not os.path.isfile(client_cred): # Runs only if there are any missing credential files Mastodon.create_app( config['main']['name'], api_base_url=api_base_url, to_file=client_cred ) picture = '/root/pwnagotchi.png' display.on_manual_mode(last_session) display.image().save(picture, 'png') display.update(force=True) try: logging.info('[mastodon] Connecting to Mastodon API') mastodon = Mastodon( client_id=client_cred, api_base_url=api_base_url ) mastodon.log_in( email, password, to_file=user_cred ) mastodon = Mastodon( access_token=user_cred, api_base_url=api_base_url ) message = Voice(lang=config['main']['lang']).on_last_session_tweet(last_session) mastodon.status_post( message, media_ids=mastodon.media_post(picture), visibility=visibility ) last_session.save_session_id() logging.info('[mastodon] posted: %s', message) display.set('status', 'Posted!') display.update(force=True) except Exception as ex: logging.exception('[mastodon] error while posting: %s', ex)
def init_twitter_api(): global api if (os.path.isfile('clientcred.secret') == False): Mastodon.create_app('ace-attorney', api_base_url=keys['domain'], to_file='clientcred.secret') if (os.path.isfile('usercred.secret') == False): m = Mastodon(client_id='clientcred.secret', api_base_url=keys['domain']) m.log_in(keys['mail'], keys['password'], to_file='usercred.secret') api = Mastodon(access_token='usercred.secret', api_base_url=keys['domain'])
def submitToot(tweetText): if DEBUG_MODE == False: Mastodon.create_app('HNToots', to_file='HNToots_clientcred.txt') mastodon = Mastodon(client_id='HNToots_clientcred.txt') mastodon.log_in(MASTADON_USER, MASTADON_PASSWORD, to_file='HNToots_usercred.txt') mastodon = Mastodon(client_id='HNToots_clientcred.txt', access_token='HNToots_usercred.txt') mastodon.toot(tweetText) else: print(tweetText)
def login(): """Logs into Mastodon and creates local credentials files.""" password = getpass.getpass("Enter Mastodon password: "******"Created credential files: {}, {}".format(CLIENT_SECRET_FILE, MASTODON_SECRET_FILE))
def create(filename): global url global user global password global secret with open(filename, "r") as f: r = f.readlines() secret = r[0].replace("\n", "") + ".secret" url = "https://" + r[0].replace("\n", "") user = r[1].replace("\n", "") password = r[2].replace("\n", "") if os.path.exists(secret) == False: Mastodon.create_app('pleromabot', api_base_url=url, to_file=secret)
def createCreds(pool): instance = pool.mastInstance user = pool.mastUser password = pool.mastPassword secPath = pool.mastSecPath appName = pool.mastAppName clientCredFile = os.path.join(secPath, "ghi_clientcred.secret") userCredFile = os.path.join(secPath, "ghi_usercred.secret") Mastodon.create_app(appName, api_base_url=instance, to_file=clientCredFile) mastodon = Mastodon(client_id=clientCredFile, api_base_url=instance) mastodon.log_in(user, password, to_file=userCredFile)
def register(args, clientcred_file, usercred_file): Mastodon.create_app(BOT_NAME, to_file=clientcred_file, api_base_url=BASE_URL) mastodon = Mastodon(client_id=clientcred_file, api_base_url=BASE_URL) (login, password) = args.register try: mastodon.log_in(login, password, to_file=usercred_file) except Exception as login_err: print('Unable to login new bot: {0}'.format(login_err)) print('Bot is registered successfully')
def register(self): import webbrowser self.check_params('handle') api_base_url = self.params['handle'].split('@')[-1] # get client data client_id = self.context.params.get(service_name, 'client_id') client_secret = self.context.params.get(service_name, 'client_secret') if (not client_id) or (not client_secret): client_id, client_secret = Mastodon.create_app( 'pywws', scopes=['write'], api_base_url=api_base_url) self.context.params.set(service_name, 'client_id', client_id) self.context.params.set(service_name, 'client_secret', client_secret) # create api api = Mastodon(client_id=client_id, client_secret=client_secret, api_base_url=api_base_url) # authorise auth_request_url = api.auth_request_url(scopes=['write']) if not webbrowser.open(auth_request_url, new=2, autoraise=0): print('Please use a web browser to open the following URL') print(auth_request_url) if sys.version_info[0] >= 3: input_ = input else: input_ = raw_input code = input_('Please enter the auth code shown in your web browser: ') code = code.strip() # log in access_token = api.log_in(code=code, scopes=['write']) self.context.params.set(service_name, 'access_token', access_token)
def auth(self, request): """ get the auth of the services :param request: contains the current session :type request: dict :rtype: dict """ # create app redirect_uris = '%s://%s%s' % (request.scheme, request.get_host(), reverse('mastodon_callback')) us = UserService.objects.get(user=request.user, name='ServiceMastodon') client_id, client_secret = MastodonAPI.create_app( client_name="TriggerHappy", api_base_url=us.host, redirect_uris=redirect_uris) us.client_id = client_id us.client_secret = client_secret us.save() us = UserService.objects.get(user=request.user, name='ServiceMastodon') # get the token by logging in mastodon = MastodonAPI( client_id=client_id, client_secret=client_secret, api_base_url=us.host ) token = mastodon.log_in(username=us.username, password=us.password) us.token = token us.save() return self.callback_url(request)
def init(config): API_BASE_URL = config['Mastodon']['API_BASE_URL'] if not os.path.exists('clientcred.secret'): Mastodon.create_app( config['Mastodon']['APP_NAME'], api_base_url = API_BASE_URL, to_file = 'clientcred.secret' ) mastodon = Mastodon( client_id = 'clientcred.secret', api_base_url = API_BASE_URL ) mastodon.log_in( config['Mastodon']['EMAIL'], config['Mastodon']['PASS_WORD'], to_file = 'usercred.secret' ) return mastodon
def check(self, request, user): """ check if the service is well configured :return: Boolean """ redirect_uris = '%s://%s%s' % (request.scheme, request.get_host(), reverse('mastodon_callback')) us = UserService.objects.get(user=user, name='ServiceMastodon') client_id, client_secret = MastodonAPI.create_app( client_name="TriggerHappy", api_base_url=us.host, redirect_uris=redirect_uris) # get the token by logging in mastodon = MastodonAPI( client_id=client_id, client_secret=client_secret, api_base_url=us.host ) try: mastodon.log_in(username=us.username, password=us.password) return True except MastodonIllegalArgumentError as e: return e
def send_toot(ticket, config): logging.info("toot the release") target = '' if ticket.voctoweb_enable and ticket.profile_voctoweb_enable: target = config['voctoweb']['instance_name'] if ticket.youtube_enable and ticket.profile_youtube_enable: if len(target) > 1: target += ' and ' target += 'YouTube' msg = ' has been released on ' + target title = ticket.title if len(title) >= (500 - len(msg)): title = title[0:len(msg)] message = title + msg if ticket.voctoweb_enable and ticket.profile_voctoweb_enable: voctoweb_url = ' ' + config['voctoweb']['frontend_url'] + '/v/' + ticket.slug if len(voctoweb_url) <= (500 - len(message)): message = message + voctoweb_url if ticket.youtube_enable and ticket.profile_youtube_enable and len(ticket.youtube_urls['YouTube.Url0']) <= (500 - len(message)): message = message + ' ' + ticket.youtube_urls['YouTube.Url0'] try: # check if we already have our client token and secret and if not get a new one if not Path('./mastodon_clientcred.secret').exists(): logging.debug('no mastodon client credentials found, get fresh ones') Mastodon.create_app( 'voctopublish', api_base_url=config['mastodon']['api_base_url'], to_file='mastodon_clientcred.secret' ) else: logging.debug('Using exisiting Mastodon client credentials') mastodon = Mastodon( client_id='mastodon_clientcred.secret', api_base_url=config['mastodon']['api_base_url'] ) # check if we already have an access token, if not get a fresh one if not Path('./mastodon_usercred.secret').exists(): logging.debug('no mastodon user credentials found, getting a fresh token') mastodon.log_in( config['mastodon']['email'], config['mastodon']['password'], to_file='mastodon_usercred.secret' ) else: logging.debug('Using existing Mastodon user token') # Create actual API instance mastodon = Mastodon( access_token='mastodon_usercred.secret', api_base_url=config['mastodon']['api_base_url'] ) mastodon.toot(message) except Exception as e_: # we don't care if tooting fails here. logging.error('Tooting failed: ' + str(e_))
return True if __name__ == '__main__': from mastodon import Mastodon try: base_url, email, password, clientname, clientcred, usercred = sys.argv[1:] except: print("Usage: %s base_url email password clientname clientcredsfile usercredsfile" % sys.argv[0]) sys.exit(2) if not os.path.isfile(clientcred): Mastodon.create_app( clientname, to_file = clientcred, scopes = [ 'read', 'write' ], api_base_url = base_url) if not os.path.isfile(usercred): mastodon_api = Mastodon( client_id = clientcred, api_base_url = base_url) mastodon_api.log_in( email, password, to_file = usercred, scopes = [ 'read', 'write' ], )