def process(self):
twitterAccount = parse_twitter_credential()
twitterApi = TwitterApi(twitterAccount)
eventReaderProcessor = EventReaderProcessor(
os.path.abspath("./events.csv"))
events = eventReaderProcessor.process()
searchResultList = []
for e in events:
searchResult = twitterApi.search(e.getSubject(), e.getDate())
tweets = searchResult["tweets"]
tweets = [{
"similarity": similarity(e.getSubject(), tweet[1]),
"text": tweet[1]
} for tweet in tweets]
searchResult["tweets"] = list(
filter(
lambda tweet: tweet["similarity"] >
RELATED_TWEET_SIMILARITY_THRESHOLD, tweets))
searchResultList.append(searchResult)
analysis = Analysis(searchResultList)
for tweetSearchResult in searchResultList:
tweetSearchResult["analysisResult"] = analysis.analyze(
tweetSearchResult)
return searchResultList
def on_button_clicked():
alert = QMessageBox()
params = {k: v.text() for k, v in self.param_edits.items()}
self.twitter_node = TwitterApi(params=params)
if self.twitter_node.is_tweepy_connected():
self.login_tweepy_screen = QGroupBox("Tweepy Connection")
alert.setText("Tweepy is connected")
else:
alert.setText("Tweepy is connected")
alert.exec_()
def __init__(self, storage, **kwargs):
super(TwitterTrainer, self).__init__(storage, **kwargs)
from twitter import TwitterApi
# The word to be used as the first search term when searching for tweets
self.random_seed_word = kwargs.get('random_seed_word', 'random')
self.api = TwitterApi(
consumer_key=kwargs.get('twitter_consumer_key'),
consumer_secret=kwargs.get('twitter_consumer_secret'),
access_token_key=kwargs.get('twitter_access_token_key'),
access_token_secret=kwargs.get('twitter_access_token_secret'))
def get_official(cls) -> '_ApiOfficial':
api = TwitterApi(consumer_key=Config.CONSUMER_KEY,
consumer_secret=Config.CONSUMER_SECRET,
access_token_key=Config.ACCESS_TOKEN,
access_token_secret=Config.ACCESS_TOKEN_SECRET)
api.VerifyCredentials()
return _ApiOfficial(api)
def getFramesAndTweetThen(url, imagesFolder, videoName, TIMER):
# get video from youtube
video = pafy.new(url)
best = video.getbest(preftype="mp4")
vidcap = cv2.VideoCapture(best.url)
success, image = vidcap.read()
count = 1
while success:
# save frame as JPEG file
cv2.imwrite("%s/frame%d.jpg" % (imagesFolder, count), image)
success, image = vidcap.read()
print("Posting frame %d" % (count))
# Tweet image and description
TwitterApi(
"%s/frame%d.jpg" % (imagesFolder, count),
'Frame %d do video %s (postado a cada %ds)' %
(count, videoName, int(TIMER)))
count += 1
time.sleep(int(TIMER))
def post_entity_tweet(
view_set_obj: Union[ActionViewSet, QuoteViewSet]) -> None:
"""Função que posta um tweet de uma entidade (ação ou declaração).
Args:
view_set_obj (Union[ActionViewSet, QuoteViewSet]): O ViewSet da entidade.
"""
api = TwitterApi(
consumer_key=settings.TWITTER_API_KEY,
consumer_secret=settings.TWITTER_API_SECRET_KEY,
access_token_key=settings.TWITTER_API_TOKEN,
access_token_secret=settings.TWITTER_API_SECRET_TOKEN,
)
entity_name = view_set_obj.__class__.__name__.split("ViewSet")[0].lower()
infos = _get_random_entity(view_set_obj=view_set_obj)
if isinstance(view_set_obj, QuoteViewSet):
infos["description"] = f'"{infos["description"]}"'
try:
api.PostUpdate(status=(
f"{infos['description']}\n\nMais informações: "
f"http://bolsonaro-api.herokuapp.com/{entity_name}s/{infos['id']}/"
))
logger.info("%s tweet postado com sucesso. ID da entidade: %s",
entity_name, infos["id"])
except TwitterError as error:
logger.error("Erro ao postar no twitter: %s", error.message)
def __init__(self, storage, **kwargs):
super(TwitterTrainer, self).__init__(storage, **kwargs)
from twitter import Api as TwitterApi
self.api = TwitterApi(
consumer_key=kwargs.get('twitter_consumer_key'),
consumer_secret=kwargs.get('twitter_consumer_secret'),
access_token_key=kwargs.get('twitter_access_token_key'),
access_token_secret=kwargs.get('twitter_access_token_secret'))
def __init__(self, chatbot, **kwargs):
super().__init__(chatbot, **kwargs)
from twitter import Api as TwitterApi
# The word to be used as the first search term when searching for tweets
self.random_seed_word = kwargs.get('random_seed_word', 'random')
self.lang = kwargs.get('twitter_lang')
self.api = TwitterApi(
consumer_key=kwargs.get('twitter_consumer_key'),
consumer_secret=kwargs.get('twitter_consumer_secret'),
access_token_key=kwargs.get('twitter_access_token_key'),
access_token_secret=kwargs.get('twitter_access_token_secret'))
def get(self):
logging.info("GetTrendsTask starting...")
try:
# create twitter client
client = TwitterApi(
consumer_key=Crenditals.CONSUMER_KEY,
consumer_secret=Crenditals.CONSUMER_SECRET,
access_token_key=Crenditals.CLIENT_TOKEN,
access_token_secret=Crenditals.CLIENT_SECRET)
q_futures = []
for region in Globals.REGIONS:
# request trends from twitter
response = client.getTrendsByWoeid(woeid=region)
# get current timestamp in seconds
timestamp = int(time.time())
# put trends to db
entityList = []
for trend in response:
entityList.append(
TrendWindow(
name=trend['name'],
woeid=region,
timestamp=timestamp,
time=10,
volume=trend['tweet_volume']))
q_futures.extend(ndb.put_multi_async(entityList))
self.updateCacheValues(region, entityList)
# wait all async put operations to finish.
ndb.Future.wait_all(q_futures)
except ValueError as v_e:
logging.error(v_e)
# self.retry()
except Exception, e:
traceback.print_exc()
Error(msg=str(e), timestamp=int(time.time())).put()
SendEmail().send('Error on GetTrendsTask', str(e))
def send_tweets(Type=None):
global Twitter,T_status
if not T_status:
print "Twitter login attempt.."
Twitter = TwitterApi(
consumer_key = RajivPySms.CREDENTIALS['twitter']['consumer_key'],
consumer_secret = RajivPySms.CREDENTIALS['twitter']['consumer_secret'],
access_token_key = RajivPySms.CREDENTIALS['twitter']['access_token_key'],
access_token_secret = RajivPySms.CREDENTIALS['twitter']['access_token_secret']
)
T_status = True
prepare_data(Type)
print "tweeting",Type
Twitter.PostUpdate(DATA[Type])
def __init__(self, **kwargs):
nltk.download("averaged_perceptron_tagger")
self.twitter = TwitterApi(
consumer_key=kwargs.get("twitter_consumer_key"),
consumer_secret=kwargs.get("twitter_consumer_secret"),
access_token_key=kwargs.get("twitter_access_token_key"),
access_token_secret=kwargs.get("twitter_access_token_secret")
)
self.google_service_url = 'https://kgsearch.googleapis.com/v1/entities:search?'
self.google_params = {
'limit': 1,
'indent': True,
'key': "AIzaSyDML6wf5I7tdkyPdNq-gPT4zUtPiZgRudE",
}
self.kernel = self._get_kernel()
self.chatbot = self._get_chatterbot()
self.sessions_path = kwargs.get("sessions_path")
class Twitter(QDialog):
def __init__(self, parent=None):
super(Twitter, self).__init__(parent)
self.param_edits = {
'consumer_key': QLineEdit(),
'consumer_secret': QLineEdit(),
'access_token': QLineEdit(),
'access_token_secret': QLineEdit()
}
self.login_tweepy_screen = None
self.authenticate_tweepy()
main_layout = QGridLayout()
main_layout.addWidget(self.login_tweepy_screen, 3, 0)
self.setLayout(main_layout)
self.twitter_node = None
def authenticate_tweepy(self):
self.login_tweepy_screen = QGroupBox("Tweepy Connection")
layout = QVBoxLayout()
labels = []
for param in self.param_edits:
l = QLabel(param)
layout.addWidget(l)
labels.append(l)
layout.addWidget(self.param_edits[param])
def on_button_clicked():
alert = QMessageBox()
params = {k: v.text() for k, v in self.param_edits.items()}
self.twitter_node = TwitterApi(params=params)
if self.twitter_node.is_tweepy_connected():
self.login_tweepy_screen = QGroupBox("Tweepy Connection")
alert.setText("Tweepy is connected")
else:
alert.setText("Tweepy is connected")
alert.exec_()
button = QPushButton('Connect')
layout.addWidget(button)
button.clicked.connect(on_button_clicked)
layout.addWidget(button)
self.login_tweepy_screen.setLayout(layout)
class TwitterTrainer(Trainer):
"""
Allows the chat bot to be trained using data
gathered from Twitter.
:param random_seed_word: The seed word to be used to get random tweets from the Twitter API.
This parameter is optional. By default it is the word 'random'.
"""
def __init__(self, storage, **kwargs):
super(TwitterTrainer, self).__init__(storage, **kwargs)
from twitter import TwitterApi
# The word to be used as the first search term when searching for tweets
self.random_seed_word = kwargs.get('random_seed_word', 'random')
self.api = TwitterApi(
consumer_key=kwargs.get('twitter_consumer_key'),
consumer_secret=kwargs.get('twitter_consumer_secret'),
access_token_key=kwargs.get('twitter_access_token_key'),
access_token_secret=kwargs.get('twitter_access_token_secret'))
def random_word(self, base_word):
"""
Generate a random word using the Twitter API.
Search twitter for recent tweets containing the term 'random'.
Then randomly select one word from those tweets and do another
search with that word. Return a randomly selected word from the
new set of results.
"""
import random
random_tweets = self.api.GetSearch(term=base_word, count=5)
random_words = get_words_from_tweets(random_tweets)
random_word = random.choice(list(random_words))
tweets = self.api.GetSearch(term=random_word, count=5)
words = get_words_from_tweets(tweets)
word = random.choice(list(words))
return word
def get_statements(self):
"""
Returns list of random statements from the API.
"""
from twitter import TwitterError
statements = []
# Generate a random word
random_word = self.random_word(self.random_seed_word)
self.logger.info(
u'Requesting 50 random tweets containing the word {}'.format(
random_word))
tweets = self.api.GetSearch(term=random_word, count=50)
for tweet in tweets:
statement = Statement(tweet.text)
if tweet.in_reply_to_status_id:
try:
status = self.api.GetStatus(tweet.in_reply_to_status_id)
statement.add_response(Response(status.text))
statements.append(statement)
except TwitterError as error:
self.logger.warning(str(error))
self.logger.info('Adding {} tweets with responses'.format(
len(statements)))
return statements
def train(self):
for _ in range(0, 10):
statements = self.get_statements()
for statement in statements:
self.storage.update(statement)
from twitter.error import TwitterError
ssm = boto3.client('ssm')
twitter_params = {
param['Name'].rsplit('/', 1)[-1]: param['Value']
for param in ssm.get_parameters(Names=[
'/howsmydrivinganalytics/consumer_key',
'/howsmydrivinganalytics/consumer_secret',
'/howsmydrivinganalytics/access_token_key',
'/howsmydrivinganalytics/access_token_secret'
],
WithDecryption=True)['Parameters']
}
twitter = TwitterApi(**twitter_params)
con = sqlite3.connect('../archive.db')
cur = con.cursor()
for tweet_id, text in cur.execute('select tweet_id, content from tweets'):
if os.path.exists('archive_images/{}.jpg'.format(tweet_id)):
print('skipping {}'.format(tweet_id))
continue
if os.path.exists('archive_images/{}.jpg'.format(tweet_id)):
print('getting details {}'.format(tweet_id))
continue
if 'balance of $0.00' in text or 'not found' in text:
print('skipping(notix) {}'.format(text))
continue
tweet = twitter.GetStatus(tweet_id, include_entities=True)
def __init__(self):
self.t = TwitterApi(auth=OAuth(OAUTH_TOKEN, OAUTH_SECRET, CONSUMER_KEY, CONSUMER_SECRET))
import logging
from twitter import TwitterAuth, TwitterApi
from resources.config import configuration
logging.getLogger("").setLevel(logging.INFO)
twitter = TwitterApi(
TwitterAuth.get_oauth1_auth(
configuration["twitter"]["consumer_key"],
configuration["twitter"]["consumer_secret"],
configuration["twitter"]["access_token_key"],
configuration["twitter"]["access_token_secret"],
))
def main():
global twitter
from resources.flask_server import app
app.run(
host=configuration["http"]["bind"]["host"],
port=configuration["http"]["bind"]["port"],
debug=False,
threaded=True,
)
f.close()
return make_tweet_list(popped_tweet)
tweet_list = []
for tweet in sys.argv[1:]:
tweet_list += make_tweet_list(tweet)
if not tweet_list:
tweet_list = pop_a_tweet()
#"""
if tweet_list:
print 'Attempting Twitter Api Login...'
Twitter = TwitterApi(
consumer_key=CREDENTIALS.get("consumer_key"),
consumer_secret=CREDENTIALS.get("consumer_secret"),
access_token_key=CREDENTIALS.get("access_token_key"),
access_token_secret=CREDENTIALS.get("access_token_secret")
)
ME = Twitter.VerifyCredentials().screen_name
print "Current user is @" + ME
if tweet_list[0] == '-g':
user_list = tweet_list[1:]
if user_list:
for user in user_list:
print
print "Recent tweets from " + user + ":"
print "===================" + "=" * (len(user) + 1)
tweets = Twitter.GetUserTimeline(user[1:])
#count = 0
for tweet in tweets:
#if count == 5: break;
