def __init__(self):

		# default initalization
		TwitterBot.__init__(self)

		# load image urls from a file
		self.load_image_urls("images.txt")
Beispiel #2
0
    def on_follow(self, follower_id):

        TwitterBot.on_follow(self, follower_id)

        try:
            self.store.save_friend((follower_id,))
        except pg.IntegrityError:
            # aborting is harmless, most likely an unfollow/refollow
            self.log("tried to add duplicate twitter friend %s" % follower_id)
Beispiel #3
0
def main():
    from argparse import ArgumentParser
    arg_parser = ArgumentParser()
    arg_parser.add_argument('--test', help='Test mode, don''t tweet', action='store_true', default=False)
    args = arg_parser.parse_args()

    import settings
    from twitterbot import TwitterBot
    bot = TwitterBot(settings, args)
    bot.run()
Beispiel #4
0
class TestTwitterBot(unittest.TestCase):
    def setUp(self):
        self.bot = TwitterBot(config_file='tests/config_test.json')

    def test_oath_config(self):
        self.assertEqual(self.bot.oauth_config,
                         ("REPLACE ME", "REPLACE ME", "REPLACE ME", "REPLACE ME"))

    @mock.patch('util.generate_text', return_value='hello')
    @mock.patch('twython.Twython.update_status')
    def test_update_status(self, update_status_mock, generate_text_mock):
        self.bot.post_update()
        generate_text_mock.assert_called_with(limit_characters=140)
        update_status_mock.assert_called_with(status='hello')
Beispiel #5
0
def main():
    requestJson = request.get_json()
    #print(json.dumps(requestJson, indent=4, sort_keys=True))
    if 'tweet_create_events' in requestJson.keys():
        mentioned_name = requestJson['tweet_create_events'][0]['entities'][0][
            "user_mentions"].get("screen_name")
        if mentioned_name == "Arkham_bot":
            replying_to = requestJson['tweet_create_events'][0]['user'][
                'screen_name']
            tweet_id = requestJson['tweet_create_events'][0]['id_str']
            TwitterBot.reply(replying_to, tweet_id)

    #elif 'follow_events' in requestJson.keys():
    #TwitterBot.follow_back()
    return ('OK')
Beispiel #6
0
def main():
    try:
        now = time()
        # Construct auth and twitterbot object
        auth = OAuth(config['access_token'], config['access_secret'], config['consumer_key'], config['consumer_secret'])
        twitterBot = TwitterBot(auth)

        # create brainyquote object and load quotes
        quote = BrainyQuote()
        quote.load()

        iter = 0
        while True:
            # Safeguard, just stop running after 1000 iterations
            if iter >= 1000:
                break

            random_quote = quote.randomize()

            if not quote.exists(random_quote):
                text, auth = random_quote
                auth = twitterify(auth)
                
                if len(auth) + len(text) > 140:
                    text = text[0:140 - len(auth)]

                tweet = '%s %s' % (text, auth)

                if twitterBot.tweet(tweet):
                    quote.save(random_quote)
                    break
            iter = iter + 1

    except Exception as err:
        Logger("Unhandled exception!: %s" % err)
    except QuoteException as qerr:
        Logger("Quote exception in program: %s" % qerr)
    finally:
        message = 'Finished running TwitterBot, date: {0}, running time: {1} secs'.format(str(datetime.now()), time() - now)
        Logger(message)
Beispiel #7
0
def repost_replies(account_name):
    bf = open('.blacklist_%s'%account_name,'a+')
    blacklist = bf.read().splitlines()
    bf.close()

    rp = open('.reposted_%s'%account_name,'a+')
    reposted = rp.read().splitlines()

    account = settings.ACCOUNTS.get(account_name)

    try:
        logging.info('[%s] Getting last mentions offset'%account_name)
        bot = TwitterBot(settings.CONSUMER_KEY,settings.CONSUMER_SECRET,
                         account['key'],account['secret'])
        mentions = []
        try:
            mentions = bot.api.mentions()
            logging.info('[%s] Got %d mentions'%(account_name,len(mentions)))
        except Exception,e:
            logging.error('[%s] Failed to get mentions. %s'%(account_name,e))

        for mess in reversed(mentions):
            try:
                author = mess.author.screen_name
                if str(author) in blacklist:
                    logging.debug('[%s] Author %s blacklisted. Skipping.'%(account_name,str(author)))
                    continue
                if str(mess.id) in reposted:
                    logging.debug('[%s] Message #%s already reposted. Skipping.'%(account_name,str(mess.id)))
                    continue

                message = mess.text.split(' ')
                if message[0] != '@%s'%account_name:
                    continue #not a "@reply"

                trigger = message[1]
                triggers = dict(account['triggers'])
                if trigger not in triggers:
                    logging.warning('[%s] Bad message format, sending DM to author'%account_name)
                    bot.dm(author,account['not_triggered'])
                else:
                    len_params = {'message':'','user':author}
                    mess_len = len(triggers[trigger]%len_params)
                    params = {'message':bot.trim_message(' '.join(message[2:]),mess_len),'user':author}
                    message = triggers[trigger]%params
                    logging.info('[%s] Tweeting message %s'%(account_name,message))
                    bot.tweet(message)
                rp.write('%s\n'%mess.id)
            except Exception,e:
                logging.error('%s'%e)
                continue
Beispiel #8
0
def update_network(accounts, depth):
    for account_id in accounts.keys():
        print '\tupdating user:'******'\t\tupdating', acc_type, 'account:', acc_username

            if acc_username == '': continue

            elif acc_type == TWITTER:
                crawler = TwitterBot.factory(acc_username, depth=depth)
                personUris.append(crawler.getUserUri(acc_username))

        # create crawlers using user network accounts data
        crawler.crawlUserNetwork(start_time=sdate)

        # link resources to each other
        Resource.unify_all(personUris)
def main():
    feed = feedparser.parse(
        'https://fedoramagazine.org/feed/')  # read the feed
    try:
        links = pickle.load(open('tweeted_links', 'rb'))  # load posted links
    except FileNotFoundError:
        links = set()  # no link is posted yet

    try:
        bot = TwitterBot(USERNAME, PASSWORD)
        for entry in feed.entries[::-1]:
            link = entry.link
            title = entry.title
            print(title, link)
            if link not in links:
                bot.tweet(title + '\n' + link)
                links.add(link)
        bot.quit()  # quits and clears the chromedriver from memory
    finally:
        pickle.dump(links, open('tweeted_links',
                                'wb'))  # add the posted links to the file
Beispiel #10
0
# Import the TwitterBot class
from twitterbot import TwitterBot

# create a new bot
bot = TwitterBot("my_username", "my_secret_password")

# tweet
bot.tweet("Hello world from python and selenium")

# quit the bot and close the chrome window
bot.quit()
Beispiel #11
0

def generate_word(clean_data):
    with open(clean_data_file, 'r') as f:
        for line in f:
            for word in line.split():
                yield word


if __name__ == '__main__':
    logging.info("Initializing bot_data file.")
    with open(bot_data_file, 'w') as file:
        json.dump({"last_id_seen": None, "last_reply_id_seen": None}, file)

    markov = Markov()
    twitterbot = TwitterBot()

    logging.info("Connecting to the database.")
    markov._connect_db()
    markov.cur.execute(
        """
        SELECT EXISTS(SELECT 1 FROM information_schema.tables \
        WHERE table_catalog=%(db_name)s \
        AND table_schema='public' \
        AND table_name='transition');
        """, {'db_name': config.DATABASE_NAME})
    table_exists = markov.cur.fetchone()[0]

    if not table_exists:
        logging.info("Transition table does not exist.  Creating it now...")
        markov.cur.execute("""
Beispiel #12
0
    # Get the filename of the response file from the config file.
    responsefile = config.get(botname, 'responsefile')

    # Determine which of the microblog classes to instantiate.
    microblog_type = config.get(botname, 'type')
    if microblog_type == 'twitter':
        # Load the Twitter API keys from the config file.
        api_key = config.get(botname, 'api_key')
        api_secret = config.get(botname, 'api_secret')
        access_token = config.get(botname, 'access_token')
        access_token_secret = config.get(botname, 'access_token_secret')

        # Instantiate a Twitter bot.
        bot = TwitterBot(owner, botname, username, password, muc, muclogin,
            imalive, responsefile, function, api_key, api_secret, access_token,
            access_token_secret)
    else:
        print "No other kinds of microblog bots are defined yet."
        sys.exit(0)

    # Connect to the XMPP server and start processing messages.
    if bot.connect():
        bot.process(block=False)
    else:
        print "ERROR: Unable to connect to XMPP server."
        sys.exit(1)

# Fin.

Beispiel #13
0
                    continue #not a "@reply"

                trigger = message[1]
                triggers = dict(account['triggers'])
                if trigger not in triggers:
                    logging.warning('[%s] Bad message format, sending DM to author'%account_name)
                    bot.dm(author,account['not_triggered'])
                else:
                    len_params = {'message':'','user':author}
                    mess_len = len(triggers[trigger]%len_params)
                    params = {'message':bot.trim_message(' '.join(message[2:]),mess_len),'user':author}
                    message = triggers[trigger]%params
                    logging.info('[%s] Tweeting message %s'%(account_name,message))
                    bot.tweet(message)
                rp.write('%s\n'%mess.id)
            except Exception,e:
                logging.error('%s'%e)
                continue
    except Exception,e:
        logging.error('%s'%e)
    finally:
        rp.close()

if options.authorize:
    bot = TwitterBot(settings.CONSUMER_KEY,settings.CONSUMER_SECRET)
    bot.get_tokens()
    sys.exit('Bye ;)')

if options.repost:
    for account in options.repost.split(' '):
        repost_replies(account.strip())
from apscheduler.scheduler import Scheduler
from twitterbot import TwitterBot
import time
from app_config import AppConfig

sched = Scheduler()
config = AppConfig()
bot = TwitterBot(config)
bot.send_tweet()


@sched.interval_schedule(minutes=120)
def timed_job():
    bot.send_tweet()


sched.start()

while True:
    time.sleep(1)
Beispiel #15
0
    logging.basicConfig(level=loglevel, format='%(levelname)-8s %(message)s')

    # Get the filename of the response file from the config file.
    responsefile = config.get(botname, 'responsefile')

    # Determine which of the microblog classes to instantiate.
    microblog_type = config.get(botname, 'type')
    if microblog_type == 'twitter':
        # Load the Twitter API keys from the config file.
        api_key = config.get(botname, 'api_key')
        api_secret = config.get(botname, 'api_secret')
        access_token = config.get(botname, 'access_token')
        access_token_secret = config.get(botname, 'access_token_secret')

        # Instantiate a Twitter bot.
        bot = TwitterBot(owner, botname, username, password, muc, muclogin,
                         imalive, responsefile, function, api_key, api_secret,
                         access_token, access_token_secret)
    else:
        print "No other kinds of microblog bots are defined yet."
        sys.exit(0)

    # Connect to the XMPP server and start processing messages.
    if bot.connect():
        bot.process(block=False)
    else:
        print "ERROR: Unable to connect to XMPP server."
        sys.exit(1)

# Fin.
Beispiel #16
0
fetchers = []
for i in xrange(feeds_count):
    # TODO: abstract fetcher_args object
    fetchers.append(FeedFetcher(
        feed_url=feeds[i],
        data_dir=data_dir,
        cache_dir=cache_dir,
        cache_feed=cache_feed,
        verbose=args.verbose,
        no_cache=args.no_cache))
if args.verbose > 2:
    print(fetchers)

if args.twitter:
    # TODO: pass in all args
    twitter_bot = TwitterBot(args.config_file, args.verbose)
    tweeted_file = open(cp.get('General', 'tweeted'), 'r+')
    tweeted = set(tweeted_file.read().split('\n'))
    if args.verbose > 2:
        print(tweeted)

if args.database:
    # TODO: abstract db_args object
    host = cp.get('General', 'db_host')
    user = cp.get('General', 'db_user')
    cred = cp.get('General', 'db_cred')
    db = cp.get('General', 'db_name')
    db_saver = DBSaver(host, user, cred, db, args=args)

try:
    while True:
Beispiel #17
0
import tweepy
import time
from accesskeys import *
from twitterbot import TwitterBot


# Twitter restricts number of bot activites by 1000 per day as of now.
number_of_iterations = 50

# Your query to search and like the tweets.
search_query = 'medical%20students'

# The SECRECT_KEY, SECRET_TOKEN, ACCESS_KEY, ACESS_TOKEN
# can be accessed from https://developer.twitter.com/en/apps

bot = TwitterBot(number_of_iterations, SECRECT_KEY,
                 SECRET_TOKEN, ACCESS_KEY, ACESS_TOKEN)

# Followback all your followers if you are not already following them
bot.follow_followers()

# Like 100 tweets from the provided query
bot.like_tweets(search_query)

bot.follow_from_tweets(search_query)
Beispiel #18
0
parser = argparse.ArgumentParser(description='Respond to Twitter mentions.',
                                 epilog='example: main.py -l "happy birthday" \
                                         "hbd" -r "thanks HANDLE!"')
parser.add_argument('-l',
                    '--listen',
                    nargs='+',
                    default=['happy birthday'],
                    help='phrase(s) to reply to (separate by space)')
parser.add_argument('-r',
                    '--reply',
                    default='HANDLE thanks!',
                    help='reply text (use HANDLE for user handle)')

# instantiate TwitterBot outside of main since it's required for reply
args = parser.parse_args()
bot = TwitterBot(keys, args.listen, args.reply.replace('HANDLE', '@{}'))


def reply(bot=bot):
    print(' Running...')
    bot.reply_to_mention()
    print(' Finished running at {}'.format(datetime.datetime.now()))


def main():
    print('Starting bot...')
    # start loop, run once every 2 minutes
    scheduler = BlockingScheduler()
    scheduler.add_job(reply, 'interval', minutes=2)
    scheduler.start()
Beispiel #19
0
 def setUp(self):
     self.bot = TwitterBot(config_file='tests/config_test.json')
Beispiel #20
0
fetchers = []
for i in xrange(feeds_count):
    # TODO: abstract fetcher_args object
    fetchers.append(
        FeedFetcher(feed_url=feeds[i],
                    data_dir=data_dir,
                    cache_dir=cache_dir,
                    cache_feed=cache_feed,
                    verbose=args.verbose,
                    no_cache=args.no_cache))
if args.verbose > 2:
    print(fetchers)

if args.twitter:
    # TODO: pass in all args
    twitter_bot = TwitterBot(args.config_file, args.verbose)
    tweeted_file = open(cp.get('General', 'tweeted'), 'r+')
    tweeted = set(tweeted_file.read().split('\n'))
    if args.verbose > 2:
        print(tweeted)

if args.database:
    # TODO: abstract db_args object
    host = cp.get('General', 'db_host')
    user = cp.get('General', 'db_user')
    cred = cp.get('General', 'db_cred')
    db = cp.get('General', 'db_name')
    db_saver = DBSaver(host, user, cred, db, args=args)

try:
    while True:
Beispiel #21
0
import json
from twitterbot import TwitterBot

with open('app/config/secret.json') as arq:
    credentials = json.load(arq)
    login = credentials['login']
    password = credentials['password']

bot = TwitterBot(login, password)

bot.reuitar('o jogo')