def check_user_info(self):
     """
     Searches for twitter user profile and saves the data
     :return:
     """
     #connect to the api
     api = Tapi.TwitterAPI(cons_key, cons_secret, token, token_secret)
     #get request
     out = api.request('users/lookup', {'Name': '{}'.format(self.username), 'screen_name': '{}'.format(self.username)})
     if out is not None:
         for i in out:
             info = i
         following = info['friends_count']
         followers = info['followers_count']
         join_date = info['created_at']
         location = info['location']
         description = info['description']
         user_id = info['id_str']
         #create user
         self.user = TwitterUser(username=info['screen_name'], location=location, description=description,
                                 date_joined=join_date, following=following, followers=followers,id=user_id)
         # save this user
         TwitterUserDA().save_user(self.user)
     else:
         self.user = TwitterUser(username=self.username, location="", description="*manually created*",
                                 date_joined="Joined June 2009", following='', followers='')
Exemplo n.º 2
0
def lambda_handler(event, context):
    with open("credentials.json", "r") as creds_file:
        creds = json.load(creds_file)
        oauth_consumer_key = creds["oauth_consumer_key"]
        oauth_consumer_secret = creds["oauth_consumer_secret"]
        oauth_token = creds["oauth_token"]
        oauth_token_secret = creds["oauth_token_secret"]

        api = TwitterAPI(consumer_key=oauth_consumer_key,
                         consumer_secret=oauth_consumer_secret,
                         access_token_key=oauth_token,
                         access_token_secret=oauth_token_secret)

        username = event.get('payload')
        msg = "Remember to LOCK the door!"

        event = {
            "event": {
                "type": "message_create",
                "message_create": {
                    "target": {
                        "recipient_id": username
                    },
                    "message_data": {
                        "text": msg
                    }
                }
            }
        }

    send_msg = api.request('direct_messages/events/new', json.dumps(event))

    print('SUCCESS' if send_msg.status_code == 200 else 'PROBLEM: ' +
          send_msg.text)
Exemplo n.º 3
0
def send_tweet(message_to_tweet: str, url_to_media: str) -> int:
    """
    Send a tweet with an image.
    :param message_to_tweet: Message to send
    :param url_to_media: Image to upload
    :return: Tweet ID (-1 if it failed)
    :raises Exception: Tweet failed to send for some reason
    """
    twitter_api = TwitterAPI.TwitterAPI(
        config.get('twitter', 'CONSUMER_KEY'),
        config.get('twitter', 'CONSUMER_SECRET'),
        config.get('twitter', 'ACCESS_TOKEN_KEY'),
        config.get('twitter', 'ACCESS_TOKEN_SECRET'),
    )

    logging.info('Tweet to send: {}'.format(message_to_tweet))
    try:
        if url_to_media is not None:
            resize_image(url_to_media)
            photo = open(url_to_media, 'rb')
            status = twitter_api.request('statuses/update_with_media',
                                         {'status': message_to_tweet},
                                         {'media[]': photo})
            logging.info('Twitter Status Code: {}'.format(status.status_code))

            response = TwitterAPI.TwitterResponse(status, False).json()
            logging.info('Twitter Response Parsed: {}'.format(response))
            return int(response['id_str'])
        raise Exception("No image attached to tweet")
    except UnicodeDecodeError:
        logging.exception(
            'Your message could not be encoded. Perhaps it contains non-ASCII characters?'
        )
        raise Exception("Tweet failed to send")
def main():
    app_settings = settings.get_app_settings()
    api = TwitterAPI.TwitterAPI(**app_settings)

    store_data = store.get_data()

    search_term = 'vnnlp'
    query = {'screen_name': search_term}

    filename = 'user_timeline/{}.yaml'.format(search_term)

    utils.ensure_dir(filename)

    if 'user_timeline' in store_data and 'max_id' in store_data[
            'user_timeline']:
        query['max_id'] = store_data['user_timeline']['max_id'] - 1

    max_id = None
    try:
        with open(filename, 'a') as output_file:
            r = TwitterAPI.TwitterPager(api, 'statuses/user_timeline', query)

            for tweet in r.get_iterator():
                yaml.dump([tweet], output_file, default_flow_style=False)
                if 'id' in tweet:
                    max_id = tweet['id']

    except KeyboardInterrupt:
        pass

    if not 'user_timeline' in store_data:
        store_data['user_timeline'] = {}

    store_data['user_timeline']['max_id'] = max_id
    store.store_data(store_data)
Exemplo n.º 5
0
def main():
    app_settings = settings.get_app_settings()
    api = TwitterAPI.TwitterAPI(**app_settings)

    search_term = 'dongng'
    query = {'screen_name': search_term}

    twitter.fetch_one(api, 'followers/list', search_term, query)
Exemplo n.º 6
0
    def setUp(self):
        """Read credentials from TwitterAPI/credentials.txt. You
		must copy your credentials into this text file.
		"""
        oa = TwitterAPI.TwitterOAuth.read_file()
        self.api = TwitterAPI.TwitterAPI(oa.consumer_key, oa.consumer_secret,
                                         oa.access_token_key,
                                         oa.access_token_secret)
Exemplo n.º 7
0
def main():
    app_settings = settings.get_app_settings()
    api = TwitterAPI.TwitterAPI(**app_settings)

    search_term = 'dongng'
    query = {'q': search_term}

    twitter.fetch(api, 'search/tweets', search_term, query)
Exemplo n.º 8
0
    def __init__(self, tweet_count=200, twitter_account='stackdevjobs'):

        self.tweet_count = tweet_count
        self.twitter_account = twitter_account

        self.api = TwitterAPI.TwitterAPI(self.consumer_key,
                                         self.consumer_secret,
                                         auth_type='oAuth2')
Exemplo n.º 9
0
def tweetImage(message, image_file):
    api = ta.TwitterAPI(consumer_key, consumer_secret, access_token_key,
                        access_token_secret)
    file = open(image_file, 'rb')
    data = file.read()
    r = api.request('statuses/update_with_media', {'status': message},
                    {'media[]': data})
    return 'SUCCESS' if r.status_code == 200 else 'FAILURE'
Exemplo n.º 10
0
def main():
    api = TwitterAPI.TwitterAPI(**settings.get_app_settings())

    # twitter.fetch(api, 'search/tweets', 'input', {'q': 'coccoc', 'lang': 'vi'})
    # twitter.fetch(api, 'search/tweets', 'input', {'q': '#coccoc', 'lang': 'vi'})
    # twitter.fetch(api, 'search/tweets', 'input', {'q': 'cntt', 'lang': 'vi'})
    # twitter.fetch(api, 'search/tweets', 'input', {'q': 'ifan', 'lang': 'vi'})
    # twitter.fetch(api, 'search/tweets', 'input', {'q': 'yêu', 'lang': 'vi'})
    twitter.fetch(api, 'search/tweets', 'input', {'q': 'ghét', 'lang': 'vi'})
Exemplo n.º 11
0
def get_results() -> Tuple[List[Dict[str, str]], List[Dict[str, str]]]:
    """
    Get the results from the competition and print it out
    :return: Winner's name and their query
    """
    twitter_api = TwitterAPI.TwitterAPI(
        config.get('twitter', 'CONSUMER_KEY'),
        config.get('twitter', 'CONSUMER_SECRET'),
        config.get('twitter', 'ACCESS_TOKEN_KEY'),
        config.get('twitter', 'ACCESS_TOKEN_SECRET'),
    )

    valid_normal_entries: List[Dict[str, Any]] = []
    valid_regex_entries: List[Dict[str, Any]] = []

    logging.info('GET RESULTS')

    json_db: Dict[str, Any] = load_json_db(
        config.get('scryfallCardGolf', 'TWEET_DATABASE'))
    max_key: str = max(json_db.keys())

    r = TwitterAPI.TwitterPager(twitter_api, 'statuses/mentions_timeline', {
        'count': 200,
        'since_id': json_db[max_key]['tweet_id']
    })

    for item in r.get_iterator():
        if 'text' not in item:
            logging.warning('SUSPEND, RATE LIMIT EXCEEDED: ' + item['message'])
            break

        logging.info('[TWEET] ' + item['user']['screen_name'] + ': ' +
                     item['text'])
        for url in item['entities']['urls']:
            test_url = url['expanded_url']
            if 'scryfall.com' not in test_url:
                continue

            logging.info('{} submitted solution: {}'.format(
                item['user']['screen_name'], test_url))
            test_query_results = test_query(item['user']['screen_name'],
                                            test_url)
            if test_query_results:
                user_json_entry: Dict[str, Any] = {
                    'name': item['user']['screen_name'],
                    'length': len(test_query_results),
                    'query': test_query_results
                }

                if re.search(r'/.+/', test_query_results):
                    valid_regex_entries.append(user_json_entry)
                else:
                    valid_normal_entries.append(user_json_entry)

    return valid_normal_entries, valid_regex_entries
Exemplo n.º 12
0
def connect_to_streaming_API():
    ''' Connect to twitter streaming API
        Returns an iterator with all the stream data. '''

    api = TwitterAPI.TwitterAPI(
        'f8olfZWtAPvgANdP9qecg', 'bSEnCXJuWazjT8S8hZ6BLWMo1C7egIKNgjObHM6Ck',
        '1726636778-jEn4qUAj2wV60ckbskNSbLJgTRr0c7hiemVOU7x',
        'UgwEfM3cukoWIxCWjCiIZiJ0gnQVGH9U42WLfJjnEFODw')

    r = api.request('statuses/filter', {'track': '#rip'})

    return r.get_iterator()
Exemplo n.º 13
0
    def getTweetCount(q, p=False, debug=False):
        auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
        auth.set_access_token(access_token, access_token_secret)

        api = TwitterAPI.TwitterAPI(consumer_key, consumer_secret,
                                    access_token, access_token_secret)

        #today's info
        a = time.time()
        timeStamp = datetime.datetime.utcnow().date()
        tDay = timeStamp.day
        tMonth = timeStamp.strftime("%b")

        api = TwitterAPI.TwitterAPI(consumer_key, consumer_secret,
                                    access_token, access_token_secret)
        count = 0
        r = TwitterPager(api, 'search/tweets', {'q': q, 'count': 100})
        for item in r.get_iterator(wait=6):
            time_stamp = item['created_at']
            day = int(time_stamp[8:10])
            if (tDay != day and tDay - 1 != day):
                break
            if 'message' in item and item['code'] == 88:
                print('SUSPEND, RATE LIMIT EXCEEDED: %s' % item['message'])
                break
            if (tDay - 1 == day):
                count += 1
                if (p):
                    print("Term: " + q + " on " + item["created_at"])

        if (debug):
            b = time.time()
            c = int(b - a)
            print("\nThis took " + str(round(c / 60, 2)) + " minutes")

        return count


#res = tweet.getTweetCount("qwertyuiop", False,True)
#print(res)
 def __init__(self):
     self.name = 'TwitterApi'
     self.keys_dict = json.loads(open(twitter_key_path, 'r').read())
     self.twitter_api = twitter.TwitterAPI(
         consumer_key=self.keys_dict['consumer_key'],
         consumer_secret=self.keys_dict['consumer_secret'],
         access_token_key=self.keys_dict['access_token_key'],
         access_token_secret=self.keys_dict['access_token_secret'])
     self.querying_types = [
         # TwitterApi.ResultType.popular,
         # TwitterApi.ResultType.recent,
         TwitterApi.ResultType.mixed
     ]
Exemplo n.º 15
0
 def __init__(self, twitter_creds, host, port):
     self.api = TwitterAPI(twitter_creds["consumer_key"],
                           twitter_creds["consumer_secret"],
                           twitter_creds["access_token_key"],
                           twitter_creds["access_token_secret"])
     self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     self.s.bind((host, port))
     print host, port
     self.s.listen(5)
     while True:
         try:
             c, addr = self.s.accept()
             self.c = c
             self.stream()
         except Exception as e:
             print e
Exemplo n.º 16
0
    def __init__(
        self,
        logger,
        consumer_key,
        consumer_secret,
        oauth_token,
        oauth_secret
    ):
        # initialize superclass
        Stream.__init__(self, logger)

        self.basetime = datetime.now()
        self.limit = 140

        self.api = TwitterAPI.TwitterAPI(
            consumer_key,
            consumer_secret,
            oauth_token,
            oauth_secret
        )
Exemplo n.º 17
0
def sendtotwitter(list2):
    filename = "/Users/kylebauder/Documents/Anki/User 1/collection.media/" + str(
        list2[1])

    # ALL YOUR SECRET STUFF!
    # Consumer Key (API Key)
    cons_key = 'Y7dzXbP9Jx7HPnLyscaAcuzHD'
    # Consumer Secret (API Secret)
    cons_secret = 'OE9tDUnQLzJGZ6LcwliVt5OJ3M3u8Xdx21ETSJMQtaRT0qe9qA'
    # Access Token
    access_token = '953403732384886784-A4eYTNV8nfb8meOEoN0zbQvvchi0Agr'
    # Access Token Secret
    access_token_secret = 'jfm2s1wkORCc1HgGyCV28c7pRnMuGAzU4TvLgz0QOpTDR'

    api = TwitterAPI.TwitterAPI(cons_key, cons_secret, access_token,
                                access_token_secret)
    file = open(filename, 'rb')
    data = file.read()
    hashtag = randomizer()
    stringtoadd = list2[0] + " >>> " + list2[2] + hashtag
    r = api.request('statuses/update_with_media', {'status': stringtoadd},
                    {'media[]': data})
Exemplo n.º 18
0
def analyze(username):
    # collect data
    api = TwitterAPI.TwitterAPI()
    print 'Getting user information...'
    user = api.get_user(username)
    print 'Getting frineds information...'
    friends = api.get_friends(username)
    print 'Getting tweets...'
    tweets = api.get_statuses(username)
    print 'All data collected!'
    if not (user and friends and tweets):
        print 'Incomplete Data. No analysis performed.'
        return None

    res = {'analysis': {}, 'data': {}, 'user': copy.deepcopy(user)}
    # datetime is converted to ISO string to be serializable
    res['user']['created_at'] = res['user']['created_at'].isoformat()
    total = []

    # user analysis
    print '\nPerforming user analysis...'
    res['analysis']['user'] = {}
    print 'Analyzing profile...'
    profileAnalyzer = UserAnalysis.ProfileAnalysis()
    res['analysis']['user']['profile'] = profileAnalyzer.analyze(user)
    total.append(res['analysis']['user']['profile'])
    print 'Analyzing friends...'
    friendsAnalyzer = UserAnalysis.FriendsAnalysis()
    res['analysis']['user']['friends'] = friendsAnalyzer.analyze(friends)
    total.append(res['analysis']['user']['friends'])

    # status analysis
    print '\nPerforming status analysis...'
    res['analysis']['status'] = {}
    print 'Analyzing frequency...'
    timeSeriesAnalyer = StatusAnalysis.TimeSeriesAnalysis()
    res['analysis']['status']['frequency'] = timeSeriesAnalyer.analyze(tweets)
    total.append(res['analysis']['status']['frequency'])
    print 'Analyzing sentiment...'
    sentimentAnalyzer = StatusAnalysis.SentimentAnalysis()
    res['analysis']['status']['sentiment'] = sentimentAnalyzer.analyze(tweets)
    total.append(res['analysis']['status']['sentiment'])
    print 'Analyzing words...'
    wordAnalyzer = StatusAnalysis.WordAnalysis()
    res['analysis']['status']['word'] = wordAnalyzer.analyze(tweets)
    total.append(res['analysis']['status']['word'])

    print 'Analysis done!'

    # data for front end
    print '\nPreparing data...'
    res['data']['friends'] = []
    for friend in friends:
        info = {
            k: friend[k]
            for k in friend
            if k in ['screen_name', 'followers_count', 'profile_image_url']
        }
        res['data']['friends'].append(info)
    # top 10 words, only work after word analysis
    words_count = wordAnalyzer.stats['words_count']
    res['data']['words'] = map(
        lambda k: (k, words_count[k]),
        heapq.nlargest(10, words_count, key=lambda k: words_count[k]))
    print 'Data prepared!'

    # total score
    #res['analysis']['total'] = sum(total) / len(total)
    res['analysis']['total'] = min(total)
    return res
    'root': {
        'level': 'INFO',
        'handlers': ['wsgi']
    }
})

app = flask.Flask(__name__)
kinesis = boto3.client(
    'kinesis',
    aws_access_key_id=CONSTANTS.get('AWS').get('aws_access_key_id'),
    aws_secret_access_key=CONSTANTS.get('AWS').get('aws_secret_access_key'),
    region_name=CONSTANTS.get('AWS').get('region_name'),
)
twitter_client = twitter.TwitterAPI(
    CONSTANTS.get('TWITTER').get('consumer_key'),
    CONSTANTS.get('TWITTER').get('consumer_secret'),
    CONSTANTS.get('TWITTER').get('access_token_key'),
    CONSTANTS.get('TWITTER').get('access_token_secret'),
)
topics = ['trans', 'transgender']
hook = twitter_hook.TwitterDataStream(
    kinesis,
    twitter_client,
    logger=app.logger,
    topics=topics
)


@app.route('/')
def index():
    if hook.is_alive():
        latest_tweet = twitter_hook.TwitterDataStream.latest_tweet
Exemplo n.º 20
0
def get_twitter(config_file):
    token1, token2, token3, token4 = ''  # To be replaced with tokens
    config = configparser.ConfigParser()
    config.read(config_file)
    twitter = TwitterAPI.TwitterAPI(token1, token2, token3, token4)
    return twitter
import sys
import json
import os.path
import time
import requests

#Credencias de acesso App Twitter
consumer_key = "NBL0CtVrn2ajbpaGEWC1GBY2c"
consumer_secret = "2F5Uz5VYg0ONu4xTYYZsWkAGfc3TYXCkXLCsXMJ1eCKOfhBTfS"
access_token = "2345718031-we2K2PETQXkz7NCexjdGuvE2L2rnd5KfouzN3Up"
access_token_secret = "aEQPKGifu1y29Wbh3u6Z0YIcjAsBC8VeD4Y75CDL2r12o"

#acessa OAuth
# Referencia para API: https://dev.twitter.com/rest/reference
twitter = TwitterAPI(consumer_key, consumer_secret, auth_type='oAuth2')

##DataBase s
client = MongoClient()
db = client.baseTweetsTCC

tweets = db.tweets.find()

users_count = 0

#print('Buscando...\n')
#print('Isso Pode Demorar Um Pouco..\n')
it = 1

for document in tweets:
    try:
Exemplo n.º 22
0
import json
import TwitterAPI
import database
from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer

with open('./config.json', encoding='utf-8') as f:
    data = json.load(f)

api_key = data['api_key']
api_secret = data['api_secret']
access_key = data['access_key']
access_secret = data['access_secret']
url = data['url']
locations = data['locations']

api = TwitterAPI.TwitterAPI(api_key, api_secret, access_key, access_secret)
db = database.Couchdb(url)
analyzer = SentimentIntensityAnalyzer()


def extract(tweet):
    if 'text' not in tweet or tweet['text'].startswith('RT'):
        return None
    if 'place' not in tweet or 'full_name' not in tweet['place']:
        return None
    location = tweet['place']['full_name']
    if 'Queensland' in location:
        db_name = 'queens'
    elif 'New South Wales' in location:
        db_name = 'nsw'
    elif 'Victoria' in location:
def get_authentication():
    api = TwitterAPI.TwitterAPI(twitter_credentials.consumer_key,
                     twitter_credentials.consumer_secret,
                     twitter_credentials.access_token,
                     twitter_credentials.access_token_secret)
    return api
Exemplo n.º 24
0
 def auth_lib(self):
     auth = TwitterAPI(self.consumer_key, self.consumer_secret, 
                      self.access_token, self.access_secret)
     
     return auth
Exemplo n.º 25
0
app = flask.Flask(__name__)

# filename?
fn = 'config.json.example'
if os.path.isfile('config.json'):
    fn = 'config.json'

print("opening fn: " + fn)
with open(fn) as json_data_file:
    config = json.load(json_data_file)

tweet_limit = config["tweet_limit"]

#AUTH
api = TwitterAPI.TwitterAPI(config["consumer_key"], config["consumer_secret"],
                            config["access_token_key"],
                            config["access_token_secret"])


# HELPERS
def statuses(username):
    r = api.request("statuses/user_timeline", {
        "count": tweet_limit,
        "screen_name": username
    })
    return r.get_iterator()


#def statuses(username):
#    return [{'egg': 'yes', 'ham': 'yes', 'spam': 'no'}, {'egg': 'yes', 'ham': 'yes', 'spam': 'no'}, {'egg': 'yes', 'ham': 'yes', 'spam': 'no'}]
Exemplo n.º 26
0
 def auth(self):
     self.api = TwitterAPI(self.CONSUMER_KEY, self.CONSUMER_SECRET, self.ACCESS_TOKEN, self.ACCESS_TOKEN_SECRET)
Exemplo n.º 27
0
consumer_secret = 'eig9biZmFBVK8iy1VobOwwIsvaD7jM6fF0ODmUulc8yTJVpaCZ'

filename = 'twitter_output.txt'
file = open(filename, 'a')

filename_id = 'since_id.txt'
file_id = open(filename_id, 'r')
if os.stat(filename_id).st_size == 0:
    since_id = ''
else:
    ids = file_id.readlines()
    since_id = ids[-1]
file_id.close()

api = TwitterAPI.TwitterAPI(consumer_key=consumer_key,
                            consumer_secret=consumer_secret,
                            auth_type='oAuth2')

if since_id:
    pager = TwitterAPI.TwitterRestPager(api, 'statuses/user_timeline', {
        'count': 200,
        'screen_name': 'wx_copenhagen',
        'since_id': since_id
    })
else:
    pager = TwitterAPI.TwitterRestPager(api, 'statuses/user_timeline', {
        'count': 200,
        'screen_name': 'wx_copenhagen'
    })

Exemplo n.º 28
0
 def __init__(self, endpoint, params, user=None, rcfile=None, times=1):
     self.endpoint = endpoint
     self.params = params
     self.api = T.TwitterAPI(*keys.keys(user, rcfile))
     self.times = times
     self.stop, self.cursor, self.response = self.get_first()
 def __init__(self):
     self.t_api = twitter_api.TwitterAPI("keys.json")
Exemplo n.º 30
0
                CHECKINS_QUEUE.put_nowait(None)
                break


if __name__ == '__main__':
    # pylint: disable=C0103
    if DB:
        DB.checkin.ensure_index([('loc', cm.pymongo.GEOSPHERE),
                                 ('lid', cm.pymongo.ASCENDING),
                                 ('city', cm.pymongo.ASCENDING),
                                 ('time', cm.pymongo.ASCENDING)])
    SAVE = save_checkins_mongo if ARGS.mongodb else th.save_checkins_json
    config = ConfigParser.ConfigParser()
    config.read('api_keys.cfg')
    api = twitter.TwitterAPI(config.get('twitter', 'consumer_key'),
                             config.get('twitter', 'consumer_secret'),
                             config.get('twitter', 'access_token'),
                             config.get('twitter', 'access_token_secret'))
    accu = Thread(target=accumulate_checkins, name='AccumulateCheckins')
    accu.daemon = True
    accu.start()
    start = clock()
    end = start + ARGS.duration * 60 * 60
    failures = th.Failures(initial_waiting_time=2.0)
    while clock() < end:
        try:
            read_twitter_stream(api, end)
        except (KeyboardInterrupt, SystemExit):
            CHECKINS_QUEUE.put_nowait(None)
            raise
        except:
            msg = 'Fail to read or enqueue tweet\n'