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")