Python API.search方法代码示例

# 需要导入模块: from tweepy import API [as 别名]
# 或者: from tweepy.API import search [as 别名]
class TweepyApi(BaseTweepyApi, ApiAdapter):
    """
    A `ApiAdapter` implementation using `tweepy` library.

        http://github.com/tweepy/tweepy/
    """

    def __init__(self, *args, **kwargs):
        ApiAdapter.__init__(self, *args, **kwargs)

    # from `turses.api.base.ApiAdapter`

    def init_api(self):
        oauth_handler = TweepyOAuthHandler(self._consumer_key,
                                           self._consumer_secret)
        oauth_handler.set_access_token(self._access_token_key,
                                       self._access_token_secret)
        self._api = BaseTweepyApi(oauth_handler)

    @to_user
    def verify_credentials(self):
        return self._api.me()

    @to_user
    @include_entities
    def get_user(self, screen_name, **kwargs):
        return self._api.get_user(screen_name=screen_name, **kwargs)

    # timelines

    @to_status
    @include_entities
    def get_home_timeline(self, **kwargs):
        tweets = self._api.home_timeline(**kwargs)
        retweets = self._api.retweeted_to_me(**kwargs)
        tweets.extend(retweets)
        return tweets

    @to_status
    @include_entities
    def get_user_timeline(self, screen_name, **kwargs):
        return self._api.user_timeline(screen_name, **kwargs)

    @to_status
    @include_entities
    def get_own_timeline(self, **kwargs):
        me = self.verify_credentials()
        tweets = self._api.user_timeline(screen_name=me.screen_name,
                                         **kwargs)
        retweets = self._api.retweeted_by_me(**kwargs)
        tweets.extend(retweets)
        return tweets

    @to_status
    @include_entities
    def get_mentions(self, **kwargs):
        return self._api.mentions(**kwargs)

    @to_status
    @include_entities
    def get_favorites(self, **kwargs):
        return self._api.favorites(**kwargs)

    @to_direct_message
    @include_entities
    def get_direct_messages(self, **kwargs):
        dms = self._api.direct_messages(**kwargs)
        sent = self._api.sent_direct_messages(**kwargs)
        dms.extend(sent)
        return dms

    # NOTE:
    #  `get_thread` is not decorated with `to_status` because
    #  it uses `TweepyApi.get_user_timeline` which is already
    #  decorated
    @include_entities
    def get_thread(self, status, **kwargs):
        """
        Get the conversation to which `status` belongs.

        It filters the last tweets by the participanting users and
        based on mentions to each other.
        """
        author = status.authors_username
        mentioned = status.mentioned_usernames
        if author not in mentioned:
            mentioned.append(author)

        tweets = []
        for username in mentioned:
            tweets.extend(self.get_user_timeline(username, **kwargs))

        def belongs_to_conversation(status):
            for username in mentioned:
                if username in status.text:
                    return True

        return filter(belongs_to_conversation, tweets)

    @to_status_from_search
#.........这里部分代码省略.........

# 需要导入模块: from tweepy import API [as 别名]
# 或者: from tweepy.API import search [as 别名]
    def get(self, request, *args, **kwargs):
        """
        The GET method controller for the API endpoint and saves the results
        to a CSV file.
        Accepts query strings:
            - keyword: the keyword that searched for
            - count: number of results retrieved (default = 100)
        """
        keyword = request.GET.get('keyword')
        count = request.GET.get('count', 100)
        if not keyword:
            return Response(HTTP_400_BAD_REQUEST)

        auth = twitter_auth()
        api = API(auth, parser=JSONParser())
        data = []
        results = api.search(q=keyword, count=count)
        filename = 'search_{}_{}.csv'.format(
            keyword, datetime.now().isoformat()
        )
        for result in results['statuses']:
            data.append({
                'user': parse_tweet(result['user']['name']),
                'tweet': parse_tweet(result['text'])
            })
        save_to_csv(filename, data)
        response_text = 'Saved {} objects.'.format(
            results['search_metadata']['count']
        )
        return Response(response_text)

# 需要导入模块: from tweepy import API [as 别名]
# 或者: from tweepy.API import search [as 别名]
def runTest(auth, geocode):
    searchText = "flash mob OR mobs OR flashmob"
    nycGeoCode = "40.714353,-74.00597299999998,20km"

    api = API(auth)

    if geocode is True:
        tweets = api.search(searchText, geocode=nycGeoCode, lang="en", rpp="100")
    else:
        #Note: This may cause a too many requests Twitter error
        tweets = api.search(searchText, lang="en", rpp="100")

    #basically find tweets that match the search criteria
    users_list = []
    i = 0
    for tweet in tweets:
        print(i)
        i = i + 1
        name = tweet.user.name.encode("utf-8", errors='ignore')
        user_id = tweet.user.id #.encode("utf-8", errors='ignore')
        tweet_text = tweet.text.encode("utf-8", errors='ignore')

        #Ignore users we have already checked
        if (users_list.count(name)):
            continue
        else:
            users_list.append(name)

        #Add number of times the user has used the search criteria in the past
        tweet_count = 0
        retweet_count = 0
        users_tweets = api.user_timeline(id=user_id, count="500")
        for users_tweet in users_tweets:
            if (re.search(r'flash[ ]?mob[s]?', users_tweet.text, flags=re.IGNORECASE)):
                tweet_count = tweet_count + 1
                #Check how many times the past tweets have been retweeted
                retweet_count = retweet_count + len(api.retweets(id=users_tweet.id))

        #Checks how many followers this person has
        followers_count = len(api.followers_ids(id=user_id))

        print("User ID:       ", user_id)
        print("Tweet count:   ", tweet_count)
        print("retweet_count: ", retweet_count)
        print()

    return

# 需要导入模块: from tweepy import API [as 别名]
# 或者: from tweepy.API import search [as 别名]
class Crawler(API):
    #initialise the api with itself and details
    def __init__(self,auth):
        self.auth = auth
        self.api = API(self.auth)
    
    def search(self,query):
        print "Searching for '" + query + "'\n"
        self.data =  self.api.search(query)
        return self.data

# 需要导入模块: from tweepy import API [as 别名]
# 或者: from tweepy.API import search [as 别名]
def post_gettweets():
    page = 1
    keyword = bottle.request.forms.get("tweetKeyword")
    maxPage = bottle.request.forms.get("pages")
    print keyword
    print maxPage
    results =[]
    twitter_api = API()
    for page in range(int(maxPage)):
        tweets = twitter_api.search(keyword, page=page)
        for tweet in tweets:
            result.append(tweet)
    print len(result)

# 需要导入模块: from tweepy import API [as 别名]
# 或者: from tweepy.API import search [as 别名]
 def command_tweep(self, rest):
     """Searches twitter via tweepy for querystring or a tweet with pyladies in it."""
     if rest:
         query = rest
     else:
         query = "pyladies"
     twitter_search = API()
     tweets = twitter_search.search(q=query, lang="en", rpp=100, geo=1)
     if not len(tweets):
         return "Sadly, the twitterverse is silent about %s." % query
     tweet = random.choice(tweets)
     if tweet.__dict__["geo"]:
         loc = get_geo(tweet["geo"])
         if loc:
             return "@%s - %s (%s)" % (tweet.__dict__["from_user"], tweet.__dict__["text"], loc)
     return "@%s - %s" % (tweet.__dict__["from_user"], tweet.__dict__["text"])

# 需要导入模块: from tweepy import API [as 别名]
# 或者: from tweepy.API import search [as 别名]
def search(query):
    '''Uses Twitter search API to search the keywords individually that are requested
    by the user from command-line.'''
    listener = TweetStreamListener()
    auth = OAuthHandler(consumer_key, consumer_secret)
    auth.set_access_token(access_token, access_secret)

    api = API(auth)
    for term in query:
        print 'Searching for:' + term
        results = api.search(q=term, lang=language, result_type='mixed'
                             , include_entities=True, rpp=100)
        for status in results:
            found = posts.find_one({'id': status.id})
            if found == None:
                listener.save(status)

# 需要导入模块: from tweepy import API [as 别名]
# 或者: from tweepy.API import search [as 别名]
 def command_tweep(self, rest):
     '''Searches twitter via tweepy for querystring or a tweet with pyladies in it.'''
     if rest:
         query = rest
     else:
         query = "pyladies"
     twitter_search = API()
     tweets = twitter_search.search(q=query,lang='en',rpp=100,geo=1)
     if not len(tweets):
         return 'Sadly, the twitterverse is silent about %s.' % query
     tweet = random.choice(tweets)
     if tweet.__dict__['geo']:
         loc = get_geo(tweet['geo'])
         if loc:
             return '@%s - %s (%s)' % (tweet.__dict__['from_user'],tweet.__dict__['text'],loc)
     return '@%s - %s' % (tweet.__dict__['from_user'],tweet.__dict__['text'])

# 需要导入模块: from tweepy import API [as 别名]
# 或者: from tweepy.API import search [as 别名]
class Twitter(object):
    """Thin wrapper around Tweepy to configure the OAuth from a import Flask app
    to make it a little easier to deal with, such as throwing application specific
    exceptions rather than TweepyError and configuring from a passed application.
    """

    def __init__(self, app=None):
        self._api = None

        if app:
            self.init_app(app)

    def init_app(self, app):
        self._api = API(OAuthHandler(app.config["TWITTER_KEY"], app.config["TWITTER_SECRET"]))

    def search(self, term):
        if self._api is None:
            raise TwitterError("Can't connect to Twitter right now.")

        return [self._format(tweet) for tweet in self._search(term)]

    def _search(self, term):
        "Attempts to search twitter and raises a TwitterError if it fails."
        try:
            return self._api.search(term)
        except TweepError as e:
            self._throw_from_tweepy_error(e, "Sorry, we're having trouble with Twitter right now.")

    def _format(self, tweet):
        return {
            "user": tweet.user.screen_name,
            "text": tweet.text,
            "url": self._build_url(tweet.user.screen_name, tweet.id_str),
        }

    @staticmethod
    def _build_url(username, status_id):
        return "https://twitter.com/{0}/status/{1}".format(username, status_id)

    @staticmethod
    def _throw_from_tweepy_error(e, msg=None, code=500):
        "Converts a tweepy error into an application specific error"
        if msg is None:
            msg = e.reason

        raise TwitterError(msg, code)

# 需要导入模块: from tweepy import API [as 别名]
# 或者: from tweepy.API import search [as 别名]
class Collect(object):
    """
    Collect tweet from Twitter

    environments vars:
        --consumer-key    : the twitter consumer key
        --consumer-secret : the twitter consumer secret
        --access-key      : the twitter access token key
        --access-secret   : the twitter access token secret

    required params:
        @arg is a argument for query in Twitter

        Ex.: Collect("python").search()
    """

    def __init__(self, arg):
        self.arg = arg
        self.consumer_key = environ.get("CONSUMER_KEY", None)
        self.consumer_secret = environ.get("CONSUMER_SECRET", None)
        self.access_token_key = environ.get("ACCESS_TOKEN", None)
        self.access_token_secret = environ.get("ACCESS_TOKEN_SECRET", None)
        self.api = self.connect_with_twitter()
        self.tweets = []

    def connect_with_twitter(self):
        auth = OAuthHandler(self.consumer_key, self.consumer_secret)
        auth.set_access_token(self.access_token_key, self.access_token_secret)
        self.api = API(auth)
        return self.api

    def search(self):
        """"
        reference:
            https://github.com/tweepy/tweepy/blob/master/tweepy/api.py

        allowed_params:
            'q', 'lang', 'locale', 'since_id', 'geocode', 'since', 'until',
            'result_type', 'count', 'include_entities', 'from', 'to', 'source'
        """
        self.tweets = self.api.search(q=self.arg)
        return self.tweets

# 需要导入模块: from tweepy import API [as 别名]
# 或者: from tweepy.API import search [as 别名]
    except Exception:
        logger.exception("Unexpected exception")

class StdOutListener(StreamListener):

    def on_data(self, data):
        #print data
        extract_media_url(json.loads(data))
        return True

    def on_error(self, status):
        print status

if __name__ == '__main__':
    FORMAT = '%(asctime)-15s %(message)s'
    logging.basicConfig(format=FORMAT, level=logging.INFO)
    args = docopt(__doc__)
    keys = json.loads(open(os.path.join(os.environ['HOME'], '.twitter-keys')).read())
    l = StdOutListener()
    auth = OAuthHandler(keys['consumer_key'], keys['consumer_secret'])
    auth.set_access_token(keys['access_token'], keys['access_token_secret'])
    api = API(auth)
    logger.info("Connected to twitter.  Scanning recent tweets.")
    for status in api.search(args['<search-term>']):
        extract_media_url(status._json)
    logger.info("Waiting for new tweets.")
    stream = Stream(auth, l)
    stream.filter(track=[args['<search-term>']])

# 需要导入模块: from tweepy import API [as 别名]
# 或者: from tweepy.API import search [as 别名]
# Remove lines starting with ; and remove line breaks
negWords = [ line for line in lines if not line.startswith(';') ]
negWords = [ negWord.replace('\n', '').replace('\r', '') for negWord in negWords ]
searchQueriesPerBank = {
    'Bank of America': "@BofA_Help OR #BankofAmerica OR #BofA OR \"Bank of America\"",
    'Barclays': "@Barclays OR @BarclaysOnline OR #Barclays OR Barclays",
    'Citi': "@Citi OR @AskCiti OR #Citi OR Citi"
}

started = time.time()
for bank in searchQueriesPerBank:
    searchQuery = searchQueriesPerBank[bank]
    max_id = 0
    while True:
        if max_id == 0:
            results = api.search(q = searchQuery, count=100, lang='en')
        else:
            results = api.search(q = searchQuery, max_id=max_id, count=100, lang='en')
        
        count_neg_tweets = 0
        for result in results:
            max_id = result.id
            if any(negWord in result.text for negWord in negWords):
                count_neg_tweets += 1
                if result.retweet_count >= retweet_threshold:
                    print "\n======= TWEET ======="
                    print "ID: " + str(result.id)
                    print "USER: " + str(result.user.name)
                    print "DATE: " + str(result.created_at)
                    print "RETWEETS: " + str(result.retweet_count)
                    print "TEXT: " + str(result.text)

# 需要导入模块: from tweepy import API [as 别名]
# 或者: from tweepy.API import search [as 别名]
# author: jason chang
from tweepy import OAuthHandler
from tweepy import API

consumer_key = 'UTQo43HVZJVmqydZ1S2hiPDaw'
consumer_secret = 'uCXkRQpeJ1Wy55whXsrOFnVuIWBzl3uBmZKtCoGCJyDkbdKkJB'
access_token = '627714227-XgUMt9espQA69FAAw5qbb6KPB0FtqGC2jSt2dyEx'
access_secret = 'FnoJwswLnEFsiY7O3BRqy87ZZMOUdRTmmSja4xTgpTPWX'

if __name__ == '__main__':

    # Puts in Twitter authentication and connects to Twitter Streaming API
    auth = OAuthHandler(consumer_key, consumer_secret)
    auth.set_access_token(access_token, access_secret)
    api = API(auth)
    
    # Used to output all tweets within a given date range with specified key words
    start_id = 624368394029125633           # id of the tweet with the starting time 
    end_id = 624730781902999552             # id of the tweet with the ending time
    while(end_id >= start_id)               # makes sure end_id is greater than or equal to the start_id number, to keep it within date range
        id_numbers = []                     # creates an empty list for the id numbers that will be loaded in by the for loop
        results = api.search(q="fiorentina", since_id=start_id, max_id=end_id, count=200)   # list of 200 or less most recent tweets between the ids that have the key word fiorentina in it
        for result in results:              # for each tweet do this:
            unicode_string = result.text    # stores text in var
            encoded_string = unicode_string.encode('utf-8')     # converts text to string using 'utf-8'
            result.text = encoded_string                        # reassigns text to the converted string
            print result                                        # prints out formatted string
            id_numbers.append(result.id)                        # appends id of tweet to end of id list
        end_id = min(id_number)                                 # end_id is reassigned to the minimum id number in the list of id numbers

# 需要导入模块: from tweepy import API [as 别名]
# 或者: from tweepy.API import search [as 别名]

#.........这里部分代码省略.........
        return filter(belongs_to_conversation, tweets_from_participants)

    def _get_older_and_newer_tweets(self, screen_name, tweet_id, count=20):
        """
        Get tweets from the user with `screen_name` username that are older
        and newer than `tweet_id`.

        By default, 20 tweets are fetched. If provided, `count` controls how
        many tweets are requested.
        """
        older = self.get_user_timeline(screen_name,
                                       max_id=tweet_id,
                                       count=count/2)
        newer = self.get_user_timeline(screen_name,
                                       since_id=tweet_id,
                                       count=count/2)
        return older + newer

    def get_message_thread(self, dm, **kwargs):
        messages = self.get_direct_messages(**kwargs)

        me = self.verify_credentials()
        if dm.sender_screen_name == me.screen_name:
            with_user = dm.recipient_screen_name
        else:
            with_user = dm.sender_screen_name

        def belongs_to_conversation(message):
            return (message.sender_screen_name == with_user or
                    message.recipient_screen_name == with_user)

        return filter(belongs_to_conversation, messages)

    @to_status_from_search
    @include_entities
    def search(self, text, **kwargs):
        return self._api.search(text, **kwargs)

    @to_status
    @include_entities
    def get_retweets_of_me(self, **kwargs):
        return self._api.retweets_of_me(**kwargs)

    def update(self, text):
        self._api.update_status(text)

    def reply(self, status, text):
        self._api.update_status(text, in_reply_to_status_id=status.id)

    def destroy_status(self, status):
        self._api.destroy_status(status.id)

    def retweet(self, status):
        self._api.retweet(status.id)

    def direct_message(self, username, text):
        self._api.send_direct_message(user=username, text=text)

    def destroy_direct_message(self, dm):
        self._api.destroy_direct_message(dm.id)

    def create_friendship(self, screen_name):
        self._api.create_friendship(screen_name=screen_name)

    def destroy_friendship(self, screen_name):
        self._api.destroy_friendship(screen_name=screen_name)

# 需要导入模块: from tweepy import API [as 别名]
# 或者: from tweepy.API import search [as 别名]
class TweepyAPITests(unittest.TestCase):

    def setUp(self):
        auth = OAuthHandler(oauth_consumer_key, oauth_consumer_secret)
        auth.set_access_token(oauth_token, oauth_token_secret)
        self.api = API(auth)
        self.api.retry_count = 2
        self.api.retry_delay = 5

    def testhometimeline(self):
        self.api.home_timeline()

    def testfriendstimeline(self):
        self.api.friends_timeline()

    def testusertimeline(self):
        self.api.user_timeline()
        self.api.user_timeline('twitter')

    def testmentions(self):
        self.api.mentions()

    def testretweetedbyme(self):
        self.api.retweeted_by_me()

    def testretweetedbyuser(self):
        self.api.retweeted_by_user('twitter')

    def testretweetedtome(self):
        self.api.retweeted_to_me()

    def testretweetsofme(self):
        self.api.retweets_of_me()

    def testretweet(self):
        s = self.api.retweet(test_tweet_id)
        s.destroy()

    def testretweets(self):
        self.api.retweets(test_tweet_id)

    def testgetstatus(self):
        self.api.get_status(id=test_tweet_id)

    def testupdateanddestroystatus(self):
        # test update
        text = 'testing %i' % random.randint(0, 1000)
        update = self.api.update_status(status=text)
        self.assertEqual(update.text, text)

        # test destroy
        deleted = self.api.destroy_status(id=update.id)
        self.assertEqual(deleted.id, update.id)

    def testgetuser(self):
        u = self.api.get_user('twitter')
        self.assertEqual(u.screen_name, 'twitter')

        u = self.api.get_user(783214)
        self.assertEqual(u.screen_name, 'twitter')

    def testsearchusers(self):
        self.api.search_users('twitter')

    def testme(self):
        me = self.api.me()
        self.assertEqual(me.screen_name, username)

    def testfriends(self):
        self.api.friends()

    def testfollowers(self):
        self.api.followers()

    def testdirectmessages(self):
        self.api.direct_messages()

    def testsentdirectmessages(self):
        self.api.sent_direct_messages()

    def testsendanddestroydirectmessage(self):
        # send
        sent_dm = self.api.send_direct_message(username, text='test message')
        self.assertEqual(sent_dm.text, 'test message')
        self.assertEqual(sent_dm.sender.screen_name, username)
        self.assertEqual(sent_dm.recipient.screen_name, username)

        # destroy
        destroyed_dm = self.api.destroy_direct_message(sent_dm.id)
        self.assertEqual(destroyed_dm.text, sent_dm.text)
        self.assertEqual(destroyed_dm.id, sent_dm.id)
        self.assertEqual(destroyed_dm.sender.screen_name, username)
        self.assertEqual(destroyed_dm.recipient.screen_name, username)

    def testcreatedestroyfriendship(self):
        enemy = self.api.destroy_friendship('twitter')
        self.assertEqual(enemy.screen_name, 'twitter')

        # Wait 5 seconds to allow Twitter time
        # to process the friendship destroy request.
#.........这里部分代码省略.........