def index(request):
# Set up Twitter API with our auth details
api = Api(consumer_key=CONSUMER_KEY,
consumer_secret=CONSUMER_SECRET,
access_token_key=ACCESS_TOKEN_KEY,
access_token_secret=ACCESS_TOKEN_SECRET)
profile, _ = Profile.objects.get_or_create(user=request.user)
if profile.twitter_name: # If we had a profile and saved a twitter name, use it here or use our username
user_id = profile.twitter_name
else:
user_id = request.user.username
if request.method == "GET":
if 'user' in request.GET:
user_id = request.GET['user']
twitter = api.GetUserTimeline(screen_name=user_id, count=10)
twitter_user = api.GetUser(screen_name=user_id)
country_list = Country.objects.values('name', 'longitude', 'latitude')
for tweet in twitter: # this is horribly slow atm, could speed this up if I thought about it harder.
for country in country_list:
if country[
'name'] in tweet.text: # stupid simple search method, doesn't rank countries by relevance
tweet.country = {
'name': country['name'],
'latitude': country['latitude'],
'longitude': country['longitude']
}
break
return render(request, 'index.html', {
'twitter': twitter,
'twitter_user': twitter_user
})
def get_tweets(screen_name, limit):
api = Api(consumer_key=app.config['CONSUMER_KEY'],
consumer_secret=app.config['CONSUMER_SECRET'],
access_token_key=app.config['ACCESS_TOKEN_KEY'],
access_token_secret=app.config['ACCESS_TOKEN_SECRET'])
api.VerifyCredentials()
tweets = api.GetUserTimeline(screen_name=screen_name, count=limit)
include_tweets(screen_name, tweets)
return database.tweets.find()
def get_tweets(screen_name, limit):
api = Api(consumer_key=app.config['CONSUMER_KEY'],
consumer_secret=app.config['CONSUMER_SECRET'],
access_token_key=app.config['ACCESS_TOKEN_KEY'],
access_token_secret=app.config['ACCESS_TOKEN_SECRET'])
api.VerifyCredentials()
tweets = api.GetUserTimeline(screen_name=screen_name, count=limit)
for tweet in tweets:
tweet.url = 'https://twitter.com/{}/statuses/{}'.format(
screen_name, tweet.id)
return tweets
def get_latest_tweets_sorted():
api = Api(CONSUMER_KEY, CONSUMER_SECRET, ACCESS_TOKEN, ACCESS_TOKEN_SECRET)
statuses = api.GetUserTimeline(user_id=USER_ID)
status_list = list()
for status in statuses:
created_at = time.strftime(
'%Y-%m-%d %H:%M:%S',
time.strptime(status.created_at, '%a %b %d %H:%M:%S +0000 %Y'))
status_list.append(
dict(user=status.user.screen_name,
text=status.text,
id=status.id,
created=created_at))
status_list = sorted(status_list, key=lambda k: k['created'])
return status_list
def retweet(self):
""" Retweet from twitter account provided earlier """
api = Api(consumer_key=settings.CONSUMER_KEY,
consumer_secret=settings.CONSUMER_SECRET,
access_token_key=settings.ACCESS_TOKEN_KEY,
access_token_secret=settings.ACCESS_TOKEN_SECRET)
try:
RetweetUser.objects.get()
tweet = api.GetUserTimeline(screen_name='screen_name')[0]
tweet.GetId()
api.PostRetweet(tweet.GetId())
except RetweetUser.DoesNotExist:
pass
except RetweetUser.MultipleObjectsReturned:
pass
class TwitterProducer:
logging.basicConfig(filename='tweets.py', level=logging.NOTSET)
def run(self):
self.stream_mentions()
# def _producer(self):
# pass
def __init__(self):
self.api = Api(CONSUMER, CONSUMER_SECRET, ACCESS_TOKEN,
ACCESS_TOKEN_SECRET)
self._producer = KafkaProducer(bootstrap_servers='localhost:9092',
max_in_flight_requests_per_connection=5,
acks='all',
api_version=(0, 10),
retries=100000000000)
def stream_mentions(self):
with open('output.txt', 'a') as f:
for msg in self.api.GetStreamFilter(track=['@tolumide_ng'],
languages=['en']):
f.write(json.dumps(msg))
logging.info(msg)
self._producer.send('twitter_mentions', None, msg)
f.write('\n')
def stream_timeline(self, user):
with open('timeline.txt', 'a') as f:
statuses = self.api.GetUserTimeline(user_id=user)
# print([s.text for s in statuses])
for s in statuses:
# f.write(json.dumps(s.text))
val = bytes(s.text, encoding='utf-8')
print(val)
self._producer.send('twitter_timelines', val)
f.write('\n')
f.close()
def get_followers(self, user):
users = self.api.GetFriends(user)
logging.info([u.name for u in users])
def set_up_sample_test_data():
with open('token/tokens.json', "r") as file:
tokens = json.load(file)
api = Api(consumer_key=tokens["consumer_key"],
consumer_secret=tokens["consumer_secret"],
access_token_key=tokens["access_token_key"],
access_token_secret=tokens["access_token_secret"],
tweet_mode="extended")
timeline = api.GetUserTimeline(screen_name="Piechocinski",
count=5,
trim_user=False,
include_rts=False)
json_timeline = [post.AsDict() for post in timeline]
with open("test.json", "w") as file:
json.dump(json_timeline, file, indent=4)
user = api.GetUser(screen_name="Piechocinski")
json_user = user.AsDict()
with open("test2.json", "w") as file:
json.dump(json_user, file, indent=4)
def run(self):
try:
from twitter import Api
except ImportError as ie:
raise ie
d = dict()
api = Api(Consumer_Key, Consumer_Secret, Access_Token,
Access_Token_Secret)
cdlt = api.UsersLookup(screen_name=["CordaDLT"])[0]
corda_followers = api.GetFollowers(user_id=cdlt)
d["twitter_followers"] = len(corda_followers)
usertimeline = [
x for x in api.GetUserTimeline(count=100) if x.retweeted == False
]
total_faves = 0
total_retweets = 0
for x in usertimeline[0:10]:
#print x
# print x.text, x.favorite_count, x.retweet_count
total_faves += x.favorite_count
total_retweets += x.retweet_count
# print "In last 10 tweets"
# print total_faves, "faves", total_retweets, "retweets"
d["twitter_running_10_average_faves"] = total_faves / 10.0
d["twitter_running_10_retweets"] = total_retweets / 10.0
return d
class Twitter:
def __init__(self):
# Create API object
self.api = Api(consumer_key=CONSUMER_KEY,
consumer_secret=CONSUMER_SECRET,
access_token_key=ACCESS_TOKEN,
access_token_secret=ACCESS_TOKEN_SECRET)
def get_direct_messages(self):
data = self.api.GetDirectMessages()
for message in data:
pprint(message)
def get_post(self):
for tweet in self.api.GetUserTimeline(
user_id="spacex"): # since_id=1111
print(f"{tweet.user.name}:{tweet.text}:{tweet.entities}")
def create_post(self, text, file):
if file:
res = self.api.UploadMediaSimple(file)
print(res)
self.api.PostUpdate(text, media=file)
class GomiPeopleBot(object):
"""ｺﾞﾐﾋﾟｰﾌﾟﾙBotクラス."""
def __init__(self,
consumer_key: str,
consumer_secret: str,
access_token_key: str,
access_token_secret: str,
model_filepath: str,
cuda: bool = False,
logger: Optional[Logger] = None):
"""コンストラクタ.
Parameters
----------
consumer_key : str
TwitterのConsumer Key
consumer_secret : str
TwitterのConsumer Secret
access_token_key : str
TwitterのAccess Token
access_token_secret : str
TwitterのAccess Token Secret
model_filepath : str
モデルファイルパス
cuda : bool, default False
CUDAの利用するか否かのフラグ（デフォルト：利用しない）
logger : Optional[logging.Logger], default None
ロガー
"""
self.twitter_api = TwitterAPI(consumer_key=consumer_key,
consumer_secret=consumer_secret,
access_token_key=access_token_key,
access_token_secret=access_token_secret)
self.logger = logger if logger else self.create_logger()
self.model_filepath = model_filepath
self.cuda = cuda
self.gp_generator: Optional[GenerateGPText] = None
self.steady_tweets = self.load_steady_tweets()
self.tz = timezone(timedelta(hours=+9), 'Asia/Tokyo')
@staticmethod
def create_logger() -> Logger:
"""ロガーの生成.
Returns
-------
Logger
ロガー
"""
handler = logging.StreamHandler()
formatter = logging.Formatter(
"[%(asctime)s][%(levelname)s] in %(filename)s: %(message)s")
handler.setFormatter(formatter)
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
logger.addHandler(handler)
return logger
def get_latest_status_id(self) -> Optional[str]:
"""自身の直近の返信ツイートのIDを取得する.
Returns
-------
Optional[str]
自身の直近の返信ツイートのID
"""
statuses = self.twitter_api.GetUserTimeline(count=20)
if len(statuses) == 0:
return None
for status in statuses:
# 返信しているツイートを見つけたらそのIDを返す
if status.in_reply_to_status_id is not None:
return cast(str, status.id_str)
else:
# 返信しているツイートがなければ最新の自身のツイートIDを返す
return cast(str, statuses[0].id_str)
def load_steady_tweets(self,
path: str = "./steady_tweets.yml"
) -> List[Dict[str, str]]:
"""定常ツイートを読み込む.
Parameters
----------
path : str, optional
定常ツイートを格納したYamlファイルパス（デフォルト：./steady_tweets.yml）
Returns
-------
List[Dict[str, str]]
定常ツイート情報
"""
with open(path) as fp:
return cast(List[Dict[str, str]], yaml.safe_load(fp)["tweets"])
def generate_text(self, max_length: int) -> str:
"""ｺﾞﾐﾋﾟｰﾌﾟﾙテキストの生成.
Parameters
----------
max_length : int
テキストの最大長
Returns
-------
str
生成したｺﾞﾐﾋﾟｰﾌﾟﾙテキスト
"""
if self.gp_generator is None:
self.gp_generator = GenerateGPText(self.model_filepath, self.cuda)
texts: List[str] = []
scores: List[float] = []
for _ in range(N_GENERATE_TEXT):
text, avg_weight, std_weight = self.gp_generator(max_length)
texts.append(text)
# 重みの平均が大きく、分散が小さいほどスコアを高くする
scores.append(avg_weight / std_weight if std_weight > 0 else 0.0)
return cast(str, texts[np.argmax(scores)])
def do_mentions(self, now: datetime,
latest_status_id: Optional[str]) -> bool:
"""ユーザへのリプライを行う.
Parameters
----------
now : datetime.datetime
現在日時
latest_status_id : Optional[str]
最後にリプライしたツイートのID
Returns
-------
bool
定常ツイートした場合はTrue、しなかった場合はFalse
Notes
-----
* MENTION_MINUTEで指定した分間隔でリプライする
"""
if int(now.strftime("%M")) % MENTION_MINUTE != 0:
return False
random.seed()
# Botへのリプライを取得
self.logger.info(f"Latest status id: {latest_status_id}")
statuses = self.twitter_api.GetMentions(count=100,
since_id=latest_status_id)
if len(statuses) == 0:
self.logger.info("No reply.")
return False
if latest_status_id is None and len(statuses) > 0:
self.logger.info("No latest status ID")
return False
# ユーザIDとツイートIDのマッピングを記憶する
# -> 同じユーザから複数ツイートあっても1ツイート分しか記憶しない
tweet_id_map: Dict[str, str] = {
st.user.screen_name: st.id_str
for st in statuses
}
targets = list(tweet_id_map.items())
if len(targets) > MAX_N_MENTIONS:
# MAX_N_MENTIONSで指定した数よりリプライが多ければリプライをランダムに抽出
targets = random.sample(targets, MAX_N_MENTIONS)
for screen_name, id_str in targets:
# リプライ対象のツイートごとにテキストを生成してツイート
text_prefix = f"@{screen_name} "
text = self.generate_text(TWEET_MAX_LENGTH - len(text_prefix))
self.post(text_prefix + text, id_str)
return True
def do_steady_tweets(self, now: datetime) -> bool:
"""定常ツイートを行う.
Parameters
----------
now : datetime.datetime
現在日時
Returns
-------
bool
定常ツイートした場合はTrue、しなかった場合はFalse
"""
for tweet in self.steady_tweets:
if now.strftime(tweet["type"]) == tweet["dt"]:
self.post(tweet["text"])
return True
return False
def post(self,
text: Optional[str],
mention_id: Optional[str] = None) -> str:
"""ツイート.
Parameters
----------
text : Optional[str]
ツイートするテキスト
mention_id : Optional[str], optional
リプライ先のツイートID
Returns
-------
str
ツイートのID
Raises
------
ValueError
ツイートするテキストが空の場合
"""
if text is None or len(text) == 0:
raise ValueError("Tweet is empty.")
result = self.twitter_api.PostUpdate(status=text,
in_reply_to_status_id=mention_id)
return cast(str, result.id_str)
def main(self, force: bool = False) -> None:
"""main関数.
Parameters
----------
force : bool, default False
強制的に通常ツイートを行うかどうかのフラグ（デフォルト：強制しない）
"""
self.logger.info("Start tweet.")
now = datetime.now().astimezone(self.tz)
try:
# 定常ツイート
if not force and self.do_steady_tweets(now):
# 定常ツイートした場合は終了
self.logger.info("Successfully steady tweet.")
return
# 通常ツイート
if force or int(now.strftime("%M")) % NORMAL_MINUTE == 0:
self.post(self.generate_text(TWEET_MAX_LENGTH))
self.logger.info("Successfully tweet.")
return
# リプライ
latest_status_id = self.get_latest_status_id()
if self.do_mentions(now, latest_status_id):
# リプライした場合は終了
self.logger.info("Successfully replies.")
return
self.logger.info("No action.")
except Exception:
self.logger.error("Failed to tweet.")
self.logger.error(traceback.format_exc())
raise
return
class Twitter(commands.Cog):
def __init__(self, discordClient):
self.bot = discordClient
self.api = Api(consumer_key=consumerKey,
consumer_secret=consumerSecret,
access_token_key=accessTokenKey,
access_token_secret=accessTokenSecret)
self.localTimeZone = pytz.timezone('Europe/Oslo')
self.timeFormat = '%d %b %Y' + ' at ' + '%H:%M' + ' Central European'
self.db = 'guild_settings.db'
self.table = 'settings'
self.settings = {
'guild_id': 'guild_id',
'guild_name': 'guild_name',
'commands_disabled': 'commands_disabled',
'roll_channel': 'roll_channel',
'osu_channel': 'osu_channel',
'admin_role': 'admin_role'
}
def check_command_disabled(self, guild):
conn = sqlite3.connect(self.db)
c = conn.cursor()
with conn:
c.execute(
"SELECT {} FROM {} WHERE guild_id=?".format(
self.settings['commands_disabled'], self.table),
(guild.id, ))
commands_disabled = c.fetchone()
conn.close()
return (commands_disabled[0] == 0)
@commands.command(pass_context=True)
@commands.cooldown(1, 10.0, type=commands.BucketType.user)
async def twitter(self, ctx, stebenTwitterId=962385627663695872):
if not self.check_command_disabled(ctx.message.guild):
return (await ctx.say("This command is disabled"))
try:
tweetJSON = self.api.GetUserTimeline(user_id=stebenTwitterId,
count=1,
exclude_replies=True)[0]
except TwitterError as e:
return (await ctx.send(str(e)))
tweetObject = json.loads(str(tweetJSON))
embedTweet = discord.Embed(
title="Go to tweet",
description=tweetObject["text"],
url="https://twitter.com/{0}/status/{1}".format(
tweetObject["user"]["screen_name"], tweetObject["id_str"]),
color=0x00aced)
embedTweet.set_author(
name="{0} ({1})".format(tweetObject["user"]["screen_name"],
tweetObject["user"]["name"]),
url="https://twitter.com/{}".format(
tweetObject["user"]["screen_name"]),
icon_url=tweetObject["user"]["profile_image_url"])
utcTime = datetime.strptime(tweetObject["created_at"][4:],
'%b %d %H:%M:%S %z %Y')
localTime = utcTime.astimezone(self.localTimeZone).strftime(
self.timeFormat)
embedTweet.set_footer(text=localTime)
return (await ctx.send(embed=embedTweet))
from twitter import Api
import json
with open('token/tokens.json', "r") as file:
tokens = json.load(file)
api = Api(consumer_key=tokens["consumer_key"],
consumer_secret=tokens["consumer_secret"],
access_token_key=tokens["access_token_key"],
access_token_secret=tokens["access_token_secret"])
timeline = api.GetUserTimeline(screen_name="AndrzejDuda", count=10, trim_user=True)
# metody dostępne dla Api możecie znaleźć w dokumentacji na stronie:
# https://python-twitter.readthedocs.io/en/latest/twitter.html#module-twitter.api
# najbardziej przydatne będa dla was metody zaczynające się od Get, zwłaszcza metoda "GetUserTimeline"
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;
print "$", tweet.text
#count += 1
else:
print
print "Recent tweets from friends:"
print "==========================="
for tweet in Twitter.GetFriendsTimeline():
if tweet.user.screen_name != ME:
print "@" + tweet.user.screen_name + ":", tweet.text
else:
for tweet in tweet_list:
Twitter.PostUpdate(tweet)
class TwitterApi:
DESTROY_STATUS_ENDPOINT = "https://api.twitter.com/1.1/statuses/destroy/:id.json"
DESTROY_FAVORITE_ENDPOINT = "https://api.twitter.com/1.1/favorites/destroy.json"
# Rate limit per 15 minutes window # TODO use a queue
POST_DIRECT_MESSAGE_RATE_LIMIT = 10
# Maximum amount of friendships we can look at with "GET friendships/lookup"
MAX_AMOUNT_FRIENDSHIPS_LOOKUP = 100
def __init__(self, twitter_credentials):
try:
self.username = twitter_credentials["username"]
# python-twitter
self.api = Api(
consumer_key=twitter_credentials["consumer_key"],
consumer_secret=twitter_credentials["consumer_secret"],
access_token_key=twitter_credentials["access_token"],
access_token_secret=twitter_credentials["access_token_secret"])
# tweepy
auth = tweepy.OAuthHandler(twitter_credentials["consumer_key"],
twitter_credentials["consumer_secret"])
auth.set_access_token(twitter_credentials["access_token"],
twitter_credentials["access_token_secret"])
self.tweepy_api = tweepy.API(auth)
except KeyError as key_error:
logging.critical(
"Invalid \"twitter_credentials\" argument: {}".format(
key_error.args[0]))
raise
except TypeError as type_error:
logging.critical(
"Incorrect \"twitter_credentials\" argument: {}".format(
type_error.args[0]))
raise
def check_rate_limit(self, endpoint_url):
try:
return self.api.CheckRateLimit(endpoint_url)
except error.TwitterError as e:
logging.critical(
'An error happened when rate limit of endpoint {} was checked: {}'
.format(endpoint_url, e.message))
return None
def verify_credentials(self):
try:
return self.api.VerifyCredentials(None, True)
except error.TwitterError as e:
logging.error(
'An error happened while checking the Twitter API credentials validity: {}'
.format(e.message))
raise
def get_followers_set(self):
try:
return set(self.api.GetFollowerIDs())
except error.TwitterError as e:
logging.critical(
'Twitter Supervisor is unable to get the user\'s followers IDs list: {}'
.format(e.message))
raise
def get_user(self, user_id):
try:
return self.api.GetUser(user_id), None
except error.TwitterError as e:
logging.error(
'An error happened while searching for user n°{0}: {1}'.format(
user_id, e.message))
return None, e.message
def get_friendship_lookup(self, users_id):
try:
return self.api.LookupFriendship(users_id)
except error.TwitterError as e:
logging.critical(
'An error happened while looking up friendships: {}'.format(
e.message))
raise
def get_friendship_show(self, target_id):
try:
return self.tweepy_api.show_friendship(
source_screen_name=self.username, target_id=target_id), None
except tweepy.TweepError as e:
return None, e
def send_direct_message(self, text):
logging.info('Sending direct message: \"{}\"'.format(text))
try:
return self.api.PostDirectMessage(text, screen_name=self.username)
except error.TwitterError as e:
logging.error('Unable to send direct message: {}'.format(
e.message))
return None
def get_user_timeline(self):
try:
return self.api.GetUserTimeline(screen_name=self.username,
count=200,
since_id=20)
except error.TwitterError as e:
logging.error('Unable to get user @{0} timeline: {1}'.format(
self.username, e.message))
return None
def get_favorites(self):
try:
return self.api.GetFavorites(screen_name=self.username,
count=200,
since_id=20)
except error.TwitterError as e:
logging.error('Unable to get user @{0} favorites: {1}'.format(
self.username, e.message))
return None
def delete_status(self, status_id):
try:
return self.api.DestroyStatus(status_id)
except error.TwitterError as e:
logging.error(
'Unable to delete status n°{0} because of error: {1}'.format(
status_id, e.message))
return None
def delete_favorite(self, status_id):
try:
return self.api.DestroyFavorite(status_id=status_id)
except error.TwitterError as e:
logging.error(
'Unable to delete favorite tweet n°{0} because of error: {1}'.
format(status_id, e.message))
return None
def delete_old_stuff(self, items_type, number_of_preserved_items):
if items_type == 'tweet' or items_type == 'retweet':
items = self.get_user_timeline()
rate_limit = self.check_rate_limit(self.DESTROY_STATUS_ENDPOINT)
if items_type == 'retweet':
items = list(filter(lambda x: x.retweeted is True, items))
elif items_type == 'favorite':
items = self.get_favorites()
rate_limit = self.check_rate_limit(self.DESTROY_FAVORITE_ENDPOINT)
else:
logging.error(
'This type of item to delete is not valid: {0}'.format(
items_type))
return []
if rate_limit is not None:
logging.debug(
'Deletable status - Remaining: {} - Reset: {}'.format(
rate_limit.remaining, rate_limit.reset))
if rate_limit.remaining < len(items) - number_of_preserved_items:
start_index = len(items) - rate_limit.remaining
else:
start_index = number_of_preserved_items
else:
logging.error(
'Unable to check the rate limit of the endpoint used to destroy {0}. No {0} will be deleted.'
)
return []
deleted_items = []
for i in range(start_index, len(items)):
if items_type == 'favorite':
deleted_item = self.delete_favorite(items[i].id)
else:
deleted_item = self.delete_status(items[i].id)
if deleted_item is not None:
deleted_items.append(deleted_item)
logging.info('Delete {0} n°{1} from {2}'.format(
items_type, items[i].id, items[i].user.screen_name))
return deleted_items
class TwitterLink:
def __init__(self, parent, target, keywords=[], hashtagclear=False):
self.parent = parent
self.target = target
self.keywords = keywords
self.hashtagclear = hashtagclear
try:
self.f = file(target + ".txt", "r")
r = self.f.read().split("\n")
print r[-1]
self.old_tweet = str(r[-1])
self.f.close()
except (IndexError, IOError) as E:
self.old_tweet = ""
print "old_tweet:" + self.old_tweet
self.f = file(target + ".txt", "a")
self.api = Api(consumer_key=CONSUMER_KEY,
consumer_secret=CONSUMER_SECRET,
access_token_key=ACCESS_KEY,
access_token_secret=ACCESS_SECRET)
def FetchTwitter(self, limit=1):
statuses = self.api.GetUserTimeline(screen_name="@" + self.target,
count=limit)
s = str(statuses[limit - 1].text)
return s
def __call__(self):
limit = 1
try:
new_tweet = self.FetchTwitter()
except URLError:
return
if self.hashtagclear:
new_tweet = remove_hashtags(new_tweet)
write_tweet = "\n" + new_tweet
while str(self.old_tweet) != str(new_tweet):
limit += 1
maybe_new_tweet = self.FetchTwitter(limit)
if self.hashtagclear:
maybe_new_tweet = remove_hashtags(maybe_new_tweet)
b = True
for i in self.keywords:
if not i in maybe_new_tweet:
b = False
break
if str(maybe_new_tweet) == str(self.old_tweet):
break
elif b:
new_tweet = maybe_new_tweet
if str(self.old_tweet) != str(new_tweet):
for i in self.keywords:
if not i in new_tweet:
return
print write_tweet
self.f.write(write_tweet)
self.old_tweet = new_tweet
self.parent.send_message(mto=self.parent.channel,
mbody="@" + self.target + "\n\t" +
new_tweet,
mtype="groupchat")
