How to use the tweepy.Cursor function in tweepy

tmp=api.lookup_users(screen_names=l)
  		for u in tmp:
  			twd.append(u)
  			twn.append(u.screen_name)
else: exit(-1)

for user in twn:
	currSampleSize=sampleSize
	source=user
	twd=[]
	fd='reports/'+fpath #+user+'/'
	
	fn=fd+user+'_fo_'+str(sampleSize)+'_'+now.strftime("_%Y-%m-%d-%H-%M-%S")+'.csv'
	print 'grabbing follower IDs for',user
	try:
		mi=tweepy.Cursor(api.followers_ids,id=user).items()
	except: 
		continue
	users=[]
	try:
		for m in mi: users.append(m)
	except: continue
	biglen=str(len(users))
	print 'Number of followers:',biglen
	#HACK
	if str(len(users))>10000: currSampleSize=10000
	#this breaks the date recreation on followers - need a run of 10000 users
	if currSampleSize>0:
		if len(users)>currSampleSize:
			if ORDEREDSAMPLE !=1:
				users=random.sample(users, currSampleSize)
				print 'Using a random sample of '+str(currSampleSize)+' from '+str(biglen)

def get_following (user_keys,api,user,dict_friends,f_log,f_out,flag_friends):
  print 'Getting user following',user
  try:
    profile=api.get_user( screen_name=user)
    num_following=profile.friends_count
    if flag_friends:
      put_profile (api,user,profile,'root',f_log, f_out)
    following_getting=0
    try:
      print 'user: %s --> getting %s following profiles' % (user,num_following)
      for page in tweepy.Cursor(api.friends,screen_name=user,
                                count=200,
                                monitor_rate_limit=True, 
                                wait_on_rate_limit=True,
                                wait_on_rate_limit_notify = True,
                                retry_count = 5, 
                                retry_delay = 5 ).pages():
        following_getting += len(page)
        print 'user: %s --> collected %s following profiles of %s' % (user,following_getting,num_following)
        for profile in page:
          relation='following'
          if profile.id in dict_friends:
            relation='friend'
          if relation == 'friend' and not flag_friends:
            pass
          else:
            put_profile (api,user,profile,relation,f_log, f_out)

def get_followers(self, n_pages=-1):
        """
        Get followers
        :return:
        """
        follower_list = list()
        page_count = 0
        # For each pages
        for page in tweepy.Cursor(self._api.followers).pages():
            # For each follower in the page
            for follower in page:
                follower_list.append(follower)
            # end for

            # Inc
            page_count += 1

            # Limit
            if n_pages != -1 and page_count >= n_pages:
                break
            # end if

            # Wait 60s
            time.sleep(60)
        # end for

def readTimeLine(api):
    for status in tweepy.Cursor(api.home_timeline).items(10):
        # process a single status
        # print(status.text)
        process_or_store(status._json)

def list_tweets_list(topo):
    api = twitter_auth.autentica_list()

    tweets = []

    for status in tweepy.Cursor(api.list_timeline,tweet_mode='extended', owner_screen_name="projeto7c0", slug="politicos-br", since_id=topo, count=200).items():
        print(status)
        tweets.append(status)

    return tweets

def get_followers_ids(api, user_id):
    """
    Given a Tweepy/smappPy TweepyPool api, query twitter's rest API for followers of
    given user_id. Returns IDs only (much faster / more per request).
    Parameters:
        api     - fully authenticated Tweepy api or smappPy TweepyPool api
        user_id - twitter user id
    Returns tuple: return code, list of IDs or None (if API call fails)
    """
    cursor = Cursor(api.followers_ids, user_id=user_id)
    user_list, ret_code = call_with_error_handling(list, cursor.items())

    if ret_code != 0:
        logger.warning("User {0}: Followers request failed".format(user_id))
    
    # Return user list from API or None (call_with_error_handling returns None if
    # call fail)
    return ret_code, user_list

async def twitter_status(self, ctx, handle : str, replies : bool = False, retweets : bool = False):
		'''
		Get twitter status
		Excludes replies and retweets by default
		Limited to 3200 most recent Tweets
		'''
		tweet = None
		if handle.lower().strip('@') in self.blacklisted_handles:
			return await ctx.embed_reply(":no_entry: Error: Unauthorized")
		try:
			for status in tweepy.Cursor(self.bot.twitter_api.user_timeline, screen_name = handle, 
										exclude_replies = not replies, include_rts = retweets, 
										tweet_mode = "extended", count = 200).items():
				tweet = status
				break
		except tweepy.error.TweepError as e:
			if e.api_code == 34:
				return await ctx.embed_reply(f":no_entry: Error: @{handle} not found")
			else:
				return await ctx.embed_reply(f":no_entry: Error: {e}")
		if not tweet:
			return await ctx.embed_reply(":no_entry: Error: Status not found")
		text = self.process_tweet_text(tweet.full_text, tweet.entities)
		image_url = None
		if hasattr(tweet, "extended_entities") and tweet.extended_entities["media"][0]["type"] == "photo":
			image_url = tweet.extended_entities["media"][0]["media_url_https"]
			text = text.replace(tweet.extended_entities["media"][0]["url"], "")

i=0
  membersid=[]
  for id in members:
    membersid.append(members[id].id)
  M=len(members)
  Ms=str(M)
  for id in members:
    i=i+1
    friend=members[id]
    foafs={}
    report("- finding "+typ+" of whatever (friends? followers?) was passed in of "+friend.screen_name+' ('+str(i)+' of '+Ms+')')
    #danger hack AJH TH - try to minimise long waits for large friend counts
    if typ == 'friends' and int(friend.friends_count)>0 and int(friend.friends_count)0 and int(friend.followers_count)

output_file = args.file

    tweets = []  # list of tweets obtained from user timeline
    count = defaultdict(int)
    total_tweets_analyzed = 0
    total_results = 0

    # make connection
    auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
    auth.set_access_token(access_token, access_token_secret)
    api = tweepy.API(auth, wait_on_rate_limit=True)

    print('\nAnalyzing tweets. This could take a few seconds...')

    # get tweets from user's timeline
    for tweet in tweepy.Cursor(api.user_timeline, screen_name=user).items():
        tweets.append(tweet._json['text'].lower())

    # get rid of stop words
    # list of stop words https://gist.github.com/sebleier/554280
    stop_words = stopwords.words('english') + list(
        string.punctuation) + ['“', '”']

    # words to ignore in results
    BACKLIST_WORDS = [
        'https',
        '``',
        '...',
        'http',
        'rt',
    ]

def save_tweets_with_retweets(screen_name):
    timestamp = time.strftime("%d.%m.%Y %H:%M:%S", time.localtime())
    print(timestamp)
    for tweet in limit_handled(tweepy.Cursor(TWITTER_API.user_timeline, id=screen_name, count=200).items()):
        retweets = get_retweets(tweet.id)
        db.saveRetweets(tweet, retweets)